Skip to content

Commit 3fd9848

Browse files
lukaszkurantdevlukaszkurantdev
committed
refactor: smart pointers with arguments container
1 parent a1e2cc3 commit 3fd9848

File tree

8 files changed

+1565
-1431
lines changed

8 files changed

+1565
-1431
lines changed

‎cpp/FOCV_Function.cpp

Lines changed: 1337 additions & 1353 deletions
Large diffs are not rendered by default.

‎cpp/FOCV_FunctionArguments.cpp

Lines changed: 84 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,84 @@
1+
//
2+
// FOCV_FunctionArguments.cpp
3+
// react-native-fast-opencv
4+
//
5+
// Created by Łukasz Kurant on 20/08/2024.
6+
//
7+
8+
#include "FOCV_FunctionArguments.hpp"
9+
#include <opencv2/opencv.hpp>
10+
#include "FOCV_Storage.hpp"
11+
#include "FOCV_JsiObject.hpp"
12+
13+
FOCV_FunctionArguments::FOCV_FunctionArguments(jsi::Runtime& runtime, const jsi::Value* arguments) {
14+
this->arguments = arguments;
15+
this->runtime = &runtime;
16+
}
17+
18+
double FOCV_FunctionArguments::asNumber(int index) {
19+
return this->arguments[index].asNumber();
20+
}
21+
22+
bool FOCV_FunctionArguments::asBool(int index) {
23+
return this->arguments[index].asBool();
24+
}
25+
26+
std::string FOCV_FunctionArguments::asString(int index) {
27+
return this->arguments[index].asString(*this->runtime).utf8(*this->runtime);
28+
}
29+
30+
std::shared_ptr<cv::Mat> FOCV_FunctionArguments::asMatPtr(int index) {
31+
return FOCV_Storage::get<cv::Mat>(FOCV_JsiObject::id_from_wrap(*this->runtime, arguments[index]));
32+
}
33+
34+
std::shared_ptr<std::vector<cv::Mat>> FOCV_FunctionArguments::asMatVectorPtr(int index) {
35+
return FOCV_Storage::get<std::vector<cv::Mat>>(FOCV_JsiObject::id_from_wrap(*this->runtime, arguments[index]));
36+
}
37+
38+
std::shared_ptr<cv::Point> FOCV_FunctionArguments::asPointPtr(int index) {
39+
return FOCV_Storage::get<cv::Point>(FOCV_JsiObject::id_from_wrap(*this->runtime, arguments[index]));
40+
}
41+
42+
std::shared_ptr<std::vector<cv::Point>> FOCV_FunctionArguments::asPointVectorPtr(int index) {
43+
return FOCV_Storage::get<std::vector<cv::Point>>(FOCV_JsiObject::id_from_wrap(*this->runtime, arguments[index]));
44+
}
45+
46+
std::shared_ptr<cv::Rect> FOCV_FunctionArguments::asRectPtr(int index) {
47+
return FOCV_Storage::get<cv::Rect>(FOCV_JsiObject::id_from_wrap(*this->runtime, arguments[index]));
48+
}
49+
50+
std::shared_ptr<std::vector<cv::Rect>> FOCV_FunctionArguments::asRectVectorPtr(int index) {
51+
return FOCV_Storage::get<std::vector<cv::Rect>>(FOCV_JsiObject::id_from_wrap(*this->runtime, arguments[index]));
52+
}
53+
54+
std::shared_ptr<cv::Size> FOCV_FunctionArguments::asSizePtr(int index) {
55+
return FOCV_Storage::get<cv::Size>(FOCV_JsiObject::id_from_wrap(*this->runtime, arguments[index]));
56+
}
57+
58+
std::shared_ptr<cv::Scalar> FOCV_FunctionArguments::asScalarPtr(int index) {
59+
return FOCV_Storage::get<cv::Scalar>(FOCV_JsiObject::id_from_wrap(*this->runtime, arguments[index]));
60+
}
61+
62+
std::shared_ptr<cv::RotatedRect> FOCV_FunctionArguments::asRotatedRectPtr(int index) {
63+
return FOCV_Storage::get<cv::RotatedRect>(FOCV_JsiObject::id_from_wrap(*this->runtime, arguments[index]));
64+
}
65+
66+
bool FOCV_FunctionArguments::isNumber(int index) {
67+
return this->arguments[index].isNumber();
68+
}
69+
70+
bool FOCV_FunctionArguments::isBool(int index) {
71+
return this->arguments[index].isNumber();
72+
}
73+
74+
bool FOCV_FunctionArguments::isString(int index) {
75+
return this->arguments[index].isNumber();
76+
}
77+
78+
bool FOCV_FunctionArguments::isObject(int index) {
79+
return this->arguments[index].isNumber();
80+
}
81+
82+
bool FOCV_FunctionArguments::isMat(int index) {
83+
return FOCV_JsiObject::type_from_wrap(*this->runtime, arguments[index]) == "mat";
84+
}

‎cpp/FOCV_FunctionArguments.hpp

Lines changed: 59 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,59 @@
1+
//
2+
// FOCV_FunctionArguments.hpp
3+
// react-native-fast-opencv
4+
//
5+
// Created by Łukasz Kurant on 20/08/2024.
6+
//
7+
8+
#ifndef FOCV_FunctionArguments_hpp
9+
#define FOCV_FunctionArguments_hpp
10+
11+
#include <jsi/jsilib.h>
12+
#include <jsi/jsi.h>
13+
#include <stdio.h>
14+
15+
#ifdef __cplusplus
16+
#undef YES
17+
#undef NO
18+
#include <opencv2/opencv.hpp>
19+
using namespace cv;
20+
#if __has_feature(objc_bool)
21+
#define YES __objc_yes
22+
#define NO __objc_no
23+
#else
24+
#define YES ((BOOL)1)
25+
#define NO ((BOOL)0)
26+
#endif
27+
#endif
28+
29+
using namespace facebook;
30+
31+
class FOCV_FunctionArguments {
32+
private:
33+
const jsi::Value* arguments;
34+
jsi::Runtime* runtime;
35+
36+
public:
37+
FOCV_FunctionArguments(jsi::Runtime& runtime, const jsi::Value* arguments);
38+
double asNumber(int index);
39+
bool asBool(int index);
40+
std::string asString(int index);
41+
42+
std::shared_ptr<cv::Mat> asMatPtr(int index);
43+
std::shared_ptr<std::vector<cv::Mat>> asMatVectorPtr(int index);
44+
std::shared_ptr<cv::Point> asPointPtr(int index);
45+
std::shared_ptr<std::vector<cv::Point>> asPointVectorPtr(int index);
46+
std::shared_ptr<cv::Rect> asRectPtr(int index);
47+
std::shared_ptr<std::vector<cv::Rect>> asRectVectorPtr(int index);
48+
std::shared_ptr<cv::Size> asSizePtr(int index);
49+
std::shared_ptr<cv::Scalar> asScalarPtr(int index);
50+
std::shared_ptr<cv::RotatedRect> asRotatedRectPtr(int index);
51+
52+
bool isNumber(int index);
53+
bool isBool(int index);
54+
bool isString(int index);
55+
bool isObject(int index);
56+
bool isMat(int index);
57+
};
58+
59+
#endif /* FOCV_FunctionArguments_hpp */

‎cpp/FOCV_Object.cpp

Lines changed: 39 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -25,47 +25,55 @@ constexpr uint64_t hashString(const char* str, size_t length) {
2525
}
2626

2727
jsi::Object FOCV_Object::create(jsi::Runtime& runtime, const jsi::Value* arguments) {
28-
std::any object;
28+
std::string id = "";
2929
std::string objectType = arguments[0].asString(runtime).utf8(runtime);
3030

3131
switch(hashString(objectType.c_str(), objectType.size())) {
3232
case hashString("mat", 3): {
3333
int rows = arguments[1].asNumber();
3434
int cols = arguments[2].asNumber();
3535
int type = arguments[3].asNumber();
36-
object = cv::Mat(rows, cols, type);
36+
cv::Mat object(rows, cols, type);
37+
id = FOCV_Storage::save(object);
3738
} break;
3839
case hashString("mat_vector", 10): {
39-
object = std::vector<cv::Mat>();
40+
std::vector<cv::Mat> object;
41+
id = FOCV_Storage::save(object);
4042
} break;
4143
case hashString("rect", 4): {
4244
int x = arguments[1].asNumber();
4345
int y = arguments[2].asNumber();
4446
int width = arguments[3].asNumber();
4547
int height = arguments[4].asNumber();
46-
object = cv::Rect(x, y, width, height);
48+
cv::Rect object(x, y, width, height);
49+
id = FOCV_Storage::save(object);
4750
} break;
4851
case hashString("rect_vector", 11): {
49-
object = std::vector<cv::Rect>();
52+
std::vector<cv::Rect> object;
53+
id = FOCV_Storage::save(object);
5054
} break;
5155
case hashString("point", 5): {
5256
int x = arguments[1].asNumber();
5357
int y = arguments[2].asNumber();
54-
object = cv::Point(x, y);
58+
cv::Point object(x, y);
59+
id = FOCV_Storage::save(object);
5560
} break;
5661
case hashString("point_vector", 12): {
57-
object = std::vector<cv::Point>();
62+
std::vector<cv::Point> object;
63+
id = FOCV_Storage::save(object);
5864
} break;
5965
case hashString("size", 4): {
6066
int width = arguments[1].asNumber();
6167
int height = arguments[2].asNumber();
62-
object = cv::Size(width, height);
68+
cv::Size object(width, height);
69+
id = FOCV_Storage::save(object);
6370
} break;
6471
case hashString("vec3b", 5): {
6572
int a = arguments[1].asNumber();
6673
int b = arguments[2].asNumber();
6774
int c = arguments[3].asNumber();
68-
object = cv::Vec3b(a, b, c);
75+
cv::Vec3b object(a, b, c);
76+
id = FOCV_Storage::save(object);
6977
} break;
7078
case hashString("scalar", 6): {
7179
if(arguments[4].isNumber()) {
@@ -74,16 +82,19 @@ jsi::Object FOCV_Object::create(jsi::Runtime& runtime, const jsi::Value* argumen
7482
int c = arguments[3].asNumber();
7583
int d = arguments[3].asNumber();
7684

77-
object = cv::Scalar(a, b, c, d);
85+
cv::Scalar object(a, b, c, d);
86+
id = FOCV_Storage::save(object);
7887
} else if(arguments[3].isNumber()) {
7988
int a = arguments[1].asNumber();
8089
int b = arguments[2].asNumber();
8190
int c = arguments[3].asNumber();
8291

83-
object = cv::Scalar(a, b, c);
92+
cv::Scalar object(a, b, c);
93+
id = FOCV_Storage::save(object);
8494
} else {
8595
int a = arguments[1].asNumber();
86-
object = cv::Scalar(a);
96+
cv::Scalar object(a);
97+
id = FOCV_Storage::save(object);
8798
}
8899
} break;
89100
case hashString("rotated_rect", 12): {
@@ -93,11 +104,12 @@ jsi::Object FOCV_Object::create(jsi::Runtime& runtime, const jsi::Value* argumen
93104
int height = arguments[4].asNumber();
94105
int angle = arguments[5].asNumber();
95106

96-
object = cv::RotatedRect(cv::Point(x,y), cv::Size(width, height), angle);
107+
cv::RotatedRect object(cv::Point(x,y), cv::Size(width, height), angle);
108+
id = FOCV_Storage::save(object);
97109
} break;
98110
}
99111

100-
std::string id = FOCV_Storage::save(object);
112+
101113
return FOCV_JsiObject::wrap(runtime, objectType, id);
102114
}
103115

@@ -108,15 +120,15 @@ jsi::Object FOCV_Object::convertToJSI(jsi::Runtime& runtime, const jsi::Value* a
108120

109121
switch(hashString(objectType.c_str(), objectType.size())) {
110122
case hashString("mat", 3): {
111-
cv::Mat mat = FOCV_Storage::get<cv::Mat>(id);
123+
auto mat = *FOCV_Storage::get<cv::Mat>(id);
112124

113125
value.setProperty(runtime, "base64", jsi::String::createFromUtf8(runtime, ImageConverter::mat2str(mat)));
114126
value.setProperty(runtime, "size", jsi::Value(mat.size));
115127
value.setProperty(runtime, "cols", jsi::Value(mat.cols));
116128
value.setProperty(runtime, "rows", jsi::Value(mat.rows));
117129
} break;
118130
case hashString("mat_vector", 10): {
119-
std::vector<cv::Mat> mats = FOCV_Storage::get<std::vector<cv::Mat>>(id);
131+
auto mats = *FOCV_Storage::get<std::vector<cv::Mat>>(id);
120132

121133
auto array = jsi::Array(runtime, mats.size());
122134

@@ -132,15 +144,15 @@ jsi::Object FOCV_Object::convertToJSI(jsi::Runtime& runtime, const jsi::Value* a
132144
value.setProperty(runtime, "array", array);
133145
} break;
134146
case hashString("rect", 4): {
135-
cv::Rect rect = FOCV_Storage::get<cv::Rect>(id);
147+
auto rect = *FOCV_Storage::get<cv::Rect>(id);
136148

137149
value.setProperty(runtime, "x", jsi::Value(rect.x));
138150
value.setProperty(runtime, "y", jsi::Value(rect.y));
139151
value.setProperty(runtime, "width", jsi::Value(rect.width));
140152
value.setProperty(runtime, "height", jsi::Value(rect.height));
141153
} break;
142154
case hashString("rect_vector", 11): {
143-
std::vector<cv::Rect> rects = FOCV_Storage::get<std::vector<cv::Rect>>(id);
155+
auto rects = *FOCV_Storage::get<std::vector<cv::Rect>>(id);
144156

145157
auto array = jsi::Array(runtime, rects.size());
146158

@@ -157,13 +169,13 @@ jsi::Object FOCV_Object::convertToJSI(jsi::Runtime& runtime, const jsi::Value* a
157169
value.setProperty(runtime, "array", array);
158170
} break;
159171
case hashString("point", 5): {
160-
cv::Point point = FOCV_Storage::get<cv::Point>(id);
172+
auto point = *FOCV_Storage::get<cv::Point>(id);
161173

162174
value.setProperty(runtime, "x", jsi::Value(point.x));
163175
value.setProperty(runtime, "y", jsi::Value(point.y));
164176
} break;
165177
case hashString("point_vector", 12): {
166-
std::vector<cv::Point> points = FOCV_Storage::get<std::vector<cv::Point>>(id);
178+
auto points = *FOCV_Storage::get<std::vector<cv::Point>>(id);
167179

168180
auto array = jsi::Array(runtime, points.size());
169181

@@ -178,28 +190,28 @@ jsi::Object FOCV_Object::convertToJSI(jsi::Runtime& runtime, const jsi::Value* a
178190
value.setProperty(runtime, "array", array);
179191
} break;
180192
case hashString("size", 4): {
181-
cv::Size size = FOCV_Storage::get<cv::Size>(id);
193+
auto size = *FOCV_Storage::get<cv::Size>(id);
182194

183195
value.setProperty(runtime, "width", jsi::Value(size.width));
184196
value.setProperty(runtime, "height", jsi::Value(size.height));
185197
} break;
186198
case hashString("vec3b", 5): {
187-
cv::Vec3b vec = FOCV_Storage::get<cv::Vec3b>(id);
199+
auto vec = *FOCV_Storage::get<cv::Vec3b>(id);
188200

189201
value.setProperty(runtime, "a", jsi::Value(vec.val[0]));
190202
value.setProperty(runtime, "b", jsi::Value(vec.val[1]));
191203
value.setProperty(runtime, "c", jsi::Value(vec.val[2]));
192204
} break;
193205
case hashString("scalar", 6): {
194-
cv::Scalar scalar = FOCV_Storage::get<cv::Scalar>(id);
206+
auto scalar = *FOCV_Storage::get<cv::Scalar>(id);
195207

196208
value.setProperty(runtime, "a", jsi::Value(scalar.val[0]));
197209
value.setProperty(runtime, "b", jsi::Value(scalar.val[1]));
198210
value.setProperty(runtime, "c", jsi::Value(scalar.val[2]));
199211
value.setProperty(runtime, "d", jsi::Value(scalar.val[3]));
200212
} break;
201213
case hashString("rotated_rect", 12): {
202-
cv::RotatedRect rect = FOCV_Storage::get<cv::RotatedRect>(id);
214+
auto rect = *FOCV_Storage::get<cv::RotatedRect>(id);
203215

204216
value.setProperty(runtime, "centerX", jsi::Value(rect.center.x));
205217
value.setProperty(runtime, "centerY", jsi::Value(rect.center.y));
@@ -222,19 +234,19 @@ jsi::Object FOCV_Object::copyObjectFromVector(jsi::Runtime& runtime, const jsi::
222234

223235
switch(hashString(objectType.c_str(), objectType.size())) {
224236
case hashString("mat_vector", 10): {
225-
std::vector<cv::Mat> array = FOCV_Storage::get<std::vector<cv::Mat>>(vectorId);
237+
auto array = *FOCV_Storage::get<std::vector<cv::Mat>>(vectorId);
226238
cv::Mat mat = array.at(index);
227239
createdId = FOCV_Storage::save(mat);
228240
return FOCV_JsiObject::wrap(runtime, "mat", createdId);
229241
} break;
230242
case hashString("rect_vector", 11): {
231-
std::vector<cv::Rect> array = FOCV_Storage::get<std::vector<cv::Rect>>(vectorId);
243+
auto array = *FOCV_Storage::get<std::vector<cv::Rect>>(vectorId);
232244
cv::Rect rect = array.at(index);
233245
createdId = FOCV_Storage::save(rect);
234246
return FOCV_JsiObject::wrap(runtime, "rect", createdId);
235247
} break;
236248
case hashString("point_vector", 12): {
237-
std::vector<cv::Point> array = FOCV_Storage::get<std::vector<cv::Point>>(vectorId);
249+
auto array = *FOCV_Storage::get<std::vector<cv::Point>>(vectorId);
238250
cv::Point point = array.at(index);
239251
createdId = FOCV_Storage::save(point);
240252
return FOCV_JsiObject::wrap(runtime, "point", createdId);

‎cpp/FOCV_Storage.hpp

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -26,7 +26,7 @@ class FOCV_Storage {
2626

2727
public:
2828
template <typename T>
29-
static T get(std::string key);
29+
static std::shared_ptr<T> get(std::string key);
3030

3131
template <typename T>
3232
static std::string save(T &item);
@@ -48,25 +48,25 @@ std::string FOCV_Storage::save(T &item) {
4848
boost::uuids::uuid uuid = boost::uuids::random_generator()();
4949
std::string key = boost::uuids::to_string(uuid);
5050

51-
items.insert_or_assign(key, item);
51+
items.insert_or_assign(key, std::make_shared<T>(item));
5252

5353
return key;
5454
}
5555

5656
template <typename T>
5757
std::string FOCV_Storage::save(std::string key, T &item) {
58-
items.insert_or_assign(key, item);
58+
items.insert_or_assign(key, std::make_shared<T>(item));
5959

6060
return key;
6161
}
6262

6363
template <typename T>
64-
T FOCV_Storage::get(std::string key) {
64+
std::shared_ptr<T> FOCV_Storage::get(std::string key) {
6565
if(!items.contains(key)) {
6666
// Error here!
6767
}
6868

69-
return std::any_cast<T>(items.at(key));
69+
return std::any_cast<std::shared_ptr<T>>(items.at(key));
7070
}
7171

7272

0 commit comments

Comments
 (0)