/
core_array.ts
2679 lines (2517 loc) · 114 KB
/
core_array.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
import { bool, double, InputArray, InputArrayOfArrays, InputOutputArray, InputOutputArrayOfArrays, int, Mat, OutputArray, OutputArrayOfArrays, Scalar, size_t } from './_types'
/*
* # Operations on arrays
*
*/
/**
* The function [cv::absdiff] calculates: Absolute difference between two arrays when they have the
* same size and type: `\\[\\texttt{dst}(I) = \\texttt{saturate} (| \\texttt{src1}(I) -
* \\texttt{src2}(I)|)\\]` Absolute difference between an array and a scalar when the second array is
* constructed from Scalar or has as many elements as the number of channels in `src1`:
* `\\[\\texttt{dst}(I) = \\texttt{saturate} (| \\texttt{src1}(I) - \\texttt{src2} |)\\]` Absolute
* difference between a scalar and an array when the first array is constructed from Scalar or has as
* many elements as the number of channels in `src2`: `\\[\\texttt{dst}(I) = \\texttt{saturate} (|
* \\texttt{src1} - \\texttt{src2}(I) |)\\]` where I is a multi-dimensional index of array elements. In
* case of multi-channel arrays, each channel is processed independently.
*
* Saturation is not applied when the arrays have the depth CV_32S. You may even get a negative value
* in the case of overflow.
*
* cv::abs(const Mat&)
*
* @param src1 first input array or a scalar.
*
* @param src2 second input array or a scalar.
*
* @param dst output array that has the same size and type as input arrays.
*/
export declare function absdiff(src1: InputArray, src2: InputArray, dst: OutputArray): void
/**
* The function add calculates:
*
* Sum of two arrays when both input arrays have the same size and the same number of channels:
* `\\[\\texttt{dst}(I) = \\texttt{saturate} ( \\texttt{src1}(I) + \\texttt{src2}(I)) \\quad
* \\texttt{if mask}(I) \\ne0\\]`
* Sum of an array and a scalar when src2 is constructed from Scalar or has the same number of elements
* as `src1.channels()`: `\\[\\texttt{dst}(I) = \\texttt{saturate} ( \\texttt{src1}(I) + \\texttt{src2}
* ) \\quad \\texttt{if mask}(I) \\ne0\\]`
* Sum of a scalar and an array when src1 is constructed from Scalar or has the same number of elements
* as `src2.channels()`: `\\[\\texttt{dst}(I) = \\texttt{saturate} ( \\texttt{src1} + \\texttt{src2}(I)
* ) \\quad \\texttt{if mask}(I) \\ne0\\]` where `I` is a multi-dimensional index of array elements. In
* case of multi-channel arrays, each channel is processed independently.
*
* The first function in the list above can be replaced with matrix expressions:
*
* ```cpp
* dst = src1 + src2;
* dst += src1; // equivalent to add(dst, src1, dst);
* ```
*
* The input arrays and the output array can all have the same or different depths. For example, you
* can add a 16-bit unsigned array to a 8-bit signed array and store the sum as a 32-bit floating-point
* array. Depth of the output array is determined by the dtype parameter. In the second and third cases
* above, as well as in the first case, when src1.depth() == src2.depth(), dtype can be set to the
* default -1. In this case, the output array will have the same depth as the input array, be it src1,
* src2 or both.
*
* Saturation is not applied when the output array has the depth CV_32S. You may even get result of an
* incorrect sign in the case of overflow.
*
* [subtract], [addWeighted], [scaleAdd], [Mat::convertTo]
*
* @param src1 first input array or a scalar.
*
* @param src2 second input array or a scalar.
*
* @param dst output array that has the same size and number of channels as the input array(s); the
* depth is defined by dtype or src1/src2.
*
* @param mask optional operation mask - 8-bit single channel array, that specifies elements of the
* output array to be changed.
*
* @param dtype optional depth of the output array (see the discussion below).
*/
export declare function add(src1: InputArray, src2: InputArray, dst: OutputArray, mask?: InputArray, dtype?: int): void
/**
* The function addWeighted calculates the weighted sum of two arrays as follows: `\\[\\texttt{dst}
* (I)= \\texttt{saturate} ( \\texttt{src1} (I)* \\texttt{alpha} + \\texttt{src2} (I)* \\texttt{beta} +
* \\texttt{gamma} )\\]` where I is a multi-dimensional index of array elements. In case of
* multi-channel arrays, each channel is processed independently. The function can be replaced with a
* matrix expression:
*
* ```cpp
* dst = src1*alpha + src2*beta + gamma;
* ```
*
* Saturation is not applied when the output array has the depth CV_32S. You may even get result of an
* incorrect sign in the case of overflow.
*
* [add], [subtract], [scaleAdd], [Mat::convertTo]
*
* @param src1 first input array.
*
* @param alpha weight of the first array elements.
*
* @param src2 second input array of the same size and channel number as src1.
*
* @param beta weight of the second array elements.
*
* @param gamma scalar added to each sum.
*
* @param dst output array that has the same size and number of channels as the input arrays.
*
* @param dtype optional depth of the output array; when both input arrays have the same depth, dtype
* can be set to -1, which will be equivalent to src1.depth().
*/
export declare function addWeighted(src1: InputArray, alpha: double, src2: InputArray, beta: double, gamma: double, dst: OutputArray, dtype?: int): void
/**
* see
*/
export declare function batchDistance(src1: InputArray, src2: InputArray, dist: OutputArray, dtype: int, nidx: OutputArray, normType?: int, K?: int, mask?: InputArray, update?: int, crosscheck?: bool): void
/**
* The function [cv::bitwise_and] calculates the per-element bit-wise logical conjunction for: Two
* arrays when src1 and src2 have the same size: `\\[\\texttt{dst} (I) = \\texttt{src1} (I) \\wedge
* \\texttt{src2} (I) \\quad \\texttt{if mask} (I) \\ne0\\]` An array and a scalar when src2 is
* constructed from Scalar or has the same number of elements as `src1.channels()`: `\\[\\texttt{dst}
* (I) = \\texttt{src1} (I) \\wedge \\texttt{src2} \\quad \\texttt{if mask} (I) \\ne0\\]` A scalar and
* an array when src1 is constructed from Scalar or has the same number of elements as
* `src2.channels()`: `\\[\\texttt{dst} (I) = \\texttt{src1} \\wedge \\texttt{src2} (I) \\quad
* \\texttt{if mask} (I) \\ne0\\]` In case of floating-point arrays, their machine-specific bit
* representations (usually IEEE754-compliant) are used for the operation. In case of multi-channel
* arrays, each channel is processed independently. In the second and third cases above, the scalar is
* first converted to the array type.
*
* @param src1 first input array or a scalar.
*
* @param src2 second input array or a scalar.
*
* @param dst output array that has the same size and type as the input arrays.
*
* @param mask optional operation mask, 8-bit single channel array, that specifies elements of the
* output array to be changed.
*/
export declare function bitwise_and(src1: InputArray, src2: InputArray, dst: OutputArray, mask?: InputArray): void
/**
* The function [cv::bitwise_not] calculates per-element bit-wise inversion of the input array:
* `\\[\\texttt{dst} (I) = \\neg \\texttt{src} (I)\\]` In case of a floating-point input array, its
* machine-specific bit representation (usually IEEE754-compliant) is used for the operation. In case
* of multi-channel arrays, each channel is processed independently.
*
* @param src input array.
*
* @param dst output array that has the same size and type as the input array.
*
* @param mask optional operation mask, 8-bit single channel array, that specifies elements of the
* output array to be changed.
*/
export declare function bitwise_not(src: InputArray, dst: OutputArray, mask?: InputArray): void
/**
* The function [cv::bitwise_or] calculates the per-element bit-wise logical disjunction for: Two
* arrays when src1 and src2 have the same size: `\\[\\texttt{dst} (I) = \\texttt{src1} (I) \\vee
* \\texttt{src2} (I) \\quad \\texttt{if mask} (I) \\ne0\\]` An array and a scalar when src2 is
* constructed from Scalar or has the same number of elements as `src1.channels()`: `\\[\\texttt{dst}
* (I) = \\texttt{src1} (I) \\vee \\texttt{src2} \\quad \\texttt{if mask} (I) \\ne0\\]` A scalar and an
* array when src1 is constructed from Scalar or has the same number of elements as `src2.channels()`:
* `\\[\\texttt{dst} (I) = \\texttt{src1} \\vee \\texttt{src2} (I) \\quad \\texttt{if mask} (I)
* \\ne0\\]` In case of floating-point arrays, their machine-specific bit representations (usually
* IEEE754-compliant) are used for the operation. In case of multi-channel arrays, each channel is
* processed independently. In the second and third cases above, the scalar is first converted to the
* array type.
*
* @param src1 first input array or a scalar.
*
* @param src2 second input array or a scalar.
*
* @param dst output array that has the same size and type as the input arrays.
*
* @param mask optional operation mask, 8-bit single channel array, that specifies elements of the
* output array to be changed.
*/
export declare function bitwise_or(src1: InputArray, src2: InputArray, dst: OutputArray, mask?: InputArray): void
/**
* The function [cv::bitwise_xor] calculates the per-element bit-wise logical "exclusive-or" operation
* for: Two arrays when src1 and src2 have the same size: `\\[\\texttt{dst} (I) = \\texttt{src1} (I)
* \\oplus \\texttt{src2} (I) \\quad \\texttt{if mask} (I) \\ne0\\]` An array and a scalar when src2 is
* constructed from Scalar or has the same number of elements as `src1.channels()`: `\\[\\texttt{dst}
* (I) = \\texttt{src1} (I) \\oplus \\texttt{src2} \\quad \\texttt{if mask} (I) \\ne0\\]` A scalar and
* an array when src1 is constructed from Scalar or has the same number of elements as
* `src2.channels()`: `\\[\\texttt{dst} (I) = \\texttt{src1} \\oplus \\texttt{src2} (I) \\quad
* \\texttt{if mask} (I) \\ne0\\]` In case of floating-point arrays, their machine-specific bit
* representations (usually IEEE754-compliant) are used for the operation. In case of multi-channel
* arrays, each channel is processed independently. In the 2nd and 3rd cases above, the scalar is first
* converted to the array type.
*
* @param src1 first input array or a scalar.
*
* @param src2 second input array or a scalar.
*
* @param dst output array that has the same size and type as the input arrays.
*
* @param mask optional operation mask, 8-bit single channel array, that specifies elements of the
* output array to be changed.
*/
export declare function bitwise_xor(src1: InputArray, src2: InputArray, dst: OutputArray, mask?: InputArray): void
/**
* The function computes and returns the coordinate of a donor pixel corresponding to the specified
* extrapolated pixel when using the specified extrapolation border mode. For example, if you use
* [cv::BORDER_WRAP] mode in the horizontal direction, [cv::BORDER_REFLECT_101] in the vertical
* direction and want to compute value of the "virtual" pixel Point(-5, 100) in a floating-point image
* img , it looks like:
*
* ```cpp
* float val = img.at<float>(borderInterpolate(100, img.rows, cv::BORDER_REFLECT_101),
* borderInterpolate(-5, img.cols, cv::BORDER_WRAP));
* ```
*
* Normally, the function is not called directly. It is used inside filtering functions and also in
* copyMakeBorder.
*
* [copyMakeBorder]
*
* @param p 0-based coordinate of the extrapolated pixel along one of the axes, likely <0 or >= len
*
* @param len Length of the array along the corresponding axis.
*
* @param borderType Border type, one of the BorderTypes, except for BORDER_TRANSPARENT and
* BORDER_ISOLATED . When borderType==BORDER_CONSTANT , the function always returns -1, regardless of p
* and len.
*/
export declare function borderInterpolate(p: int, len: int, borderType: int): int
/**
* The function [cv::calcCovarMatrix] calculates the covariance matrix and, optionally, the mean vector
* of the set of input vectors.
*
* [PCA], [mulTransposed], [Mahalanobis]
*
* @param samples samples stored as separate matrices
*
* @param nsamples number of samples
*
* @param covar output covariance matrix of the type ctype and square size.
*
* @param mean input or output (depending on the flags) array as the average value of the input
* vectors.
*
* @param flags operation flags as a combination of CovarFlags
*
* @param ctype type of the matrixl; it equals 'CV_64F' by default.
*/
export declare function calcCovarMatrix(samples: any, nsamples: int, covar: any, mean: any, flags: int, ctype?: int): void
/**
* This is an overloaded member function, provided for convenience. It differs from the above function
* only in what argument(s) it accepts.
*
* use [COVAR_ROWS] or [COVAR_COLS] flag
*
* @param samples samples stored as rows/columns of a single matrix.
*
* @param covar output covariance matrix of the type ctype and square size.
*
* @param mean input or output (depending on the flags) array as the average value of the input
* vectors.
*
* @param flags operation flags as a combination of CovarFlags
*
* @param ctype type of the matrixl; it equals 'CV_64F' by default.
*/
export declare function calcCovarMatrix(samples: InputArray, covar: OutputArray, mean: InputOutputArray, flags: int, ctype?: int): void
/**
* The function [cv::cartToPolar] calculates either the magnitude, angle, or both for every 2D vector
* (x(I),y(I)): `\\[\\begin{array}{l} \\texttt{magnitude} (I)=
* \\sqrt{\\texttt{x}(I)^2+\\texttt{y}(I)^2} , \\\\ \\texttt{angle} (I)= \\texttt{atan2} ( \\texttt{y}
* (I), \\texttt{x} (I))[ \\cdot180 / \\pi ] \\end{array}\\]`
*
* The angles are calculated with accuracy about 0.3 degrees. For the point (0,0), the angle is set to
* 0.
*
* [Sobel], [Scharr]
*
* @param x array of x-coordinates; this must be a single-precision or double-precision floating-point
* array.
*
* @param y array of y-coordinates, that must have the same size and same type as x.
*
* @param magnitude output array of magnitudes of the same size and type as x.
*
* @param angle output array of angles that has the same size and type as x; the angles are measured in
* radians (from 0 to 2*Pi) or in degrees (0 to 360 degrees).
*
* @param angleInDegrees a flag, indicating whether the angles are measured in radians (which is by
* default), or in degrees.
*/
export declare function cartToPolar(x: InputArray, y: InputArray, magnitude: OutputArray, angle: OutputArray, angleInDegrees?: bool): void
/**
* The function [cv::checkRange] checks that every array element is neither NaN nor infinite. When
* minVal > -DBL_MAX and maxVal < DBL_MAX, the function also checks that each value is between minVal
* and maxVal. In case of multi-channel arrays, each channel is processed independently. If some values
* are out of range, position of the first outlier is stored in pos (when pos != NULL). Then, the
* function either returns false (when quiet=true) or throws an exception.
*
* @param a input array.
*
* @param quiet a flag, indicating whether the functions quietly return false when the array elements
* are out of range or they throw an exception.
*
* @param pos optional output parameter, when not NULL, must be a pointer to array of src.dims
* elements.
*
* @param minVal inclusive lower boundary of valid values range.
*
* @param maxVal exclusive upper boundary of valid values range.
*/
export declare function checkRange(a: InputArray, quiet?: bool, pos?: any, minVal?: double, maxVal?: double): bool
/**
* The function compares: Elements of two arrays when src1 and src2 have the same size:
* `\\[\\texttt{dst} (I) = \\texttt{src1} (I) \\,\\texttt{cmpop}\\, \\texttt{src2} (I)\\]` Elements of
* src1 with a scalar src2 when src2 is constructed from Scalar or has a single element:
* `\\[\\texttt{dst} (I) = \\texttt{src1}(I) \\,\\texttt{cmpop}\\, \\texttt{src2}\\]` src1 with
* elements of src2 when src1 is constructed from Scalar or has a single element: `\\[\\texttt{dst} (I)
* = \\texttt{src1} \\,\\texttt{cmpop}\\, \\texttt{src2} (I)\\]` When the comparison result is true,
* the corresponding element of output array is set to 255. The comparison operations can be replaced
* with the equivalent matrix expressions:
*
* ```cpp
* Mat dst1 = src1 >= src2;
* Mat dst2 = src1 < 8;
* ...
* ```
*
* [checkRange], [min], [max], [threshold]
*
* @param src1 first input array or a scalar; when it is an array, it must have a single channel.
*
* @param src2 second input array or a scalar; when it is an array, it must have a single channel.
*
* @param dst output array of type ref CV_8U that has the same size and the same number of channels as
* the input arrays.
*
* @param cmpop a flag, that specifies correspondence between the arrays (cv::CmpTypes)
*/
export declare function compare(src1: InputArray, src2: InputArray, dst: OutputArray, cmpop: int): void
/**
* The function [cv::completeSymm] copies the lower or the upper half of a square matrix to its another
* half. The matrix diagonal remains unchanged:
*
* `$\\texttt{m}_{ij}=\\texttt{m}_{ji}$` for `$i > j$` if lowerToUpper=false
* `$\\texttt{m}_{ij}=\\texttt{m}_{ji}$` for `$i < j$` if lowerToUpper=true
*
* [flip], [transpose]
*
* @param m input-output floating-point square matrix.
*
* @param lowerToUpper operation flag; if true, the lower half is copied to the upper half. Otherwise,
* the upper half is copied to the lower half.
*/
export declare function completeSymm(m: InputOutputArray, lowerToUpper?: bool): void
/**
* This function converts FP32 (single precision floating point) from/to FP16 (half precision floating
* point). CV_16S format is used to represent FP16 data. There are two use modes (src -> dst): CV_32F
* -> CV_16S and CV_16S -> CV_32F. The input array has to have type of CV_32F or CV_16S to represent
* the bit depth. If the input array is neither of them, the function will raise an error. The format
* of half precision floating point is defined in IEEE 754-2008.
*
* @param src input array.
*
* @param dst output array.
*/
export declare function convertFp16(src: InputArray, dst: OutputArray): void
/**
* On each element of the input array, the function convertScaleAbs performs three operations
* sequentially: scaling, taking an absolute value, conversion to an unsigned 8-bit type:
* `\\[\\texttt{dst} (I)= \\texttt{saturate\\_cast<uchar>} (| \\texttt{src} (I)* \\texttt{alpha} +
* \\texttt{beta} |)\\]` In case of multi-channel arrays, the function processes each channel
* independently. When the output is not 8-bit, the operation can be emulated by calling the
* [Mat::convertTo] method (or by using matrix expressions) and then by calculating an absolute value
* of the result. For example:
*
* ```cpp
* Mat_<float> A(30,30);
* randu(A, Scalar(-100), Scalar(100));
* Mat_<float> B = A*5 + 3;
* B = abs(B);
* // Mat_<float> B = abs(A*5+3) will also do the job,
* // but it will allocate a temporary matrix
* ```
*
* [Mat::convertTo], cv::abs(const Mat&)
*
* @param src input array.
*
* @param dst output array.
*
* @param alpha optional scale factor.
*
* @param beta optional delta added to the scaled values.
*/
export declare function convertScaleAbs(src: InputArray, dst: OutputArray, alpha?: double, beta?: double): void
/**
* The function copies the source image into the middle of the destination image. The areas to the
* left, to the right, above and below the copied source image will be filled with extrapolated pixels.
* This is not what filtering functions based on it do (they extrapolate pixels on-fly), but what other
* more complex functions, including your own, may do to simplify image boundary handling.
*
* The function supports the mode when src is already in the middle of dst . In this case, the function
* does not copy src itself but simply constructs the border, for example:
*
* ```cpp
* // let border be the same in all directions
* int border=2;
* // constructs a larger image to fit both the image and the border
* Mat gray_buf(rgb.rows + border*2, rgb.cols + border*2, rgb.depth());
* // select the middle part of it w/o copying data
* Mat gray(gray_canvas, Rect(border, border, rgb.cols, rgb.rows));
* // convert image from RGB to grayscale
* cvtColor(rgb, gray, COLOR_RGB2GRAY);
* // form a border in-place
* copyMakeBorder(gray, gray_buf, border, border,
* border, border, BORDER_REPLICATE);
* // now do some custom filtering ...
* ...
* ```
*
* When the source image is a part (ROI) of a bigger image, the function will try to use the pixels
* outside of the ROI to form a border. To disable this feature and always do extrapolation, as if src
* was not a ROI, use borderType | [BORDER_ISOLATED].
*
* [borderInterpolate]
*
* @param src Source image.
*
* @param dst Destination image of the same type as src and the size Size(src.cols+left+right,
* src.rows+top+bottom) .
*
* @param top the top pixels
*
* @param bottom the bottom pixels
*
* @param left the left pixels
*
* @param right Parameter specifying how many pixels in each direction from the source image rectangle
* to extrapolate. For example, top=1, bottom=1, left=1, right=1 mean that 1 pixel-wide border needs to
* be built.
*
* @param borderType Border type. See borderInterpolate for details.
*
* @param value Border value if borderType==BORDER_CONSTANT .
*/
export declare function copyMakeBorder(src: InputArray, dst: OutputArray, top: int, bottom: int, left: int, right: int, borderType: int, value?: any): void
/**
* @param src source matrix.
*
* @param dst Destination matrix. If it does not have a proper size or type before the operation, it is
* reallocated.
*
* @param mask Operation mask of the same size as *this. Its non-zero elements indicate which matrix
* elements need to be copied. The mask has to be of type CV_8U and can have 1 or multiple channels.
*/
export declare function copyTo(src: InputArray, dst: OutputArray, mask: InputArray): void
/**
* The function returns the number of non-zero elements in src : `\\[\\sum _{I: \\; \\texttt{src} (I)
* \\ne0 } 1\\]`
*
* [mean], [meanStdDev], [norm], [minMaxLoc], [calcCovarMatrix]
*
* @param src single-channel array.
*/
export declare function countNonZero(src: InputArray): int
/**
* The function [cv::dct] performs a forward or inverse discrete Cosine transform (DCT) of a 1D or 2D
* floating-point array:
*
* Forward Cosine transform of a 1D vector of N elements: `\\[Y = C^{(N)} \\cdot X\\]` where
* `\\[C^{(N)}_{jk}= \\sqrt{\\alpha_j/N} \\cos \\left ( \\frac{\\pi(2k+1)j}{2N} \\right )\\]` and
* `$\\alpha_0=1$`, `$\\alpha_j=2$` for *j > 0*.
* Inverse Cosine transform of a 1D vector of N elements: `\\[X = \\left (C^{(N)} \\right )^{-1} \\cdot
* Y = \\left (C^{(N)} \\right )^T \\cdot Y\\]` (since `$C^{(N)}$` is an orthogonal matrix, `$C^{(N)}
* \\cdot \\left(C^{(N)}\\right)^T = I$` )
* Forward 2D Cosine transform of M x N matrix: `\\[Y = C^{(N)} \\cdot X \\cdot \\left (C^{(N)} \\right
* )^T\\]`
* Inverse 2D Cosine transform of M x N matrix: `\\[X = \\left (C^{(N)} \\right )^T \\cdot X \\cdot
* C^{(N)}\\]`
*
* The function chooses the mode of operation by looking at the flags and size of the input array:
*
* If (flags & [DCT_INVERSE]) == 0 , the function does a forward 1D or 2D transform. Otherwise, it is
* an inverse 1D or 2D transform.
* If (flags & [DCT_ROWS]) != 0 , the function performs a 1D transform of each row.
* If the array is a single column or a single row, the function performs a 1D transform.
* If none of the above is true, the function performs a 2D transform.
*
* Currently dct supports even-size arrays (2, 4, 6 ...). For data analysis and approximation, you can
* pad the array when necessary. Also, the function performance depends very much, and not
* monotonically, on the array size (see getOptimalDFTSize ). In the current implementation DCT of a
* vector of size N is calculated via DFT of a vector of size N/2 . Thus, the optimal DCT size N1 >= N
* can be calculated as:
*
* ```cpp
* size_t getOptimalDCTSize(size_t N) { return 2*getOptimalDFTSize((N+1)/2); }
* N1 = getOptimalDCTSize(N);
* ```
*
* [dft] , [getOptimalDFTSize] , [idct]
*
* @param src input floating-point array.
*
* @param dst output array of the same size and type as src .
*
* @param flags transformation flags as a combination of cv::DftFlags (DCT_*)
*/
export declare function dct(src: InputArray, dst: OutputArray, flags?: int): void
/**
* The function [cv::determinant] calculates and returns the determinant of the specified matrix. For
* small matrices ( mtx.cols=mtx.rows<=3 ), the direct method is used. For larger matrices, the
* function uses LU factorization with partial pivoting.
*
* For symmetric positively-determined matrices, it is also possible to use eigen decomposition to
* calculate the determinant.
*
* [trace], [invert], [solve], [eigen], [MatrixExpressions]
*
* @param mtx input matrix that must have CV_32FC1 or CV_64FC1 type and square size.
*/
export declare function determinant(mtx: InputArray): double
/**
* The function [cv::dft] performs one of the following:
*
* Forward the Fourier transform of a 1D vector of N elements: `\\[Y = F^{(N)} \\cdot X,\\]` where
* `$F^{(N)}_{jk}=\\exp(-2\\pi i j k/N)$` and `$i=\\sqrt{-1}$`
* Inverse the Fourier transform of a 1D vector of N elements: `\\[\\begin{array}{l} X'= \\left
* (F^{(N)} \\right )^{-1} \\cdot Y = \\left (F^{(N)} \\right )^* \\cdot y \\\\ X = (1/N) \\cdot X,
* \\end{array}\\]` where `$F^*=\\left(\\textrm{Re}(F^{(N)})-\\textrm{Im}(F^{(N)})\\right)^T$`
* Forward the 2D Fourier transform of a M x N matrix: `\\[Y = F^{(M)} \\cdot X \\cdot F^{(N)}\\]`
* Inverse the 2D Fourier transform of a M x N matrix: `\\[\\begin{array}{l} X'= \\left (F^{(M)}
* \\right )^* \\cdot Y \\cdot \\left (F^{(N)} \\right )^* \\\\ X = \\frac{1}{M \\cdot N} \\cdot X'
* \\end{array}\\]`
*
* In case of real (single-channel) data, the output spectrum of the forward Fourier transform or input
* spectrum of the inverse Fourier transform can be represented in a packed format called *CCS*
* (complex-conjugate-symmetrical). It was borrowed from IPL (Intel* Image Processing Library). Here is
* how 2D *CCS* spectrum looks: `\\[\\begin{bmatrix} Re Y_{0,0} & Re Y_{0,1} & Im Y_{0,1} & Re Y_{0,2}
* & Im Y_{0,2} & \\cdots & Re Y_{0,N/2-1} & Im Y_{0,N/2-1} & Re Y_{0,N/2} \\\\ Re Y_{1,0} & Re Y_{1,1}
* & Im Y_{1,1} & Re Y_{1,2} & Im Y_{1,2} & \\cdots & Re Y_{1,N/2-1} & Im Y_{1,N/2-1} & Re Y_{1,N/2}
* \\\\ Im Y_{1,0} & Re Y_{2,1} & Im Y_{2,1} & Re Y_{2,2} & Im Y_{2,2} & \\cdots & Re Y_{2,N/2-1} & Im
* Y_{2,N/2-1} & Im Y_{1,N/2} \\\\ \\hdotsfor{9} \\\\ Re Y_{M/2-1,0} & Re Y_{M-3,1} & Im Y_{M-3,1} &
* \\hdotsfor{3} & Re Y_{M-3,N/2-1} & Im Y_{M-3,N/2-1}& Re Y_{M/2-1,N/2} \\\\ Im Y_{M/2-1,0} & Re
* Y_{M-2,1} & Im Y_{M-2,1} & \\hdotsfor{3} & Re Y_{M-2,N/2-1} & Im Y_{M-2,N/2-1}& Im Y_{M/2-1,N/2}
* \\\\ Re Y_{M/2,0} & Re Y_{M-1,1} & Im Y_{M-1,1} & \\hdotsfor{3} & Re Y_{M-1,N/2-1} & Im
* Y_{M-1,N/2-1}& Re Y_{M/2,N/2} \\end{bmatrix}\\]`
*
* In case of 1D transform of a real vector, the output looks like the first row of the matrix above.
*
* So, the function chooses an operation mode depending on the flags and size of the input array:
*
* If [DFT_ROWS] is set or the input array has a single row or single column, the function performs a
* 1D forward or inverse transform of each row of a matrix when [DFT_ROWS] is set. Otherwise, it
* performs a 2D transform.
* If the input array is real and [DFT_INVERSE] is not set, the function performs a forward 1D or 2D
* transform:
*
* When [DFT_COMPLEX_OUTPUT] is set, the output is a complex matrix of the same size as input.
* When [DFT_COMPLEX_OUTPUT] is not set, the output is a real matrix of the same size as input. In case
* of 2D transform, it uses the packed format as shown above. In case of a single 1D transform, it
* looks like the first row of the matrix above. In case of multiple 1D transforms (when using the
* [DFT_ROWS] flag), each row of the output matrix looks like the first row of the matrix above.
*
* If the input array is complex and either [DFT_INVERSE] or [DFT_REAL_OUTPUT] are not set, the output
* is a complex array of the same size as input. The function performs a forward or inverse 1D or 2D
* transform of the whole input array or each row of the input array independently, depending on the
* flags DFT_INVERSE and DFT_ROWS.
* When [DFT_INVERSE] is set and the input array is real, or it is complex but [DFT_REAL_OUTPUT] is
* set, the output is a real array of the same size as input. The function performs a 1D or 2D inverse
* transformation of the whole input array or each individual row, depending on the flags [DFT_INVERSE]
* and [DFT_ROWS].
*
* If [DFT_SCALE] is set, the scaling is done after the transformation.
*
* Unlike dct , the function supports arrays of arbitrary size. But only those arrays are processed
* efficiently, whose sizes can be factorized in a product of small prime numbers (2, 3, and 5 in the
* current implementation). Such an efficient DFT size can be calculated using the getOptimalDFTSize
* method.
*
* The sample below illustrates how to calculate a DFT-based convolution of two 2D real arrays:
*
* ```cpp
* void convolveDFT(InputArray A, InputArray B, OutputArray C)
* {
* // reallocate the output array if needed
* C.create(abs(A.rows - B.rows)+1, abs(A.cols - B.cols)+1, A.type());
* Size dftSize;
* // calculate the size of DFT transform
* dftSize.width = getOptimalDFTSize(A.cols + B.cols - 1);
* dftSize.height = getOptimalDFTSize(A.rows + B.rows - 1);
*
* // allocate temporary buffers and initialize them with 0's
* Mat tempA(dftSize, A.type(), Scalar::all(0));
* Mat tempB(dftSize, B.type(), Scalar::all(0));
*
* // copy A and B to the top-left corners of tempA and tempB, respectively
* Mat roiA(tempA, Rect(0,0,A.cols,A.rows));
* A.copyTo(roiA);
* Mat roiB(tempB, Rect(0,0,B.cols,B.rows));
* B.copyTo(roiB);
*
* // now transform the padded A & B in-place;
* // use "nonzeroRows" hint for faster processing
* dft(tempA, tempA, 0, A.rows);
* dft(tempB, tempB, 0, B.rows);
*
* // multiply the spectrums;
* // the function handles packed spectrum representations well
* mulSpectrums(tempA, tempB, tempA);
*
* // transform the product back from the frequency domain.
* // Even though all the result rows will be non-zero,
* // you need only the first C.rows of them, and thus you
* // pass nonzeroRows == C.rows
* dft(tempA, tempA, DFT_INVERSE + DFT_SCALE, C.rows);
*
* // now copy the result back to C.
* tempA(Rect(0, 0, C.cols, C.rows)).copyTo(C);
*
* // all the temporary buffers will be deallocated automatically
* }
* ```
*
* To optimize this sample, consider the following approaches:
*
* Since nonzeroRows != 0 is passed to the forward transform calls and since A and B are copied to the
* top-left corners of tempA and tempB, respectively, it is not necessary to clear the whole tempA and
* tempB. It is only necessary to clear the tempA.cols - A.cols ( tempB.cols - B.cols) rightmost
* columns of the matrices.
* This DFT-based convolution does not have to be applied to the whole big arrays, especially if B is
* significantly smaller than A or vice versa. Instead, you can calculate convolution by parts. To do
* this, you need to split the output array C into multiple tiles. For each tile, estimate which parts
* of A and B are required to calculate convolution in this tile. If the tiles in C are too small, the
* speed will decrease a lot because of repeated work. In the ultimate case, when each tile in C is a
* single pixel, the algorithm becomes equivalent to the naive convolution algorithm. If the tiles are
* too big, the temporary arrays tempA and tempB become too big and there is also a slowdown because of
* bad cache locality. So, there is an optimal tile size somewhere in the middle.
* If different tiles in C can be calculated in parallel and, thus, the convolution is done by parts,
* the loop can be threaded.
*
* All of the above improvements have been implemented in [matchTemplate] and [filter2D] . Therefore,
* by using them, you can get the performance even better than with the above theoretically optimal
* implementation. Though, those two functions actually calculate cross-correlation, not convolution,
* so you need to "flip" the second convolution operand B vertically and horizontally using flip .
*
* An example using the discrete fourier transform can be found at
* opencv_source_code/samples/cpp/dft.cpp
* (Python) An example using the dft functionality to perform Wiener deconvolution can be found at
* opencv_source/samples/python/deconvolution.py
* (Python) An example rearranging the quadrants of a Fourier image can be found at
* opencv_source/samples/python/dft.py
*
* [dct] , [getOptimalDFTSize] , [mulSpectrums], [filter2D] , [matchTemplate] , [flip] , [cartToPolar]
* , [magnitude] , [phase]
*
* @param src input array that could be real or complex.
*
* @param dst output array whose size and type depends on the flags .
*
* @param flags transformation flags, representing a combination of the DftFlags
*
* @param nonzeroRows when the parameter is not zero, the function assumes that only the first
* nonzeroRows rows of the input array (DFT_INVERSE is not set) or only the first nonzeroRows of the
* output array (DFT_INVERSE is set) contain non-zeros, thus, the function can handle the rest of the
* rows more efficiently and save some time; this technique is very useful for calculating array
* cross-correlation or convolution using DFT.
*/
export declare function dft(src: InputArray, dst: OutputArray, flags?: int, nonzeroRows?: int): void
/**
* The function [cv::divide] divides one array by another: `\\[\\texttt{dst(I) =
* saturate(src1(I)*scale/src2(I))}\\]` or a scalar by an array when there is no src1 :
* `\\[\\texttt{dst(I) = saturate(scale/src2(I))}\\]`
*
* Different channels of multi-channel arrays are processed independently.
*
* For integer types when src2(I) is zero, dst(I) will also be zero.
*
* In case of floating point data there is no special defined behavior for zero src2(I) values. Regular
* floating-point division is used. Expect correct IEEE-754 behaviour for floating-point data (with
* NaN, Inf result values).
*
* Saturation is not applied when the output array has the depth CV_32S. You may even get result of an
* incorrect sign in the case of overflow.
*
* [multiply], [add], [subtract]
*
* @param src1 first input array.
*
* @param src2 second input array of the same size and type as src1.
*
* @param dst output array of the same size and type as src2.
*
* @param scale scalar factor.
*
* @param dtype optional depth of the output array; if -1, dst will have depth src2.depth(), but in
* case of an array-by-array division, you can only pass -1 when src1.depth()==src2.depth().
*/
export declare function divide(src1: InputArray, src2: InputArray, dst: OutputArray, scale?: double, dtype?: int): void
/**
* This is an overloaded member function, provided for convenience. It differs from the above function
* only in what argument(s) it accepts.
*/
export declare function divide(scale: double, src2: InputArray, dst: OutputArray, dtype?: int): void
/**
* The function [cv::eigen] calculates just eigenvalues, or eigenvalues and eigenvectors of the
* symmetric matrix src:
*
* ```cpp
* src*eigenvectors.row(i).t() = eigenvalues.at<srcType>(i)*eigenvectors.row(i).t()
* ```
*
* Use [cv::eigenNonSymmetric] for calculation of real eigenvalues and eigenvectors of non-symmetric
* matrix.
*
* [eigenNonSymmetric], [completeSymm] , [PCA]
*
* @param src input matrix that must have CV_32FC1 or CV_64FC1 type, square size and be symmetrical
* (src ^T^ == src).
*
* @param eigenvalues output vector of eigenvalues of the same type as src; the eigenvalues are stored
* in the descending order.
*
* @param eigenvectors output matrix of eigenvectors; it has the same size and type as src; the
* eigenvectors are stored as subsequent matrix rows, in the same order as the corresponding
* eigenvalues.
*/
export declare function eigen(src: InputArray, eigenvalues: OutputArray, eigenvectors?: OutputArray): bool
/**
* Assumes real eigenvalues.
* The function calculates eigenvalues and eigenvectors (optional) of the square matrix src:
*
* ```cpp
* src*eigenvectors.row(i).t() = eigenvalues.at<srcType>(i)*eigenvectors.row(i).t()
* ```
*
* [eigen]
*
* @param src input matrix (CV_32FC1 or CV_64FC1 type).
*
* @param eigenvalues output vector of eigenvalues (type is the same type as src).
*
* @param eigenvectors output matrix of eigenvectors (type is the same type as src). The eigenvectors
* are stored as subsequent matrix rows, in the same order as the corresponding eigenvalues.
*/
export declare function eigenNonSymmetric(src: InputArray, eigenvalues: OutputArray, eigenvectors: OutputArray): void
/**
* The function [cv::exp] calculates the exponent of every element of the input array:
* `\\[\\texttt{dst} [I] = e^{ src(I) }\\]`
*
* The maximum relative error is about 7e-6 for single-precision input and less than 1e-10 for
* double-precision input. Currently, the function converts denormalized values to zeros on output.
* Special values (NaN, Inf) are not handled.
*
* [log] , [cartToPolar] , [polarToCart] , [phase] , [pow] , [sqrt] , [magnitude]
*
* @param src input array.
*
* @param dst output array of the same size and type as src.
*/
export declare function exp(src: InputArray, dst: OutputArray): void
/**
* [mixChannels], [split]
*
* @param src input array
*
* @param dst output array
*
* @param coi index of channel to extract
*/
export declare function extractChannel(src: InputArray, dst: OutputArray, coi: int): void
/**
* Given a binary matrix (likely returned from an operation such as [threshold()], [compare()], >, ==,
* etc, return all of the non-zero indices as a [cv::Mat] or std::vector<cv::Point> (x,y) For example:
*
* ```cpp
* cv::Mat binaryImage; // input, binary image
* cv::Mat locations; // output, locations of non-zero pixels
* cv::findNonZero(binaryImage, locations);
*
* // access pixel coordinates
* Point pnt = locations.at<Point>(i);
* ```
*
* or
*
* ```cpp
* cv::Mat binaryImage; // input, binary image
* vector<Point> locations; // output, locations of non-zero pixels
* cv::findNonZero(binaryImage, locations);
*
* // access pixel coordinates
* Point pnt = locations[i];
* ```
*
* @param src single-channel array
*
* @param idx the output array, type of cv::Mat or std::vector<Point>, corresponding to non-zero
* indices in the input
*/
export declare function findNonZero(src: InputArray, idx: OutputArray): void
/**
* The function [cv::flip] flips the array in one of three different ways (row and column indices are
* 0-based): `\\[\\texttt{dst} _{ij} = \\left\\{ \\begin{array}{l l} \\texttt{src}
* _{\\texttt{src.rows}-i-1,j} & if\\; \\texttt{flipCode} = 0 \\\\ \\texttt{src} _{i,
* \\texttt{src.cols} -j-1} & if\\; \\texttt{flipCode} > 0 \\\\ \\texttt{src} _{ \\texttt{src.rows}
* -i-1, \\texttt{src.cols} -j-1} & if\\; \\texttt{flipCode} < 0 \\\\ \\end{array} \\right.\\]` The
* example scenarios of using the function are the following: Vertical flipping of the image (flipCode
* == 0) to switch between top-left and bottom-left image origin. This is a typical operation in video
* processing on Microsoft Windows* OS. Horizontal flipping of the image with the subsequent horizontal
* shift and absolute difference calculation to check for a vertical-axis symmetry (flipCode > 0).
* Simultaneous horizontal and vertical flipping of the image with the subsequent shift and absolute
* difference calculation to check for a central symmetry (flipCode < 0). Reversing the order of point
* arrays (flipCode > 0 or flipCode == 0).
*
* [transpose] , [repeat] , [completeSymm]
*
* @param src input array.
*
* @param dst output array of the same size and type as src.
*
* @param flipCode a flag to specify how to flip the array; 0 means flipping around the x-axis and
* positive value (for example, 1) means flipping around y-axis. Negative value (for example, -1) means
* flipping around both axes.
*/
export declare function flip(src: InputArray, dst: OutputArray, flipCode: int): void
/**
* The function [cv::gemm] performs generalized matrix multiplication similar to the gemm functions in
* BLAS level 3. For example, `gemm(src1, src2, alpha, src3, beta, dst, GEMM_1_T + GEMM_3_T)`
* corresponds to `\\[\\texttt{dst} = \\texttt{alpha} \\cdot \\texttt{src1} ^T \\cdot \\texttt{src2} +
* \\texttt{beta} \\cdot \\texttt{src3} ^T\\]`
*
* In case of complex (two-channel) data, performed a complex matrix multiplication.
*
* The function can be replaced with a matrix expression. For example, the above call can be replaced
* with:
*
* ```cpp
* dst = alpha*src1.t()*src2 + beta*src3.t();
* ```
*
* [mulTransposed] , [transform]
*
* @param src1 first multiplied input matrix that could be real(CV_32FC1, CV_64FC1) or
* complex(CV_32FC2, CV_64FC2).
*
* @param src2 second multiplied input matrix of the same type as src1.
*
* @param alpha weight of the matrix product.
*
* @param src3 third optional delta matrix added to the matrix product; it should have the same type as
* src1 and src2.
*
* @param beta weight of src3.
*
* @param dst output matrix; it has the proper size and the same type as input matrices.
*
* @param flags operation flags (cv::GemmFlags)
*/
export declare function gemm(src1: InputArray, src2: InputArray, alpha: double, src3: InputArray, beta: double, dst: OutputArray, flags?: int): void
/**
* DFT performance is not a monotonic function of a vector size. Therefore, when you calculate
* convolution of two arrays or perform the spectral analysis of an array, it usually makes sense to
* pad the input data with zeros to get a bit larger array that can be transformed much faster than the
* original one. Arrays whose size is a power-of-two (2, 4, 8, 16, 32, ...) are the fastest to process.
* Though, the arrays whose size is a product of 2's, 3's, and 5's (for example, 300 = 5*5*3*2*2) are
* also processed quite efficiently.
*
* The function [cv::getOptimalDFTSize] returns the minimum number N that is greater than or equal to
* vecsize so that the DFT of a vector of size N can be processed efficiently. In the current
* implementation N = 2 ^p^ * 3 ^q^ * 5 ^r^ for some integer p, q, r.
*
* The function returns a negative number if vecsize is too large (very close to INT_MAX ).
*
* While the function cannot be used directly to estimate the optimal vector size for DCT transform
* (since the current DCT implementation supports only even-size vectors), it can be easily processed
* as getOptimalDFTSize((vecsize+1)/2)*2.
*
* [dft] , [dct] , [idft] , [idct] , [mulSpectrums]
*
* @param vecsize vector size.
*/
export declare function getOptimalDFTSize(vecsize: int): int
/**
* The function horizontally concatenates two or more [cv::Mat] matrices (with the same number of
* rows).
*
* ```cpp
* cv::Mat matArray[] = { cv::Mat(4, 1, CV_8UC1, cv::Scalar(1)),
* cv::Mat(4, 1, CV_8UC1, cv::Scalar(2)),
* cv::Mat(4, 1, CV_8UC1, cv::Scalar(3)),};
*
* cv::Mat out;
* cv::hconcat( matArray, 3, out );
* //out:
* //[1, 2, 3;
* // 1, 2, 3;
* // 1, 2, 3;
* // 1, 2, 3]
* ```
*
* [cv::vconcat(const Mat*, size_t, OutputArray)],
*
* [cv::vconcat(InputArrayOfArrays, OutputArray)] and
*
* [cv::vconcat(InputArray, InputArray, OutputArray)]
*
* @param src input array or vector of matrices. all of the matrices must have the same number of rows
* and the same depth.
*
* @param nsrc number of matrices in src.
*
* @param dst output array. It has the same number of rows and depth as the src, and the sum of cols of
* the src.
*/
export declare function hconcat(src: any, nsrc: size_t, dst: OutputArray): void
/**
* This is an overloaded member function, provided for convenience. It differs from the above function
* only in what argument(s) it accepts.
*
* ```cpp
* cv::Mat_<float> A = (cv::Mat_<float>(3, 2) << 1, 4,
* 2, 5,
* 3, 6);
* cv::Mat_<float> B = (cv::Mat_<float>(3, 2) << 7, 10,
* 8, 11,
* 9, 12);
*
* cv::Mat C;
* cv::hconcat(A, B, C);
* //C:
* //[1, 4, 7, 10;
* // 2, 5, 8, 11;
* // 3, 6, 9, 12]
* ```
*
* @param src1 first input array to be considered for horizontal concatenation.
*
* @param src2 second input array to be considered for horizontal concatenation.
*
* @param dst output array. It has the same number of rows and depth as the src1 and src2, and the sum
* of cols of the src1 and src2.
*/
export declare function hconcat(src1: InputArray, src2: InputArray, dst: OutputArray): void
/**
* This is an overloaded member function, provided for convenience. It differs from the above function
* only in what argument(s) it accepts.
*
* ```cpp
* std::vector<cv::Mat> matrices = { cv::Mat(4, 1, CV_8UC1, cv::Scalar(1)),
* cv::Mat(4, 1, CV_8UC1, cv::Scalar(2)),
* cv::Mat(4, 1, CV_8UC1, cv::Scalar(3)),};
*
* cv::Mat out;
* cv::hconcat( matrices, out );
* //out:
* //[1, 2, 3;
* // 1, 2, 3;
* // 1, 2, 3;
* // 1, 2, 3]
* ```
*
* @param src input array or vector of matrices. all of the matrices must have the same number of rows
* and the same depth.
*
* @param dst output array. It has the same number of rows and depth as the src, and the sum of cols of
* the src. same depth.
*/
export declare function hconcat(src: InputArrayOfArrays, dst: OutputArray): void
/**
* idct(src, dst, flags) is equivalent to dct(src, dst, flags | DCT_INVERSE).
*
* [dct], [dft], [idft], [getOptimalDFTSize]