mirror of
https://github.com/opencv/opencv.git
synced 2026-11-21 08:45:29 -06:00
* experimental new arithmetics; work-in-progress * continue working on new-gen arithmetic expressions * * improved performance of the new add on small arrays * added sub * extended tests * fixed potential bug when adding multi-channel array and a single-channel scalar * improved const handling * * added copyMask * added mul/dev (without scale so far) * * accelerated mul * addedd scale to mul and div * * done substantial refactoring; however a few more rounds of refactoring are ahead. * added min, max, absdiff, addweighted. * improved performance of the new arithmetic functions, but some of them are still slow, e.g. operations with mask have some bugs (that affect speed, not accuracy). * * further (significantly) accelerated several functions, especially on small arrays: mul, binary ops with mask * further polished the new arithmetic engine * started integration of the new element-wise arithmetic engine into core * big step forward. We now use the new engine inside cv::add, subtract, multiply, divide, absdiff, min and max. * big progress: * added bitwise operations * fixed and accelerated compare * ported regression tests to test new broadcasting behaviour of arithmetic functions * lot's of improvements in compare, divide, addWeighted! * lot's of small and big performance improvements in the new arithmetics * * some more optimizations; parsing texpr-expressions is now faster as well * port new_arithm to Linux/x86: dispatch guards, scalar-Mat compat fallback, dnn shape-contract fixes Core: - arithm.simd.hpp: CV_CPU_OPTIMIZATION_DECLARATIONS_ONLY guards (the file is included once per dispatched mode on x86), vx_load_expand instead of the 128-bit v_load_expand, VTraits::vlanes() instead of ::nlanes - arithm.cpp/precomp.hpp: compat fallback for scalar-like Mat operands (1x1, 1xcn/cnx1, 4x1 CV_64F - java/python tuples, operator-(Mat, Matx)): treated as a per-channel scalar ONLY when the shapes are not broadcast-compatible, so every valid numpy-style broadcast keeps its meaning and calls that would otherwise throw get the 4.x semantics DNN (fallout of the stricter shape semantics, found by the new engine): - dict.hpp: DictValue relied on fresh AutoBuffer having size()==fixed_size; allocate explicitly - batch_norm: weights_/bias_ are 1-D [n] now; 0/1-D forward runs on exact-shape 1-D views - net_impl2: extend the post-forward sanity check to non-temp outputs - a layer that reallocates its preallocated output tensor now fails loudly instead of silently detaching the result from the graph - LSTM/LSTM2 batchwise (layout=1): getMemoryShapes now matches what forward() writes (ONNX: Y=(batch,seq,dirs,hid), Yh/Yc=(batch,dirs,hid)); forward assembles seq-major results in a local buffer and transposes INTO the preallocated outputs in place Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * u8/s8 multiply: exact integer SIMD path on non-FP16 builds (3-10x vs 5.x) The unit-scale branch of vecBinaryKernel already supported a separate work-vector type Wvec1 (used by the ARM f16 build and by u16/s16 everywhere), but on x86 the u8/s8 same-type multiply still went through the f32 hub. Route it through v_uint16/v_int16: products of 8-bit values fit exactly (255^2 < 2^16), the saturating pack on store gives bit-exact results at half the vector traffic. Also fix a latent kernel bug this exposed: the unit-scale branch stepped by Wvec's lane count while loading/storing Wvec1 vectors. All previous Wvec1 instantiations had equal lane counts, but u8's v_uint16 has 2x the lanes of v_float32 - the pairs overlapped (50% redundant work) and the tail backoff could write VECSZ bytes past the row end. The branch now derives its step, offsets and tail condition from Wvec1 itself. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * vecBinaryKernel: constexpr Op::useScalar instead of a runtime-only scale check Every binary op functor now declares whether it consumes the scale scalar (params[0]): true only for mul and the two div variants. Ops that ignore it (add/sub/min/max/absdiff) take the fast 2-arg branch unconditionally - the 'scalar == 1' check used to fail for them (their params[0] is 0), sending them through the preproc branch, and the condition now folds at compile time. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * restore cv::hal::mul8u as a wrapper over the element-wise engine The symbol is still declared in core/hal/hal.hpp and called directly by external code (the G-API fluid backend in opencv_contrib), but its implementation went away with the old arithm kernels. Forward it to getMulFunc(CV_8U, CV_8U) - with scale==1 it lands on the new exact integer SIMD path. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * silence every new-arithm warning reported by CI (ARM64/Mac) and gcc 15 - arithm.cpp: bitwise_op_ocl and the actualScalarDepth/coerceTypes helpers are consumed only by the OpenCL paths - guard them with HAVE_OPENCL; haveScalar in cv::compare is read only inside CV_OCL_RUN - CV_UNUSED for OpenCL-less builds - arithm_expr.hpp: declare getBitwiseFunc/getNotFunc/getAddWeightedFunc next to the other per-op entry points (-Wmissing-prototypes in arithm.dispatch.cpp) - arithm.simd.hpp: define CV_SIMD_16F to 0 when FP16 SIMD is absent (-Wundef); {}-init the expandScalar staging buffers (-Wmaybe-uninitialized: they are fully written before use, but the compiler cannot prove it with runtime vector widths); rename the compare kernel's lambda parameter (-Wshadow) - arithm_expr.cpp: rename the exec tile-lambda's hot-field locals that shadowed TExpr members and outer locals (-Wshadow) - test_new_arithm_extensive.cpp: rename the name-generator lambdas' parameter shadowing the INSTANTIATE macro's own (-Wshadow), drop an unused variable Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * restore 4.x scalar semantics for the bindings' 4x1 CV_64F Scalar columns The python/java bindings materialize numbers and tuples as a 2-D 4x1 CV_64F Mat - or UMat, when the call carries UMat arguments. Three CI-reported python failures came from those pseudo-scalars reaching the engine as arrays: - absdiff(int_arr, 0): the (4,1) column is broadcast-COMPATIBLE with a 1-D array, so numpy semantics silently won - an outer-product f64 result instead of the int per-channel-scalar one; - subtract(u8 4x8x4, (40,)): same, by the rows==4 coincidence; - multiply(UMat, 2., dst=UMat): the scalar arrives as a UMAT, which the scalar detection did not recognize at all. isScalarArg now treats the exact bindings shape - 2-D 4x1 CV_64F single-channel Mat/UMat against a <=4-channel array - as a scalar UNCONDITIONALLY (a 1-D [4] array has dims==1 and still broadcasts). One exception, decided in arithm_op: when the partner is itself a tiny scalar-shaped array, both are honest data and ride the broadcast (compare(Mat 4x1, Mat 1x1) - issue #8999 - stays elementwise). Small-array discipline, this all runs per engine call: the probes read Mat/UMat fields directly (rows == 4 alone rejects almost everything, no _InputArray getter dispatch), and a UMAT scalar's 32 bytes are copied into a caller-stack buffer - no heap, no getMat mapping. Measured: no latency change on 4x4/16x16 element-wise calls. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * cv::texpr: std::string_view -> const std::string& in the public API string_view in an exported signature breaks some CUDA toolchain builds, and for short expression strings the difference is immaterial (SSO, parsed once). The parser internals keep string_view - the argument converts implicitly. Also drop the now-unused <string_view> include from cvstd.hpp, so the header does not reach every nvcc TU. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * compare boundary-rewrite: fixed 4-slot kind/bound arrays instead of AutoBuffers A CONST operand is capped at 4 channels (addConst), so the per-channel kind/bound staging needs no dynamic buffers - plain int[4]/double[4], with a CV_Assert on the contract. This is also what gcc's -Wmaybe-uninitialized was flagging (it could not see the AutoBuffer's inline storage get filled). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * element-wise engine: unary math kernels (sqrt/exp/log/sin/cos/tanh/erf/relu) + select New dispatched pair math.simd.hpp / math.dispatch.cpp - the unary/ternary sibling of arithm.simd.hpp: - vecUnaryKernel: T -> T over f16/bf16/f32/f64 on top of the intrin_math primitives (v_exp/v_log/v_sin/v_cos/v_sqrt/v_erf/v_max). f32/f64 compute natively, f16/bf16 ride the f32 hub inside the kernel (vx_load_pair_as / v_store_pair_as) - no materialized casts. Continuity collapse + the halide right-edge backoff, suppressed in-place (it would re-apply Op to already-written values). tanh = (e^2x-1)/(e^2x+1) with the input clamped to +/-10 (f32) / +/-20 (f64) - unclamped saturation hits inf/inf = NaN. erf has no f64 SIMD primitive: std::erf per lane. - selectKernel(mask, x, y): 1-byte mask expanded to lane width and tested against zero in the INTEGER domain (immune to DAZ/FTZ), branches of any depth by element size, broadcast branches supported. - emitUnary: math over a float input is T -> T now (f16 in -> f16 out, native kernel when input and result depths match); integer inputs still compute in the float domain and land in f32. - emitTernary/select: literal branches are typed via typedConstFrom (an OP_CAST of a depth-less flex const crashed); a non-1-byte mask is normalized by an explicit "mask != 0" compare, never a value cast. texpr already parsed the function names - they now execute. Tests: per-depth accuracy of all 8 ops against the double std:: reference, integer input, in-place, select over 4 depths / const branch / float mask. Perf vs the classic kernels (1920x1080 f32, 16 threads, AVX2): exp 3.7x, log 2.6x, sqrt 5.7x faster; polarToCart expressed as (r*cos(a), r*sin(a)) 4.0x. Accuracy improves too (max rel err vs f64 reference): exp 8.1e-8 vs 2.1e-7, log 8.0e-8 vs 1.5e-7. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * engine: OP_COPY_MASK folded into OP_SELECT; selectKernel moved to arithm.simd.hpp copyMask(dst, mask, src) is select(mask, src, dst) - one masking primitive instead of two. The compiler emits the masked-op tail as addInsn(OP_SELECT, mask, r, out, out): the output slot rides as both arg2 and the result, so unmasked elements are preserved by reading them back through the b-branch. OP_COPY_MASK, copyMaskKernel and getCopyMaskFunc are gone. selectKernel (moved from math.simd.hpp to arithm.simd.hpp) inherits every copyMaskKernel optimization: - the interleaved multichannel fast path (2..4 channels under a per-pixel mask: expand the mask once per VECSZ rows, v_store_interleave across lanes); - the per-row scalar path with the row-skip when the selected source row IS dst (the "leave the output untouched" half of copyMask); - plus the select-specific ones: branch broadcasts (stepx == 0) and the right-edge tail backoff under dst-aliases-a-branch - safe because re-running select over already-blended elements is idempotent; only dst == mask keeps the backoff off (the store would rewrite mask bytes before the re-read). Masked-add perf is on par with the old copyMask (1280x720, 1 thread: 8UC3 204 -> 198 us, 32FC3 1395 -> 1344, 8UC1/32FC1 within noise). Full core suite 24117 green. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * engine: dedicated vectorized pow kernel (moved from arithm to math.simd.hpp) pow was the last scalar-only binary op (scalarBinaryKernel + std::pow, f32/f64 only). The new powKernel keeps exact std::pow semantics and is T x T -> T over all four float depths (f16/bf16 via the f32 hub): - scalar exponent (the dominant call shape - texpr literals ride as 0-dim broadcast consts) is dispatched PER ROW to the special cases: y==2 -> x*x, y==3 -> x*x*x, y==0.5 -> v_sqrt, y==1 -> copy, y==0 -> fill 1; - everything else - including a per-element exponent array - runs the general vectorized exp(y * log(x)) path, valid for x > 0; a vector pair containing any x <= 0 lane falls back to scalar std::pow for that pair (v_check_any), which preserves every std::pow subtlety: signed results for integer y on negative bases, NaN for fractional y, the x == 0 family; - no right-edge tail backoff: pow is not idempotent, in-place calls finish rows in the scalar tail. Perf vs the classic cv::pow (1920x1080 f32, 16 threads, AVX2): p=2 1.4x (classic special-cases it too), p=3 6.1x, p=0.5 6.3x, fractional p 4.5x with slightly better accuracy (6.1e-7 vs 7.4e-7 max rel err). Tests: exponent sweep 2/3/0.5/1/0/2.5/-1.5 vs the double std::pow reference on f32/f64, negative bases (exact signed cubes, NaN for fractional), array exponent. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * powKernel: halide right-edge tail backoff in every SIMD loop Same shape as vecBinaryKernel: the final partial vector re-processes [width - VECSZ*2, width) instead of finishing scalar, suppressed when dst aliases an input (pow is not idempotent - the overlap region must be recomputed from an untouched source, which the no-alias case guarantees). Modest measured win (~2% on ROI rows for the special-cased exponents; the general path tail was already cheap - modern libm powf is fast), no regressions; mainly aligns the kernel with the house style, where every SIMD loop ends vector-wide. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix MSVC 2019 C2975: function-local constexpr as a template argument inside a lambda MSVC 2019 loses the constexpr-ness of function-local constants (LOCAL_OPS, MAX_DIMS, ...) when they are used as template arguments inside a lambda body (AutoBuffer<Slice, LOCAL_OPS> / std::array<int, MAX_DIMS> in the parallel bodies of BroadcastOp::run and TExpr::exec). Hoist them to namespace scope - no behavior change. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * ocl_arithm_op: route 16U multiply to the CPU engine on Apple OpenCL The Apple OpenCL driver miscompiles the 16U multiply kernel: products near the top of the u16 range come back wrapped instead of saturated (CPU vs GPU NORM_INF up to 65535 in OCL_Arithm/Mul.Mat CV_16U cases). The same arithm.cl kernel is correct on Intel NEO and NVIDIA drivers - verified not to reproduce on Linux/Intel iGPU - so gate the decline to __APPLE__ only; the CPU engine computes 16u multiply exactly (integer SIMD path). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * engine: neg/abs as compositions, clamp kernel, ** and ?: operators, abs(a-b) peephole - OP_NEG and OP_ABS need no kernels: neg = sub(0, a), abs = absdiff(a, 0) - including the engine absdiff auto-type rule (signed |a| lands in the UNSIGNED type of the same width: |SHRT_MIN| fits u16 exactly instead of saturating; NB the public cv::absdiff auto depth keeps the source type for 4.x compatibility - values agree, the depth rule is the engine own). - peephole: abs(x - y) rewrites to absdiff(x, y) ALWAYS. On integers the literal semantics differ (the subtract saturates first: u8 gives max(x-y, 0)), but whoever writes abs(a - b) means absdiff - we deliberately hand out the useful semantics instead of the saturation artifact. The just- emitted OP_SUB is retired via the moveToOutput manoeuvre, so the program shrinks to the single absdiff instruction. abs(x), abs(x - 0) and absdiff(x, 0) all give one result. - OP_CLAMP kernel (arithm.simd.hpp): v_min(v_max(x, lo), hi) over u8/s8/u16/s16/u32/s32/f32 (+f64 with 64-bit SIMD), scalar f16/bf16/64-bit ints; lo/hi may broadcast (the common clamp(img, a, b) shape) or be full arrays; the tail backoff stays on under dst-aliases-x (clamp is idempotent). emitTernary types literal bounds via typedConstFrom (same flex-const crash select had) and keeps the auto result type pinned to x. - parser: "a ** b" == pow(a, b), precedence above * /, RIGHT-associative (a ** 2 ** 3 == a ** 8); "cond ? a : b" == select(cond, a, b), precedence below everything, right-associative chains (f1 ? a : f2 ? b : c) work without parentheses. parseTernary() is the expression entry point now. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * cv::exp/log/sqrt on the engine via math_op; hal functions wrapped as engine kernels math_op is the master function of the unary math family (the arithm_op analogue): same-shape same-type output over f16/bf16/f32/f64 (classic exp/log accepted f32/f64 only - the half floats are new), two tiers: - small (<= 100000 elements) and continuous: call the kernel DIRECTLY over the flattened data - no TExpr, no broadcastOp, no parallel_for setup; - everything else: the usual single-instruction program via compile()/exec() (parallelism for large arrays, real steps for ROIs). getMathFunc routes OP_EXP/OP_LOG at f32/f64 through the full cv::hal stack - an external vendor HAL (CALL_HAL), IPP, or the built-in table kernels, whichever is installed - by wrapping hal::exp32f/exp64f/log32f/log64f as engine kernels with the function pointer in TKernel::userdata, the same mechanism castKernel uses for core BinaryFuncs. The engine adds tiling and parallelism on top, so every tier gets the best available scalar-span implementation. v_exp/v_log remain for f16/bf16 (the f32 hub) and the ops hal has no entry points for. v_log_default_32f: the degree-8 polynomial is evaluated by Estrin pairing (4 dependent levels) instead of an 8-FMA Horner chain (~5% on the f16 hub path). An exp64 Taylor-without-division rewrite was tried and benched SLOWER than the Cephes Pade scheme (the evaluation is FMA-throughput-bound, and vdivpd pipelines well enough) - reverted; a table-based reduction is the only way further there. cv::exp f32 (16 threads, AVX2+IPP build), old -> new: 640 elements 0.16 -> 0.15 us, 16k 2.79 -> 2.49, 640x480 47 -> 20, 1920x1080 452 -> 60 us (the old CPU loops were single-threaded); f64 exp 1080p 1295 -> 161 us. No size regresses; small arrays now run at installed-HAL speed. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * getMathFunc: IPP tier + raw-HAL probing; the exp/log table kernels are deleted The raw cv_hal_* entry points return int for a reason: without an installed HAL they are stubs returning CV_HAL_ERROR_NOT_IMPLEMENTED. getMathFunc now selects the exp/log implementation in three tiers: 1. HAVE_IPP && ipp::useIPP(): ippsExp/ippsLn through thin int adapters (IPP is not routed through the cv_hal_ hooks, so it needs its own tier); 2. the raw cv_hal_exp32f/... hook, PROBED once with a 1-element call on the safe input 1.0 (cached in magic statics): implemented -> wrapped as an engine kernel with the function pointer in TKernel::userdata; 3. the engine own v_exp/v_log kernels. Whichever wins, the engine adds tiling and parallelism on top. The EXPTAB/LOGTAB table kernels and their tables (~790 lines in mathfuncs_core.simd.hpp + mathfuncs.cpp) are DELETED: they benched within ~15% of v_exp/v_log, not worth a second implementation. The public cv::hal::exp32f/exp64f/log32f/log64f keep their contract - CALL_HAL, then IPP, then the built-in implementation - but the built-in is now the engine vector kernel via ew::mathSpanEngine (one contiguous span, exported from math.dispatch.cpp). All unary math kernels (vec/scalar/hal wrappers, pow) also handle the vertical-broadcast tile (s0y == 0, a row expanded into a matrix): the first row is computed, the rest are memcpy of it - transcendentals cost far more than a row copy. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * texpr: hypot(x, y) binary op (alias: mag) hypot = sqrt(x^2 + y^2), NAIVE like cv::magnitude (not the overflow-safe std::hypot), computed in the float work type; kernels for the four float depths only (T x T -> T; integer inputs ride the usual f32-compute + cast). A 10-line EwHypot functor on top of vecBinaryKernel in arithm.simd.hpp - broadcast branches, continuity collapse and the tail backoff come for free. Registered in the parser as both "hypot" (the C/numpy name) and "mag" (the cv::magnitude-flavored alias). A building block for the future cartToPolar. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * texpr: atan2(y, x) binary op - radians, standard C range v_atan2 (arithm.simd.hpp, generic over the universal-intrinsic float vector): the fastAtan2 minimax polynomial from mathfuncs_core v_atan_f32 reworked to plain radians - the 180/pi factor dropped from the coefficients and the C quadrant logic instead of the [0, 360) wrap, so the result matches std::atan2 over (-pi, pi]. Measured absolute accuracy ~1.6e-4 rad. (v_atan_f32 itself is untouched - cv::phase/fastAtan2 keep their degree semantics.) EwAtan2 rides vecBinaryKernel: f16/bf16/f32 through v_atan2 (the f32 hub), f64 through exact scalar std::atan2. arg0 = y, arg1 = x, like std::atan2; float depths only, same emitBinary policy as pow/hypot. Parser name "atan2". Together with hypot this completes the cartToPolar building blocks. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix the RISC-V RVV build and two ARM64 warnings The new f64 kernel registrations (hypot, pow, the unary math family) gate on CV_SIMD_64F || CV_SIMD_SCALABLE_64F, but the vx_setall_as(const double*, v_float64&) helper family in arithm.simd.hpp was still CV_SIMD_64F-only - scalable platforms (RVV) have v_float64 with CV_SIMD_64F == 0, so vecBinaryKernel<double, ...> failed to instantiate there. Widen the helper gate to match (verified with a riscv64 rv64gcv cross-build of opencv_core - the engine f64 paths now vectorize on RVV instead of not compiling). cv::exp/cv::log: the depth local is consumed by CV_OCL_RUN only - CV_UNUSED for OpenCL-less builds (ARM64 -Wunused-variable). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * silence the remaining ARM64 gcc warnings - compare boundary-rewrite: {}-init the fixed kind/bound arrays (filled for every channel used below, but gcc cannot prove it across the cn <= 4 loop); - cv::exp/log: [[maybe_unused]] on the depth local (consumed by CV_OCL_RUN only), instead of the CV_UNUSED idiom; - AutoBuffer::reserve: a targeted -Wmaybe-uninitialized suppression around the live-element copy loop - only [0, sz) is read, all written before, but gcc inlining a grow-from-inline-storage chain cannot see that. An annotation for the analyzer, no behavior change. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * saturating 32-bit add/sub kernels; cv::texpr python binding; two CI warnings - v_add_sat/v_sub_sat for v_int32/v_uint32, local to arithm.simd.hpp for now (the plan is to grow them into proper universal intrinsics later): NEON single-instruction vqadd/vqsub, elsewhere the Hacker Delight bit tricks over universal intrinsics (u32 add is 2 ops: or with the wrapped-compare mask). EwAdd/EwSub overload vec() for the 32-bit lanes and getAddSubFunc routes 32S/32U T->T through vecBinaryKernel instead of the former pure scalar kernel. Semantics unchanged - the scalar int64 tail already saturated; directed boundary tests added (both rails, 0 - INT_MIN, u32 cases, a full-range random block vs an exact int64 reference). 640x480 32S add: 0.48x of 5.x -> parity (memory-bound); 1080p: 6-8x. - cv::texpr becomes CV_EXPORTS_W: python gets cv.texpr(expr, [inputs]) -> tuple of ndarrays, so `res, = cv.texpr(...)` and `mag, ang = cv.texpr(...)` unpacking both work. modules/python/test/test_expr.py covers arithmetic, the fused abs(a-b), casts, broadcasting, ?: and ** operators, math functions vs numpy, clamp, named temporaries, tuple outputs, the one-line cartToPolar and the int32 saturation cases. - warnings: {}-init the parser args array (gcc -Wmaybe-uninitialized on Ubuntu 20/22); the compare short-row block gates sizeof(T) <= 4 as constexpr so the f64 instantiation does not leave set-but-unused locals (gcc 9 -Wunused-but-set-variable). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * arithm_op: direct-kernel fast path for small continuous arrays Building and compiling the 1-instruction program plus the BroadcastOp setup costs ~40-250ns per call - negligible on big images, dominant at 127x61-class sizes where the classic 5.x functions were 1.3-2x faster. Mirror math_op two tiers in arithm_op: two same-type same-shape continuous arrays, no mask, no scalar, result depth == input depth, <= 100k elements -> call the T x T -> T kernel directly over the flattened elements (checks ordered cheapest-first). Applies to add/subtract/min/max/absdiff/multiply/addWeighted/and/or/xor; compare and divide lower to more than a single kernel (boundary rewrites, int guards) and keep the ordinary path. addWeighted falls through automatically for the 32/64-bit int types whose lowering is wide-compute + cast (getElemwiseFunc returns no direct kernel there). 127x61 vs 5.x, was -> now: add/subtract 8UC1 0.76x -> 1.3x, min/max u8 0.6x -> ~1x, addWeighted 1.0x -> 1.1-1.4x (32SC1 stays 4.5x); the one remaining laggard is add/sub 32SC1 (0.74-0.82x) - the price of the new SATURATING semantics (7-instruction AVX2 emulation vs the wrapping single add of 5.x; single-instruction on NEON). The 127x61 size is ADDED PERMANENTLY to the arithmetic/addWeighted/compare perf grids: per-call overhead regressions in these base functions must be caught by CI, not discovered by users. dst creation goes through createSameSize (whole-shape transfer including layout and future metadata, not piecemeal dims+sizes) here and in math_op. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * cv::pow rebuilt on the engine; integer-exponent and 1/sqrt(x) kernel branches Routing: p = 0/1/2 keep their early special cases (fill/copy/multiply); an INTEGER array with an INTEGER power keeps the classic iPow multiply chain - bit-exact compatibility, including its wrap-around quirks (iPow squares in int, so e.g. pow(255,4) on u8 wraps negative and saturates to 0 - somebody may rely on that). Everything else goes through the engine with the math_op two-tier scheme: small continuous arrays call powKernel directly (the exponent rides as a broadcast T scalar), the rest run the tiled parallel program. Integer arrays with fractional powers compute in the float domain and saturate back; the 32U/64-bit depths (classic iPow asserted on them) and f16/bf16 (the classic float path misread them) now just work. powKernel gets two new per-row exponent branches: - p == -0.5: 1/v_sqrt(x) (the classic path used IPP ippsInvSqrt_A21, a 21-bit approximation; ours is exact - slightly slower on small arrays, 4.5x faster at 1080p via parallelism); - any other INTEGER p (|p| <= 65536): LSB-first binary exponentiation, the same multiply chain and order as iPow, fully vectorized - a few ulp accurate vs ~2e-7 of exp(p*log x), and exact on non-positive bases (the sign falls out of the multiplies, 0^negative divides to inf) - no scalar patching. cv::pow f32 vs 5.x: p=0.5 365 -> 61 us at 1080p (6x), p=3 7.7x, p=5 7x AND faster at every size (the old scalar chain: 0.81 -> 0.47 us at 127x61), p=2.5 5.3x. The s16^5 iPow path is untouched (118.7 == 118.5 us). pow_exponents accuracy tests extended to 11 exponents x f32/f64 against the double std::pow reference. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * perf: SANITY_CHECK_NOTHING for the tests whose grids got the 127x61 size The 127x61 entry added to guard per-call overhead has no regression data in opencv_extra, so the legacy SANITY_CHECK in addWeighted/compare failed on CI (locally it passes silently without the test-data path). Accuracy of both functions is covered by the accuracy suite; the perf tests should measure time. PatchNaNs/finiteMask keep their SANITY_CHECK - their grids are untouched. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix a temp-buffer double release in the liveness pass ("d*d" crash) When the same temp is passed as SEVERAL arguments of its last-use instruction (e.g. the named-intermediate expression "d = {0} - {1}; d*d", where the MUL consumes slot d twice), the buffer-reuse scan pushed the temp's physical buffer onto the free list once per argument. That overflows the ntemps-sized freeBufs array (caught by the AutoBuffer range check in Debug: python test_expr.py::test_named_temporary) and, in larger programs, would hand the same physical buffer to two live temps. Release the buffer once by retiring lastUse[t] after the first hit. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * executor: recalibrate opCost to vectorized cycles + clamp the stripe count The per-element op costs fed into the parallel_for_ stripe hint were scalar-era estimates (~20x above the vectorized reality: the atan2/exp polynomials run at ~1.5 cycles/element, not 30). The hint therefore split transcendental/divide work into hundreds of ~1 us jobs, which the macOS/GCD backend dispatches poorly under sustained load, on top of the P/E-core equal-share straggler effect. Measured on M4 Max (12P+4E), sustained medians @1920x1080 f32: texpr atan2 320 -> 133 us, cv::exp 280 -> 141 us, cv::log 301 -> ~200 us, cv::pow(x,2.5) 388 -> 376 us; the PR tables' math rows improved ~1.5-2x across the board. - opCost is now in units of ~1/4 cycle/element of the SIMD kernels: cheap ops 1 (unchanged), div/sqrt/hypot/convert_scale 10 -> 3, transcendentals 30 -> 6. - the stripe hint is clamped by min(4*nthreads, max(32, 3*nthreads)): ~4 stripes/thread is plenty of granularity for element-wise work, and the ceiling is 32 pieces except on machines with many (heterogeneous) cores, where anything coarser than ~3 pieces/worker turns the slow cores into equal-share bottlenecks (measured: 32 stripes on 16 threads is the worst point of the curve - 193 us vs 137 us at 48 for atan2). getNumThreads() is clamped from below (WINRT/plugin backends may report 0). Not addressed here (needs cross-machine data, M2/M3 Ultra): streaming memory-bound ops saturate the M4 Max fabric at ~8 fat stripes and E-core participation only adds contention - a cost model cannot express that; candidate follow-up is a bytes-aware clamp or a GCD-backend-level fix. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * multiply: v_mul_sat integer kernels (full product clamped to the type) v_mul_sat(V, V) -> V for u8/s8/u16/s16/u32/s32 - the full-precision product clamped to the lane type, which is exactly cv::multiply's integer semantics at scale == 1. Local to arithm.simd.hpp for now, next to v_add_sat/v_sub_sat, to be promoted into proper universal intrinsics later. NEON: widening vmull + saturating narrow (vqmovn); other backends: the portable v_mul_expand + saturating v_pack composition for 8/16-bit lanes. 32-bit lanes have no universal widening multiply (no v_mul_expand for s32), so the 32-bit integer fast path is NEON-only for now and the other backends keep the previous f64 work-vector kernels (which measure well on x86 with IPP-free AVX2). EwMul::vec() now routes the integer lane types through v_mul_sat, and getMulFunc_ passes the NATIVE lane vector as the scale==1 fast-path type: whole-register loads/stores, the widening happens inside the multiply. Replaces both the half-register widening loads (u8/s8/u16/s16) and the scalar-equivalent f64 path for 32S/32U on NEON. M4 Max, 640x480 (the sizes where the old kernels lost to carotene): 8U 22.0 -> 13.6 us, 8S 15.0 -> 11.1, 16S 21.2 -> 17.4, 32S 84.8 -> 30.5 (parity with the classic path everywhere, 32S was 0.38x). 1920x1080: 8S 1.30x -> 1.78x, 16S 2.57x -> 2.98x, 32S 2.20x -> 4.02x vs 5.x. Correctness: exhaustive 8-bit (all 65536 pairs per sign), directed saturation corners for 16/32-bit (46341^2, INT_MIN*-1, 65536*65536, all sign combinations) against an exact int64 reference. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * NEON: make v_cvt_f64(v_int32) exact (was via f32, losing bits > 2^24) The NEON implementations of v_cvt_f64/v_cvt_f64_high for v_int32 did s32 -> f32 -> f64 (vcvt_f32_s32 + vcvt_f64_f32), silently rounding any |x| > 2^24. Every vectorized f64 work path with int32 inputs on AArch64 was affected: the engine's addWeighted/divide 32S kernels, convertTo 32S -> 64F, etc. Found via addWeighted 32SC1 on values ~1e9: max error was 32 vs the exact double reference (the classic carotene path is worse still - it computes in f32 end-to-end with f32-truncated weights, max error 96 on the same data). The exact sequence sxtl + scvtf (vmovl_s32 + vcvtq_f64_s64) is the same 2 instructions, so there is no cost. addWeighted 32SC1 on the engine now matches the exact-double reference bit-for-bit and stays at parity/1.4x vs the classic path (640x480/1920x1080). Pre-existing upstream bug (same code in 4.x) - worth a standalone backport with directed large-value tests. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * math_op: drop the temporary direct-IPP tier for exp/log Upstream moved the IPP math wrappers into the hal/ipp HAL module (cv_hal_exp32f/ log32f & co now resolve to ipp_hal_* which honor cv::ipp::useIPP via CV_HAL_CHECK_USE_IPP). The engine's single probeHalUnary(cv_hal_*) probe already picks that up uniformly, so the stopgap #ifdef HAVE_IPP ippExp/ippLog tier and its ipp::useIPP() branch in getMathFunc are now redundant - removed. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * arithm: restore cv::hal::and8u/or8u/xor8u/not8u as engine wrappers These public CV_EXPORTS entry points (core/hal/hal.hpp) lost their definitions when the bitwise ops moved to the element-wise engine, but they are still declared and called by other modules (opencv_objdetect's aruco) and external code - the link broke with undefined references to cv::hal::and8u/xor8u. Restore them as thin forwarders over the engine's byte-wise bitwise kernels (getBitwiseFunc / getNotFunc), mirroring the existing mul8u wrapper. CV_Assert guards the kernel lookup. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * blobdetector: guard empty contour when computing blob radius The new AutoBuffer leaves its tail uninitialized for trivial types, which surfaced a -Wmaybe-uninitialized in findBlobs where the median of per-point distances is read. Use a std::vector, default the radius to 0, and compute the median only for a non-empty contour - no unproven size invariant. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
1665 lines
53 KiB
C++
1665 lines
53 KiB
C++
/*M///////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
|
//
|
|
// By downloading, copying, installing or using the software you agree to this license.
|
|
// If you do not agree to this license, do not download, install,
|
|
// copy or use the software.
|
|
//
|
|
//
|
|
// License Agreement
|
|
// For Open Source Computer Vision Library
|
|
//
|
|
// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
|
|
// Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
|
|
// Copyright (C) 2014-2015, Itseez Inc., all rights reserved.
|
|
// Third party copyrights are property of their respective owners.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without modification,
|
|
// are permitted provided that the following conditions are met:
|
|
//
|
|
// * Redistribution's of source code must retain the above copyright notice,
|
|
// this list of conditions and the following disclaimer.
|
|
//
|
|
// * Redistribution's in binary form must reproduce the above copyright notice,
|
|
// this list of conditions and the following disclaimer in the documentation
|
|
// and/or other materials provided with the distribution.
|
|
//
|
|
// * The name of the copyright holders may not be used to endorse or promote products
|
|
// derived from this software without specific prior written permission.
|
|
//
|
|
// This software is provided by the copyright holders and contributors "as is" and
|
|
// any express or implied warranties, including, but not limited to, the implied
|
|
// warranties of merchantability and fitness for a particular purpose are disclaimed.
|
|
// In no event shall the Intel Corporation or contributors be liable for any direct,
|
|
// indirect, incidental, special, exemplary, or consequential damages
|
|
// (including, but not limited to, procurement of substitute goods or services;
|
|
// loss of use, data, or profits; or business interruption) however caused
|
|
// and on any theory of liability, whether in contract, strict liability,
|
|
// or tort (including negligence or otherwise) arising in any way out of
|
|
// the use of this software, even if advised of the possibility of such damage.
|
|
//
|
|
//M*/
|
|
|
|
#include "precomp.hpp"
|
|
#include "opencl_kernels_core.hpp"
|
|
#include <atomic>
|
|
#include <limits>
|
|
#include <iostream>
|
|
#include <algorithm>
|
|
#include <cmath>
|
|
#include "mathfuncs.hpp"
|
|
#include "arithm_expr.hpp" // the element-wise engine: getMathFunc + TExpr for cv::exp/log/sqrt
|
|
|
|
namespace cv
|
|
{
|
|
|
|
typedef void (*MathFunc)(const void* src, void* dst, int len);
|
|
|
|
#ifdef HAVE_OPENCL
|
|
|
|
enum { OCL_OP_LOG=0, OCL_OP_EXP=1, OCL_OP_MAG=2, OCL_OP_PHASE_DEGREES=3, OCL_OP_PHASE_RADIANS=4 };
|
|
|
|
static const char* oclop2str[] = { "OP_LOG", "OP_EXP", "OP_MAG", "OP_PHASE_DEGREES", "OP_PHASE_RADIANS", 0 };
|
|
|
|
static bool ocl_math_op(InputArray _src1, InputArray _src2, OutputArray _dst, int oclop)
|
|
{
|
|
int type = _src1.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
|
|
int kercn = oclop == OCL_OP_PHASE_DEGREES ||
|
|
oclop == OCL_OP_PHASE_RADIANS ? 1 : ocl::predictOptimalVectorWidth(_src1, _src2, _dst);
|
|
|
|
const ocl::Device d = ocl::Device::getDefault();
|
|
bool double_support = d.doubleFPConfig() > 0;
|
|
if (!double_support && depth == CV_64F)
|
|
return false;
|
|
int rowsPerWI = d.isIntel() ? 4 : 1;
|
|
|
|
ocl::Kernel k("KF", ocl::core::arithm_oclsrc,
|
|
format("-D %s -D %s -D dstT=%s -D DEPTH_dst=%d -D rowsPerWI=%d%s", _src2.empty() ? "UNARY_OP" : "BINARY_OP",
|
|
oclop2str[oclop], ocl::typeToStr(CV_MAKE_TYPE(depth, kercn)), depth, rowsPerWI,
|
|
double_support ? " -D DOUBLE_SUPPORT" : ""));
|
|
if (k.empty())
|
|
return false;
|
|
|
|
UMat src1 = _src1.getUMat(), src2 = _src2.getUMat();
|
|
_dst.createSameSize(src1, type);
|
|
UMat dst = _dst.getUMat();
|
|
|
|
ocl::KernelArg src1arg = ocl::KernelArg::ReadOnlyNoSize(src1),
|
|
src2arg = ocl::KernelArg::ReadOnlyNoSize(src2),
|
|
dstarg = ocl::KernelArg::WriteOnly(dst, cn, kercn);
|
|
|
|
if (src2.empty())
|
|
k.args(src1arg, dstarg);
|
|
else
|
|
k.args(src1arg, src2arg, dstarg);
|
|
|
|
size_t globalsize[] = { (size_t)src1.cols * cn / kercn, ((size_t)src1.rows + rowsPerWI - 1) / rowsPerWI };
|
|
return k.run(2, globalsize, 0, false);
|
|
}
|
|
|
|
#endif
|
|
|
|
/* ************************************************************************** *\
|
|
Fast cube root by Ken Turkowski
|
|
(http://www.worldserver.com/turk/computergraphics/papers.html)
|
|
\* ************************************************************************** */
|
|
CV_DISABLE_UBSAN float cubeRoot( float value )
|
|
{
|
|
CV_INSTRUMENT_REGION();
|
|
|
|
float fr;
|
|
Cv32suf v, m;
|
|
int ix, s;
|
|
int ex, shx;
|
|
|
|
v.f = value;
|
|
ix = v.i & 0x7fffffff;
|
|
s = v.i & 0x80000000;
|
|
ex = (ix >> 23) - 127;
|
|
shx = ex % 3;
|
|
shx -= shx >= 0 ? 3 : 0;
|
|
ex = (ex - shx) / 3; /* exponent of cube root */
|
|
v.i = (ix & ((1<<23)-1)) | ((shx + 127)<<23);
|
|
fr = v.f;
|
|
|
|
/* 0.125 <= fr < 1.0 */
|
|
/* Use quartic rational polynomial with error < 2^(-24) */
|
|
fr = (float)(((((45.2548339756803022511987494 * fr +
|
|
192.2798368355061050458134625) * fr +
|
|
119.1654824285581628956914143) * fr +
|
|
13.43250139086239872172837314) * fr +
|
|
0.1636161226585754240958355063)/
|
|
((((14.80884093219134573786480845 * fr +
|
|
151.9714051044435648658557668) * fr +
|
|
168.5254414101568283957668343) * fr +
|
|
33.9905941350215598754191872) * fr +
|
|
1.0));
|
|
|
|
/* fr *= 2^ex * sign */
|
|
m.f = value;
|
|
v.f = fr;
|
|
v.i = (v.i + (ex << 23) + s) & (m.i*2 != 0 ? -1 : 0);
|
|
return v.f;
|
|
}
|
|
|
|
/****************************************************************************************\
|
|
* Cartezian -> Polar *
|
|
\****************************************************************************************/
|
|
|
|
void magnitude( InputArray src1, InputArray src2, OutputArray dst )
|
|
{
|
|
CV_INSTRUMENT_REGION();
|
|
|
|
int type = src1.type(), depth = src1.depth(), cn = src1.channels();
|
|
CV_Assert( src1.size() == src2.size() && type == src2.type() && (depth == CV_32F || depth == CV_64F));
|
|
|
|
CV_OCL_RUN(dst.isUMat() && src1.dims() <= 2 && src2.dims() <= 2,
|
|
ocl_math_op(src1, src2, dst, OCL_OP_MAG))
|
|
|
|
Mat X = src1.getMat(), Y = src2.getMat();
|
|
dst.create(X.size, X.type());
|
|
Mat Mag = dst.getMat();
|
|
|
|
const Mat* arrays[] = {&X, &Y, &Mag, 0};
|
|
uchar* ptrs[3] = {};
|
|
NAryMatIterator it(arrays, ptrs);
|
|
int len = (int)it.size*cn;
|
|
|
|
for( size_t i = 0; i < it.nplanes; i++, ++it )
|
|
{
|
|
if( depth == CV_32F )
|
|
{
|
|
const float *x = (const float*)ptrs[0], *y = (const float*)ptrs[1];
|
|
float *mag = (float*)ptrs[2];
|
|
hal::magnitude32f( x, y, mag, len );
|
|
}
|
|
else
|
|
{
|
|
const double *x = (const double*)ptrs[0], *y = (const double*)ptrs[1];
|
|
double *mag = (double*)ptrs[2];
|
|
hal::magnitude64f( x, y, mag, len );
|
|
}
|
|
}
|
|
}
|
|
|
|
void phase( InputArray src1, InputArray src2, OutputArray dst, bool angleInDegrees )
|
|
{
|
|
CV_INSTRUMENT_REGION();
|
|
|
|
int type = src1.type(), depth = src1.depth(), cn = src1.channels();
|
|
CV_Assert( src1.size() == src2.size() && type == src2.type() && (depth == CV_32F || depth == CV_64F));
|
|
|
|
CV_OCL_RUN(dst.isUMat() && src1.dims() <= 2 && src2.dims() <= 2,
|
|
ocl_math_op(src1, src2, dst, angleInDegrees ? OCL_OP_PHASE_DEGREES : OCL_OP_PHASE_RADIANS))
|
|
|
|
Mat X = src1.getMat(), Y = src2.getMat();
|
|
dst.create( X.size, type );
|
|
Mat Angle = dst.getMat();
|
|
|
|
const Mat* arrays[] = {&X, &Y, &Angle, 0};
|
|
uchar* ptrs[3] = {};
|
|
NAryMatIterator it(arrays, ptrs);
|
|
int j, total = (int)(it.size*cn), blockSize = total;
|
|
size_t esz1 = X.elemSize1();
|
|
for( size_t i = 0; i < it.nplanes; i++, ++it )
|
|
{
|
|
for( j = 0; j < total; j += blockSize )
|
|
{
|
|
int len = std::min(total - j, blockSize);
|
|
if( depth == CV_32F )
|
|
{
|
|
const float *x = (const float*)ptrs[0], *y = (const float*)ptrs[1];
|
|
float *angle = (float*)ptrs[2];
|
|
hal::fastAtan32f( y, x, angle, len, angleInDegrees );
|
|
}
|
|
else
|
|
{
|
|
const double *x = (const double*)ptrs[0], *y = (const double*)ptrs[1];
|
|
double *angle = (double*)ptrs[2];
|
|
hal::fastAtan64f(y, x, angle, len, angleInDegrees);
|
|
}
|
|
ptrs[0] += len*esz1;
|
|
ptrs[1] += len*esz1;
|
|
ptrs[2] += len*esz1;
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef HAVE_OPENCL
|
|
|
|
static bool ocl_cartToPolar( InputArray _src1, InputArray _src2,
|
|
OutputArray _dst1, OutputArray _dst2, bool angleInDegrees )
|
|
{
|
|
const ocl::Device & d = ocl::Device::getDefault();
|
|
int type = _src1.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type),
|
|
rowsPerWI = d.isIntel() ? 4 : 1;
|
|
bool doubleSupport = d.doubleFPConfig() > 0;
|
|
|
|
const bool _src1IsDstMag = (_src1.getObj() == _dst1.getObj());
|
|
const bool _src1IsDstAngle = (_src1.getObj() == _dst2.getObj());
|
|
const bool _src2IsDstMag = (_src2.getObj() == _dst1.getObj());
|
|
const bool _src2IsDstAngle = (_src2.getObj() == _dst2.getObj());
|
|
|
|
if ( !(_src1.dims() <= 2 && _src2.dims() <= 2 &&
|
|
(depth == CV_32F || depth == CV_64F) && type == _src2.type()) ||
|
|
(depth == CV_64F && !doubleSupport) )
|
|
return false;
|
|
|
|
ocl::Kernel k("KF", ocl::core::arithm_oclsrc,
|
|
format("-D BINARY_OP -D dstT=%s -D DEPTH_dst=%d -D rowsPerWI=%d -D OP_CTP_%s%s%s%s%s%s",
|
|
ocl::typeToStr(CV_MAKE_TYPE(depth, 1)), depth,
|
|
rowsPerWI, angleInDegrees ? "AD" : "AR",
|
|
doubleSupport ? " -D DOUBLE_SUPPORT" : "",
|
|
_src1IsDstMag ? " -D SRC1_IS_DST_MAG" : "",
|
|
_src1IsDstAngle ? " -D SRC1_IS_DST_ANGLE" : "",
|
|
_src2IsDstMag ? " -D SRC2_IS_DST_MAG" : "",
|
|
_src2IsDstAngle ? " -D SRC2_IS_DST_ANGLE" : ""
|
|
));
|
|
if (k.empty())
|
|
return false;
|
|
|
|
UMat src1 = _src1.getUMat(), src2 = _src2.getUMat();
|
|
Size size = src1.size();
|
|
CV_Assert( size == src2.size() );
|
|
|
|
_dst1.create(size, type);
|
|
_dst2.create(size, type);
|
|
UMat dst1 = _dst1.getUMat(), dst2 = _dst2.getUMat();
|
|
|
|
k.args(_src1IsDstMag || _src1IsDstAngle ? ocl::KernelArg::ReadWriteNoSize(src1) : ocl::KernelArg::ReadOnlyNoSize(src1),
|
|
_src2IsDstMag || _src2IsDstAngle ? ocl::KernelArg::ReadWriteNoSize(src2) : ocl::KernelArg::ReadOnlyNoSize(src2),
|
|
ocl::KernelArg::WriteOnly(dst1, cn),
|
|
ocl::KernelArg::WriteOnlyNoSize(dst2));
|
|
|
|
size_t globalsize[2] = { (size_t)dst1.cols * cn, ((size_t)dst1.rows + rowsPerWI - 1) / rowsPerWI };
|
|
return k.run(2, globalsize, NULL, false);
|
|
}
|
|
|
|
#endif
|
|
|
|
void cartToPolar( InputArray src1, InputArray src2,
|
|
OutputArray dst1, OutputArray dst2, bool angleInDegrees )
|
|
{
|
|
CV_INSTRUMENT_REGION();
|
|
|
|
CV_Assert(dst1.getObj() != dst2.getObj());
|
|
|
|
CV_OCL_RUN(dst1.isUMat() && dst2.isUMat(),
|
|
ocl_cartToPolar(src1, src2, dst1, dst2, angleInDegrees))
|
|
|
|
Mat X = src1.getMat(), Y = src2.getMat();
|
|
int type = X.type(), depth = X.depth(), cn = X.channels();
|
|
CV_Assert( X.size == Y.size && type == Y.type() && (depth == CV_32F || depth == CV_64F));
|
|
dst1.create( X.size, type );
|
|
dst2.create( X.size, type );
|
|
Mat Mag = dst1.getMat(), Angle = dst2.getMat();
|
|
|
|
const Mat* arrays[] = {&X, &Y, &Mag, &Angle, 0};
|
|
uchar* ptrs[4] = {};
|
|
NAryMatIterator it(arrays, ptrs);
|
|
int j, total = (int)(it.size*cn), blockSize = std::min(total, ((BLOCK_SIZE+cn-1)/cn)*cn);
|
|
size_t esz1 = X.elemSize1();
|
|
|
|
for( size_t i = 0; i < it.nplanes; i++, ++it )
|
|
{
|
|
for( j = 0; j < total; j += blockSize )
|
|
{
|
|
int len = std::min(total - j, blockSize);
|
|
if( depth == CV_32F )
|
|
{
|
|
const float *x = (const float*)ptrs[0], *y = (const float*)ptrs[1];
|
|
float *mag = (float*)ptrs[2], *angle = (float*)ptrs[3];
|
|
hal::cartToPolar32f( x, y, mag, angle, len, angleInDegrees );
|
|
}
|
|
else
|
|
{
|
|
const double *x = (const double*)ptrs[0], *y = (const double*)ptrs[1];
|
|
double *mag = (double*)ptrs[2], *angle = (double*)ptrs[3];
|
|
hal::cartToPolar64f(x, y, mag, angle, len, angleInDegrees);
|
|
}
|
|
ptrs[0] += len*esz1;
|
|
ptrs[1] += len*esz1;
|
|
ptrs[2] += len*esz1;
|
|
ptrs[3] += len*esz1;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/****************************************************************************************\
|
|
* Polar -> Cartezian *
|
|
\****************************************************************************************/
|
|
|
|
#ifdef HAVE_OPENCL
|
|
|
|
static bool ocl_polarToCart( InputArray _mag, InputArray _angle,
|
|
OutputArray _dst1, OutputArray _dst2, bool angleInDegrees )
|
|
{
|
|
const ocl::Device & d = ocl::Device::getDefault();
|
|
int type = _angle.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type),
|
|
rowsPerWI = d.isIntel() ? 4 : 1;
|
|
bool doubleSupport = d.doubleFPConfig() > 0;
|
|
|
|
const bool _src1IsDstX = (_mag.getObj() == _dst1.getObj());
|
|
const bool _src1IsDstY = (_mag.getObj() == _dst2.getObj());
|
|
const bool _src2IsDstX = (_angle.getObj() == _dst1.getObj());
|
|
const bool _src2IsDstY = (_angle.getObj() == _dst2.getObj());
|
|
|
|
if ( !doubleSupport && depth == CV_64F )
|
|
return false;
|
|
|
|
ocl::Kernel k("KF", ocl::core::arithm_oclsrc,
|
|
format("-D dstT=%s -D DEPTH_dst=%d -D rowsPerWI=%d -D BINARY_OP -D OP_PTC_%s%s%s%s%s%s",
|
|
ocl::typeToStr(CV_MAKE_TYPE(depth, 1)), depth,
|
|
rowsPerWI,
|
|
angleInDegrees ? "AD" : "AR",
|
|
doubleSupport ? " -D DOUBLE_SUPPORT" : "",
|
|
_src1IsDstX ? " -D SRC1_IS_DST_X" : "",
|
|
_src1IsDstY ? " -D SRC1_IS_DST_Y" : "",
|
|
_src2IsDstX ? " -D SRC2_IS_DST_X" : "",
|
|
_src2IsDstY ? " -D SRC2_IS_DST_Y" : ""));
|
|
if (k.empty())
|
|
return false;
|
|
|
|
UMat mag = _mag.getUMat(), angle = _angle.getUMat();
|
|
Size size = angle.size();
|
|
CV_Assert(mag.size() == size);
|
|
|
|
_dst1.create(size, type);
|
|
_dst2.create(size, type);
|
|
UMat dst1 = _dst1.getUMat(), dst2 = _dst2.getUMat();
|
|
|
|
k.args(_src1IsDstX || _src1IsDstY ? ocl::KernelArg::ReadWriteNoSize(mag) : ocl::KernelArg::ReadOnlyNoSize(mag),
|
|
_src2IsDstX || _src2IsDstY ? ocl::KernelArg::ReadWriteNoSize(angle) : ocl::KernelArg::ReadOnlyNoSize(angle),
|
|
ocl::KernelArg::WriteOnly(dst1, cn),
|
|
ocl::KernelArg::WriteOnlyNoSize(dst2));
|
|
|
|
size_t globalsize[2] = { (size_t)dst1.cols * cn, ((size_t)dst1.rows + rowsPerWI - 1) / rowsPerWI };
|
|
return k.run(2, globalsize, NULL, false);
|
|
}
|
|
|
|
#endif
|
|
|
|
void polarToCart( InputArray src1, InputArray src2,
|
|
OutputArray dst1, OutputArray dst2, bool angleInDegrees )
|
|
{
|
|
CV_INSTRUMENT_REGION();
|
|
|
|
CV_Assert(dst1.getObj() != dst2.getObj());
|
|
|
|
int type = src2.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
|
|
CV_Assert((depth == CV_32F || depth == CV_64F) && (src1.empty() || src1.type() == type));
|
|
|
|
CV_OCL_RUN(!src1.empty() && src2.dims() <= 2 && dst1.isUMat() && dst2.isUMat(),
|
|
ocl_polarToCart(src1, src2, dst1, dst2, angleInDegrees))
|
|
|
|
Mat Mag = src1.getMat(), Angle = src2.getMat();
|
|
CV_Assert( Mag.empty() || Angle.size == Mag.size);
|
|
dst1.create( Angle.size, type );
|
|
dst2.create( Angle.size, type );
|
|
Mat X = dst1.getMat(), Y = dst2.getMat();
|
|
|
|
const Mat* arrays[] = {&Mag, &Angle, &X, &Y, 0};
|
|
uchar* ptrs[4] = {};
|
|
NAryMatIterator it(arrays, ptrs);
|
|
int j, total = (int)(it.size*cn), blockSize = std::min(total, ((BLOCK_SIZE+cn-1)/cn)*cn);
|
|
size_t esz1 = Angle.elemSize1();
|
|
|
|
for( size_t i = 0; i < it.nplanes; i++, ++it )
|
|
{
|
|
for( j = 0; j < total; j += blockSize )
|
|
{
|
|
int len = std::min(total - j, blockSize);
|
|
if ( depth == CV_32F )
|
|
{
|
|
const float *mag = (const float*)ptrs[0], *angle = (const float*)ptrs[1];
|
|
float *x = (float*)ptrs[2], *y = (float*)ptrs[3];
|
|
hal::polarToCart32f( mag, angle, x, y, len, angleInDegrees );
|
|
}
|
|
else
|
|
{
|
|
const double *mag = (const double*)ptrs[0], *angle = (const double*)ptrs[1];
|
|
double *x = (double*)ptrs[2], *y = (double*)ptrs[3];
|
|
hal::polarToCart64f( mag, angle, x, y, len, angleInDegrees );
|
|
}
|
|
|
|
if( ptrs[0] )
|
|
ptrs[0] += len*esz1;
|
|
ptrs[1] += len*esz1;
|
|
ptrs[2] += len*esz1;
|
|
ptrs[3] += len*esz1;
|
|
}
|
|
}
|
|
}
|
|
|
|
/****************************************************************************************\
|
|
* E X P *
|
|
\****************************************************************************************/
|
|
|
|
// The master function of the unary math family (cv::exp/log/sqrt - the analogue of arithm_op):
|
|
// same-shape same-type output over the four float depths, computed by the element-wise engine's
|
|
// kernels (math.simd.hpp). Two tiers:
|
|
// - SMALL and continuous (a common pattern - exp() over one image row as a lookup substitute):
|
|
// call the kernel DIRECTLY over the flattened elements. No TExpr, no broadcastOp, no
|
|
// parallel_for machinery - their setup dominates at these sizes.
|
|
// - everything else (large arrays - worth parallelizing; ROIs - need real steps): the usual
|
|
// 1-instruction program via compile()/exec().
|
|
enum { MATH_OP_SMALL = 100000 }; // elements; tune with a benchmark if the crossover moves
|
|
|
|
static void math_op(ew::TOp op, InputArray _src, OutputArray _dst)
|
|
{
|
|
int type = _src.type(), depth = CV_MAT_DEPTH(type);
|
|
CV_Assert(depth == CV_16F || depth == CV_16BF || depth == CV_32F || depth == CV_64F);
|
|
|
|
Mat src = _src.getMat();
|
|
_dst.createSameSize(_src, type); // whole-shape transfer (layout & future metadata included)
|
|
Mat dst = _dst.getMat();
|
|
if (src.empty())
|
|
return;
|
|
|
|
const size_t total = src.total() * src.channels();
|
|
if (src.isContinuous() && dst.isContinuous() && total <= (size_t)MATH_OP_SMALL)
|
|
{
|
|
ew::TKernel k = ew::getMathFunc(op, depth);
|
|
CV_Assert(k.fptr);
|
|
static const double noparams[4] = {};
|
|
k.fptr(src.data, 0, 1, nullptr, 0, 0, nullptr, 0, 0,
|
|
dst.data, 0, (int)total, 1, noparams, k.flags, k.userdata);
|
|
return;
|
|
}
|
|
|
|
ew::TExpr p;
|
|
const int a = p.addInput(depth);
|
|
const int out = p.addOutput(depth);
|
|
p.moveToOutput(p.emitUnary(op, a, depth), out);
|
|
p.compile();
|
|
const Mat* inputs[] = { &src };
|
|
p.exec(inputs, &dst);
|
|
}
|
|
|
|
void exp( InputArray _src, OutputArray _dst )
|
|
{
|
|
CV_INSTRUMENT_REGION();
|
|
|
|
[[maybe_unused]] int depth = _src.depth(); // consumed by CV_OCL_RUN only
|
|
|
|
CV_OCL_RUN(_dst.isUMat() && _src.dims() <= 2 && (depth == CV_32F || depth == CV_64F),
|
|
ocl_math_op(_src, noArray(), _dst, OCL_OP_EXP))
|
|
|
|
math_op(ew::OP_EXP, _src, _dst);
|
|
}
|
|
|
|
|
|
/****************************************************************************************\
|
|
* L O G *
|
|
\****************************************************************************************/
|
|
|
|
void log( InputArray _src, OutputArray _dst )
|
|
{
|
|
CV_INSTRUMENT_REGION();
|
|
|
|
[[maybe_unused]] int depth = _src.depth(); // consumed by CV_OCL_RUN only
|
|
|
|
CV_OCL_RUN( _dst.isUMat() && _src.dims() <= 2 && (depth == CV_32F || depth == CV_64F),
|
|
ocl_math_op(_src, noArray(), _dst, OCL_OP_LOG))
|
|
|
|
math_op(ew::OP_LOG, _src, _dst);
|
|
}
|
|
|
|
/****************************************************************************************\
|
|
* P O W E R *
|
|
\****************************************************************************************/
|
|
|
|
template <typename T, typename WT>
|
|
struct iPow_SIMD
|
|
{
|
|
int operator() ( const T *, T *, int, int)
|
|
{
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
#if (CV_SIMD || CV_SIMD_SCALABLE)
|
|
|
|
template <>
|
|
struct iPow_SIMD<uchar, unsigned>
|
|
{
|
|
int operator() ( const uchar * src, uchar * dst, int len, int power )
|
|
{
|
|
int i = 0;
|
|
v_uint32 v_1 = vx_setall_u32(1u);
|
|
|
|
for ( ; i <= len - VTraits<v_uint16>::vlanes(); i += VTraits<v_uint16>::vlanes())
|
|
{
|
|
v_uint32 v_a1 = v_1, v_a2 = v_1;
|
|
v_uint16 v = vx_load_expand(src + i);
|
|
v_uint32 v_b1, v_b2;
|
|
v_expand(v, v_b1, v_b2);
|
|
int p = power;
|
|
|
|
while( p > 1 )
|
|
{
|
|
if (p & 1)
|
|
{
|
|
v_a1 = v_mul(v_a1, v_b1);
|
|
v_a2 = v_mul(v_a2, v_b2);
|
|
}
|
|
v_b1 = v_mul(v_b1, v_b1);
|
|
v_b2 = v_mul(v_b2, v_b2);
|
|
p >>= 1;
|
|
}
|
|
|
|
v_a1 = v_mul(v_a1, v_b1);
|
|
v_a2 = v_mul(v_a2, v_b2);
|
|
|
|
v = v_pack(v_a1, v_a2);
|
|
v_pack_store(dst + i, v);
|
|
}
|
|
vx_cleanup();
|
|
|
|
return i;
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct iPow_SIMD<schar, int>
|
|
{
|
|
int operator() ( const schar * src, schar * dst, int len, int power)
|
|
{
|
|
int i = 0;
|
|
v_int32 v_1 = vx_setall_s32(1);
|
|
|
|
for ( ; i <= len - VTraits<v_int16>::vlanes(); i += VTraits<v_int16>::vlanes())
|
|
{
|
|
v_int32 v_a1 = v_1, v_a2 = v_1;
|
|
v_int16 v = vx_load_expand(src + i);
|
|
v_int32 v_b1, v_b2;
|
|
v_expand(v, v_b1, v_b2);
|
|
int p = power;
|
|
|
|
while( p > 1 )
|
|
{
|
|
if (p & 1)
|
|
{
|
|
v_a1 = v_mul(v_a1, v_b1);
|
|
v_a2 = v_mul(v_a2, v_b2);
|
|
}
|
|
v_b1 = v_mul(v_b1, v_b1);
|
|
v_b2 = v_mul(v_b2, v_b2);
|
|
p >>= 1;
|
|
}
|
|
|
|
v_a1 = v_mul(v_a1, v_b1);
|
|
v_a2 = v_mul(v_a2, v_b2);
|
|
|
|
v = v_pack(v_a1, v_a2);
|
|
v_pack_store(dst + i, v);
|
|
}
|
|
vx_cleanup();
|
|
|
|
return i;
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct iPow_SIMD<ushort, unsigned>
|
|
{
|
|
int operator() ( const ushort * src, ushort * dst, int len, int power)
|
|
{
|
|
int i = 0;
|
|
v_uint32 v_1 = vx_setall_u32(1u);
|
|
|
|
for ( ; i <= len - VTraits<v_uint16>::vlanes(); i += VTraits<v_uint16>::vlanes())
|
|
{
|
|
v_uint32 v_a1 = v_1, v_a2 = v_1;
|
|
v_uint16 v = vx_load(src + i);
|
|
v_uint32 v_b1, v_b2;
|
|
v_expand(v, v_b1, v_b2);
|
|
int p = power;
|
|
|
|
while( p > 1 )
|
|
{
|
|
if (p & 1)
|
|
{
|
|
v_a1 = v_mul(v_a1, v_b1);
|
|
v_a2 = v_mul(v_a2, v_b2);
|
|
}
|
|
v_b1 = v_mul(v_b1, v_b1);
|
|
v_b2 = v_mul(v_b2, v_b2);
|
|
p >>= 1;
|
|
}
|
|
|
|
v_a1 = v_mul(v_a1, v_b1);
|
|
v_a2 = v_mul(v_a2, v_b2);
|
|
|
|
v = v_pack(v_a1, v_a2);
|
|
v_store(dst + i, v);
|
|
}
|
|
vx_cleanup();
|
|
|
|
return i;
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct iPow_SIMD<short, int>
|
|
{
|
|
int operator() ( const short * src, short * dst, int len, int power)
|
|
{
|
|
int i = 0;
|
|
v_int32 v_1 = vx_setall_s32(1);
|
|
|
|
for ( ; i <= len - VTraits<v_int16>::vlanes(); i += VTraits<v_int16>::vlanes())
|
|
{
|
|
v_int32 v_a1 = v_1, v_a2 = v_1;
|
|
v_int16 v = vx_load(src + i);
|
|
v_int32 v_b1, v_b2;
|
|
v_expand(v, v_b1, v_b2);
|
|
int p = power;
|
|
|
|
while( p > 1 )
|
|
{
|
|
if (p & 1)
|
|
{
|
|
v_a1 = v_mul(v_a1, v_b1);
|
|
v_a2 = v_mul(v_a2, v_b2);
|
|
}
|
|
v_b1 = v_mul(v_b1, v_b1);
|
|
v_b2 = v_mul(v_b2, v_b2);
|
|
p >>= 1;
|
|
}
|
|
|
|
v_a1 = v_mul(v_a1, v_b1);
|
|
v_a2 = v_mul(v_a2, v_b2);
|
|
|
|
v = v_pack(v_a1, v_a2);
|
|
v_store(dst + i, v);
|
|
}
|
|
vx_cleanup();
|
|
|
|
return i;
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct iPow_SIMD<int, int>
|
|
{
|
|
int operator() ( const int * src, int * dst, int len, int power)
|
|
{
|
|
int i = 0;
|
|
v_int32 v_1 = vx_setall_s32(1);
|
|
|
|
for ( ; i <= len - VTraits<v_int32>::vlanes()*2; i += VTraits<v_int32>::vlanes()*2)
|
|
{
|
|
v_int32 v_a1 = v_1, v_a2 = v_1;
|
|
v_int32 v_b1 = vx_load(src + i), v_b2 = vx_load(src + i + VTraits<v_int32>::vlanes());
|
|
int p = power;
|
|
|
|
while( p > 1 )
|
|
{
|
|
if (p & 1)
|
|
{
|
|
v_a1 = v_mul(v_a1, v_b1);
|
|
v_a2 = v_mul(v_a2, v_b2);
|
|
}
|
|
v_b1 = v_mul(v_b1, v_b1);
|
|
v_b2 = v_mul(v_b2, v_b2);
|
|
p >>= 1;
|
|
}
|
|
|
|
v_a1 = v_mul(v_a1, v_b1);
|
|
v_a2 = v_mul(v_a2, v_b2);
|
|
|
|
v_store(dst + i, v_a1);
|
|
v_store(dst + i + VTraits<v_int32>::vlanes(), v_a2);
|
|
}
|
|
vx_cleanup();
|
|
|
|
return i;
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct iPow_SIMD<float, float>
|
|
{
|
|
int operator() ( const float * src, float * dst, int len, int power)
|
|
{
|
|
int i = 0;
|
|
v_float32 v_1 = vx_setall_f32(1.f);
|
|
|
|
for ( ; i <= len - VTraits<v_float32>::vlanes()*2; i += VTraits<v_float32>::vlanes()*2)
|
|
{
|
|
v_float32 v_a1 = v_1, v_a2 = v_1;
|
|
v_float32 v_b1 = vx_load(src + i), v_b2 = vx_load(src + i + VTraits<v_float32>::vlanes());
|
|
int p = std::abs(power);
|
|
if( power < 0 )
|
|
{
|
|
v_b1 = v_div(v_1, v_b1);
|
|
v_b2 = v_div(v_1, v_b2);
|
|
}
|
|
|
|
while( p > 1 )
|
|
{
|
|
if (p & 1)
|
|
{
|
|
v_a1 = v_mul(v_a1, v_b1);
|
|
v_a2 = v_mul(v_a2, v_b2);
|
|
}
|
|
v_b1 = v_mul(v_b1, v_b1);
|
|
v_b2 = v_mul(v_b2, v_b2);
|
|
p >>= 1;
|
|
}
|
|
|
|
v_a1 = v_mul(v_a1, v_b1);
|
|
v_a2 = v_mul(v_a2, v_b2);
|
|
|
|
v_store(dst + i, v_a1);
|
|
v_store(dst + i + VTraits<v_float32>::vlanes(), v_a2);
|
|
}
|
|
vx_cleanup();
|
|
|
|
return i;
|
|
}
|
|
};
|
|
|
|
#if (CV_SIMD_64F || CV_SIMD_SCALABLE_64F)
|
|
template <>
|
|
struct iPow_SIMD<double, double>
|
|
{
|
|
int operator() ( const double * src, double * dst, int len, int power)
|
|
{
|
|
int i = 0;
|
|
v_float64 v_1 = vx_setall_f64(1.);
|
|
|
|
for ( ; i <= len - VTraits<v_float64>::vlanes()*2; i += VTraits<v_float64>::vlanes()*2)
|
|
{
|
|
v_float64 v_a1 = v_1, v_a2 = v_1;
|
|
v_float64 v_b1 = vx_load(src + i), v_b2 = vx_load(src + i + VTraits<v_float64>::vlanes());
|
|
int p = std::abs(power);
|
|
if( power < 0 )
|
|
{
|
|
v_b1 = v_div(v_1, v_b1);
|
|
v_b2 = v_div(v_1, v_b2);
|
|
}
|
|
|
|
while( p > 1 )
|
|
{
|
|
if (p & 1)
|
|
{
|
|
v_a1 = v_mul(v_a1, v_b1);
|
|
v_a2 = v_mul(v_a2, v_b2);
|
|
}
|
|
v_b1 = v_mul(v_b1, v_b1);
|
|
v_b2 = v_mul(v_b2, v_b2);
|
|
p >>= 1;
|
|
}
|
|
|
|
v_a1 = v_mul(v_a1, v_b1);
|
|
v_a2 = v_mul(v_a2, v_b2);
|
|
|
|
v_store(dst + i, v_a1);
|
|
v_store(dst + i + VTraits<v_float64>::vlanes(), v_a2);
|
|
}
|
|
vx_cleanup();
|
|
|
|
return i;
|
|
}
|
|
};
|
|
#endif
|
|
|
|
#endif
|
|
|
|
template<typename T, typename WT>
|
|
static void
|
|
iPow_i( const T* src, T* dst, int len, int power )
|
|
{
|
|
if( power < 0 )
|
|
{
|
|
T tab[5] =
|
|
{
|
|
saturate_cast<T>(power == -1 ? -1 : 0), saturate_cast<T>((power & 1) ? -1 : 1),
|
|
std::numeric_limits<T>::max(), 1, saturate_cast<T>(power == -1 ? 1 : 0)
|
|
};
|
|
for( int i = 0; i < len; i++ )
|
|
{
|
|
T val = src[i];
|
|
dst[i] = cv_abs(val) <= 2 ? tab[val + 2] : (T)0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
iPow_SIMD<T, WT> vop;
|
|
int i = vop(src, dst, len, power);
|
|
|
|
for( ; i < len; i++ )
|
|
{
|
|
WT a = 1, b = src[i];
|
|
int p = power;
|
|
while( p > 1 )
|
|
{
|
|
if( p & 1 )
|
|
a *= b;
|
|
b *= b;
|
|
p >>= 1;
|
|
}
|
|
|
|
a *= b;
|
|
dst[i] = saturate_cast<T>(a);
|
|
}
|
|
}
|
|
}
|
|
|
|
template<typename T>
|
|
static void
|
|
iPow_f( const T* src, T* dst, int len, int power0 )
|
|
{
|
|
iPow_SIMD<T, T> vop;
|
|
int i = vop(src, dst, len, power0);
|
|
int power = std::abs(power0);
|
|
|
|
for( ; i < len; i++ )
|
|
{
|
|
T a = 1, b = src[i];
|
|
int p = power;
|
|
if( power0 < 0 )
|
|
b = 1/b;
|
|
|
|
while( p > 1 )
|
|
{
|
|
if( p & 1 )
|
|
a *= b;
|
|
b *= b;
|
|
p >>= 1;
|
|
}
|
|
|
|
a *= b;
|
|
dst[i] = a;
|
|
}
|
|
}
|
|
|
|
static void iPow8u(const uchar* src, uchar* dst, int len, int power)
|
|
{
|
|
iPow_i<uchar, unsigned>(src, dst, len, power);
|
|
}
|
|
|
|
static void iPow8s(const schar* src, schar* dst, int len, int power)
|
|
{
|
|
iPow_i<schar, int>(src, dst, len, power);
|
|
}
|
|
|
|
static void iPow16u(const ushort* src, ushort* dst, int len, int power)
|
|
{
|
|
iPow_i<ushort, unsigned>(src, dst, len, power);
|
|
}
|
|
|
|
static void iPow16s(const short* src, short* dst, int len, int power)
|
|
{
|
|
iPow_i<short, int>(src, dst, len, power);
|
|
}
|
|
|
|
static void iPow32s(const int* src, int* dst, int len, int power)
|
|
{
|
|
iPow_i<int, int>(src, dst, len, power);
|
|
}
|
|
|
|
static void iPow32f(const float* src, float* dst, int len, int power)
|
|
{
|
|
iPow_f<float>(src, dst, len, power);
|
|
}
|
|
|
|
static void iPow64f(const double* src, double* dst, int len, int power)
|
|
{
|
|
iPow_f<double>(src, dst, len, power);
|
|
}
|
|
|
|
|
|
typedef void (*IPowFunc)( const uchar* src, uchar* dst, int len, int power );
|
|
|
|
static IPowFunc ipowTab[CV_DEPTH_MAX] =
|
|
{
|
|
(IPowFunc)iPow8u, (IPowFunc)iPow8s, (IPowFunc)iPow16u, (IPowFunc)iPow16s,
|
|
(IPowFunc)iPow32s, (IPowFunc)iPow32f, (IPowFunc)iPow64f, 0
|
|
};
|
|
|
|
#ifdef HAVE_OPENCL
|
|
|
|
static bool ocl_pow(InputArray _src, double power, OutputArray _dst,
|
|
bool is_ipower, int ipower)
|
|
{
|
|
const ocl::Device & d = ocl::Device::getDefault();
|
|
int type = _src.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type),
|
|
rowsPerWI = d.isIntel() ? 4 : 1;
|
|
bool doubleSupport = d.doubleFPConfig() > 0;
|
|
|
|
_dst.createSameSize(_src, type);
|
|
if (is_ipower)
|
|
{
|
|
if( ipower < 0 )
|
|
{
|
|
if( depth == CV_32F || depth == CV_64F )
|
|
is_ipower = false;
|
|
else
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (depth == CV_64F && !doubleSupport)
|
|
return false;
|
|
|
|
bool issqrt = std::abs(power - 0.5) < DBL_EPSILON;
|
|
const char * const op = issqrt ? "OP_SQRT" : is_ipower ? "OP_POWN" : "OP_POW";
|
|
|
|
// Note: channels are unrolled
|
|
|
|
std::string extra_opts ="";
|
|
if (is_ipower)
|
|
{
|
|
int wdepth = CV_32F;
|
|
if (depth == CV_64F)
|
|
wdepth = CV_64F;
|
|
else if (depth == CV_16F)
|
|
wdepth = CV_16F;
|
|
|
|
char cvt[2][50];
|
|
extra_opts = format(
|
|
" -D srcT1=%s -DsrcT1_C1=%s"
|
|
" -D srcT2=int -D workST=int"
|
|
" -D workT=%s -D wdepth=%d -D convertToWT1=%s"
|
|
" -D convertToDT=%s"
|
|
" -D workT1=%s",
|
|
ocl::typeToStr(CV_MAKE_TYPE(depth, 1)),
|
|
ocl::typeToStr(CV_MAKE_TYPE(depth, 1)),
|
|
ocl::typeToStr(CV_MAKE_TYPE(wdepth, 1)),
|
|
wdepth,
|
|
ocl::convertTypeStr(depth, wdepth, 1, cvt[0], sizeof(cvt[0])),
|
|
ocl::convertTypeStr(wdepth, depth, 1, cvt[1], sizeof(cvt[1])),
|
|
ocl::typeToStr(wdepth)
|
|
);
|
|
}
|
|
|
|
ocl::Kernel k("KF", ocl::core::arithm_oclsrc,
|
|
format("-D cn=%d -D dstT=%s -D dstT_C1=%s -D DEPTH_dst=%d -D rowsPerWI=%d -D %s%s%s%s",
|
|
1,
|
|
ocl::typeToStr(depth), ocl::typeToStr(depth), depth, rowsPerWI, op,
|
|
" -D UNARY_OP=1",
|
|
extra_opts.empty() ? "" : extra_opts.c_str(),
|
|
doubleSupport ? " -D DOUBLE_SUPPORT" : ""));
|
|
if (k.empty())
|
|
return false;
|
|
|
|
UMat src = _src.getUMat();
|
|
_dst.createSameSize(src, type);
|
|
UMat dst = _dst.getUMat();
|
|
|
|
ocl::KernelArg srcarg = ocl::KernelArg::ReadOnlyNoSize(src),
|
|
dstarg = ocl::KernelArg::WriteOnly(dst, cn);
|
|
|
|
if (issqrt)
|
|
k.args(srcarg, dstarg);
|
|
else if (is_ipower)
|
|
k.args(srcarg, dstarg, ipower);
|
|
else
|
|
{
|
|
if (depth == CV_32F)
|
|
k.args(srcarg, dstarg, (float)power);
|
|
else
|
|
k.args(srcarg, dstarg, power);
|
|
}
|
|
|
|
size_t globalsize[2] = { (size_t)dst.cols * cn, ((size_t)dst.rows + rowsPerWI - 1) / rowsPerWI };
|
|
return k.run(2, globalsize, NULL, false);
|
|
}
|
|
|
|
#endif
|
|
|
|
void pow( InputArray _src, double power, OutputArray _dst )
|
|
{
|
|
CV_INSTRUMENT_REGION();
|
|
|
|
int type = _src.type(), depth = CV_MAT_DEPTH(type),
|
|
cn = CV_MAT_CN(type), ipower = cvRound(power);
|
|
bool is_ipower = fabs(ipower - power) < DBL_EPSILON;
|
|
#ifdef HAVE_OPENCL
|
|
bool useOpenCL = _dst.isUMat() && _src.dims() <= 2;
|
|
#endif
|
|
|
|
if (is_ipower)
|
|
{
|
|
switch( ipower )
|
|
{
|
|
case 0:
|
|
_dst.createSameSize(_src, type);
|
|
_dst.setTo(Scalar::all(1));
|
|
return;
|
|
case 1:
|
|
_src.copyTo(_dst);
|
|
return;
|
|
case 2:
|
|
multiply(_src, _src, _dst);
|
|
return;
|
|
}
|
|
}
|
|
|
|
CV_OCL_RUN(useOpenCL, ocl_pow(_src, power, _dst, is_ipower, ipower))
|
|
|
|
const bool floatDepth = depth == CV_16F || depth == CV_16BF || depth == CV_32F || depth == CV_64F;
|
|
|
|
// INTEGER array ** INTEGER power: keep the classic iPow kernels (an exact multiply chain with
|
|
// the classic wrap-around semantics) - full bit-exact compatibility for whoever relies on it.
|
|
// Everything else - any power on a float array, a fractional power on an integer one (computed
|
|
// in the float domain and saturated back), plus the 32U/64-bit depths iPow never supported -
|
|
// goes through the engine below.
|
|
if( is_ipower && !floatDepth && ipowTab[depth] )
|
|
{
|
|
Mat src = _src.getMat();
|
|
_dst.createSameSize(_src, type);
|
|
Mat dst = _dst.getMat();
|
|
|
|
const Mat* arrays[] = {&src, &dst, 0};
|
|
uchar* ptrs[2] = {};
|
|
NAryMatIterator it(arrays, ptrs);
|
|
int len = (int)(it.size*cn);
|
|
IPowFunc func = ipowTab[depth];
|
|
|
|
for( size_t i = 0; i < it.nplanes; i++, ++it )
|
|
func( ptrs[0], ptrs[1], len, ipower );
|
|
return;
|
|
}
|
|
|
|
// The engine path, two tiers like math_op: the pow kernel special-cases the exponents
|
|
// 3/0.5 (2/1/0 never reach here) per row and vectorizes the general exp(p*log x) with an exact
|
|
// std::pow patch for non-positive bases (0^negative -> inf, negative^fractional -> NaN).
|
|
Mat src = _src.getMat();
|
|
_dst.createSameSize(_src, type);
|
|
Mat dst = _dst.getMat();
|
|
if (src.empty())
|
|
return;
|
|
|
|
const size_t total = src.total() * cn;
|
|
if (floatDepth && src.isContinuous() && dst.isContinuous() && total <= (size_t)MATH_OP_SMALL)
|
|
{
|
|
ew::TKernel k = ew::getPowFunc(depth, depth);
|
|
if (k.fptr)
|
|
{
|
|
double pvstore; // the broadcast exponent, stored as T
|
|
void* pv = &pvstore;
|
|
switch (depth)
|
|
{
|
|
case CV_16F: *(hfloat*)pv = saturate_cast<hfloat>(power); break;
|
|
case CV_16BF: *(bfloat*)pv = saturate_cast<bfloat>(power); break;
|
|
case CV_32F: *(float*)pv = (float)power; break;
|
|
default: pvstore = power; break;
|
|
}
|
|
static const double noparams[4] = {};
|
|
k.fptr(src.data, 0, 1, pv, 0, 0, nullptr, 0, 0,
|
|
dst.data, 0, (int)total, 1, noparams, k.flags, k.userdata);
|
|
return;
|
|
}
|
|
}
|
|
|
|
ew::TExpr prog;
|
|
const int a = prog.addInput(depth);
|
|
const int c = prog.addConst(ew::EW_DEPTH_NONE, Scalar(power), 1);
|
|
const int out = prog.addOutput(depth);
|
|
prog.moveToOutput(prog.emitBinary(ew::OP_POW, a, c, depth), out);
|
|
prog.compile();
|
|
const Mat* inputs[] = { &src };
|
|
prog.exec(inputs, &dst);
|
|
}
|
|
|
|
void sqrt(InputArray a, OutputArray b)
|
|
{
|
|
CV_INSTRUMENT_REGION();
|
|
|
|
if (b.isUMat() && a.dims() <= 2) // the OpenCL route (via ocl_pow) is unchanged
|
|
{
|
|
cv::pow(a, 0.5, b);
|
|
return;
|
|
}
|
|
math_op(ew::OP_SQRT, a, b);
|
|
}
|
|
|
|
/************************** CheckArray for NaN's, Inf's *********************************/
|
|
|
|
template<int cv_mat_type> struct mat_type_assotiations{};
|
|
|
|
template<> struct mat_type_assotiations<CV_8U>
|
|
{
|
|
typedef unsigned char type;
|
|
static const type min_allowable = 0x0;
|
|
static const type max_allowable = 0xFF;
|
|
};
|
|
|
|
template<> struct mat_type_assotiations<CV_8S>
|
|
{
|
|
typedef signed char type;
|
|
static const type min_allowable = SCHAR_MIN;
|
|
static const type max_allowable = SCHAR_MAX;
|
|
};
|
|
|
|
template<> struct mat_type_assotiations<CV_16U>
|
|
{
|
|
typedef unsigned short type;
|
|
static const type min_allowable = 0x0;
|
|
static const type max_allowable = USHRT_MAX;
|
|
};
|
|
template<> struct mat_type_assotiations<CV_16S>
|
|
{
|
|
typedef signed short type;
|
|
static const type min_allowable = SHRT_MIN;
|
|
static const type max_allowable = SHRT_MAX;
|
|
};
|
|
|
|
template<> struct mat_type_assotiations<CV_32S>
|
|
{
|
|
typedef int type;
|
|
static const type min_allowable = (-INT_MAX - 1);
|
|
static const type max_allowable = INT_MAX;
|
|
};
|
|
|
|
template<int depth>
|
|
static bool checkIntegerRange(cv::Mat src, Point& bad_pt, int minVal, int maxVal)
|
|
{
|
|
typedef mat_type_assotiations<depth> type_ass;
|
|
|
|
if (minVal < type_ass::min_allowable && maxVal > type_ass::max_allowable)
|
|
{
|
|
return true;
|
|
}
|
|
else if (minVal > type_ass::max_allowable || maxVal < type_ass::min_allowable || maxVal < minVal)
|
|
{
|
|
bad_pt = cv::Point(0,0);
|
|
return false;
|
|
}
|
|
cv::Mat as_one_channel = src.reshape(1,0);
|
|
|
|
for (int j = 0; j < as_one_channel.rows; ++j)
|
|
for (int i = 0; i < as_one_channel.cols; ++i)
|
|
{
|
|
typename type_ass::type v = as_one_channel.at<typename type_ass::type>(j ,i);
|
|
if (v < minVal || v > maxVal)
|
|
{
|
|
bad_pt.y = j;
|
|
bad_pt.x = i / src.channels();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
typedef bool (*check_range_function)(cv::Mat src, Point& bad_pt, int minVal, int maxVal);
|
|
|
|
check_range_function check_range_functions[] =
|
|
{
|
|
&checkIntegerRange<CV_8U>,
|
|
&checkIntegerRange<CV_8S>,
|
|
&checkIntegerRange<CV_16U>,
|
|
&checkIntegerRange<CV_16S>,
|
|
&checkIntegerRange<CV_32S>
|
|
};
|
|
|
|
bool checkRange(InputArray _src, bool quiet, Point* pt, double minVal, double maxVal)
|
|
{
|
|
CV_INSTRUMENT_REGION();
|
|
|
|
Mat src = _src.getMat();
|
|
|
|
if ( src.dims > 2 )
|
|
{
|
|
CV_Assert(pt == NULL); // no way to provide location info
|
|
|
|
const Mat* arrays[] = {&src, 0};
|
|
Mat planes[1];
|
|
NAryMatIterator it(arrays, planes);
|
|
|
|
for ( size_t i = 0; i < it.nplanes; i++, ++it )
|
|
{
|
|
if (!checkRange( it.planes[0], quiet, NULL, minVal, maxVal ))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
int depth = src.depth();
|
|
Point badPt(-1, -1);
|
|
|
|
if (depth < CV_32F)
|
|
{
|
|
int minVali = minVal <= INT_MIN ? INT_MIN : cvFloor(minVal);
|
|
int maxVali = maxVal > INT_MAX ? INT_MAX : cvCeil(maxVal) - 1;
|
|
|
|
(check_range_functions[depth])(src, badPt, minVali, maxVali);
|
|
}
|
|
else
|
|
{
|
|
int i, loc = 0;
|
|
int cn = src.channels();
|
|
Size size = getContinuousSize2D(src, cn);
|
|
|
|
if( depth == CV_32F )
|
|
{
|
|
Cv32suf a, b;
|
|
int ia, ib;
|
|
const int* isrc = src.ptr<int>();
|
|
size_t step = src.step/sizeof(isrc[0]);
|
|
|
|
a.f = (float)std::max(minVal, (double)-FLT_MAX);
|
|
b.f = (float)std::min(maxVal, (double)FLT_MAX);
|
|
|
|
ia = CV_TOGGLE_FLT(a.i);
|
|
ib = CV_TOGGLE_FLT(b.i);
|
|
|
|
for( ; badPt.x < 0 && size.height--; loc += size.width, isrc += step )
|
|
{
|
|
for( i = 0; i < size.width; i++ )
|
|
{
|
|
int val = isrc[i];
|
|
val = CV_TOGGLE_FLT(val);
|
|
|
|
if( val < ia || val >= ib )
|
|
{
|
|
int pixelId = (loc + i) / cn;
|
|
badPt = Point(pixelId % src.cols, pixelId / src.cols);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Cv64suf a, b;
|
|
int64 ia, ib;
|
|
const int64* isrc = src.ptr<int64>();
|
|
size_t step = src.step/sizeof(isrc[0]);
|
|
|
|
a.f = minVal;
|
|
b.f = maxVal;
|
|
|
|
ia = CV_TOGGLE_DBL(a.i);
|
|
ib = CV_TOGGLE_DBL(b.i);
|
|
|
|
for( ; badPt.x < 0 && size.height--; loc += size.width, isrc += step )
|
|
{
|
|
for( i = 0; i < size.width; i++ )
|
|
{
|
|
int64 val = isrc[i];
|
|
val = CV_TOGGLE_DBL(val);
|
|
|
|
if( val < ia || val >= ib )
|
|
{
|
|
int pixelId = (loc + i) / cn;
|
|
badPt = Point(pixelId % src.cols, pixelId / src.cols);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if( badPt.x >= 0 )
|
|
{
|
|
if( pt )
|
|
*pt = badPt;
|
|
if( !quiet )
|
|
{
|
|
cv::String value_str;
|
|
value_str << src(cv::Range(badPt.y, badPt.y + 1), cv::Range(badPt.x, badPt.x + 1));
|
|
CV_Error_( cv::Error::StsOutOfRange,
|
|
("the value at (%d, %d)=%s is out of range [%f, %f)", badPt.x, badPt.y, value_str.c_str(), minVal, maxVal));
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
} // namespace cv
|
|
|
|
/*
|
|
Finds real roots of cubic, quadratic or linear equation.
|
|
The original code has been taken from Ken Turkowski web page
|
|
(http://www.worldserver.com/turk/opensource/) and adopted for OpenCV.
|
|
Here is the copyright notice.
|
|
|
|
-----------------------------------------------------------------------
|
|
Copyright (C) 1978-1999 Ken Turkowski. <turk@computer.org>
|
|
|
|
All rights reserved.
|
|
|
|
Warranty Information
|
|
Even though I have reviewed this software, I make no warranty
|
|
or representation, either express or implied, with respect to this
|
|
software, its quality, accuracy, merchantability, or fitness for a
|
|
particular purpose. As a result, this software is provided "as is,"
|
|
and you, its user, are assuming the entire risk as to its quality
|
|
and accuracy.
|
|
|
|
This code may be used and freely distributed as long as it includes
|
|
this copyright notice and the above warranty information.
|
|
-----------------------------------------------------------------------
|
|
*/
|
|
|
|
int cv::solveCubic( InputArray _coeffs, OutputArray _roots )
|
|
{
|
|
CV_INSTRUMENT_REGION();
|
|
|
|
const int n0 = 3;
|
|
Mat coeffs = _coeffs.getMat();
|
|
int ctype = coeffs.type();
|
|
|
|
CV_Assert( ctype == CV_32F || ctype == CV_64F );
|
|
CV_Assert( (coeffs.size() == Size(n0, 1) ||
|
|
coeffs.size() == Size(n0+1, 1) ||
|
|
coeffs.size() == Size(1, n0) ||
|
|
coeffs.size() == Size(1, n0+1)) );
|
|
|
|
_roots.create(n0, 1, ctype, -1, true, _OutputArray::DEPTH_MASK_FLT);
|
|
Mat roots = _roots.getMat();
|
|
|
|
int i = -1, n = 0;
|
|
double a0 = 1., a1, a2, a3;
|
|
double x0 = 0., x1 = 0., x2 = 0.;
|
|
int ncoeffs = coeffs.rows + coeffs.cols - 1;
|
|
|
|
if( ctype == CV_32FC1 )
|
|
{
|
|
if( ncoeffs == 4 )
|
|
a0 = coeffs.at<float>(++i);
|
|
|
|
a1 = coeffs.at<float>(i+1);
|
|
a2 = coeffs.at<float>(i+2);
|
|
a3 = coeffs.at<float>(i+3);
|
|
}
|
|
else
|
|
{
|
|
if( ncoeffs == 4 )
|
|
a0 = coeffs.at<double>(++i);
|
|
|
|
a1 = coeffs.at<double>(i+1);
|
|
a2 = coeffs.at<double>(i+2);
|
|
a3 = coeffs.at<double>(i+3);
|
|
}
|
|
|
|
// Fix for Issue #27748: Normalize coefficients to avoid overflow/underflow
|
|
// and correctly detect negligible cubic terms.
|
|
double max_coeff = std::max({std::abs(a0), std::abs(a1), std::abs(a2), std::abs(a3)});
|
|
|
|
// If max_coeff is effectively zero, the equation is 0=0
|
|
if (max_coeff < std::numeric_limits<double>::epsilon())
|
|
return -1;
|
|
|
|
// Check if the cubic term is negligible relative to the largest coefficient
|
|
if( std::abs(a0) < std::numeric_limits<double>::epsilon() * max_coeff )
|
|
{
|
|
if( std::abs(a1) < std::numeric_limits<double>::epsilon() * max_coeff )
|
|
{
|
|
if( std::abs(a2) < std::numeric_limits<double>::epsilon() * max_coeff )
|
|
n = std::abs(a3) < std::numeric_limits<double>::epsilon() * max_coeff ? -1 : 0;
|
|
else
|
|
{
|
|
// linear equation
|
|
x0 = -a3/a2;
|
|
n = 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// quadratic equation
|
|
double d = a2*a2 - 4*a1*a3;
|
|
if( d >= 0 )
|
|
{
|
|
d = std::sqrt(d);
|
|
double q1 = (-a2 + d) * 0.5;
|
|
double q2 = (a2 + d) * -0.5;
|
|
if( std::abs(q1) > std::abs(q2) )
|
|
{
|
|
x0 = q1 / a1;
|
|
x1 = a3 / q1;
|
|
}
|
|
else
|
|
{
|
|
x0 = q2 / a1;
|
|
x1 = a3 / q2;
|
|
}
|
|
n = d > 0 ? 2 : 1;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// cubic equation
|
|
// Normalize coefficients in-place to prevent overflow/instability
|
|
double scale = 1.0 / max_coeff;
|
|
a0 *= scale;
|
|
a1 *= scale;
|
|
a2 *= scale;
|
|
a3 *= scale;
|
|
|
|
a0 = 1./a0;
|
|
a1 *= a0;
|
|
a2 *= a0;
|
|
a3 *= a0;
|
|
|
|
double Q = (a1 * a1 - 3 * a2) * (1./9);
|
|
double R = (a1 * (2 * a1 * a1 - 9 * a2) + 27 * a3) * (1./54);
|
|
double Qcubed = Q * Q * Q;
|
|
|
|
/*
|
|
Here we expand expression `Qcubed - R * R` for `d` variable
|
|
to reduce common terms `a1^6 / 729` and `-a1^4 * a2 / 81`
|
|
and thus decrease rounding error (in case of quite big coefficients).
|
|
|
|
And then we additionally group terms to further reduce rounding error.
|
|
*/
|
|
double d = (a1 * a1 * (a2 * a2 - 4 * a1 * a3) + 2 * a2 * (9 * a1 * a3 - 2 * a2 * a2) - 27 * a3 * a3) * (1./108);
|
|
|
|
if( d > 0 )
|
|
{
|
|
double theta = acos(R / sqrt(Qcubed));
|
|
double sqrtQ = sqrt(Q);
|
|
double t0 = -2 * sqrtQ;
|
|
double t1 = theta * (1./3);
|
|
double t2 = a1 * (1./3);
|
|
x0 = t0 * cos(t1) - t2;
|
|
x1 = t0 * cos(t1 + (2.*CV_PI/3)) - t2;
|
|
x2 = t0 * cos(t1 + (4.*CV_PI/3)) - t2;
|
|
n = 3;
|
|
}
|
|
else if( d == 0 )
|
|
{
|
|
x0 = -2*std::cbrt(R) - a1/3;
|
|
x1 = std::cbrt(R) - a1/3;
|
|
x2 = 0;
|
|
n = x0 == x1 ? 1 : 2;
|
|
x1 = x0 == x1 ? 0 : x1;
|
|
}
|
|
else
|
|
{
|
|
double e;
|
|
d = sqrt(-d);
|
|
e = std::cbrt(d + fabs(R));
|
|
if( R > 0 )
|
|
e = -e;
|
|
x0 = (e + Q / e) - a1 * (1./3);
|
|
n = 1;
|
|
}
|
|
}
|
|
|
|
if( roots.type() == CV_32FC1 )
|
|
{
|
|
roots.at<float>(0) = (float)x0;
|
|
roots.at<float>(1) = (float)x1;
|
|
roots.at<float>(2) = (float)x2;
|
|
}
|
|
else
|
|
{
|
|
roots.at<double>(0) = x0;
|
|
roots.at<double>(1) = x1;
|
|
roots.at<double>(2) = x2;
|
|
}
|
|
|
|
return n;
|
|
}
|
|
|
|
/* finds complex roots of a polynomial using Durand-Kerner method:
|
|
http://en.wikipedia.org/wiki/Durand%E2%80%93Kerner_method */
|
|
double cv::solvePoly( InputArray _coeffs0, OutputArray _roots0, int maxIters )
|
|
{
|
|
CV_INSTRUMENT_REGION();
|
|
|
|
typedef Complex<double> C;
|
|
|
|
double maxDiff = 0;
|
|
int iter, i, j;
|
|
Mat coeffs0 = _coeffs0.getMat();
|
|
int ctype = _coeffs0.type();
|
|
int cdepth = CV_MAT_DEPTH(ctype);
|
|
|
|
CV_Assert( CV_MAT_DEPTH(ctype) >= CV_32F && CV_MAT_CN(ctype) <= 2 );
|
|
CV_Assert( coeffs0.rows == 1 || coeffs0.cols == 1 );
|
|
|
|
int n0 = coeffs0.cols + coeffs0.rows - 2, n = n0;
|
|
|
|
_roots0.create(n, 1, CV_MAKETYPE(cdepth, 2), -1, true, _OutputArray::DEPTH_MASK_FLT);
|
|
Mat roots0 = _roots0.getMat();
|
|
|
|
AutoBuffer<C> buf(n*2+2);
|
|
C *coeffs = buf.data(), *roots = coeffs + n + 1;
|
|
Mat coeffs1(coeffs0.size(), CV_MAKETYPE(CV_64F, coeffs0.channels()), coeffs0.channels() == 2 ? coeffs : roots);
|
|
coeffs0.convertTo(coeffs1, coeffs1.type());
|
|
if( coeffs0.channels() == 1 )
|
|
{
|
|
const double* rcoeffs = (const double*)roots;
|
|
for( i = 0; i <= n; i++ )
|
|
coeffs[i] = C(rcoeffs[i], 0);
|
|
}
|
|
|
|
for( ; n > 1; n-- )
|
|
{
|
|
if( std::abs(coeffs[n].re) + std::abs(coeffs[n].im) > DBL_EPSILON )
|
|
break;
|
|
}
|
|
|
|
// Related issue: https://github.com/opencv/opencv/issues/23644,
|
|
// This the initialization scheme of "Initial approximations in Durand-Kerner's root finding method" by Guggenheimer.
|
|
// https://link.springer.com/article/10.1007/BF01935059
|
|
// We put the initial points equidistantly on a circle on the complex plane. This code computes the circle radius as in the paper.
|
|
Mat absCoeffs(n + 1, 1, CV_64F);
|
|
for( i = 0; i <= n; i++ )
|
|
absCoeffs.at<double>(i) = abs(coeffs[i]);
|
|
|
|
int nonZeroCoeffs = 0;
|
|
Mat u(n, 1, CV_64F, Scalar(0)), v(n, 1, CV_64F, Scalar(0));
|
|
for( i = 0; i <= n; i++ )
|
|
{
|
|
double coeff = absCoeffs.at<double>(i);
|
|
if( coeff > DBL_EPSILON )
|
|
{
|
|
if( i != n )
|
|
u.at<double>(i) = 2.0 * pow(coeff / absCoeffs.at<double>(n), 1.0 / (n - i));
|
|
if( i != 0 )
|
|
v.at<double>(i - 1) = 0.5 * pow(absCoeffs.at<double>(0) / coeff, 1.0 / i);
|
|
nonZeroCoeffs++;
|
|
}
|
|
}
|
|
double scale = 1;
|
|
if( nonZeroCoeffs > 2 )
|
|
{
|
|
Point maxU, minV;
|
|
minMaxLoc(u, nullptr, nullptr, nullptr, &maxU);
|
|
minMaxLoc(v, nullptr, nullptr, &minV);
|
|
u.at<double>(maxU) = 0;
|
|
v.at<double>(minV) = 0;
|
|
scale = (sum(u).val[0] + sum(v).val[0]) / (2 * nonZeroCoeffs - 2);
|
|
}
|
|
|
|
C p(scale, 0), r(cos(CV_2PI / n), sin(CV_2PI / n));
|
|
|
|
for( i = 0; i < n; i++ )
|
|
{
|
|
roots[i] = p;
|
|
p = p * r;
|
|
}
|
|
|
|
maxIters = maxIters <= 0 ? 1000 : maxIters;
|
|
for( iter = 0; iter < maxIters; iter++ )
|
|
{
|
|
maxDiff = 0;
|
|
for( i = 0; i < n; i++ )
|
|
{
|
|
p = roots[i];
|
|
C num = coeffs[n], denom = coeffs[n];
|
|
int num_same_root = 1;
|
|
for( j = 0; j < n; j++ )
|
|
{
|
|
num = num*p + coeffs[n-j-1];
|
|
if( j != i )
|
|
{
|
|
if ( (p - roots[j]).re != 0 || (p - roots[j]).im != 0 )
|
|
denom = denom * (p - roots[j]);
|
|
else
|
|
num_same_root++;
|
|
}
|
|
}
|
|
num /= denom;
|
|
if( num_same_root > 1)
|
|
{
|
|
double old_num_re = num.re;
|
|
double old_num_im = num.im;
|
|
int square_root_times = num_same_root % 2 == 0 ? num_same_root / 2 : num_same_root / 2 - 1;
|
|
|
|
for( j = 0; j < square_root_times; j++)
|
|
{
|
|
num.re = old_num_re*old_num_re + old_num_im*old_num_im;
|
|
num.re = sqrt(num.re);
|
|
num.re += old_num_re;
|
|
num.im = num.re - old_num_re;
|
|
num.re /= 2;
|
|
num.re = sqrt(num.re);
|
|
|
|
num.im /= 2;
|
|
num.im = sqrt(num.im);
|
|
if( old_num_re < 0 ) num.im = -num.im;
|
|
}
|
|
|
|
if( num_same_root % 2 != 0){
|
|
Mat cube_coefs(4, 1, CV_64FC1);
|
|
Mat cube_roots(3, 1, CV_64FC2);
|
|
cube_coefs.at<double>(3) = -(std::pow(old_num_re, 3));
|
|
cube_coefs.at<double>(2) = -(15*std::pow(old_num_re, 2) + 27*std::pow(old_num_im, 2));
|
|
cube_coefs.at<double>(1) = -48*old_num_re;
|
|
cube_coefs.at<double>(0) = 64;
|
|
solveCubic(cube_coefs, cube_roots);
|
|
|
|
num.re = std::cbrt(cube_roots.at<double>(0));
|
|
num.im = sqrt(std::pow(num.re, 2) / 3 - old_num_re / (3*num.re));
|
|
}
|
|
}
|
|
roots[i] = p - num;
|
|
maxDiff = std::max(maxDiff, cv::abs(num));
|
|
}
|
|
if( maxDiff <= 0 )
|
|
break;
|
|
}
|
|
|
|
if( coeffs0.channels() == 1 )
|
|
{
|
|
const double verySmallEps = 1e-100;
|
|
for( i = 0; i < n; i++ )
|
|
if( fabs(roots[i].im) < verySmallEps )
|
|
roots[i].im = 0;
|
|
}
|
|
|
|
for( ; n < n0; n++ )
|
|
roots[n+1] = roots[n];
|
|
|
|
Mat(roots0.size(), CV_64FC2, roots).convertTo(roots0, roots0.type());
|
|
return maxDiff;
|
|
}
|
|
|
|
|
|
/* End of file. */
|