Skip to content

Commit 90c46a6

Browse files
lukaszkurantdevlukaszkurantdev
committed
feat: compare and bitwise functions extensions
1 parent c4a384a commit 90c46a6

File tree

4 files changed

+205
-31
lines changed

4 files changed

+205
-31
lines changed

‎cpp/FOCV_Function.cpp

Lines changed: 130 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -93,17 +93,48 @@ jsi::Object FOCV_Function::invoke(jsi::Runtime& runtime, const jsi::Value* argum
9393
cv::batchDistance(*src1, *src2, *dist, dtype, *nidx, normType, K, *mask, update, crosscheck);
9494
} break;
9595
case hashString("bitwise_and", 11): {
96-
auto src1 = args.asMatPtr(1);
97-
auto src2 = args.asMatPtr(2);
9896
auto dst = args.asMatPtr(3);
9997

100-
if (count > 4) {
101-
auto mask = args.asMatPtr(4);
98+
if (args.isMat(1)) {
99+
auto src1 = args.asMatPtr(1);
102100

103-
cv::bitwise_and(*src1, *src2, *dst, *mask);
104-
break;
101+
if(args.isScalar(2)) {
102+
auto src2 = args.asScalarPtr(2);
103+
cv::bitwise_and(*src1, *src2, *dst);
104+
105+
if (count > 4) {
106+
auto mask = args.asMatPtr(4);
107+
108+
cv::bitwise_and(*src1, *src2, *dst, *mask);
109+
break;
110+
}
111+
112+
} else {
113+
auto src2 = args.asMatPtr(2);
114+
115+
if (count > 4) {
116+
auto mask = args.asMatPtr(4);
117+
118+
cv::bitwise_and(*src1, *src2, *dst, *mask);
119+
break;
120+
}
121+
122+
cv::bitwise_and(*src1, *src2, *dst);
123+
}
124+
} else {
125+
auto src1 = args.asScalarPtr(1);
126+
auto src2 = args.asMatPtr(2);
127+
128+
129+
if (count > 4) {
130+
auto mask = args.asMatPtr(4);
131+
132+
cv::bitwise_and(*src1, *src2, *dst, *mask);
133+
break;
134+
}
135+
136+
cv::bitwise_and(*src1, *src2, *dst);
105137
}
106-
cv::bitwise_and(*src1, *src2, *dst);
107138
} break;
108139
case hashString("bitwise_not", 11): {
109140
auto src = args.asMatPtr(1);
@@ -118,30 +149,90 @@ jsi::Object FOCV_Function::invoke(jsi::Runtime& runtime, const jsi::Value* argum
118149
cv::bitwise_not(*src, *dst);
119150
} break;
120151
case hashString("bitwise_or", 10): {
121-
auto src1 = args.asMatPtr(1);
122-
auto src2 = args.asMatPtr(2);
123152
auto dst = args.asMatPtr(3);
124153

125-
if (count > 4) {
126-
auto mask = args.asMatPtr(4);
154+
if (args.isMat(1)) {
155+
auto src1 = args.asMatPtr(1);
127156

128-
cv::bitwise_or(*src1, *src2, *dst, *mask);
129-
break;
157+
if(args.isScalar(2)) {
158+
auto src2 = args.asScalarPtr(2);
159+
cv::bitwise_or(*src1, *src2, *dst);
160+
161+
if (count > 4) {
162+
auto mask = args.asMatPtr(4);
163+
164+
cv::bitwise_or(*src1, *src2, *dst, *mask);
165+
break;
166+
}
167+
168+
} else {
169+
auto src2 = args.asMatPtr(2);
170+
171+
if (count > 4) {
172+
auto mask = args.asMatPtr(4);
173+
174+
cv::bitwise_or(*src1, *src2, *dst, *mask);
175+
break;
176+
}
177+
178+
cv::bitwise_or(*src1, *src2, *dst);
179+
}
180+
} else {
181+
auto src1 = args.asScalarPtr(1);
182+
auto src2 = args.asMatPtr(2);
183+
184+
if (count > 4) {
185+
auto mask = args.asMatPtr(4);
186+
187+
cv::bitwise_or(*src1, *src2, *dst, *mask);
188+
break;
189+
}
190+
191+
cv::bitwise_or(*src1, *src2, *dst);
130192
}
131-
cv::bitwise_or(*src1, *src2, *dst);
132193
} break;
133194
case hashString("bitwise_xor", 11): {
134-
auto src1 = args.asMatPtr(1);
135-
auto src2 = args.asMatPtr(2);
136195
auto dst = args.asMatPtr(3);
137196

138-
if (count > 4) {
139-
auto mask = args.asMatPtr(4);
197+
if (args.isMat(1)) {
198+
auto src1 = args.asMatPtr(1);
140199

141-
cv::bitwise_xor(*src1, *src2, *dst, *mask);
142-
break;
200+
if(args.isScalar(2)) {
201+
auto src2 = args.asScalarPtr(2);
202+
cv::bitwise_xor(*src1, *src2, *dst);
203+
204+
if (count > 4) {
205+
auto mask = args.asMatPtr(4);
206+
207+
cv::bitwise_xor(*src1, *src2, *dst, *mask);
208+
break;
209+
}
210+
211+
} else {
212+
auto src2 = args.asMatPtr(2);
213+
214+
if (count > 4) {
215+
auto mask = args.asMatPtr(4);
216+
217+
cv::bitwise_xor(*src1, *src2, *dst, *mask);
218+
break;
219+
}
220+
221+
cv::bitwise_xor(*src1, *src2, *dst);
222+
}
223+
} else {
224+
auto src1 = args.asScalarPtr(1);
225+
auto src2 = args.asMatPtr(2);
226+
227+
if (count > 4) {
228+
auto mask = args.asMatPtr(4);
229+
230+
cv::bitwise_xor(*src1, *src2, *dst, *mask);
231+
break;
232+
}
233+
234+
cv::bitwise_xor(*src1, *src2, *dst);
143235
}
144-
cv::bitwise_xor(*src1, *src2, *dst);
145236
} break;
146237
case hashString("borderInterpolate", 17): {
147238
auto p = args.asNumber(1);
@@ -203,12 +294,26 @@ jsi::Object FOCV_Function::invoke(jsi::Runtime& runtime, const jsi::Value* argum
203294
} break;
204295

205296
case hashString("compare", 7): {
206-
auto src1 = args.asMatPtr(1);
207-
auto src2 = args.asMatPtr(2);
208-
auto dst = args.asMatPtr(3);
209297
auto cmpop = args.asNumber(4);
298+
auto dst = args.asMatPtr(3);
210299

211-
cv::compare(*src1, *src2, *dst, cmpop);
300+
if (args.isMat(1)) {
301+
auto src1 = args.asMatPtr(1);
302+
303+
if(args.isScalar(2)) {
304+
auto src2 = args.asScalarPtr(2);
305+
cv::compare(*src1, *src2, *dst, cmpop);
306+
} else {
307+
auto src2 = args.asMatPtr(2);
308+
cv::compare(*src1, *src2, *dst, cmpop);
309+
}
310+
} else {
311+
auto src1 = args.asScalarPtr(1);
312+
auto src2 = args.asMatPtr(2);
313+
314+
cv::compare(*src1, *src2, *dst, cmpop);
315+
}
316+
212317
} break;
213318
case hashString("completeSymm", 12): {
214319
auto lowerToUpper = args.asBool(2);

‎docs/pages/apidetails.md

Lines changed: 13 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -61,6 +61,19 @@ copyObjectFromVector(vector: RectVector, itemIndex: number): Rect;
6161

6262
---
6363

64+
### Add Object to Vector
65+
66+
Adds an object to a vector.
67+
68+
```js
69+
addObjectToVector(vector: MatVector, object: Mat): void;
70+
addObjectToVector(vector: PointVector, object: Point): void;
71+
addObjectToVector(vector: RectVector, object: Rect): void;
72+
addObjectToVector(vector: PointVectorOfVectors, object: PointVector): void;
73+
```
74+
75+
---
76+
6477
### To JS Value
6578

6679
Converts an object to a JS-readable object.

‎docs/pages/availablefunctions.md

Lines changed: 13 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -88,7 +88,8 @@ computes bitwise conjunction of the two arrays (dst = src1 & src2) Calculates th
8888
- mask optional operation mask, 8-bit single channel array, that specifies elements of the output array to be changed.
8989

9090
```js
91-
invoke(name: 'bitwise_and', src1: Mat, src2: Mat, dst: Mat, mask?: Mat): void;
91+
invoke(name: 'bitwise_and', src1: Mat, src2: Mat | Scalar, dst: Mat, mask?: Mat)
92+
invoke(name: 'bitwise_and', src1: Scalar, src2: Mat, dst: Mat, mask?: Mat): void;
9293
```
9394

9495
### bitwise_not
@@ -113,7 +114,8 @@ Calculates the per-element bit-wise disjunction of two arrays or an array and a
113114
- mask optional operation mask, 8-bit single channel array, that specifies elements of the output array to be changed.
114115

115116
```js
116-
invoke(name: 'bitwise_or', src1: Mat, src2: Mat, dst: Mat, mask?: Mat): void;
117+
invoke(name: 'bitwise_or', src1: Mat, src2: Mat | Scalar, dst: Mat, mask?: Mat): void;
118+
invoke(name: 'bitwise_or', src1: Scalar, src2: Mat, dst: Mat, mask?: Mat): void;
117119
```
118120

119121
### bitwise_xor
@@ -126,7 +128,8 @@ Calculates the per-element bit-wise "exclusive or" operation on two arrays or an
126128
- mask optional operation mask, 8-bit single channel array, that specifies elements of the output array to be changed.
127129

128130
```js
129-
invoke(name: 'bitwise_xor', src1: Mat, src2: Mat, dst: Mat, mask?: Mat): void;
131+
invoke(name: 'bitwise_xor', src1: Mat, src2: Mat | Scalar, dst: Mat, mask?: Mat)
132+
invoke(name: 'bitwise_xor', src1: Scalar, src2: Mat, dst: Mat, mask?: Mat): void;
130133
```
131134

132135
### borderInterpolate
@@ -242,6 +245,13 @@ Performs the per-element comparison of two arrays or an array and scalar value
242245
invoke(
243246
name: 'compare',
244247
src1: Mat,
248+
src2: Mat | Scalar,
249+
dst: Mat,
250+
cmpop: CmpTypes
251+
): void;
252+
invoke(
253+
name: 'compare',
254+
src1: Scalar,
245255
src2: Mat,
246256
dst: Mat,
247257
cmpop: CmpTypes

‎src/functions/Core.ts

Lines changed: 49 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -99,7 +99,20 @@ export type Core = {
9999
* @param dst output array that has the same size and type as the input arrays.
100100
* @param mask optional operation mask, 8-bit single channel array, that specifies elements of the output array to be changed.
101101
*/
102-
invoke(name: 'bitwise_and', src1: Mat, src2: Mat, dst: Mat, mask?: Mat): void;
102+
invoke(
103+
name: 'bitwise_and',
104+
src1: Mat,
105+
src2: Mat | Scalar,
106+
dst: Mat,
107+
mask?: Mat
108+
): void;
109+
invoke(
110+
name: 'bitwise_and',
111+
src1: Scalar,
112+
src2: Mat,
113+
dst: Mat,
114+
mask?: Mat
115+
): void;
103116
/**
104117
* Inverts every bit of an array.
105118
* @param name Function name.
@@ -116,7 +129,20 @@ export type Core = {
116129
* @param dst output array that has the same size and type as the input arrays.
117130
* @param mask optional operation mask, 8-bit single channel array, that specifies elements of the output array to be changed.
118131
*/
119-
invoke(name: 'bitwise_or', src1: Mat, src2: Mat, dst: Mat, mask?: Mat): void;
132+
invoke(
133+
name: 'bitwise_or',
134+
src1: Mat,
135+
src2: Mat | Scalar,
136+
dst: Mat,
137+
mask?: Mat
138+
): void;
139+
invoke(
140+
name: 'bitwise_or',
141+
src1: Scalar,
142+
src2: Mat,
143+
dst: Mat,
144+
mask?: Mat
145+
): void;
120146
/**
121147
* Calculates the per-element bit-wise "exclusive or" operation on two arrays or an array and a scalar.
122148
* @param name Function name.
@@ -125,7 +151,20 @@ export type Core = {
125151
* @param dst output array that has the same size and type as the input arrays.
126152
* @param mask optional operation mask, 8-bit single channel array, that specifies elements of the output array to be changed.
127153
*/
128-
invoke(name: 'bitwise_xor', src1: Mat, src2: Mat, dst: Mat, mask?: Mat): void;
154+
invoke(
155+
name: 'bitwise_xor',
156+
src1: Mat,
157+
src2: Mat | Scalar,
158+
dst: Mat,
159+
mask?: Mat
160+
): void;
161+
invoke(
162+
name: 'bitwise_xor',
163+
src1: Scalar,
164+
src2: Mat,
165+
dst: Mat,
166+
mask?: Mat
167+
): void;
129168

130169
/**
131170
* Computes the source location of an extrapolated pixel.
@@ -222,6 +261,13 @@ export type Core = {
222261
invoke(
223262
name: 'compare',
224263
src1: Mat,
264+
src2: Mat | Scalar,
265+
dst: Mat,
266+
cmpop: CmpTypes
267+
): void;
268+
invoke(
269+
name: 'compare',
270+
src1: Scalar,
225271
src2: Mat,
226272
dst: Mat,
227273
cmpop: CmpTypes

0 commit comments

Comments
 (0)