API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Dec 8th, 2016
87
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 448.88 KB | None | 0 0
raw download clone embed print report
  1. // Generated by JavaCPP version 1.2: DO NOT EDIT THIS FILE
  2.  
  3.  
  4. #ifdef _WIN32
  5. #define _JAVASOFT_JNI_MD_H_
  6.  
  7. #define JNIEXPORT __declspec(dllexport)
  8. #define JNIIMPORT __declspec(dllimport)
  9. #define JNICALL __stdcall
  10.  
  11. typedef int jint;
  12. typedef long long jlong;
  13. typedef signed char jbyte;
  14. #elif defined(__GNUC__)
  15. #define _JAVASOFT_JNI_MD_H_
  16.  
  17. #define JNIEXPORT __attribute__((visibility("default")))
  18. #define JNIIMPORT
  19. #define JNICALL
  20.  
  21. typedef int jint;
  22. typedef long long jlong;
  23. typedef signed char jbyte;
  24. #endif
  25.  
  26. #include <jni.h>
  27.  
  28. #ifdef ANDROID
  29. #include <android/log.h>
  30. #elif defined(__APPLE__) && defined(__OBJC__)
  31. #include <TargetConditionals.h>
  32. #include <Foundation/Foundation.h>
  33. #endif
  34. #if defined(ANDROID) || TARGET_OS_IPHONE
  35. #define NewWeakGlobalRef(obj) NewGlobalRef(obj)
  36. #define DeleteWeakGlobalRef(obj) DeleteGlobalRef(obj)
  37. #endif
  38.  
  39. #include <limits.h>
  40. #include <stddef.h>
  41. #ifndef _WIN32
  42. #include <stdint.h>
  43. #endif
  44. #include <stdio.h>
  45. #include <stdlib.h>
  46. #include <string.h>
  47. #include <exception>
  48. #include <memory>
  49. #include <new>
  50.  
  51. #if defined(NATIVE_ALLOCATOR) && defined(NATIVE_DEALLOCATOR)
  52. void* operator new(std::size_t size, const std::nothrow_t&) throw() {
  53. return NATIVE_ALLOCATOR(size);
  54. }
  55. void* operator new[](std::size_t size, const std::nothrow_t&) throw() {
  56. return NATIVE_ALLOCATOR(size);
  57. }
  58. void* operator new(std::size_t size) throw(std::bad_alloc) {
  59. return NATIVE_ALLOCATOR(size);
  60. }
  61. void* operator new[](std::size_t size) throw(std::bad_alloc) {
  62. return NATIVE_ALLOCATOR(size);
  63. }
  64. void operator delete(void* ptr) throw() {
  65. NATIVE_DEALLOCATOR(ptr);
  66. }
  67. void operator delete[](void* ptr) throw() {
  68. NATIVE_DEALLOCATOR(ptr);
  69. }
  70. #endif
  71.  
  72. #define jlong_to_ptr(a) ((void*)(uintptr_t)(a))
  73. #define ptr_to_jlong(a) ((jlong)(uintptr_t)(a))
  74.  
  75. #if defined(_MSC_VER)
  76. #define JavaCPP_noinline __declspec(noinline)
  77. #define JavaCPP_hidden /* hidden by default */
  78. #elif defined(__GNUC__)
  79. #define JavaCPP_noinline __attribute__((noinline))
  80. #define JavaCPP_hidden __attribute__((visibility("hidden")))
  81. #else
  82. #define JavaCPP_noinline
  83. #define JavaCPP_hidden
  84. #endif
  85.  
  86. #include <opencv2/core/hal/interface.h>
  87. #include <opencv2/core/cvdef.h>
  88. #include <opencv2/core/hal/hal.hpp>
  89. #include <opencv2/core/fast_math.hpp>
  90. #include <algorithm>
  91. #include <opencv2/core/saturate.hpp>
  92. #include <opencv2/core/version.hpp>
  93. #include <opencv2/core/base.hpp>
  94. #include <opencv2/core/cvstd.hpp>
  95. #include <opencv2/core/utility.hpp>
  96. #include <opencv2/core/types_c.h>
  97. #include <opencv2/core/core_c.h>
  98. #include <opencv2/core/types.hpp>
  99. #include <opencv2/core.hpp>
  100. #include <opencv2/core/operations.hpp>
  101. #include <opencv2/core/bufferpool.hpp>
  102. #include <opencv2/core/mat.hpp>
  103. #include <opencv2/core/persistence.hpp>
  104. #include <opencv2/core/optim.hpp>
  105. #include "opencv_adapters.h"
  106. #include <opencv2/imgproc/types_c.h>
  107. #include <opencv2/imgproc/imgproc_c.h>
  108. #include <opencv2/imgproc.hpp>
  109. #include <opencv2/imgproc/detail/distortion_model.hpp>
  110. #include <opencv2/imgcodecs/imgcodecs_c.h>
  111. #include <opencv2/imgcodecs.hpp>
  112. #include <opencv2/videoio/videoio_c.h>
  113. #include <opencv2/videoio.hpp>
  114. #include <opencv2/highgui/highgui_c.h>
  115. #include <opencv2/highgui.hpp>
  116. #include <opencv2/ml.hpp>
  117. #include <opencv2/text.hpp>
  118. #include <opencv2/text/erfilter.hpp>
  119. #include <opencv2/text/ocr.hpp>
  120.  
  121. static JavaVM* JavaCPP_vm = NULL;
  122. static bool JavaCPP_haveAllocObject = false;
  123. static bool JavaCPP_haveNonvirtual = false;
  124. static const char* JavaCPP_classNames[35] = {
  125. "org/bytedeco/javacpp/Pointer",
  126. "org/bytedeco/javacpp/BytePointer",
  127. "org/bytedeco/javacpp/ShortPointer",
  128. "org/bytedeco/javacpp/IntPointer",
  129. "org/bytedeco/javacpp/LongPointer",
  130. "org/bytedeco/javacpp/FloatPointer",
  131. "org/bytedeco/javacpp/DoublePointer",
  132. "org/bytedeco/javacpp/CharPointer",
  133. "org/bytedeco/javacpp/PointerPointer",
  134. "org/bytedeco/javacpp/BoolPointer",
  135. "org/bytedeco/javacpp/CLongPointer",
  136. "org/bytedeco/javacpp/SizeTPointer",
  137. "java/lang/String",
  138. "org/bytedeco/javacpp/Pointer$NativeDeallocator",
  139. "org/bytedeco/javacpp/Loader",
  140. "java/nio/Buffer",
  141. "java/lang/Object",
  142. "java/lang/NullPointerException",
  143. "java/lang/RuntimeException",
  144. "org/bytedeco/javacpp/opencv_text$OCRBeamSearchDecoder$ClassifierCallback",
  145. "org/bytedeco/javacpp/opencv_text$OCRBeamSearchDecoder",
  146. "org/bytedeco/javacpp/opencv_text$OCRHMMDecoder$ClassifierCallback",
  147. "org/bytedeco/javacpp/opencv_text$OCRHMMDecoder",
  148. "org/bytedeco/javacpp/opencv_text$OCRTesseract",
  149. "org/bytedeco/javacpp/opencv_text$ERStat",
  150. "org/bytedeco/javacpp/opencv_core$Rect",
  151. "org/bytedeco/javacpp/opencv_text$IntDeque",
  152. "org/bytedeco/javacpp/opencv_text$DoubleVector",
  153. "org/bytedeco/javacpp/opencv_core$Point",
  154. "org/bytedeco/javacpp/opencv_text$Vec2iVector",
  155. "org/bytedeco/javacpp/opencv_text$ERStatVector",
  156. "org/bytedeco/javacpp/opencv_text$IntVectorVector",
  157. "org/bytedeco/javacpp/opencv_text$ERFilter",
  158. "org/bytedeco/javacpp/opencv_text$ERFilter$Callback",
  159. "org/bytedeco/javacpp/opencv_core$Mat" };
  160. static jclass JavaCPP_classes[35] = { NULL };
  161. static jfieldID JavaCPP_addressFID = NULL;
  162. static jfieldID JavaCPP_positionFID = NULL;
  163. static jfieldID JavaCPP_limitFID = NULL;
  164. static jfieldID JavaCPP_capacityFID = NULL;
  165. static jfieldID JavaCPP_deallocatorFID = NULL;
  166. static jfieldID JavaCPP_ownerAddressFID = NULL;
  167. static jmethodID JavaCPP_initMID = NULL;
  168. static jmethodID JavaCPP_arrayMID = NULL;
  169. static jmethodID JavaCPP_stringMID = NULL;
  170. static jmethodID JavaCPP_getBytesMID = NULL;
  171. static jmethodID JavaCPP_toStringMID = NULL;
  172.  
  173. static inline void JavaCPP_log(const char* fmt, ...) {
  174. va_list ap;
  175. va_start(ap, fmt);
  176. #ifdef ANDROID
  177. __android_log_vprint(ANDROID_LOG_ERROR, "javacpp", fmt, ap);
  178. #elif defined(__APPLE__) && defined(__OBJC__)
  179. NSLogv([NSString stringWithUTF8String:fmt], ap);
  180. #else
  181. vfprintf(stderr, fmt, ap);
  182. fprintf(stderr, "\n");
  183. #endif
  184. va_end(ap);
  185. }
  186.  
  187. static JavaCPP_noinline jclass JavaCPP_getClass(JNIEnv* env, int i) {
  188. if (JavaCPP_classes[i] == NULL && env->PushLocalFrame(1) == 0) {
  189. jclass cls = env->FindClass(JavaCPP_classNames[i]);
  190. if (cls == NULL || env->ExceptionCheck()) {
  191. JavaCPP_log("Error loading class %s.", JavaCPP_classNames[i]);
  192. return NULL;
  193. }
  194. JavaCPP_classes[i] = (jclass)env->NewWeakGlobalRef(cls);
  195. if (JavaCPP_classes[i] == NULL || env->ExceptionCheck()) {
  196. JavaCPP_log("Error creating global reference of class %s.", JavaCPP_classNames[i]);
  197. return NULL;
  198. }
  199. env->PopLocalFrame(NULL);
  200. }
  201. return JavaCPP_classes[i];
  202. }
  203.  
  204. static JavaCPP_noinline jfieldID JavaCPP_getFieldID(JNIEnv* env, int i, const char* name, const char* sig) {
  205. jclass cls = JavaCPP_getClass(env, i);
  206. if (cls == NULL) {
  207. return NULL;
  208. }
  209. jfieldID fid = env->GetFieldID(cls, name, sig);
  210. if (fid == NULL || env->ExceptionCheck()) {
  211. JavaCPP_log("Error getting field ID of %s/%s", JavaCPP_classNames[i], name);
  212. return NULL;
  213. }
  214. return fid;
  215. }
  216.  
  217. static JavaCPP_noinline jmethodID JavaCPP_getMethodID(JNIEnv* env, int i, const char* name, const char* sig) {
  218. jclass cls = JavaCPP_getClass(env, i);
  219. if (cls == NULL) {
  220. return NULL;
  221. }
  222. jmethodID mid = env->GetMethodID(cls, name, sig);
  223. if (mid == NULL || env->ExceptionCheck()) {
  224. JavaCPP_log("Error getting method ID of %s/%s", JavaCPP_classNames[i], name);
  225. return NULL;
  226. }
  227. return mid;
  228. }
  229.  
  230. static JavaCPP_noinline jmethodID JavaCPP_getStaticMethodID(JNIEnv* env, int i, const char* name, const char* sig) {
  231. jclass cls = JavaCPP_getClass(env, i);
  232. if (cls == NULL) {
  233. return NULL;
  234. }
  235. jmethodID mid = env->GetStaticMethodID(cls, name, sig);
  236. if (mid == NULL || env->ExceptionCheck()) {
  237. JavaCPP_log("Error getting static method ID of %s/%s", JavaCPP_classNames[i], name);
  238. return NULL;
  239. }
  240. return mid;
  241. }
  242.  
  243. static JavaCPP_noinline jobject JavaCPP_createPointer(JNIEnv* env, int i, jclass cls = NULL) {
  244. if (cls == NULL && (cls = JavaCPP_getClass(env, i)) == NULL) {
  245. return NULL;
  246. }
  247. if (JavaCPP_haveAllocObject) {
  248. return env->AllocObject(cls);
  249. } else {
  250. jmethodID mid = env->GetMethodID(cls, "<init>", "(Lorg/bytedeco/javacpp/Pointer;)V");
  251. if (mid == NULL || env->ExceptionCheck()) {
  252. JavaCPP_log("Error getting Pointer constructor of %s, while VM does not support AllocObject()", JavaCPP_classNames[i]);
  253. return NULL;
  254. }
  255. return env->NewObject(cls, mid, NULL);
  256. }
  257. }
  258.  
  259. static JavaCPP_noinline void JavaCPP_initPointer(JNIEnv* env, jobject obj, const void* ptr, long long size, void* owner, void (*deallocator)(void*)) {
  260. if (deallocator != NULL) {
  261. jvalue args[4];
  262. args[0].j = ptr_to_jlong(ptr);
  263. args[1].j = (jlong)size;
  264. args[2].j = ptr_to_jlong(owner);
  265. args[3].j = ptr_to_jlong(deallocator);
  266. if (JavaCPP_haveNonvirtual) {
  267. env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 0), JavaCPP_initMID, args);
  268. } else {
  269. env->CallVoidMethodA(obj, JavaCPP_initMID, args);
  270. }
  271. } else {
  272. env->SetLongField(obj, JavaCPP_addressFID, ptr_to_jlong(ptr));
  273. env->SetLongField(obj, JavaCPP_limitFID, (jlong)size);
  274. env->SetLongField(obj, JavaCPP_capacityFID, (jlong)size);
  275. }
  276. }
  277.  
  278. static JavaCPP_noinline jstring JavaCPP_createString(JNIEnv* env, const char* ptr) {
  279. if (ptr == NULL) {
  280. return NULL;
  281. }
  282. #ifdef MODIFIED_UTF8_STRING
  283. return env->NewStringUTF(ptr);
  284. #else
  285. size_t length = strlen(ptr);
  286. jbyteArray bytes = env->NewByteArray(length < INT_MAX ? length : INT_MAX);
  287. env->SetByteArrayRegion(bytes, 0, length < INT_MAX ? length : INT_MAX, (signed char*)ptr);
  288. return (jstring)env->NewObject(JavaCPP_getClass(env, 12), JavaCPP_stringMID, bytes);
  289. #endif
  290. }
  291.  
  292. static JavaCPP_noinline const char* JavaCPP_getStringBytes(JNIEnv* env, jstring str) {
  293. if (str == NULL) {
  294. return NULL;
  295. }
  296. #ifdef MODIFIED_UTF8_STRING
  297. return env->GetStringUTFChars(str, NULL);
  298. #else
  299. jbyteArray bytes = (jbyteArray)env->CallObjectMethod(str, JavaCPP_getBytesMID);
  300. if (bytes == NULL || env->ExceptionCheck()) {
  301. JavaCPP_log("Error getting bytes from string.");
  302. return NULL;
  303. }
  304. jsize length = env->GetArrayLength(bytes);
  305. signed char* ptr = new (std::nothrow) signed char[length + 1];
  306. if (ptr != NULL) {
  307. env->GetByteArrayRegion(bytes, 0, length, ptr);
  308. ptr[length] = 0;
  309. }
  310. return (const char*)ptr;
  311. #endif
  312. }
  313.  
  314. static JavaCPP_noinline void JavaCPP_releaseStringBytes(JNIEnv* env, jstring str, const char* ptr) {
  315. #ifdef MODIFIED_UTF8_STRING
  316. if (str != NULL) {
  317. env->ReleaseStringUTFChars(str, ptr);
  318. }
  319. #else
  320. delete[] ptr;
  321. #endif
  322. }
  323.  
  324. class JavaCPP_hidden JavaCPP_exception : public std::exception {
  325. public:
  326. JavaCPP_exception(const char* str) throw() {
  327. if (str == NULL) {
  328. strcpy(msg, "Unknown exception.");
  329. } else {
  330. strncpy(msg, str, sizeof(msg));
  331. msg[sizeof(msg) - 1] = 0;
  332. }
  333. }
  334. virtual const char* what() const throw() { return msg; }
  335. char msg[1024];
  336. };
  337.  
  338. #ifndef GENERIC_EXCEPTION_CLASS
  339. #define GENERIC_EXCEPTION_CLASS std::exception
  340. #endif
  341. static JavaCPP_noinline jthrowable JavaCPP_handleException(JNIEnv* env, int i) {
  342. jstring str = NULL;
  343. try {
  344. throw;
  345. } catch (GENERIC_EXCEPTION_CLASS& e) {
  346. str = JavaCPP_createString(env, e.what());
  347. } catch (...) {
  348. str = JavaCPP_createString(env, "Unknown exception.");
  349. }
  350. jmethodID mid = JavaCPP_getMethodID(env, i, "<init>", "(Ljava/lang/String;)V");
  351. if (mid == NULL) {
  352. return NULL;
  353. }
  354. return (jthrowable)env->NewObject(JavaCPP_getClass(env, i), mid, str);
  355. }
  356.  
  357. static JavaCPP_noinline void* JavaCPP_getPointerOwner(JNIEnv* env, jobject obj) {
  358. if (obj != NULL) {
  359. jobject deallocator = env->GetObjectField(obj, JavaCPP_deallocatorFID);
  360. if (deallocator != NULL && env->IsInstanceOf(deallocator, JavaCPP_getClass(env, 13))) {
  361. return jlong_to_ptr(env->GetLongField(deallocator, JavaCPP_ownerAddressFID));
  362. }
  363. }
  364. return NULL;
  365. }
  366.  
  367. #include <vector>
  368. template<typename P, typename T = P> class JavaCPP_hidden VectorAdapter {
  369. public:
  370. VectorAdapter(const P* ptr, typename std::vector<T>::size_type size, void* owner) : ptr((P*)ptr), size(size), owner(owner),
  371. vec2(ptr ? std::vector<T>((P*)ptr, (P*)ptr + size) : std::vector<T>()), vec(vec2) { }
  372. VectorAdapter(const std::vector<T>& vec) : ptr(0), size(0), owner(0), vec2(vec), vec(vec2) { }
  373. VectorAdapter( std::vector<T>& vec) : ptr(0), size(0), owner(0), vec(vec) { }
  374. VectorAdapter(const std::vector<T>* vec) : ptr(0), size(0), owner(0), vec(*(std::vector<T>*)vec) { }
  375. void assign(P* ptr, typename std::vector<T>::size_type size, void* owner) {
  376. this->ptr = ptr;
  377. this->size = size;
  378. this->owner = owner;
  379. vec.assign(ptr, ptr + size);
  380. }
  381. static void deallocate(void* owner) { operator delete(owner); }
  382. operator P*() {
  383. if (vec.size() > size) {
  384. ptr = (P*)(operator new(sizeof(P) * vec.size(), std::nothrow_t()));
  385. }
  386. if (ptr) {
  387. std::copy(vec.begin(), vec.end(), ptr);
  388. }
  389. size = vec.size();
  390. owner = ptr;
  391. return ptr;
  392. }
  393. operator const P*() { return &vec[0]; }
  394. operator std::vector<T>&() { return vec; }
  395. operator std::vector<T>*() { return ptr ? &vec : 0; }
  396. P* ptr;
  397. typename std::vector<T>::size_type size;
  398. void* owner;
  399. std::vector<T> vec2;
  400. std::vector<T>& vec;
  401. };
  402.  
  403. #include <string>
  404. class JavaCPP_hidden StringAdapter {
  405. public:
  406. StringAdapter(const char* ptr, size_t size, void* owner) : ptr((char*)ptr), size(size), owner(owner),
  407. str2(ptr ? (char*)ptr : "", ptr ? (size > 0 ? size : strlen((char*)ptr)) : 0), str(str2) { }
  408. StringAdapter(const signed char* ptr, size_t size, void* owner) : ptr((char*)ptr), size(size), owner(owner),
  409. str2(ptr ? (char*)ptr : "", ptr ? (size > 0 ? size : strlen((char*)ptr)) : 0), str(str2) { }
  410. StringAdapter(const unsigned char* ptr, size_t size, void* owner) : ptr((char*)ptr), size(size), owner(owner),
  411. str2(ptr ? (char*)ptr : "", ptr ? (size > 0 ? size : strlen((char*)ptr)) : 0), str(str2) { }
  412. StringAdapter(const std::string& str) : ptr(0), size(0), owner(0), str2(str), str(str2) { }
  413. StringAdapter( std::string& str) : ptr(0), size(0), owner(0), str(str) { }
  414. StringAdapter(const std::string* str) : ptr(0), size(0), owner(0), str(*(std::string*)str) { }
  415. void assign(char* ptr, size_t size, void* owner) {
  416. this->ptr = ptr;
  417. this->size = size;
  418. this->owner = owner;
  419. str.assign(ptr ? ptr : "", ptr ? (size > 0 ? size : strlen((char*)ptr)) : 0);
  420. }
  421. void assign(const char* ptr, size_t size, void* owner) { assign((char*)ptr, size, owner); }
  422. void assign(const signed char* ptr, size_t size, void* owner) { assign((char*)ptr, size, owner); }
  423. void assign(const unsigned char* ptr, size_t size, void* owner) { assign((char*)ptr, size, owner); }
  424. static void deallocate(void* owner) { delete[] (char*)owner; }
  425. operator char*() {
  426. const char* data = str.data();
  427. if (str.size() > size) {
  428. ptr = new (std::nothrow) char[str.size()+1];
  429. if (ptr) memset(ptr, 0, str.size()+1);
  430. }
  431. if (ptr && memcmp(ptr, data, str.size()) != 0) {
  432. memcpy(ptr, data, str.size());
  433. if (size > str.size()) ptr[str.size()] = 0;
  434. }
  435. size = str.size();
  436. owner = ptr;
  437. return ptr;
  438. }
  439. operator signed char*() { return (signed char*)(operator char*)(); }
  440. operator unsigned char*() { return (unsigned char*)(operator char*)(); }
  441. operator const char*() { return str.c_str(); }
  442. operator const signed char*() { return (signed char*)str.c_str(); }
  443. operator const unsigned char*() { return (unsigned char*)str.c_str(); }
  444. operator std::string&() { return str; }
  445. operator std::string*() { return ptr ? &str : 0; }
  446. char* ptr;
  447. size_t size;
  448. void* owner;
  449. std::string str2;
  450. std::string& str;
  451. };
  452.  
  453. #ifdef SHARED_PTR_NAMESPACE
  454. template<class T> class SharedPtrAdapter {
  455. public:
  456. typedef SHARED_PTR_NAMESPACE::shared_ptr<T> S;
  457. SharedPtrAdapter(const T* ptr, size_t size, void* owner) : ptr((T*)ptr), size(size), owner(owner),
  458. sharedPtr2(owner != NULL && owner != ptr ? *(S*)owner : S((T*)ptr)), sharedPtr(sharedPtr2) { }
  459. SharedPtrAdapter(const S& sharedPtr) : ptr(0), size(0), owner(0), sharedPtr2(sharedPtr), sharedPtr(sharedPtr2) { }
  460. SharedPtrAdapter( S& sharedPtr) : ptr(0), size(0), owner(0), sharedPtr(sharedPtr) { }
  461. void assign(T* ptr, size_t size, S* owner) {
  462. this->ptr = ptr;
  463. this->size = size;
  464. this->owner = owner;
  465. this->sharedPtr = owner != NULL && owner != ptr ? *(S*)owner : S((T*)ptr);
  466. }
  467. static void deallocate(void* owner) { delete (S*)owner; }
  468. operator T*() {
  469. ptr = sharedPtr.get();
  470. if (owner == NULL || owner == ptr) {
  471. owner = new S(sharedPtr);
  472. }
  473. return ptr;
  474. }
  475. operator const T*() { return sharedPtr.get(); }
  476. operator S&() { return sharedPtr; }
  477. operator S*() { return ptr ? &sharedPtr : 0; }
  478. T* ptr;
  479. size_t size;
  480. void* owner;
  481. S sharedPtr2;
  482. S& sharedPtr;
  483. };
  484. #endif
  485.  
  486.  
  487.  
  488.  
  489. static void JavaCPP_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_00024ClassifierCallback_deallocate(void *p) { delete (::cv::text::OCRBeamSearchDecoder::ClassifierCallback*)p; }
  490. static void JavaCPP_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_deallocate(void *p) { delete (::cv::text::OCRBeamSearchDecoder*)p; }
  491. static void JavaCPP_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_00024ClassifierCallback_deallocate(void *p) { delete (::cv::text::OCRHMMDecoder::ClassifierCallback*)p; }
  492. static void JavaCPP_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_deallocate(void *p) { delete (::cv::text::OCRHMMDecoder*)p; }
  493. static void JavaCPP_org_bytedeco_javacpp_opencv_1text_00024ERStat_deallocate(void *p) { delete (::cv::text::ERStat*)p; }
  494. static void JavaCPP_org_bytedeco_javacpp_opencv_1text_00024DoubleVector_deallocate(void *p) { delete (::std::vector<double>*)p; }
  495. static void JavaCPP_org_bytedeco_javacpp_opencv_1text_00024Vec2iVector_deallocate(void *p) { delete (::std::vector<cv::Vec2i>*)p; }
  496. static void JavaCPP_org_bytedeco_javacpp_opencv_1text_00024ERStatVector_deallocate(void *p) { delete (::std::vector<cv::text::ERStat>*)p; }
  497. static void JavaCPP_org_bytedeco_javacpp_opencv_1text_00024IntVectorVector_deallocate(void *p) { delete (::std::vector<std::vector<int> >*)p; }
  498. static void JavaCPP_org_bytedeco_javacpp_opencv_1text_00024IntDeque_deallocate(void *p) { delete (::std::deque<int>*)p; }
  499. static void JavaCPP_org_bytedeco_javacpp_opencv_1core_00024Mat_deallocate(void *p) { delete (::cv::Mat*)p; }
  500. static void JavaCPP_org_bytedeco_javacpp_BytePointer_deallocateArray(void* p) { delete[] (signed char*)p; }
  501. static void JavaCPP_org_bytedeco_javacpp_ShortPointer_deallocateArray(void* p) { delete[] (short*)p; }
  502. static void JavaCPP_org_bytedeco_javacpp_IntPointer_deallocateArray(void* p) { delete[] (int*)p; }
  503. static void JavaCPP_org_bytedeco_javacpp_LongPointer_deallocateArray(void* p) { delete[] (jlong*)p; }
  504. static void JavaCPP_org_bytedeco_javacpp_FloatPointer_deallocateArray(void* p) { delete[] (float*)p; }
  505. static void JavaCPP_org_bytedeco_javacpp_DoublePointer_deallocateArray(void* p) { delete[] (double*)p; }
  506. static void JavaCPP_org_bytedeco_javacpp_CharPointer_deallocateArray(void* p) { delete[] (unsigned short*)p; }
  507. static void JavaCPP_org_bytedeco_javacpp_PointerPointer_deallocateArray(void* p) { delete[] (void**)p; }
  508. static void JavaCPP_org_bytedeco_javacpp_BoolPointer_deallocateArray(void* p) { delete[] (bool*)p; }
  509. static void JavaCPP_org_bytedeco_javacpp_CLongPointer_deallocateArray(void* p) { delete[] (long*)p; }
  510. static void JavaCPP_org_bytedeco_javacpp_SizeTPointer_deallocateArray(void* p) { delete[] (size_t*)p; }
  511. static void JavaCPP_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_00024ClassifierCallback_deallocateArray(void* p) { delete[] (::cv::text::OCRBeamSearchDecoder::ClassifierCallback*)p; }
  512. static void JavaCPP_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_deallocateArray(void* p) { delete[] (::cv::text::OCRBeamSearchDecoder*)p; }
  513. static void JavaCPP_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_00024ClassifierCallback_deallocateArray(void* p) { delete[] (::cv::text::OCRHMMDecoder::ClassifierCallback*)p; }
  514. static void JavaCPP_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_deallocateArray(void* p) { delete[] (::cv::text::OCRHMMDecoder*)p; }
  515. static void JavaCPP_org_bytedeco_javacpp_opencv_1text_00024ERStat_deallocateArray(void* p) { delete[] (::cv::text::ERStat*)p; }
  516.  
  517. extern "C" {
  518.  
  519. JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved) {
  520. JNIEnv* env;
  521. if (vm->GetEnv((void**)&env, JNI_VERSION_1_4) != JNI_OK) {
  522. JavaCPP_log("Could not get JNIEnv for JNI_VERSION_1_4 inside JNI_OnLoad().");
  523. return JNI_ERR;
  524. }
  525. if (JavaCPP_vm == vm) {
  526. return env->GetVersion();
  527. }
  528. JavaCPP_vm = vm;
  529. JavaCPP_haveAllocObject = env->functions->AllocObject != NULL;
  530. JavaCPP_haveNonvirtual = env->functions->CallNonvirtualVoidMethodA != NULL;
  531. const char* members[35][1] = {
  532. { "sizeof" },
  533. { "sizeof" },
  534. { "sizeof" },
  535. { "sizeof" },
  536. { "sizeof" },
  537. { "sizeof" },
  538. { "sizeof" },
  539. { "sizeof" },
  540. { "sizeof" },
  541. { "sizeof" },
  542. { "sizeof" },
  543. { "sizeof" },
  544. { NULL },
  545. { NULL },
  546. { NULL },
  547. { NULL },
  548. { NULL },
  549. { NULL },
  550. { NULL },
  551. { "sizeof" },
  552. { "sizeof" },
  553. { "sizeof" },
  554. { "sizeof" },
  555. { "sizeof" },
  556. { "sizeof" },
  557. { NULL },
  558. { "sizeof" },
  559. { "sizeof" },
  560. { NULL },
  561. { "sizeof" },
  562. { "sizeof" },
  563. { "sizeof" },
  564. { "sizeof" },
  565. { "sizeof" },
  566. { NULL } };
  567. int offsets[35][1] = {
  568. { sizeof(void*) },
  569. { sizeof(signed char) },
  570. { sizeof(short) },
  571. { sizeof(int) },
  572. { sizeof(jlong) },
  573. { sizeof(float) },
  574. { sizeof(double) },
  575. { sizeof(unsigned short) },
  576. { sizeof(void*) },
  577. { sizeof(bool) },
  578. { sizeof(long) },
  579. { sizeof(size_t) },
  580. { -1 },
  581. { -1 },
  582. { -1 },
  583. { -1 },
  584. { -1 },
  585. { -1 },
  586. { -1 },
  587. { sizeof(::cv::text::OCRBeamSearchDecoder::ClassifierCallback) },
  588. { sizeof(::cv::text::OCRBeamSearchDecoder) },
  589. { sizeof(::cv::text::OCRHMMDecoder::ClassifierCallback) },
  590. { sizeof(::cv::text::OCRHMMDecoder) },
  591. { sizeof(::cv::text::OCRTesseract) },
  592. { sizeof(::cv::text::ERStat) },
  593. { -1 },
  594. { sizeof(::std::deque<int>) },
  595. { sizeof(::std::vector<double>) },
  596. { -1 },
  597. { sizeof(::std::vector<cv::Vec2i>) },
  598. { sizeof(::std::vector<cv::text::ERStat>) },
  599. { sizeof(::std::vector<std::vector<int> >) },
  600. { sizeof(::cv::text::ERFilter) },
  601. { sizeof(::cv::text::ERFilter::Callback) },
  602. { -1 } };
  603. int memberOffsetSizes[35] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
  604. jmethodID putMemberOffsetMID = JavaCPP_getStaticMethodID(env, 14, "putMemberOffset", "(Ljava/lang/String;Ljava/lang/String;I)Ljava/lang/Class;");
  605. if (putMemberOffsetMID == NULL) {
  606. return JNI_ERR;
  607. }
  608. for (int i = 0; i < 35 && !env->ExceptionCheck(); i++) {
  609. for (int j = 0; j < memberOffsetSizes[i] && !env->ExceptionCheck(); j++) {
  610. if (env->PushLocalFrame(3) == 0) {
  611. jvalue args[3];
  612. args[0].l = env->NewStringUTF(JavaCPP_classNames[i]);
  613. args[1].l = members[i][j] == NULL ? NULL : env->NewStringUTF(members[i][j]);
  614. args[2].i = offsets[i][j];
  615. jclass cls = (jclass)env->CallStaticObjectMethodA(JavaCPP_getClass(env, 14), putMemberOffsetMID, args);
  616. if (cls == NULL || env->ExceptionCheck()) {
  617. JavaCPP_log("Error putting member offsets for class %s.", JavaCPP_classNames[i]);
  618. return JNI_ERR;
  619. }
  620. JavaCPP_classes[i] = (jclass)env->NewWeakGlobalRef(cls);
  621. if (JavaCPP_classes[i] == NULL || env->ExceptionCheck()) {
  622. JavaCPP_log("Error creating global reference of class %s.", JavaCPP_classNames[i]);
  623. return JNI_ERR;
  624. }
  625. env->PopLocalFrame(NULL);
  626. }
  627. }
  628. }
  629. JavaCPP_addressFID = JavaCPP_getFieldID(env, 0, "address", "J");
  630. if (JavaCPP_addressFID == NULL) {
  631. return JNI_ERR;
  632. }
  633. JavaCPP_positionFID = JavaCPP_getFieldID(env, 0, "position", "J");
  634. if (JavaCPP_positionFID == NULL) {
  635. return JNI_ERR;
  636. }
  637. JavaCPP_limitFID = JavaCPP_getFieldID(env, 0, "limit", "J");
  638. if (JavaCPP_limitFID == NULL) {
  639. return JNI_ERR;
  640. }
  641. JavaCPP_capacityFID = JavaCPP_getFieldID(env, 0, "capacity", "J");
  642. if (JavaCPP_capacityFID == NULL) {
  643. return JNI_ERR;
  644. }
  645. JavaCPP_deallocatorFID = JavaCPP_getFieldID(env, 0, "deallocator", "Lorg/bytedeco/javacpp/Pointer$Deallocator;");
  646. if (JavaCPP_deallocatorFID == NULL) {
  647. return JNI_ERR;
  648. }
  649. JavaCPP_ownerAddressFID = JavaCPP_getFieldID(env, 13, "ownerAddress", "J");
  650. if (JavaCPP_ownerAddressFID == NULL) {
  651. return JNI_ERR;
  652. }
  653. JavaCPP_initMID = JavaCPP_getMethodID(env, 0, "init", "(JJJJ)V");
  654. if (JavaCPP_initMID == NULL) {
  655. return JNI_ERR;
  656. }
  657. JavaCPP_arrayMID = JavaCPP_getMethodID(env, 15, "array", "()Ljava/lang/Object;");
  658. if (JavaCPP_arrayMID == NULL) {
  659. return JNI_ERR;
  660. }
  661. JavaCPP_stringMID = JavaCPP_getMethodID(env, 12, "<init>", "([B)V");
  662. if (JavaCPP_stringMID == NULL) {
  663. return JNI_ERR;
  664. }
  665. JavaCPP_getBytesMID = JavaCPP_getMethodID(env, 12, "getBytes", "()[B");
  666. if (JavaCPP_getBytesMID == NULL) {
  667. return JNI_ERR;
  668. }
  669. JavaCPP_toStringMID = JavaCPP_getMethodID(env, 16, "toString", "()Ljava/lang/String;");
  670. if (JavaCPP_toStringMID == NULL) {
  671. return JNI_ERR;
  672. }
  673. return env->GetVersion();
  674. }
  675.  
  676.  
  677. JNIEXPORT void JNICALL JNI_OnUnload(JavaVM* vm, void* reserved) {
  678. JNIEnv* env;
  679. if (vm->GetEnv((void**)&env, JNI_VERSION_1_4) != JNI_OK) {
  680. JavaCPP_log("Could not get JNIEnv for JNI_VERSION_1_4 inside JNI_OnUnLoad().");
  681. return;
  682. }
  683. for (int i = 0; i < 35; i++) {
  684. env->DeleteWeakGlobalRef((jweak)JavaCPP_classes[i]);
  685. JavaCPP_classes[i] = NULL;
  686. }
  687. JavaCPP_vm = NULL;
  688. }
  689.  
  690.  
  691. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_Pointer_00024NativeDeallocator_deallocate(JNIEnv* env, jobject obj, jlong arg0, jlong arg1) {
  692. void* allocatedAddress = jlong_to_ptr(arg0);
  693. void (*deallocatorAddress)(void*) = (void(*)(void*))jlong_to_ptr(arg1);
  694. if (deallocatorAddress != NULL && allocatedAddress != NULL) {
  695. (*deallocatorAddress)(allocatedAddress);
  696. }
  697.  
  698. }
  699.  
  700.  
  701.  
  702. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_Pointer_memchr(JNIEnv* env, jclass cls, jobject arg0, jint arg1, jlong arg2) {
  703. char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  704. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  705. ptr0 += position0;
  706. jobject rarg = NULL;
  707. void* rptr;
  708. rptr = memchr(ptr0, arg1, arg2);
  709. if (rptr == ptr0) {
  710. rarg = arg0;
  711. } else if (rptr != NULL) {
  712. rarg = JavaCPP_createPointer(env, 0);
  713. if (rarg != NULL) {
  714. env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
  715. }
  716. }
  717. return rarg;
  718. }
  719. JNIEXPORT jint JNICALL Java_org_bytedeco_javacpp_Pointer_memcmp(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jlong arg2) {
  720. char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  721. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  722. ptr0 += position0;
  723. char* ptr1 = arg1 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  724. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  725. ptr1 += position1;
  726. jint rarg = 0;
  727. int rvalue = memcmp(ptr0, ptr1, arg2);
  728. rarg = (jint)rvalue;
  729. return rarg;
  730. }
  731. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_Pointer_memcpy(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jlong arg2) {
  732. char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  733. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  734. ptr0 += position0;
  735. char* ptr1 = arg1 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  736. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  737. ptr1 += position1;
  738. jobject rarg = NULL;
  739. void* rptr;
  740. rptr = memcpy(ptr0, ptr1, arg2);
  741. if (rptr == ptr0) {
  742. rarg = arg0;
  743. } else if (rptr == ptr1) {
  744. rarg = arg1;
  745. } else if (rptr != NULL) {
  746. rarg = JavaCPP_createPointer(env, 0);
  747. if (rarg != NULL) {
  748. env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
  749. }
  750. }
  751. return rarg;
  752. }
  753. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_Pointer_memmove(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jlong arg2) {
  754. char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  755. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  756. ptr0 += position0;
  757. char* ptr1 = arg1 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  758. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  759. ptr1 += position1;
  760. jobject rarg = NULL;
  761. void* rptr;
  762. rptr = memmove(ptr0, ptr1, arg2);
  763. if (rptr == ptr0) {
  764. rarg = arg0;
  765. } else if (rptr == ptr1) {
  766. rarg = arg1;
  767. } else if (rptr != NULL) {
  768. rarg = JavaCPP_createPointer(env, 0);
  769. if (rarg != NULL) {
  770. env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
  771. }
  772. }
  773. return rarg;
  774. }
  775. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_Pointer_memset(JNIEnv* env, jclass cls, jobject arg0, jint arg1, jlong arg2) {
  776. char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  777. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  778. ptr0 += position0;
  779. jobject rarg = NULL;
  780. void* rptr;
  781. rptr = memset(ptr0, arg1, arg2);
  782. if (rptr == ptr0) {
  783. rarg = arg0;
  784. } else if (rptr != NULL) {
  785. rarg = JavaCPP_createPointer(env, 0);
  786. if (rarg != NULL) {
  787. env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
  788. }
  789. }
  790. return rarg;
  791. }
  792. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_Pointer_asDirectBuffer(JNIEnv* env, jobject obj) {
  793. char* ptr = (char*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  794. if (ptr == NULL) {
  795. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  796. return 0;
  797. }
  798. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  799. ptr += position;
  800. jlong size = env->GetLongField(obj, JavaCPP_limitFID);
  801. size -= position;
  802. jobject rarg = NULL;
  803. char* rptr;
  804. rptr = ptr;
  805. jlong rcapacity = size;
  806. if (rptr != NULL) {
  807. jlong rcapacityptr = rcapacity * sizeof(rptr[0]);
  808. rarg = env->NewDirectByteBuffer((void*)rptr, rcapacityptr < INT_MAX ? rcapacityptr : INT_MAX);
  809. }
  810. return rarg;
  811. }
  812. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_Pointer_allocate(JNIEnv* env, jobject obj, jobject arg0) {
  813. char* ptr0 = arg0 == NULL ? NULL : (char*)env->GetDirectBufferAddress(arg0);
  814. void* rptr = ptr0;
  815. jlong rcapacity = 1;
  816. JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, NULL);
  817. }
  818.  
  819. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_BytePointer_strcat(JNIEnv* env, jclass cls, jobject arg0, jobject arg1) {
  820. signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  821. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  822. ptr0 += position0;
  823. signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  824. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  825. ptr1 += position1;
  826. jobject rarg = NULL;
  827. char* rptr;
  828. rptr = (char*)strcat((char*)ptr0, (char*)ptr1);
  829. if (rptr == (char*)ptr0) {
  830. rarg = arg0;
  831. } else if (rptr == (char*)ptr1) {
  832. rarg = arg1;
  833. } else if (rptr != NULL) {
  834. rarg = JavaCPP_createPointer(env, 1);
  835. if (rarg != NULL) {
  836. env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
  837. }
  838. }
  839. return rarg;
  840. }
  841. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_BytePointer_allocateArray(JNIEnv* env, jobject obj, jlong arg0) {
  842. signed char* rptr = new (std::nothrow) signed char[arg0];
  843. jlong rcapacity = arg0;
  844. JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_BytePointer_deallocateArray);
  845. }
  846. JNIEXPORT jint JNICALL Java_org_bytedeco_javacpp_BytePointer_strncmp(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jlong arg2) {
  847. signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  848. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  849. ptr0 += position0;
  850. signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  851. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  852. ptr1 += position1;
  853. jint rarg = 0;
  854. int rvalue = strncmp((char*)ptr0, (char*)ptr1, (size_t)arg2);
  855. rarg = (jint)rvalue;
  856. return rarg;
  857. }
  858. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_BytePointer_strncpy(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jlong arg2) {
  859. signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  860. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  861. ptr0 += position0;
  862. signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  863. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  864. ptr1 += position1;
  865. jobject rarg = NULL;
  866. char* rptr;
  867. rptr = (char*)strncpy((char*)ptr0, (char*)ptr1, (size_t)arg2);
  868. if (rptr == (char*)ptr0) {
  869. rarg = arg0;
  870. } else if (rptr == (char*)ptr1) {
  871. rarg = arg1;
  872. } else if (rptr != NULL) {
  873. rarg = JavaCPP_createPointer(env, 1);
  874. if (rarg != NULL) {
  875. env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
  876. }
  877. }
  878. return rarg;
  879. }
  880. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_BytePointer_strpbrk(JNIEnv* env, jclass cls, jobject arg0, jobject arg1) {
  881. signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  882. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  883. ptr0 += position0;
  884. signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  885. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  886. ptr1 += position1;
  887. jobject rarg = NULL;
  888. char* rptr;
  889. rptr = (char*)strpbrk((char*)ptr0, (char*)ptr1);
  890. if (rptr == (char*)ptr0) {
  891. rarg = arg0;
  892. } else if (rptr == (char*)ptr1) {
  893. rarg = arg1;
  894. } else if (rptr != NULL) {
  895. rarg = JavaCPP_createPointer(env, 1);
  896. if (rarg != NULL) {
  897. env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
  898. }
  899. }
  900. return rarg;
  901. }
  902. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_BytePointer_strrchr(JNIEnv* env, jclass cls, jobject arg0, jint arg1) {
  903. signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  904. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  905. ptr0 += position0;
  906. jobject rarg = NULL;
  907. char* rptr;
  908. rptr = (char*)strrchr((char*)ptr0, arg1);
  909. if (rptr == (char*)ptr0) {
  910. rarg = arg0;
  911. } else if (rptr != NULL) {
  912. rarg = JavaCPP_createPointer(env, 1);
  913. if (rarg != NULL) {
  914. env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
  915. }
  916. }
  917. return rarg;
  918. }
  919. JNIEXPORT jlong JNICALL Java_org_bytedeco_javacpp_BytePointer_strspn(JNIEnv* env, jclass cls, jobject arg0, jobject arg1) {
  920. signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  921. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  922. ptr0 += position0;
  923. signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  924. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  925. ptr1 += position1;
  926. jlong rarg = 0;
  927. size_t rvalue = (size_t)strspn((char*)ptr0, (char*)ptr1);
  928. rarg = (jlong)rvalue;
  929. return rarg;
  930. }
  931. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_BytePointer_strstr(JNIEnv* env, jclass cls, jobject arg0, jobject arg1) {
  932. signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  933. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  934. ptr0 += position0;
  935. signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  936. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  937. ptr1 += position1;
  938. jobject rarg = NULL;
  939. char* rptr;
  940. rptr = (char*)strstr((char*)ptr0, (char*)ptr1);
  941. if (rptr == (char*)ptr0) {
  942. rarg = arg0;
  943. } else if (rptr == (char*)ptr1) {
  944. rarg = arg1;
  945. } else if (rptr != NULL) {
  946. rarg = JavaCPP_createPointer(env, 1);
  947. if (rarg != NULL) {
  948. env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
  949. }
  950. }
  951. return rarg;
  952. }
  953. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_BytePointer_strtok(JNIEnv* env, jclass cls, jobject arg0, jobject arg1) {
  954. signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  955. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  956. ptr0 += position0;
  957. signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  958. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  959. ptr1 += position1;
  960. jobject rarg = NULL;
  961. char* rptr;
  962. rptr = (char*)strtok((char*)ptr0, (char*)ptr1);
  963. if (rptr == (char*)ptr0) {
  964. rarg = arg0;
  965. } else if (rptr == (char*)ptr1) {
  966. rarg = arg1;
  967. } else if (rptr != NULL) {
  968. rarg = JavaCPP_createPointer(env, 1);
  969. if (rarg != NULL) {
  970. env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
  971. }
  972. }
  973. return rarg;
  974. }
  975. JNIEXPORT jlong JNICALL Java_org_bytedeco_javacpp_BytePointer_strxfrm(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jlong arg2) {
  976. signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  977. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  978. ptr0 += position0;
  979. signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  980. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  981. ptr1 += position1;
  982. jlong rarg = 0;
  983. size_t rvalue = (size_t)strxfrm((char*)ptr0, (char*)ptr1, (size_t)arg2);
  984. rarg = (jlong)rvalue;
  985. return rarg;
  986. }
  987. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_BytePointer_strchr(JNIEnv* env, jclass cls, jobject arg0, jint arg1) {
  988. signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  989. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  990. ptr0 += position0;
  991. jobject rarg = NULL;
  992. char* rptr;
  993. rptr = (char*)strchr((char*)ptr0, arg1);
  994. if (rptr == (char*)ptr0) {
  995. rarg = arg0;
  996. } else if (rptr != NULL) {
  997. rarg = JavaCPP_createPointer(env, 1);
  998. if (rarg != NULL) {
  999. env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
  1000. }
  1001. }
  1002. return rarg;
  1003. }
  1004. JNIEXPORT jint JNICALL Java_org_bytedeco_javacpp_BytePointer_strcmp(JNIEnv* env, jclass cls, jobject arg0, jobject arg1) {
  1005. signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  1006. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  1007. ptr0 += position0;
  1008. signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  1009. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  1010. ptr1 += position1;
  1011. jint rarg = 0;
  1012. int rvalue = strcmp((char*)ptr0, (char*)ptr1);
  1013. rarg = (jint)rvalue;
  1014. return rarg;
  1015. }
  1016. JNIEXPORT jint JNICALL Java_org_bytedeco_javacpp_BytePointer_strcoll(JNIEnv* env, jclass cls, jobject arg0, jobject arg1) {
  1017. signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  1018. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  1019. ptr0 += position0;
  1020. signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  1021. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  1022. ptr1 += position1;
  1023. jint rarg = 0;
  1024. int rvalue = strcoll((char*)ptr0, (char*)ptr1);
  1025. rarg = (jint)rvalue;
  1026. return rarg;
  1027. }
  1028. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_BytePointer_strcpy(JNIEnv* env, jclass cls, jobject arg0, jobject arg1) {
  1029. signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  1030. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  1031. ptr0 += position0;
  1032. signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  1033. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  1034. ptr1 += position1;
  1035. jobject rarg = NULL;
  1036. char* rptr;
  1037. rptr = (char*)strcpy((char*)ptr0, (char*)ptr1);
  1038. if (rptr == (char*)ptr0) {
  1039. rarg = arg0;
  1040. } else if (rptr == (char*)ptr1) {
  1041. rarg = arg1;
  1042. } else if (rptr != NULL) {
  1043. rarg = JavaCPP_createPointer(env, 1);
  1044. if (rarg != NULL) {
  1045. env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
  1046. }
  1047. }
  1048. return rarg;
  1049. }
  1050. JNIEXPORT jlong JNICALL Java_org_bytedeco_javacpp_BytePointer_strcspn(JNIEnv* env, jclass cls, jobject arg0, jobject arg1) {
  1051. signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  1052. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  1053. ptr0 += position0;
  1054. signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  1055. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  1056. ptr1 += position1;
  1057. jlong rarg = 0;
  1058. size_t rvalue = (size_t)strcspn((char*)ptr0, (char*)ptr1);
  1059. rarg = (jlong)rvalue;
  1060. return rarg;
  1061. }
  1062. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_BytePointer_strerror(JNIEnv* env, jclass cls, jint arg0) {
  1063. jobject rarg = NULL;
  1064. char* rptr;
  1065. rptr = (char*)strerror(arg0);
  1066. if (rptr != NULL) {
  1067. rarg = JavaCPP_createPointer(env, 1);
  1068. if (rarg != NULL) {
  1069. env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
  1070. }
  1071. }
  1072. return rarg;
  1073. }
  1074. JNIEXPORT jlong JNICALL Java_org_bytedeco_javacpp_BytePointer_strlen(JNIEnv* env, jclass cls, jobject arg0) {
  1075. signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  1076. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  1077. ptr0 += position0;
  1078. jlong rarg = 0;
  1079. size_t rvalue = (size_t)strlen((char*)ptr0);
  1080. rarg = (jlong)rvalue;
  1081. return rarg;
  1082. }
  1083. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_BytePointer_strncat(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jlong arg2) {
  1084. signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  1085. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  1086. ptr0 += position0;
  1087. signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  1088. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  1089. ptr1 += position1;
  1090. jobject rarg = NULL;
  1091. char* rptr;
  1092. rptr = (char*)strncat((char*)ptr0, (char*)ptr1, (size_t)arg2);
  1093. if (rptr == (char*)ptr0) {
  1094. rarg = arg0;
  1095. } else if (rptr == (char*)ptr1) {
  1096. rarg = arg1;
  1097. } else if (rptr != NULL) {
  1098. rarg = JavaCPP_createPointer(env, 1);
  1099. if (rarg != NULL) {
  1100. env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
  1101. }
  1102. }
  1103. return rarg;
  1104. }
  1105. JNIEXPORT jbyte JNICALL Java_org_bytedeco_javacpp_BytePointer_get__J(JNIEnv* env, jobject obj, jlong arg0) {
  1106. signed char* ptr = (signed char*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1107. if (ptr == NULL) {
  1108. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1109. return 0;
  1110. }
  1111. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1112. ptr += position;
  1113. jbyte rarg = 0;
  1114. signed char rvalue = ptr[arg0];
  1115. rarg = (jbyte)rvalue;
  1116. return rarg;
  1117. }
  1118. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_BytePointer_get___3BII(JNIEnv* env, jobject obj, jbyteArray arg0, jint arg1, jint arg2) {
  1119. signed char* ptr = (signed char*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1120. if (ptr == NULL) {
  1121. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1122. return 0;
  1123. }
  1124. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1125. ptr += position;
  1126. signed char* ptr0 = arg0 == NULL ? NULL : (jbyte*)env->GetPrimitiveArrayCritical(arg0, NULL);
  1127. jobject rarg = obj;
  1128. memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
  1129. if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
  1130. return rarg;
  1131. }
  1132. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_BytePointer_put__JB(JNIEnv* env, jobject obj, jlong arg0, jbyte arg1) {
  1133. signed char* ptr = (signed char*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1134. if (ptr == NULL) {
  1135. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1136. return 0;
  1137. }
  1138. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1139. ptr += position;
  1140. jobject rarg = obj;
  1141. ptr[arg0] = arg1;
  1142. return rarg;
  1143. }
  1144. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_BytePointer_put___3BII(JNIEnv* env, jobject obj, jbyteArray arg0, jint arg1, jint arg2) {
  1145. signed char* ptr = (signed char*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1146. if (ptr == NULL) {
  1147. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1148. return 0;
  1149. }
  1150. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1151. ptr += position;
  1152. signed char* ptr0 = arg0 == NULL ? NULL : (jbyte*)env->GetPrimitiveArrayCritical(arg0, NULL);
  1153. jobject rarg = obj;
  1154. memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
  1155. if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
  1156. return rarg;
  1157. }
  1158.  
  1159. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_ShortPointer_allocateArray(JNIEnv* env, jobject obj, jlong arg0) {
  1160. short* rptr = new (std::nothrow) short[arg0];
  1161. jlong rcapacity = arg0;
  1162. JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_ShortPointer_deallocateArray);
  1163. }
  1164. JNIEXPORT jshort JNICALL Java_org_bytedeco_javacpp_ShortPointer_get__J(JNIEnv* env, jobject obj, jlong arg0) {
  1165. short* ptr = (short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1166. if (ptr == NULL) {
  1167. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1168. return 0;
  1169. }
  1170. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1171. ptr += position;
  1172. jshort rarg = 0;
  1173. short rvalue = ptr[arg0];
  1174. rarg = (jshort)rvalue;
  1175. return rarg;
  1176. }
  1177. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_ShortPointer_get___3SII(JNIEnv* env, jobject obj, jshortArray arg0, jint arg1, jint arg2) {
  1178. short* ptr = (short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1179. if (ptr == NULL) {
  1180. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1181. return 0;
  1182. }
  1183. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1184. ptr += position;
  1185. short* ptr0 = arg0 == NULL ? NULL : (jshort*)env->GetPrimitiveArrayCritical(arg0, NULL);
  1186. jobject rarg = obj;
  1187. memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
  1188. if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
  1189. return rarg;
  1190. }
  1191. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_ShortPointer_put___3SII(JNIEnv* env, jobject obj, jshortArray arg0, jint arg1, jint arg2) {
  1192. short* ptr = (short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1193. if (ptr == NULL) {
  1194. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1195. return 0;
  1196. }
  1197. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1198. ptr += position;
  1199. short* ptr0 = arg0 == NULL ? NULL : (jshort*)env->GetPrimitiveArrayCritical(arg0, NULL);
  1200. jobject rarg = obj;
  1201. memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
  1202. if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
  1203. return rarg;
  1204. }
  1205. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_ShortPointer_put__JS(JNIEnv* env, jobject obj, jlong arg0, jshort arg1) {
  1206. short* ptr = (short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1207. if (ptr == NULL) {
  1208. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1209. return 0;
  1210. }
  1211. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1212. ptr += position;
  1213. jobject rarg = obj;
  1214. ptr[arg0] = arg1;
  1215. return rarg;
  1216. }
  1217.  
  1218. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_IntPointer_allocateArray(JNIEnv* env, jobject obj, jlong arg0) {
  1219. int* rptr = new (std::nothrow) int[arg0];
  1220. jlong rcapacity = arg0;
  1221. JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_IntPointer_deallocateArray);
  1222. }
  1223. JNIEXPORT jint JNICALL Java_org_bytedeco_javacpp_IntPointer_get__J(JNIEnv* env, jobject obj, jlong arg0) {
  1224. int* ptr = (int*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1225. if (ptr == NULL) {
  1226. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1227. return 0;
  1228. }
  1229. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1230. ptr += position;
  1231. jint rarg = 0;
  1232. int rvalue = ptr[arg0];
  1233. rarg = (jint)rvalue;
  1234. return rarg;
  1235. }
  1236. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_IntPointer_get___3III(JNIEnv* env, jobject obj, jintArray arg0, jint arg1, jint arg2) {
  1237. int* ptr = (int*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1238. if (ptr == NULL) {
  1239. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1240. return 0;
  1241. }
  1242. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1243. ptr += position;
  1244. int* ptr0 = arg0 == NULL ? NULL : (jint*)env->GetPrimitiveArrayCritical(arg0, NULL);
  1245. jobject rarg = obj;
  1246. memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
  1247. if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
  1248. return rarg;
  1249. }
  1250. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_IntPointer_put___3III(JNIEnv* env, jobject obj, jintArray arg0, jint arg1, jint arg2) {
  1251. int* ptr = (int*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1252. if (ptr == NULL) {
  1253. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1254. return 0;
  1255. }
  1256. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1257. ptr += position;
  1258. int* ptr0 = arg0 == NULL ? NULL : (jint*)env->GetPrimitiveArrayCritical(arg0, NULL);
  1259. jobject rarg = obj;
  1260. memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
  1261. if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
  1262. return rarg;
  1263. }
  1264. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_IntPointer_put__JI(JNIEnv* env, jobject obj, jlong arg0, jint arg1) {
  1265. int* ptr = (int*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1266. if (ptr == NULL) {
  1267. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1268. return 0;
  1269. }
  1270. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1271. ptr += position;
  1272. jobject rarg = obj;
  1273. ptr[arg0] = arg1;
  1274. return rarg;
  1275. }
  1276.  
  1277. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_LongPointer_allocateArray(JNIEnv* env, jobject obj, jlong arg0) {
  1278. jlong* rptr = new (std::nothrow) jlong[arg0];
  1279. jlong rcapacity = arg0;
  1280. JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_LongPointer_deallocateArray);
  1281. }
  1282. JNIEXPORT jlong JNICALL Java_org_bytedeco_javacpp_LongPointer_get__J(JNIEnv* env, jobject obj, jlong arg0) {
  1283. jlong* ptr = (jlong*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1284. if (ptr == NULL) {
  1285. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1286. return 0;
  1287. }
  1288. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1289. ptr += position;
  1290. jlong rarg = 0;
  1291. jlong rvalue = ptr[arg0];
  1292. rarg = (jlong)rvalue;
  1293. return rarg;
  1294. }
  1295. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_LongPointer_get___3JII(JNIEnv* env, jobject obj, jlongArray arg0, jint arg1, jint arg2) {
  1296. jlong* ptr = (jlong*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1297. if (ptr == NULL) {
  1298. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1299. return 0;
  1300. }
  1301. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1302. ptr += position;
  1303. jlong* ptr0 = arg0 == NULL ? NULL : (jlong*)env->GetPrimitiveArrayCritical(arg0, NULL);
  1304. jobject rarg = obj;
  1305. memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
  1306. if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
  1307. return rarg;
  1308. }
  1309. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_LongPointer_put___3JII(JNIEnv* env, jobject obj, jlongArray arg0, jint arg1, jint arg2) {
  1310. jlong* ptr = (jlong*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1311. if (ptr == NULL) {
  1312. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1313. return 0;
  1314. }
  1315. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1316. ptr += position;
  1317. jlong* ptr0 = arg0 == NULL ? NULL : (jlong*)env->GetPrimitiveArrayCritical(arg0, NULL);
  1318. jobject rarg = obj;
  1319. memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
  1320. if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
  1321. return rarg;
  1322. }
  1323. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_LongPointer_put__JJ(JNIEnv* env, jobject obj, jlong arg0, jlong arg1) {
  1324. jlong* ptr = (jlong*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1325. if (ptr == NULL) {
  1326. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1327. return 0;
  1328. }
  1329. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1330. ptr += position;
  1331. jobject rarg = obj;
  1332. ptr[arg0] = arg1;
  1333. return rarg;
  1334. }
  1335.  
  1336. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_FloatPointer_allocateArray(JNIEnv* env, jobject obj, jlong arg0) {
  1337. float* rptr = new (std::nothrow) float[arg0];
  1338. jlong rcapacity = arg0;
  1339. JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_FloatPointer_deallocateArray);
  1340. }
  1341. JNIEXPORT jfloat JNICALL Java_org_bytedeco_javacpp_FloatPointer_get__J(JNIEnv* env, jobject obj, jlong arg0) {
  1342. float* ptr = (float*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1343. if (ptr == NULL) {
  1344. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1345. return 0;
  1346. }
  1347. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1348. ptr += position;
  1349. jfloat rarg = 0;
  1350. float rvalue = ptr[arg0];
  1351. rarg = (jfloat)rvalue;
  1352. return rarg;
  1353. }
  1354. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_FloatPointer_get___3FII(JNIEnv* env, jobject obj, jfloatArray arg0, jint arg1, jint arg2) {
  1355. float* ptr = (float*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1356. if (ptr == NULL) {
  1357. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1358. return 0;
  1359. }
  1360. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1361. ptr += position;
  1362. float* ptr0 = arg0 == NULL ? NULL : (jfloat*)env->GetPrimitiveArrayCritical(arg0, NULL);
  1363. jobject rarg = obj;
  1364. memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
  1365. if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
  1366. return rarg;
  1367. }
  1368. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_FloatPointer_put___3FII(JNIEnv* env, jobject obj, jfloatArray arg0, jint arg1, jint arg2) {
  1369. float* ptr = (float*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1370. if (ptr == NULL) {
  1371. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1372. return 0;
  1373. }
  1374. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1375. ptr += position;
  1376. float* ptr0 = arg0 == NULL ? NULL : (jfloat*)env->GetPrimitiveArrayCritical(arg0, NULL);
  1377. jobject rarg = obj;
  1378. memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
  1379. if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
  1380. return rarg;
  1381. }
  1382. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_FloatPointer_put__JF(JNIEnv* env, jobject obj, jlong arg0, jfloat arg1) {
  1383. float* ptr = (float*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1384. if (ptr == NULL) {
  1385. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1386. return 0;
  1387. }
  1388. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1389. ptr += position;
  1390. jobject rarg = obj;
  1391. ptr[arg0] = arg1;
  1392. return rarg;
  1393. }
  1394.  
  1395. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_DoublePointer_allocateArray(JNIEnv* env, jobject obj, jlong arg0) {
  1396. double* rptr = new (std::nothrow) double[arg0];
  1397. jlong rcapacity = arg0;
  1398. JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_DoublePointer_deallocateArray);
  1399. }
  1400. JNIEXPORT jdouble JNICALL Java_org_bytedeco_javacpp_DoublePointer_get__J(JNIEnv* env, jobject obj, jlong arg0) {
  1401. double* ptr = (double*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1402. if (ptr == NULL) {
  1403. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1404. return 0;
  1405. }
  1406. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1407. ptr += position;
  1408. jdouble rarg = 0;
  1409. double rvalue = ptr[arg0];
  1410. rarg = (jdouble)rvalue;
  1411. return rarg;
  1412. }
  1413. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_DoublePointer_get___3DII(JNIEnv* env, jobject obj, jdoubleArray arg0, jint arg1, jint arg2) {
  1414. double* ptr = (double*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1415. if (ptr == NULL) {
  1416. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1417. return 0;
  1418. }
  1419. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1420. ptr += position;
  1421. double* ptr0 = arg0 == NULL ? NULL : (jdouble*)env->GetPrimitiveArrayCritical(arg0, NULL);
  1422. jobject rarg = obj;
  1423. memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
  1424. if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
  1425. return rarg;
  1426. }
  1427. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_DoublePointer_put___3DII(JNIEnv* env, jobject obj, jdoubleArray arg0, jint arg1, jint arg2) {
  1428. double* ptr = (double*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1429. if (ptr == NULL) {
  1430. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1431. return 0;
  1432. }
  1433. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1434. ptr += position;
  1435. double* ptr0 = arg0 == NULL ? NULL : (jdouble*)env->GetPrimitiveArrayCritical(arg0, NULL);
  1436. jobject rarg = obj;
  1437. memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
  1438. if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
  1439. return rarg;
  1440. }
  1441. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_DoublePointer_put__JD(JNIEnv* env, jobject obj, jlong arg0, jdouble arg1) {
  1442. double* ptr = (double*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1443. if (ptr == NULL) {
  1444. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1445. return 0;
  1446. }
  1447. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1448. ptr += position;
  1449. jobject rarg = obj;
  1450. ptr[arg0] = arg1;
  1451. return rarg;
  1452. }
  1453.  
  1454. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_CharPointer_allocateArray(JNIEnv* env, jobject obj, jlong arg0) {
  1455. unsigned short* rptr = new (std::nothrow) unsigned short[arg0];
  1456. jlong rcapacity = arg0;
  1457. JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_CharPointer_deallocateArray);
  1458. }
  1459. JNIEXPORT jchar JNICALL Java_org_bytedeco_javacpp_CharPointer_get__J(JNIEnv* env, jobject obj, jlong arg0) {
  1460. unsigned short* ptr = (unsigned short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1461. if (ptr == NULL) {
  1462. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1463. return 0;
  1464. }
  1465. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1466. ptr += position;
  1467. jchar rarg = 0;
  1468. unsigned short rvalue = ptr[arg0];
  1469. rarg = (jchar)rvalue;
  1470. return rarg;
  1471. }
  1472. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_CharPointer_get___3CII(JNIEnv* env, jobject obj, jcharArray arg0, jint arg1, jint arg2) {
  1473. unsigned short* ptr = (unsigned short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1474. if (ptr == NULL) {
  1475. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1476. return 0;
  1477. }
  1478. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1479. ptr += position;
  1480. unsigned short* ptr0 = arg0 == NULL ? NULL : (jchar*)env->GetPrimitiveArrayCritical(arg0, NULL);
  1481. jobject rarg = obj;
  1482. memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
  1483. if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
  1484. return rarg;
  1485. }
  1486. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_CharPointer_put___3CII(JNIEnv* env, jobject obj, jcharArray arg0, jint arg1, jint arg2) {
  1487. unsigned short* ptr = (unsigned short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1488. if (ptr == NULL) {
  1489. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1490. return 0;
  1491. }
  1492. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1493. ptr += position;
  1494. unsigned short* ptr0 = arg0 == NULL ? NULL : (jchar*)env->GetPrimitiveArrayCritical(arg0, NULL);
  1495. jobject rarg = obj;
  1496. memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
  1497. if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
  1498. return rarg;
  1499. }
  1500. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_CharPointer_put__JC(JNIEnv* env, jobject obj, jlong arg0, jchar arg1) {
  1501. unsigned short* ptr = (unsigned short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1502. if (ptr == NULL) {
  1503. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1504. return 0;
  1505. }
  1506. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1507. ptr += position;
  1508. jobject rarg = obj;
  1509. ptr[arg0] = arg1;
  1510. return rarg;
  1511. }
  1512.  
  1513. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_PointerPointer_allocateArray(JNIEnv* env, jobject obj, jlong arg0) {
  1514. void** rptr = new (std::nothrow) void*[arg0];
  1515. jlong rcapacity = arg0;
  1516. JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_PointerPointer_deallocateArray);
  1517. }
  1518. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_PointerPointer_get(JNIEnv* env, jobject obj, jclass arg0, jlong arg1) {
  1519. void** ptr = (void**)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1520. if (ptr == NULL) {
  1521. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1522. return 0;
  1523. }
  1524. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1525. ptr += position;
  1526. jobject rarg = NULL;
  1527. void* rptr;
  1528. rptr = ptr[arg1];
  1529. if (rptr != NULL) {
  1530. rarg = JavaCPP_createPointer(env, 0, arg0);
  1531. if (rarg != NULL) {
  1532. env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
  1533. }
  1534. }
  1535. return rarg;
  1536. }
  1537. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_PointerPointer_put(JNIEnv* env, jobject obj, jlong arg0, jobject arg1) {
  1538. void** ptr = (void**)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1539. if (ptr == NULL) {
  1540. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1541. return 0;
  1542. }
  1543. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1544. ptr += position;
  1545. char* ptr1 = arg1 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  1546. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  1547. ptr1 += position1;
  1548. jobject rarg = obj;
  1549. ptr[arg0] = ptr1;
  1550. return rarg;
  1551. }
  1552.  
  1553. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_BoolPointer_allocateArray(JNIEnv* env, jobject obj, jlong arg0) {
  1554. bool* rptr = new (std::nothrow) bool[arg0];
  1555. jlong rcapacity = arg0;
  1556. JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_BoolPointer_deallocateArray);
  1557. }
  1558. JNIEXPORT jboolean JNICALL Java_org_bytedeco_javacpp_BoolPointer_get(JNIEnv* env, jobject obj, jlong arg0) {
  1559. bool* ptr = (bool*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1560. if (ptr == NULL) {
  1561. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1562. return 0;
  1563. }
  1564. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1565. ptr += position;
  1566. jboolean rarg = 0;
  1567. bool rvalue = (bool)ptr[arg0];
  1568. rarg = (jboolean)rvalue;
  1569. return rarg;
  1570. }
  1571. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_BoolPointer_put(JNIEnv* env, jobject obj, jlong arg0, jboolean arg1) {
  1572. bool* ptr = (bool*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1573. if (ptr == NULL) {
  1574. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1575. return 0;
  1576. }
  1577. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1578. ptr += position;
  1579. jobject rarg = obj;
  1580. ptr[arg0] = (bool)arg1;
  1581. return rarg;
  1582. }
  1583.  
  1584. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_CLongPointer_allocateArray(JNIEnv* env, jobject obj, jlong arg0) {
  1585. long* rptr = new (std::nothrow) long[arg0];
  1586. jlong rcapacity = arg0;
  1587. JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_CLongPointer_deallocateArray);
  1588. }
  1589. JNIEXPORT jlong JNICALL Java_org_bytedeco_javacpp_CLongPointer_get(JNIEnv* env, jobject obj, jlong arg0) {
  1590. long* ptr = (long*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1591. if (ptr == NULL) {
  1592. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1593. return 0;
  1594. }
  1595. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1596. ptr += position;
  1597. jlong rarg = 0;
  1598. long rvalue = (long)ptr[arg0];
  1599. rarg = (jlong)rvalue;
  1600. return rarg;
  1601. }
  1602. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_CLongPointer_put(JNIEnv* env, jobject obj, jlong arg0, jlong arg1) {
  1603. long* ptr = (long*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1604. if (ptr == NULL) {
  1605. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1606. return 0;
  1607. }
  1608. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1609. ptr += position;
  1610. jobject rarg = obj;
  1611. ptr[arg0] = (long)arg1;
  1612. return rarg;
  1613. }
  1614.  
  1615. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_SizeTPointer_allocateArray(JNIEnv* env, jobject obj, jlong arg0) {
  1616. size_t* rptr = new (std::nothrow) size_t[arg0];
  1617. jlong rcapacity = arg0;
  1618. JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_SizeTPointer_deallocateArray);
  1619. }
  1620. JNIEXPORT jlong JNICALL Java_org_bytedeco_javacpp_SizeTPointer_get(JNIEnv* env, jobject obj, jlong arg0) {
  1621. size_t* ptr = (size_t*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1622. if (ptr == NULL) {
  1623. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1624. return 0;
  1625. }
  1626. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1627. ptr += position;
  1628. jlong rarg = 0;
  1629. size_t rvalue = (size_t)ptr[arg0];
  1630. rarg = (jlong)rvalue;
  1631. return rarg;
  1632. }
  1633. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_SizeTPointer_put(JNIEnv* env, jobject obj, jlong arg0, jlong arg1) {
  1634. size_t* ptr = (size_t*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1635. if (ptr == NULL) {
  1636. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1637. return 0;
  1638. }
  1639. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1640. ptr += position;
  1641. jobject rarg = obj;
  1642. ptr[arg0] = (size_t)arg1;
  1643. return rarg;
  1644. }
  1645.  
  1646.  
  1647. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_00024ClassifierCallback_eval__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1text_00024DoubleVector_2Ljava_nio_IntBuffer_2(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jobject arg2) {
  1648. ::cv::text::OCRBeamSearchDecoder::ClassifierCallback* ptr = (::cv::text::OCRBeamSearchDecoder::ClassifierCallback*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1649. if (ptr == NULL) {
  1650. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1651. return;
  1652. }
  1653. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1654. ptr += position;
  1655. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  1656. if (ptr0 == NULL) {
  1657. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  1658. return;
  1659. }
  1660. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  1661. ptr0 += position0;
  1662. ::std::vector<double>* ptr1 = arg1 == NULL ? NULL : (::std::vector<double>*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  1663. jlong size1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_limitFID);
  1664. void* owner1 = JavaCPP_getPointerOwner(env, arg1);
  1665. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  1666. ptr1 += position1;
  1667. size1 -= position1;
  1668. VectorAdapter< ::std::vector<double> > adapter1(ptr1, size1, owner1);
  1669. int* ptr2 = arg2 == NULL ? NULL : (int*)env->GetDirectBufferAddress(arg2);
  1670. jlong size2 = arg2 == NULL ? 0 : env->GetDirectBufferCapacity(arg2);
  1671. void* owner2 = (void*)ptr2;
  1672. jintArray arr2 = NULL;
  1673. if (arg2 != NULL && ptr2 == NULL) {
  1674. arr2 = (jintArray)env->CallObjectMethod(arg2, JavaCPP_arrayMID);
  1675. if (env->ExceptionOccurred() != NULL) {
  1676. env->ExceptionClear();
  1677. } else {
  1678. ptr2 = arr2 == NULL ? NULL : env->GetIntArrayElements(arr2, NULL);
  1679. size2 = env->GetArrayLength(arr2);
  1680. }
  1681. }
  1682. VectorAdapter< int > adapter2(ptr2, size2, owner2);
  1683. jthrowable exc = NULL;
  1684. try {
  1685. ptr->eval(*ptr0, adapter1, adapter2);
  1686. } catch (...) {
  1687. exc = JavaCPP_handleException(env, 18);
  1688. }
  1689.  
  1690. ::std::vector<double>* rptr1 = adapter1;
  1691. jlong rsize1 = (jlong)adapter1.size;
  1692. void* rowner1 = adapter1.owner;
  1693. if (rptr1 != ptr1) {
  1694. JavaCPP_initPointer(env, arg1, rptr1, rsize1, rowner1, &VectorAdapter< ::std::vector<double> >::deallocate);
  1695. } else {
  1696. env->SetLongField(arg1, JavaCPP_limitFID, rsize1 + position1);
  1697. }
  1698. int* rptr2 = adapter2;
  1699. void* rowner2 = adapter2.owner;
  1700. if (rptr2 != ptr2) {
  1701. VectorAdapter< int >::deallocate(rowner2);
  1702. }
  1703. if (arr2 != NULL) env->ReleaseIntArrayElements(arr2, (jint*)ptr2, 0);
  1704. if (exc != NULL) {
  1705. env->Throw(exc);
  1706. }
  1707. }
  1708. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_00024ClassifierCallback_eval__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1text_00024DoubleVector_2_3I(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jintArray arg2) {
  1709. ::cv::text::OCRBeamSearchDecoder::ClassifierCallback* ptr = (::cv::text::OCRBeamSearchDecoder::ClassifierCallback*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1710. if (ptr == NULL) {
  1711. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1712. return;
  1713. }
  1714. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1715. ptr += position;
  1716. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  1717. if (ptr0 == NULL) {
  1718. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  1719. return;
  1720. }
  1721. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  1722. ptr0 += position0;
  1723. ::std::vector<double>* ptr1 = arg1 == NULL ? NULL : (::std::vector<double>*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  1724. jlong size1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_limitFID);
  1725. void* owner1 = JavaCPP_getPointerOwner(env, arg1);
  1726. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  1727. ptr1 += position1;
  1728. size1 -= position1;
  1729. VectorAdapter< ::std::vector<double> > adapter1(ptr1, size1, owner1);
  1730. int* ptr2 = arg2 == NULL ? NULL : env->GetIntArrayElements(arg2, NULL);
  1731. jlong size2 = arg2 == NULL ? 0 : env->GetArrayLength(arg2);
  1732. void* owner2 = (void*)ptr2;
  1733. VectorAdapter< int > adapter2(ptr2, size2, owner2);
  1734. jthrowable exc = NULL;
  1735. try {
  1736. ptr->eval(*ptr0, adapter1, adapter2);
  1737. } catch (...) {
  1738. exc = JavaCPP_handleException(env, 18);
  1739. }
  1740.  
  1741. ::std::vector<double>* rptr1 = adapter1;
  1742. jlong rsize1 = (jlong)adapter1.size;
  1743. void* rowner1 = adapter1.owner;
  1744. if (rptr1 != ptr1) {
  1745. JavaCPP_initPointer(env, arg1, rptr1, rsize1, rowner1, &VectorAdapter< ::std::vector<double> >::deallocate);
  1746. } else {
  1747. env->SetLongField(arg1, JavaCPP_limitFID, rsize1 + position1);
  1748. }
  1749. int* rptr2 = adapter2;
  1750. void* rowner2 = adapter2.owner;
  1751. if (rptr2 != ptr2) {
  1752. VectorAdapter< int >::deallocate(rowner2);
  1753. }
  1754. if (arg2 != NULL) env->ReleaseIntArrayElements(arg2, (jint*)ptr2, 0);
  1755. if (exc != NULL) {
  1756. env->Throw(exc);
  1757. }
  1758. }
  1759. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_00024ClassifierCallback_eval__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1text_00024DoubleVector_2Lorg_bytedeco_javacpp_IntPointer_2(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jobject arg2) {
  1760. ::cv::text::OCRBeamSearchDecoder::ClassifierCallback* ptr = (::cv::text::OCRBeamSearchDecoder::ClassifierCallback*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1761. if (ptr == NULL) {
  1762. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1763. return;
  1764. }
  1765. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1766. ptr += position;
  1767. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  1768. if (ptr0 == NULL) {
  1769. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  1770. return;
  1771. }
  1772. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  1773. ptr0 += position0;
  1774. ::std::vector<double>* ptr1 = arg1 == NULL ? NULL : (::std::vector<double>*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  1775. jlong size1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_limitFID);
  1776. void* owner1 = JavaCPP_getPointerOwner(env, arg1);
  1777. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  1778. ptr1 += position1;
  1779. size1 -= position1;
  1780. VectorAdapter< ::std::vector<double> > adapter1(ptr1, size1, owner1);
  1781. int* ptr2 = arg2 == NULL ? NULL : (int*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  1782. jlong size2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_limitFID);
  1783. void* owner2 = JavaCPP_getPointerOwner(env, arg2);
  1784. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  1785. ptr2 += position2;
  1786. size2 -= position2;
  1787. VectorAdapter< int > adapter2(ptr2, size2, owner2);
  1788. jthrowable exc = NULL;
  1789. try {
  1790. ptr->eval(*ptr0, adapter1, adapter2);
  1791. } catch (...) {
  1792. exc = JavaCPP_handleException(env, 18);
  1793. }
  1794.  
  1795. ::std::vector<double>* rptr1 = adapter1;
  1796. jlong rsize1 = (jlong)adapter1.size;
  1797. void* rowner1 = adapter1.owner;
  1798. if (rptr1 != ptr1) {
  1799. JavaCPP_initPointer(env, arg1, rptr1, rsize1, rowner1, &VectorAdapter< ::std::vector<double> >::deallocate);
  1800. } else {
  1801. env->SetLongField(arg1, JavaCPP_limitFID, rsize1 + position1);
  1802. }
  1803. int* rptr2 = adapter2;
  1804. jlong rsize2 = (jlong)adapter2.size;
  1805. void* rowner2 = adapter2.owner;
  1806. if (rptr2 != ptr2) {
  1807. JavaCPP_initPointer(env, arg2, rptr2, rsize2, rowner2, &VectorAdapter< int >::deallocate);
  1808. } else {
  1809. env->SetLongField(arg2, JavaCPP_limitFID, rsize2 + position2);
  1810. }
  1811. if (exc != NULL) {
  1812. env->Throw(exc);
  1813. }
  1814. }
  1815. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_00024ClassifierCallback_allocateArray(JNIEnv* env, jobject obj, jlong arg0) {
  1816. jthrowable exc = NULL;
  1817. try {
  1818. ::cv::text::OCRBeamSearchDecoder::ClassifierCallback* rptr = new ::cv::text::OCRBeamSearchDecoder::ClassifierCallback[arg0];
  1819. jlong rcapacity = arg0;
  1820. JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_00024ClassifierCallback_deallocateArray);
  1821. } catch (...) {
  1822. exc = JavaCPP_handleException(env, 18);
  1823. }
  1824.  
  1825. if (exc != NULL) {
  1826. env->Throw(exc);
  1827. }
  1828. }
  1829. JNIEXPORT jint JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_00024ClassifierCallback_getStepSize(JNIEnv* env, jobject obj) {
  1830. ::cv::text::OCRBeamSearchDecoder::ClassifierCallback* ptr = (::cv::text::OCRBeamSearchDecoder::ClassifierCallback*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1831. if (ptr == NULL) {
  1832. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1833. return 0;
  1834. }
  1835. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1836. ptr += position;
  1837. jint rarg = 0;
  1838. jthrowable exc = NULL;
  1839. try {
  1840. int rvalue = ptr->getStepSize();
  1841. rarg = (jint)rvalue;
  1842. } catch (...) {
  1843. exc = JavaCPP_handleException(env, 18);
  1844. }
  1845.  
  1846. if (exc != NULL) {
  1847. env->Throw(exc);
  1848. }
  1849. return rarg;
  1850. }
  1851. JNIEXPORT jint JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_00024ClassifierCallback_getWindowSize(JNIEnv* env, jobject obj) {
  1852. ::cv::text::OCRBeamSearchDecoder::ClassifierCallback* ptr = (::cv::text::OCRBeamSearchDecoder::ClassifierCallback*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1853. if (ptr == NULL) {
  1854. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1855. return 0;
  1856. }
  1857. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1858. ptr += position;
  1859. jint rarg = 0;
  1860. jthrowable exc = NULL;
  1861. try {
  1862. int rvalue = ptr->getWindowSize();
  1863. rarg = (jint)rvalue;
  1864. } catch (...) {
  1865. exc = JavaCPP_handleException(env, 18);
  1866. }
  1867.  
  1868. if (exc != NULL) {
  1869. env->Throw(exc);
  1870. }
  1871. return rarg;
  1872. }
  1873. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_00024ClassifierCallback_allocate(JNIEnv* env, jobject obj) {
  1874. jthrowable exc = NULL;
  1875. try {
  1876. ::cv::text::OCRBeamSearchDecoder::ClassifierCallback* rptr = new ::cv::text::OCRBeamSearchDecoder::ClassifierCallback();
  1877. jlong rcapacity = 1;
  1878. JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_00024ClassifierCallback_deallocate);
  1879. } catch (...) {
  1880. exc = JavaCPP_handleException(env, 18);
  1881. }
  1882.  
  1883. if (exc != NULL) {
  1884. env->Throw(exc);
  1885. }
  1886. }
  1887.  
  1888. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_allocateArray(JNIEnv* env, jobject obj, jlong arg0) {
  1889. jthrowable exc = NULL;
  1890. try {
  1891. ::cv::text::OCRBeamSearchDecoder* rptr = new ::cv::text::OCRBeamSearchDecoder[arg0];
  1892. jlong rcapacity = arg0;
  1893. JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_deallocateArray);
  1894. } catch (...) {
  1895. exc = JavaCPP_handleException(env, 18);
  1896. }
  1897.  
  1898. if (exc != NULL) {
  1899. env->Throw(exc);
  1900. }
  1901. }
  1902. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Lorg_bytedeco_javacpp_BytePointer_2Ljava_nio_FloatBuffer_2I(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jobject arg2, jobject arg3, jobject arg4, jobject arg5, jint arg6) {
  1903. ::cv::text::OCRBeamSearchDecoder* ptr = (::cv::text::OCRBeamSearchDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1904. if (ptr == NULL) {
  1905. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1906. return;
  1907. }
  1908. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1909. ptr += position;
  1910. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  1911. if (ptr0 == NULL) {
  1912. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  1913. return;
  1914. }
  1915. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  1916. ptr0 += position0;
  1917. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  1918. if (ptr1 == NULL) {
  1919. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  1920. return;
  1921. }
  1922. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  1923. ptr1 += position1;
  1924. signed char* ptr2 = arg2 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  1925. jlong size2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_limitFID);
  1926. void* owner2 = JavaCPP_getPointerOwner(env, arg2);
  1927. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  1928. ptr2 += position2;
  1929. size2 -= position2;
  1930. StringAdapter adapter2(ptr2, size2, owner2);
  1931. ::std::vector<cv::Rect>* ptr3 = arg3 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  1932. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  1933. ptr3 += position3;
  1934. signed char* ptr4 = arg4 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg4, JavaCPP_addressFID));
  1935. jlong size4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_limitFID);
  1936. void* owner4 = JavaCPP_getPointerOwner(env, arg4);
  1937. jlong position4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_positionFID);
  1938. ptr4 += position4;
  1939. size4 -= position4;
  1940. VectorAdapter adapter4(ptr4, size4, owner4);
  1941. float* ptr5 = arg5 == NULL ? NULL : (float*)env->GetDirectBufferAddress(arg5);
  1942. jlong size5 = arg5 == NULL ? 0 : env->GetDirectBufferCapacity(arg5);
  1943. void* owner5 = (void*)ptr5;
  1944. jfloatArray arr5 = NULL;
  1945. if (arg5 != NULL && ptr5 == NULL) {
  1946. arr5 = (jfloatArray)env->CallObjectMethod(arg5, JavaCPP_arrayMID);
  1947. if (env->ExceptionOccurred() != NULL) {
  1948. env->ExceptionClear();
  1949. } else {
  1950. ptr5 = arr5 == NULL ? NULL : env->GetFloatArrayElements(arr5, NULL);
  1951. size5 = env->GetArrayLength(arr5);
  1952. }
  1953. }
  1954. VectorAdapter< float > adapter5(ptr5, size5, owner5);
  1955. jthrowable exc = NULL;
  1956. try {
  1957. ptr->run(*ptr0, *ptr1, (std::string&)adapter2, ptr3, (std::string&)adapter4, adapter5, arg6);
  1958. } catch (...) {
  1959. exc = JavaCPP_handleException(env, 18);
  1960. }
  1961.  
  1962. signed char* rptr2 = adapter2;
  1963. jlong rsize2 = (jlong)adapter2.size;
  1964. void* rowner2 = adapter2.owner;
  1965. if (rptr2 != ptr2) {
  1966. JavaCPP_initPointer(env, arg2, rptr2, rsize2, rowner2, &StringAdapter::deallocate);
  1967. } else {
  1968. env->SetLongField(arg2, JavaCPP_limitFID, rsize2 + position2);
  1969. }
  1970. signed char* rptr4 = adapter4;
  1971. jlong rsize4 = (jlong)adapter4.size;
  1972. void* rowner4 = adapter4.owner;
  1973. if (rptr4 != ptr4) {
  1974. JavaCPP_initPointer(env, arg4, rptr4, rsize4, rowner4, &VectorAdapter::deallocate);
  1975. } else {
  1976. env->SetLongField(arg4, JavaCPP_limitFID, rsize4 + position4);
  1977. }
  1978. float* rptr5 = adapter5;
  1979. void* rowner5 = adapter5.owner;
  1980. if (rptr5 != ptr5) {
  1981. VectorAdapter< float >::deallocate(rowner5);
  1982. }
  1983. if (arr5 != NULL) env->ReleaseFloatArrayElements(arr5, (jfloat*)ptr5, 0);
  1984. if (exc != NULL) {
  1985. env->Throw(exc);
  1986. }
  1987. }
  1988. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Ljava_lang_String_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Ljava_lang_String_2Lorg_bytedeco_javacpp_FloatPointer_2I(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jstring arg2, jobject arg3, jstring arg4, jobject arg5, jint arg6) {
  1989. ::cv::text::OCRBeamSearchDecoder* ptr = (::cv::text::OCRBeamSearchDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  1990. if (ptr == NULL) {
  1991. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  1992. return;
  1993. }
  1994. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  1995. ptr += position;
  1996. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  1997. if (ptr0 == NULL) {
  1998. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  1999. return;
  2000. }
  2001. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  2002. ptr0 += position0;
  2003. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  2004. if (ptr1 == NULL) {
  2005. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  2006. return;
  2007. }
  2008. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  2009. ptr1 += position1;
  2010. const char* ptr2 = JavaCPP_getStringBytes(env, arg2);
  2011. jlong size2 = 0;
  2012. void* owner2 = (void*)ptr2;
  2013. StringAdapter adapter2(ptr2, size2, owner2);
  2014. ::std::vector<cv::Rect>* ptr3 = arg3 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  2015. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  2016. ptr3 += position3;
  2017. const char* ptr4 = JavaCPP_getStringBytes(env, arg4);
  2018. jlong size4 = 0;
  2019. void* owner4 = (void*)ptr4;
  2020. VectorAdapter adapter4(ptr4, size4, owner4);
  2021. float* ptr5 = arg5 == NULL ? NULL : (float*)jlong_to_ptr(env->GetLongField(arg5, JavaCPP_addressFID));
  2022. jlong size5 = arg5 == NULL ? 0 : env->GetLongField(arg5, JavaCPP_limitFID);
  2023. void* owner5 = JavaCPP_getPointerOwner(env, arg5);
  2024. jlong position5 = arg5 == NULL ? 0 : env->GetLongField(arg5, JavaCPP_positionFID);
  2025. ptr5 += position5;
  2026. size5 -= position5;
  2027. VectorAdapter< float > adapter5(ptr5, size5, owner5);
  2028. jthrowable exc = NULL;
  2029. try {
  2030. ptr->run(*ptr0, *ptr1, (std::string&)adapter2, ptr3, (std::string&)adapter4, adapter5, arg6);
  2031. } catch (...) {
  2032. exc = JavaCPP_handleException(env, 18);
  2033. }
  2034.  
  2035. JavaCPP_releaseStringBytes(env, arg2, ptr2);
  2036. JavaCPP_releaseStringBytes(env, arg4, ptr4);
  2037. float* rptr5 = adapter5;
  2038. jlong rsize5 = (jlong)adapter5.size;
  2039. void* rowner5 = adapter5.owner;
  2040. if (rptr5 != ptr5) {
  2041. JavaCPP_initPointer(env, arg5, rptr5, rsize5, rowner5, &VectorAdapter< float >::deallocate);
  2042. } else {
  2043. env->SetLongField(arg5, JavaCPP_limitFID, rsize5 + position5);
  2044. }
  2045. if (exc != NULL) {
  2046. env->Throw(exc);
  2047. }
  2048. }
  2049. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Ljava_lang_String_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Ljava_lang_String_2Ljava_nio_FloatBuffer_2I(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jstring arg2, jobject arg3, jstring arg4, jobject arg5, jint arg6) {
  2050. ::cv::text::OCRBeamSearchDecoder* ptr = (::cv::text::OCRBeamSearchDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  2051. if (ptr == NULL) {
  2052. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  2053. return;
  2054. }
  2055. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  2056. ptr += position;
  2057. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  2058. if (ptr0 == NULL) {
  2059. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  2060. return;
  2061. }
  2062. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  2063. ptr0 += position0;
  2064. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  2065. if (ptr1 == NULL) {
  2066. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  2067. return;
  2068. }
  2069. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  2070. ptr1 += position1;
  2071. const char* ptr2 = JavaCPP_getStringBytes(env, arg2);
  2072. jlong size2 = 0;
  2073. void* owner2 = (void*)ptr2;
  2074. StringAdapter adapter2(ptr2, size2, owner2);
  2075. ::std::vector<cv::Rect>* ptr3 = arg3 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  2076. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  2077. ptr3 += position3;
  2078. const char* ptr4 = JavaCPP_getStringBytes(env, arg4);
  2079. jlong size4 = 0;
  2080. void* owner4 = (void*)ptr4;
  2081. VectorAdapter adapter4(ptr4, size4, owner4);
  2082. float* ptr5 = arg5 == NULL ? NULL : (float*)env->GetDirectBufferAddress(arg5);
  2083. jlong size5 = arg5 == NULL ? 0 : env->GetDirectBufferCapacity(arg5);
  2084. void* owner5 = (void*)ptr5;
  2085. jfloatArray arr5 = NULL;
  2086. if (arg5 != NULL && ptr5 == NULL) {
  2087. arr5 = (jfloatArray)env->CallObjectMethod(arg5, JavaCPP_arrayMID);
  2088. if (env->ExceptionOccurred() != NULL) {
  2089. env->ExceptionClear();
  2090. } else {
  2091. ptr5 = arr5 == NULL ? NULL : env->GetFloatArrayElements(arr5, NULL);
  2092. size5 = env->GetArrayLength(arr5);
  2093. }
  2094. }
  2095. VectorAdapter< float > adapter5(ptr5, size5, owner5);
  2096. jthrowable exc = NULL;
  2097. try {
  2098. ptr->run(*ptr0, *ptr1, (std::string&)adapter2, ptr3, (std::string&)adapter4, adapter5, arg6);
  2099. } catch (...) {
  2100. exc = JavaCPP_handleException(env, 18);
  2101. }
  2102.  
  2103. JavaCPP_releaseStringBytes(env, arg2, ptr2);
  2104. JavaCPP_releaseStringBytes(env, arg4, ptr4);
  2105. float* rptr5 = adapter5;
  2106. void* rowner5 = adapter5.owner;
  2107. if (rptr5 != ptr5) {
  2108. VectorAdapter< float >::deallocate(rowner5);
  2109. }
  2110. if (arr5 != NULL) env->ReleaseFloatArrayElements(arr5, (jfloat*)ptr5, 0);
  2111. if (exc != NULL) {
  2112. env->Throw(exc);
  2113. }
  2114. }
  2115. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Ljava_lang_String_2(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jstring arg2) {
  2116. ::cv::text::OCRBeamSearchDecoder* ptr = (::cv::text::OCRBeamSearchDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  2117. if (ptr == NULL) {
  2118. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  2119. return;
  2120. }
  2121. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  2122. ptr += position;
  2123. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  2124. if (ptr0 == NULL) {
  2125. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  2126. return;
  2127. }
  2128. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  2129. ptr0 += position0;
  2130. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  2131. if (ptr1 == NULL) {
  2132. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  2133. return;
  2134. }
  2135. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  2136. ptr1 += position1;
  2137. const char* ptr2 = JavaCPP_getStringBytes(env, arg2);
  2138. jlong size2 = 0;
  2139. void* owner2 = (void*)ptr2;
  2140. StringAdapter adapter2(ptr2, size2, owner2);
  2141. jthrowable exc = NULL;
  2142. try {
  2143. ptr->run(*ptr0, *ptr1, (std::string&)adapter2);
  2144. } catch (...) {
  2145. exc = JavaCPP_handleException(env, 18);
  2146. }
  2147.  
  2148. JavaCPP_releaseStringBytes(env, arg2, ptr2);
  2149. if (exc != NULL) {
  2150. env->Throw(exc);
  2151. }
  2152. }
  2153. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_BytePointer_2(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jobject arg2) {
  2154. ::cv::text::OCRBeamSearchDecoder* ptr = (::cv::text::OCRBeamSearchDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  2155. if (ptr == NULL) {
  2156. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  2157. return;
  2158. }
  2159. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  2160. ptr += position;
  2161. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  2162. if (ptr0 == NULL) {
  2163. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  2164. return;
  2165. }
  2166. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  2167. ptr0 += position0;
  2168. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  2169. if (ptr1 == NULL) {
  2170. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  2171. return;
  2172. }
  2173. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  2174. ptr1 += position1;
  2175. signed char* ptr2 = arg2 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  2176. jlong size2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_limitFID);
  2177. void* owner2 = JavaCPP_getPointerOwner(env, arg2);
  2178. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  2179. ptr2 += position2;
  2180. size2 -= position2;
  2181. StringAdapter adapter2(ptr2, size2, owner2);
  2182. jthrowable exc = NULL;
  2183. try {
  2184. ptr->run(*ptr0, *ptr1, (std::string&)adapter2);
  2185. } catch (...) {
  2186. exc = JavaCPP_handleException(env, 18);
  2187. }
  2188.  
  2189. signed char* rptr2 = adapter2;
  2190. jlong rsize2 = (jlong)adapter2.size;
  2191. void* rowner2 = adapter2.owner;
  2192. if (rptr2 != ptr2) {
  2193. JavaCPP_initPointer(env, arg2, rptr2, rsize2, rowner2, &StringAdapter::deallocate);
  2194. } else {
  2195. env->SetLongField(arg2, JavaCPP_limitFID, rsize2 + position2);
  2196. }
  2197. if (exc != NULL) {
  2198. env->Throw(exc);
  2199. }
  2200. }
  2201. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2I(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jint arg2) {
  2202. ::cv::text::OCRBeamSearchDecoder* ptr = (::cv::text::OCRBeamSearchDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  2203. if (ptr == NULL) {
  2204. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  2205. return 0;
  2206. }
  2207. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  2208. ptr += position;
  2209. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  2210. if (ptr0 == NULL) {
  2211. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  2212. return 0;
  2213. }
  2214. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  2215. ptr0 += position0;
  2216. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  2217. if (ptr1 == NULL) {
  2218. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  2219. return 0;
  2220. }
  2221. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  2222. ptr1 += position1;
  2223. jobject rarg = NULL;
  2224. signed char* rptr;
  2225. jthrowable exc = NULL;
  2226. try {
  2227. StrAdapter radapter(ptr->run(*ptr0, *ptr1, arg2));
  2228. rptr = radapter;
  2229. jlong rcapacity = (jlong)radapter.size;
  2230. void* rowner = radapter.owner;
  2231. void (*deallocator)(void*) = &StrAdapter::deallocate;
  2232. if (rptr != NULL) {
  2233. rarg = JavaCPP_createPointer(env, 1);
  2234. if (rarg != NULL) {
  2235. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  2236. }
  2237. }
  2238. } catch (...) {
  2239. exc = JavaCPP_handleException(env, 18);
  2240. }
  2241.  
  2242. if (exc != NULL) {
  2243. env->Throw(exc);
  2244. }
  2245. return rarg;
  2246. }
  2247. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2II(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jint arg2, jint arg3) {
  2248. ::cv::text::OCRBeamSearchDecoder* ptr = (::cv::text::OCRBeamSearchDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  2249. if (ptr == NULL) {
  2250. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  2251. return 0;
  2252. }
  2253. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  2254. ptr += position;
  2255. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  2256. if (ptr0 == NULL) {
  2257. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  2258. return 0;
  2259. }
  2260. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  2261. ptr0 += position0;
  2262. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  2263. if (ptr1 == NULL) {
  2264. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  2265. return 0;
  2266. }
  2267. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  2268. ptr1 += position1;
  2269. jobject rarg = NULL;
  2270. signed char* rptr;
  2271. jthrowable exc = NULL;
  2272. try {
  2273. StrAdapter radapter(ptr->run(*ptr0, *ptr1, arg2, arg3));
  2274. rptr = radapter;
  2275. jlong rcapacity = (jlong)radapter.size;
  2276. void* rowner = radapter.owner;
  2277. void (*deallocator)(void*) = &StrAdapter::deallocate;
  2278. if (rptr != NULL) {
  2279. rarg = JavaCPP_createPointer(env, 1);
  2280. if (rarg != NULL) {
  2281. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  2282. }
  2283. }
  2284. } catch (...) {
  2285. exc = JavaCPP_handleException(env, 18);
  2286. }
  2287.  
  2288. if (exc != NULL) {
  2289. env->Throw(exc);
  2290. }
  2291. return rarg;
  2292. }
  2293. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2I(JNIEnv* env, jobject obj, jobject arg0, jint arg1) {
  2294. ::cv::text::OCRBeamSearchDecoder* ptr = (::cv::text::OCRBeamSearchDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  2295. if (ptr == NULL) {
  2296. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  2297. return 0;
  2298. }
  2299. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  2300. ptr += position;
  2301. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  2302. if (ptr0 == NULL) {
  2303. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  2304. return 0;
  2305. }
  2306. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  2307. ptr0 += position0;
  2308. jobject rarg = NULL;
  2309. signed char* rptr;
  2310. jthrowable exc = NULL;
  2311. try {
  2312. StrAdapter radapter(ptr->run(*ptr0, arg1));
  2313. rptr = radapter;
  2314. jlong rcapacity = (jlong)radapter.size;
  2315. void* rowner = radapter.owner;
  2316. void (*deallocator)(void*) = &StrAdapter::deallocate;
  2317. if (rptr != NULL) {
  2318. rarg = JavaCPP_createPointer(env, 1);
  2319. if (rarg != NULL) {
  2320. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  2321. }
  2322. }
  2323. } catch (...) {
  2324. exc = JavaCPP_handleException(env, 18);
  2325. }
  2326.  
  2327. if (exc != NULL) {
  2328. env->Throw(exc);
  2329. }
  2330. return rarg;
  2331. }
  2332. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2II(JNIEnv* env, jobject obj, jobject arg0, jint arg1, jint arg2) {
  2333. ::cv::text::OCRBeamSearchDecoder* ptr = (::cv::text::OCRBeamSearchDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  2334. if (ptr == NULL) {
  2335. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  2336. return 0;
  2337. }
  2338. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  2339. ptr += position;
  2340. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  2341. if (ptr0 == NULL) {
  2342. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  2343. return 0;
  2344. }
  2345. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  2346. ptr0 += position0;
  2347. jobject rarg = NULL;
  2348. signed char* rptr;
  2349. jthrowable exc = NULL;
  2350. try {
  2351. StrAdapter radapter(ptr->run(*ptr0, arg1, arg2));
  2352. rptr = radapter;
  2353. jlong rcapacity = (jlong)radapter.size;
  2354. void* rowner = radapter.owner;
  2355. void (*deallocator)(void*) = &StrAdapter::deallocate;
  2356. if (rptr != NULL) {
  2357. rarg = JavaCPP_createPointer(env, 1);
  2358. if (rarg != NULL) {
  2359. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  2360. }
  2361. }
  2362. } catch (...) {
  2363. exc = JavaCPP_handleException(env, 18);
  2364. }
  2365.  
  2366. if (exc != NULL) {
  2367. env->Throw(exc);
  2368. }
  2369. return rarg;
  2370. }
  2371. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Ljava_lang_String_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Ljava_lang_String_2_3FI(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jstring arg2, jobject arg3, jstring arg4, jfloatArray arg5, jint arg6) {
  2372. ::cv::text::OCRBeamSearchDecoder* ptr = (::cv::text::OCRBeamSearchDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  2373. if (ptr == NULL) {
  2374. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  2375. return;
  2376. }
  2377. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  2378. ptr += position;
  2379. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  2380. if (ptr0 == NULL) {
  2381. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  2382. return;
  2383. }
  2384. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  2385. ptr0 += position0;
  2386. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  2387. if (ptr1 == NULL) {
  2388. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  2389. return;
  2390. }
  2391. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  2392. ptr1 += position1;
  2393. const char* ptr2 = JavaCPP_getStringBytes(env, arg2);
  2394. jlong size2 = 0;
  2395. void* owner2 = (void*)ptr2;
  2396. StringAdapter adapter2(ptr2, size2, owner2);
  2397. ::std::vector<cv::Rect>* ptr3 = arg3 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  2398. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  2399. ptr3 += position3;
  2400. const char* ptr4 = JavaCPP_getStringBytes(env, arg4);
  2401. jlong size4 = 0;
  2402. void* owner4 = (void*)ptr4;
  2403. VectorAdapter adapter4(ptr4, size4, owner4);
  2404. float* ptr5 = arg5 == NULL ? NULL : env->GetFloatArrayElements(arg5, NULL);
  2405. jlong size5 = arg5 == NULL ? 0 : env->GetArrayLength(arg5);
  2406. void* owner5 = (void*)ptr5;
  2407. VectorAdapter< float > adapter5(ptr5, size5, owner5);
  2408. jthrowable exc = NULL;
  2409. try {
  2410. ptr->run(*ptr0, *ptr1, (std::string&)adapter2, ptr3, (std::string&)adapter4, adapter5, arg6);
  2411. } catch (...) {
  2412. exc = JavaCPP_handleException(env, 18);
  2413. }
  2414.  
  2415. JavaCPP_releaseStringBytes(env, arg2, ptr2);
  2416. JavaCPP_releaseStringBytes(env, arg4, ptr4);
  2417. float* rptr5 = adapter5;
  2418. void* rowner5 = adapter5.owner;
  2419. if (rptr5 != ptr5) {
  2420. VectorAdapter< float >::deallocate(rowner5);
  2421. }
  2422. if (arg5 != NULL) env->ReleaseFloatArrayElements(arg5, (jfloat*)ptr5, 0);
  2423. if (exc != NULL) {
  2424. env->Throw(exc);
  2425. }
  2426. }
  2427. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Lorg_bytedeco_javacpp_BytePointer_2_3FI(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jobject arg2, jobject arg3, jfloatArray arg4, jint arg5) {
  2428. ::cv::text::OCRBeamSearchDecoder* ptr = (::cv::text::OCRBeamSearchDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  2429. if (ptr == NULL) {
  2430. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  2431. return;
  2432. }
  2433. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  2434. ptr += position;
  2435. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  2436. if (ptr0 == NULL) {
  2437. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  2438. return;
  2439. }
  2440. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  2441. ptr0 += position0;
  2442. signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  2443. jlong size1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_limitFID);
  2444. void* owner1 = JavaCPP_getPointerOwner(env, arg1);
  2445. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  2446. ptr1 += position1;
  2447. size1 -= position1;
  2448. StringAdapter adapter1(ptr1, size1, owner1);
  2449. ::std::vector<cv::Rect>* ptr2 = arg2 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  2450. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  2451. ptr2 += position2;
  2452. signed char* ptr3 = arg3 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  2453. jlong size3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_limitFID);
  2454. void* owner3 = JavaCPP_getPointerOwner(env, arg3);
  2455. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  2456. ptr3 += position3;
  2457. size3 -= position3;
  2458. VectorAdapter adapter3(ptr3, size3, owner3);
  2459. float* ptr4 = arg4 == NULL ? NULL : env->GetFloatArrayElements(arg4, NULL);
  2460. jlong size4 = arg4 == NULL ? 0 : env->GetArrayLength(arg4);
  2461. void* owner4 = (void*)ptr4;
  2462. VectorAdapter< float > adapter4(ptr4, size4, owner4);
  2463. jthrowable exc = NULL;
  2464. try {
  2465. ptr->run(*ptr0, (std::string&)adapter1, ptr2, (std::string&)adapter3, adapter4, arg5);
  2466. } catch (...) {
  2467. exc = JavaCPP_handleException(env, 18);
  2468. }
  2469.  
  2470. signed char* rptr1 = adapter1;
  2471. jlong rsize1 = (jlong)adapter1.size;
  2472. void* rowner1 = adapter1.owner;
  2473. if (rptr1 != ptr1) {
  2474. JavaCPP_initPointer(env, arg1, rptr1, rsize1, rowner1, &StringAdapter::deallocate);
  2475. } else {
  2476. env->SetLongField(arg1, JavaCPP_limitFID, rsize1 + position1);
  2477. }
  2478. signed char* rptr3 = adapter3;
  2479. jlong rsize3 = (jlong)adapter3.size;
  2480. void* rowner3 = adapter3.owner;
  2481. if (rptr3 != ptr3) {
  2482. JavaCPP_initPointer(env, arg3, rptr3, rsize3, rowner3, &VectorAdapter::deallocate);
  2483. } else {
  2484. env->SetLongField(arg3, JavaCPP_limitFID, rsize3 + position3);
  2485. }
  2486. float* rptr4 = adapter4;
  2487. void* rowner4 = adapter4.owner;
  2488. if (rptr4 != ptr4) {
  2489. VectorAdapter< float >::deallocate(rowner4);
  2490. }
  2491. if (arg4 != NULL) env->ReleaseFloatArrayElements(arg4, (jfloat*)ptr4, 0);
  2492. if (exc != NULL) {
  2493. env->Throw(exc);
  2494. }
  2495. }
  2496. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Ljava_lang_String_2(JNIEnv* env, jobject obj, jobject arg0, jstring arg1) {
  2497. ::cv::text::OCRBeamSearchDecoder* ptr = (::cv::text::OCRBeamSearchDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  2498. if (ptr == NULL) {
  2499. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  2500. return;
  2501. }
  2502. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  2503. ptr += position;
  2504. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  2505. if (ptr0 == NULL) {
  2506. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  2507. return;
  2508. }
  2509. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  2510. ptr0 += position0;
  2511. const char* ptr1 = JavaCPP_getStringBytes(env, arg1);
  2512. jlong size1 = 0;
  2513. void* owner1 = (void*)ptr1;
  2514. StringAdapter adapter1(ptr1, size1, owner1);
  2515. jthrowable exc = NULL;
  2516. try {
  2517. ptr->run(*ptr0, (std::string&)adapter1);
  2518. } catch (...) {
  2519. exc = JavaCPP_handleException(env, 18);
  2520. }
  2521.  
  2522. JavaCPP_releaseStringBytes(env, arg1, ptr1);
  2523. if (exc != NULL) {
  2524. env->Throw(exc);
  2525. }
  2526. }
  2527. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Ljava_lang_String_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Ljava_lang_String_2Ljava_nio_FloatBuffer_2I(JNIEnv* env, jobject obj, jobject arg0, jstring arg1, jobject arg2, jstring arg3, jobject arg4, jint arg5) {
  2528. ::cv::text::OCRBeamSearchDecoder* ptr = (::cv::text::OCRBeamSearchDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  2529. if (ptr == NULL) {
  2530. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  2531. return;
  2532. }
  2533. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  2534. ptr += position;
  2535. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  2536. if (ptr0 == NULL) {
  2537. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  2538. return;
  2539. }
  2540. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  2541. ptr0 += position0;
  2542. const char* ptr1 = JavaCPP_getStringBytes(env, arg1);
  2543. jlong size1 = 0;
  2544. void* owner1 = (void*)ptr1;
  2545. StringAdapter adapter1(ptr1, size1, owner1);
  2546. ::std::vector<cv::Rect>* ptr2 = arg2 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  2547. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  2548. ptr2 += position2;
  2549. const char* ptr3 = JavaCPP_getStringBytes(env, arg3);
  2550. jlong size3 = 0;
  2551. void* owner3 = (void*)ptr3;
  2552. VectorAdapter adapter3(ptr3, size3, owner3);
  2553. float* ptr4 = arg4 == NULL ? NULL : (float*)env->GetDirectBufferAddress(arg4);
  2554. jlong size4 = arg4 == NULL ? 0 : env->GetDirectBufferCapacity(arg4);
  2555. void* owner4 = (void*)ptr4;
  2556. jfloatArray arr4 = NULL;
  2557. if (arg4 != NULL && ptr4 == NULL) {
  2558. arr4 = (jfloatArray)env->CallObjectMethod(arg4, JavaCPP_arrayMID);
  2559. if (env->ExceptionOccurred() != NULL) {
  2560. env->ExceptionClear();
  2561. } else {
  2562. ptr4 = arr4 == NULL ? NULL : env->GetFloatArrayElements(arr4, NULL);
  2563. size4 = env->GetArrayLength(arr4);
  2564. }
  2565. }
  2566. VectorAdapter< float > adapter4(ptr4, size4, owner4);
  2567. jthrowable exc = NULL;
  2568. try {
  2569. ptr->run(*ptr0, (std::string&)adapter1, ptr2, (std::string&)adapter3, adapter4, arg5);
  2570. } catch (...) {
  2571. exc = JavaCPP_handleException(env, 18);
  2572. }
  2573.  
  2574. JavaCPP_releaseStringBytes(env, arg1, ptr1);
  2575. JavaCPP_releaseStringBytes(env, arg3, ptr3);
  2576. float* rptr4 = adapter4;
  2577. void* rowner4 = adapter4.owner;
  2578. if (rptr4 != ptr4) {
  2579. VectorAdapter< float >::deallocate(rowner4);
  2580. }
  2581. if (arr4 != NULL) env->ReleaseFloatArrayElements(arr4, (jfloat*)ptr4, 0);
  2582. if (exc != NULL) {
  2583. env->Throw(exc);
  2584. }
  2585. }
  2586. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_BytePointer_2(JNIEnv* env, jobject obj, jobject arg0, jobject arg1) {
  2587. ::cv::text::OCRBeamSearchDecoder* ptr = (::cv::text::OCRBeamSearchDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  2588. if (ptr == NULL) {
  2589. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  2590. return;
  2591. }
  2592. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  2593. ptr += position;
  2594. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  2595. if (ptr0 == NULL) {
  2596. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  2597. return;
  2598. }
  2599. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  2600. ptr0 += position0;
  2601. signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  2602. jlong size1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_limitFID);
  2603. void* owner1 = JavaCPP_getPointerOwner(env, arg1);
  2604. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  2605. ptr1 += position1;
  2606. size1 -= position1;
  2607. StringAdapter adapter1(ptr1, size1, owner1);
  2608. jthrowable exc = NULL;
  2609. try {
  2610. ptr->run(*ptr0, (std::string&)adapter1);
  2611. } catch (...) {
  2612. exc = JavaCPP_handleException(env, 18);
  2613. }
  2614.  
  2615. signed char* rptr1 = adapter1;
  2616. jlong rsize1 = (jlong)adapter1.size;
  2617. void* rowner1 = adapter1.owner;
  2618. if (rptr1 != ptr1) {
  2619. JavaCPP_initPointer(env, arg1, rptr1, rsize1, rowner1, &StringAdapter::deallocate);
  2620. } else {
  2621. env->SetLongField(arg1, JavaCPP_limitFID, rsize1 + position1);
  2622. }
  2623. if (exc != NULL) {
  2624. env->Throw(exc);
  2625. }
  2626. }
  2627. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_FloatPointer_2I(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jobject arg2, jobject arg3, jobject arg4, jint arg5) {
  2628. ::cv::text::OCRBeamSearchDecoder* ptr = (::cv::text::OCRBeamSearchDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  2629. if (ptr == NULL) {
  2630. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  2631. return;
  2632. }
  2633. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  2634. ptr += position;
  2635. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  2636. if (ptr0 == NULL) {
  2637. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  2638. return;
  2639. }
  2640. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  2641. ptr0 += position0;
  2642. signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  2643. jlong size1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_limitFID);
  2644. void* owner1 = JavaCPP_getPointerOwner(env, arg1);
  2645. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  2646. ptr1 += position1;
  2647. size1 -= position1;
  2648. StringAdapter adapter1(ptr1, size1, owner1);
  2649. ::std::vector<cv::Rect>* ptr2 = arg2 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  2650. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  2651. ptr2 += position2;
  2652. signed char* ptr3 = arg3 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  2653. jlong size3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_limitFID);
  2654. void* owner3 = JavaCPP_getPointerOwner(env, arg3);
  2655. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  2656. ptr3 += position3;
  2657. size3 -= position3;
  2658. VectorAdapter adapter3(ptr3, size3, owner3);
  2659. float* ptr4 = arg4 == NULL ? NULL : (float*)jlong_to_ptr(env->GetLongField(arg4, JavaCPP_addressFID));
  2660. jlong size4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_limitFID);
  2661. void* owner4 = JavaCPP_getPointerOwner(env, arg4);
  2662. jlong position4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_positionFID);
  2663. ptr4 += position4;
  2664. size4 -= position4;
  2665. VectorAdapter< float > adapter4(ptr4, size4, owner4);
  2666. jthrowable exc = NULL;
  2667. try {
  2668. ptr->run(*ptr0, (std::string&)adapter1, ptr2, (std::string&)adapter3, adapter4, arg5);
  2669. } catch (...) {
  2670. exc = JavaCPP_handleException(env, 18);
  2671. }
  2672.  
  2673. signed char* rptr1 = adapter1;
  2674. jlong rsize1 = (jlong)adapter1.size;
  2675. void* rowner1 = adapter1.owner;
  2676. if (rptr1 != ptr1) {
  2677. JavaCPP_initPointer(env, arg1, rptr1, rsize1, rowner1, &StringAdapter::deallocate);
  2678. } else {
  2679. env->SetLongField(arg1, JavaCPP_limitFID, rsize1 + position1);
  2680. }
  2681. signed char* rptr3 = adapter3;
  2682. jlong rsize3 = (jlong)adapter3.size;
  2683. void* rowner3 = adapter3.owner;
  2684. if (rptr3 != ptr3) {
  2685. JavaCPP_initPointer(env, arg3, rptr3, rsize3, rowner3, &VectorAdapter::deallocate);
  2686. } else {
  2687. env->SetLongField(arg3, JavaCPP_limitFID, rsize3 + position3);
  2688. }
  2689. float* rptr4 = adapter4;
  2690. jlong rsize4 = (jlong)adapter4.size;
  2691. void* rowner4 = adapter4.owner;
  2692. if (rptr4 != ptr4) {
  2693. JavaCPP_initPointer(env, arg4, rptr4, rsize4, rowner4, &VectorAdapter< float >::deallocate);
  2694. } else {
  2695. env->SetLongField(arg4, JavaCPP_limitFID, rsize4 + position4);
  2696. }
  2697. if (exc != NULL) {
  2698. env->Throw(exc);
  2699. }
  2700. }
  2701. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Lorg_bytedeco_javacpp_BytePointer_2_3FI(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jobject arg2, jobject arg3, jobject arg4, jfloatArray arg5, jint arg6) {
  2702. ::cv::text::OCRBeamSearchDecoder* ptr = (::cv::text::OCRBeamSearchDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  2703. if (ptr == NULL) {
  2704. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  2705. return;
  2706. }
  2707. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  2708. ptr += position;
  2709. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  2710. if (ptr0 == NULL) {
  2711. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  2712. return;
  2713. }
  2714. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  2715. ptr0 += position0;
  2716. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  2717. if (ptr1 == NULL) {
  2718. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  2719. return;
  2720. }
  2721. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  2722. ptr1 += position1;
  2723. signed char* ptr2 = arg2 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  2724. jlong size2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_limitFID);
  2725. void* owner2 = JavaCPP_getPointerOwner(env, arg2);
  2726. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  2727. ptr2 += position2;
  2728. size2 -= position2;
  2729. StringAdapter adapter2(ptr2, size2, owner2);
  2730. ::std::vector<cv::Rect>* ptr3 = arg3 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  2731. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  2732. ptr3 += position3;
  2733. signed char* ptr4 = arg4 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg4, JavaCPP_addressFID));
  2734. jlong size4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_limitFID);
  2735. void* owner4 = JavaCPP_getPointerOwner(env, arg4);
  2736. jlong position4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_positionFID);
  2737. ptr4 += position4;
  2738. size4 -= position4;
  2739. VectorAdapter adapter4(ptr4, size4, owner4);
  2740. float* ptr5 = arg5 == NULL ? NULL : env->GetFloatArrayElements(arg5, NULL);
  2741. jlong size5 = arg5 == NULL ? 0 : env->GetArrayLength(arg5);
  2742. void* owner5 = (void*)ptr5;
  2743. VectorAdapter< float > adapter5(ptr5, size5, owner5);
  2744. jthrowable exc = NULL;
  2745. try {
  2746. ptr->run(*ptr0, *ptr1, (std::string&)adapter2, ptr3, (std::string&)adapter4, adapter5, arg6);
  2747. } catch (...) {
  2748. exc = JavaCPP_handleException(env, 18);
  2749. }
  2750.  
  2751. signed char* rptr2 = adapter2;
  2752. jlong rsize2 = (jlong)adapter2.size;
  2753. void* rowner2 = adapter2.owner;
  2754. if (rptr2 != ptr2) {
  2755. JavaCPP_initPointer(env, arg2, rptr2, rsize2, rowner2, &StringAdapter::deallocate);
  2756. } else {
  2757. env->SetLongField(arg2, JavaCPP_limitFID, rsize2 + position2);
  2758. }
  2759. signed char* rptr4 = adapter4;
  2760. jlong rsize4 = (jlong)adapter4.size;
  2761. void* rowner4 = adapter4.owner;
  2762. if (rptr4 != ptr4) {
  2763. JavaCPP_initPointer(env, arg4, rptr4, rsize4, rowner4, &VectorAdapter::deallocate);
  2764. } else {
  2765. env->SetLongField(arg4, JavaCPP_limitFID, rsize4 + position4);
  2766. }
  2767. float* rptr5 = adapter5;
  2768. void* rowner5 = adapter5.owner;
  2769. if (rptr5 != ptr5) {
  2770. VectorAdapter< float >::deallocate(rowner5);
  2771. }
  2772. if (arg5 != NULL) env->ReleaseFloatArrayElements(arg5, (jfloat*)ptr5, 0);
  2773. if (exc != NULL) {
  2774. env->Throw(exc);
  2775. }
  2776. }
  2777. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_FloatPointer_2I(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jobject arg2, jobject arg3, jobject arg4, jobject arg5, jint arg6) {
  2778. ::cv::text::OCRBeamSearchDecoder* ptr = (::cv::text::OCRBeamSearchDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  2779. if (ptr == NULL) {
  2780. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  2781. return;
  2782. }
  2783. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  2784. ptr += position;
  2785. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  2786. if (ptr0 == NULL) {
  2787. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  2788. return;
  2789. }
  2790. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  2791. ptr0 += position0;
  2792. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  2793. if (ptr1 == NULL) {
  2794. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  2795. return;
  2796. }
  2797. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  2798. ptr1 += position1;
  2799. signed char* ptr2 = arg2 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  2800. jlong size2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_limitFID);
  2801. void* owner2 = JavaCPP_getPointerOwner(env, arg2);
  2802. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  2803. ptr2 += position2;
  2804. size2 -= position2;
  2805. StringAdapter adapter2(ptr2, size2, owner2);
  2806. ::std::vector<cv::Rect>* ptr3 = arg3 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  2807. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  2808. ptr3 += position3;
  2809. signed char* ptr4 = arg4 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg4, JavaCPP_addressFID));
  2810. jlong size4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_limitFID);
  2811. void* owner4 = JavaCPP_getPointerOwner(env, arg4);
  2812. jlong position4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_positionFID);
  2813. ptr4 += position4;
  2814. size4 -= position4;
  2815. VectorAdapter adapter4(ptr4, size4, owner4);
  2816. float* ptr5 = arg5 == NULL ? NULL : (float*)jlong_to_ptr(env->GetLongField(arg5, JavaCPP_addressFID));
  2817. jlong size5 = arg5 == NULL ? 0 : env->GetLongField(arg5, JavaCPP_limitFID);
  2818. void* owner5 = JavaCPP_getPointerOwner(env, arg5);
  2819. jlong position5 = arg5 == NULL ? 0 : env->GetLongField(arg5, JavaCPP_positionFID);
  2820. ptr5 += position5;
  2821. size5 -= position5;
  2822. VectorAdapter< float > adapter5(ptr5, size5, owner5);
  2823. jthrowable exc = NULL;
  2824. try {
  2825. ptr->run(*ptr0, *ptr1, (std::string&)adapter2, ptr3, (std::string&)adapter4, adapter5, arg6);
  2826. } catch (...) {
  2827. exc = JavaCPP_handleException(env, 18);
  2828. }
  2829.  
  2830. signed char* rptr2 = adapter2;
  2831. jlong rsize2 = (jlong)adapter2.size;
  2832. void* rowner2 = adapter2.owner;
  2833. if (rptr2 != ptr2) {
  2834. JavaCPP_initPointer(env, arg2, rptr2, rsize2, rowner2, &StringAdapter::deallocate);
  2835. } else {
  2836. env->SetLongField(arg2, JavaCPP_limitFID, rsize2 + position2);
  2837. }
  2838. signed char* rptr4 = adapter4;
  2839. jlong rsize4 = (jlong)adapter4.size;
  2840. void* rowner4 = adapter4.owner;
  2841. if (rptr4 != ptr4) {
  2842. JavaCPP_initPointer(env, arg4, rptr4, rsize4, rowner4, &VectorAdapter::deallocate);
  2843. } else {
  2844. env->SetLongField(arg4, JavaCPP_limitFID, rsize4 + position4);
  2845. }
  2846. float* rptr5 = adapter5;
  2847. jlong rsize5 = (jlong)adapter5.size;
  2848. void* rowner5 = adapter5.owner;
  2849. if (rptr5 != ptr5) {
  2850. JavaCPP_initPointer(env, arg5, rptr5, rsize5, rowner5, &VectorAdapter< float >::deallocate);
  2851. } else {
  2852. env->SetLongField(arg5, JavaCPP_limitFID, rsize5 + position5);
  2853. }
  2854. if (exc != NULL) {
  2855. env->Throw(exc);
  2856. }
  2857. }
  2858. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Ljava_lang_String_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Ljava_lang_String_2_3FI(JNIEnv* env, jobject obj, jobject arg0, jstring arg1, jobject arg2, jstring arg3, jfloatArray arg4, jint arg5) {
  2859. ::cv::text::OCRBeamSearchDecoder* ptr = (::cv::text::OCRBeamSearchDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  2860. if (ptr == NULL) {
  2861. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  2862. return;
  2863. }
  2864. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  2865. ptr += position;
  2866. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  2867. if (ptr0 == NULL) {
  2868. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  2869. return;
  2870. }
  2871. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  2872. ptr0 += position0;
  2873. const char* ptr1 = JavaCPP_getStringBytes(env, arg1);
  2874. jlong size1 = 0;
  2875. void* owner1 = (void*)ptr1;
  2876. StringAdapter adapter1(ptr1, size1, owner1);
  2877. ::std::vector<cv::Rect>* ptr2 = arg2 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  2878. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  2879. ptr2 += position2;
  2880. const char* ptr3 = JavaCPP_getStringBytes(env, arg3);
  2881. jlong size3 = 0;
  2882. void* owner3 = (void*)ptr3;
  2883. VectorAdapter adapter3(ptr3, size3, owner3);
  2884. float* ptr4 = arg4 == NULL ? NULL : env->GetFloatArrayElements(arg4, NULL);
  2885. jlong size4 = arg4 == NULL ? 0 : env->GetArrayLength(arg4);
  2886. void* owner4 = (void*)ptr4;
  2887. VectorAdapter< float > adapter4(ptr4, size4, owner4);
  2888. jthrowable exc = NULL;
  2889. try {
  2890. ptr->run(*ptr0, (std::string&)adapter1, ptr2, (std::string&)adapter3, adapter4, arg5);
  2891. } catch (...) {
  2892. exc = JavaCPP_handleException(env, 18);
  2893. }
  2894.  
  2895. JavaCPP_releaseStringBytes(env, arg1, ptr1);
  2896. JavaCPP_releaseStringBytes(env, arg3, ptr3);
  2897. float* rptr4 = adapter4;
  2898. void* rowner4 = adapter4.owner;
  2899. if (rptr4 != ptr4) {
  2900. VectorAdapter< float >::deallocate(rowner4);
  2901. }
  2902. if (arg4 != NULL) env->ReleaseFloatArrayElements(arg4, (jfloat*)ptr4, 0);
  2903. if (exc != NULL) {
  2904. env->Throw(exc);
  2905. }
  2906. }
  2907. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Lorg_bytedeco_javacpp_BytePointer_2Ljava_nio_FloatBuffer_2I(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jobject arg2, jobject arg3, jobject arg4, jint arg5) {
  2908. ::cv::text::OCRBeamSearchDecoder* ptr = (::cv::text::OCRBeamSearchDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  2909. if (ptr == NULL) {
  2910. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  2911. return;
  2912. }
  2913. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  2914. ptr += position;
  2915. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  2916. if (ptr0 == NULL) {
  2917. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  2918. return;
  2919. }
  2920. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  2921. ptr0 += position0;
  2922. signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  2923. jlong size1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_limitFID);
  2924. void* owner1 = JavaCPP_getPointerOwner(env, arg1);
  2925. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  2926. ptr1 += position1;
  2927. size1 -= position1;
  2928. StringAdapter adapter1(ptr1, size1, owner1);
  2929. ::std::vector<cv::Rect>* ptr2 = arg2 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  2930. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  2931. ptr2 += position2;
  2932. signed char* ptr3 = arg3 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  2933. jlong size3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_limitFID);
  2934. void* owner3 = JavaCPP_getPointerOwner(env, arg3);
  2935. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  2936. ptr3 += position3;
  2937. size3 -= position3;
  2938. VectorAdapter adapter3(ptr3, size3, owner3);
  2939. float* ptr4 = arg4 == NULL ? NULL : (float*)env->GetDirectBufferAddress(arg4);
  2940. jlong size4 = arg4 == NULL ? 0 : env->GetDirectBufferCapacity(arg4);
  2941. void* owner4 = (void*)ptr4;
  2942. jfloatArray arr4 = NULL;
  2943. if (arg4 != NULL && ptr4 == NULL) {
  2944. arr4 = (jfloatArray)env->CallObjectMethod(arg4, JavaCPP_arrayMID);
  2945. if (env->ExceptionOccurred() != NULL) {
  2946. env->ExceptionClear();
  2947. } else {
  2948. ptr4 = arr4 == NULL ? NULL : env->GetFloatArrayElements(arr4, NULL);
  2949. size4 = env->GetArrayLength(arr4);
  2950. }
  2951. }
  2952. VectorAdapter< float > adapter4(ptr4, size4, owner4);
  2953. jthrowable exc = NULL;
  2954. try {
  2955. ptr->run(*ptr0, (std::string&)adapter1, ptr2, (std::string&)adapter3, adapter4, arg5);
  2956. } catch (...) {
  2957. exc = JavaCPP_handleException(env, 18);
  2958. }
  2959.  
  2960. signed char* rptr1 = adapter1;
  2961. jlong rsize1 = (jlong)adapter1.size;
  2962. void* rowner1 = adapter1.owner;
  2963. if (rptr1 != ptr1) {
  2964. JavaCPP_initPointer(env, arg1, rptr1, rsize1, rowner1, &StringAdapter::deallocate);
  2965. } else {
  2966. env->SetLongField(arg1, JavaCPP_limitFID, rsize1 + position1);
  2967. }
  2968. signed char* rptr3 = adapter3;
  2969. jlong rsize3 = (jlong)adapter3.size;
  2970. void* rowner3 = adapter3.owner;
  2971. if (rptr3 != ptr3) {
  2972. JavaCPP_initPointer(env, arg3, rptr3, rsize3, rowner3, &VectorAdapter::deallocate);
  2973. } else {
  2974. env->SetLongField(arg3, JavaCPP_limitFID, rsize3 + position3);
  2975. }
  2976. float* rptr4 = adapter4;
  2977. void* rowner4 = adapter4.owner;
  2978. if (rptr4 != ptr4) {
  2979. VectorAdapter< float >::deallocate(rowner4);
  2980. }
  2981. if (arr4 != NULL) env->ReleaseFloatArrayElements(arr4, (jfloat*)ptr4, 0);
  2982. if (exc != NULL) {
  2983. env->Throw(exc);
  2984. }
  2985. }
  2986. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Ljava_lang_String_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Ljava_lang_String_2Lorg_bytedeco_javacpp_FloatPointer_2I(JNIEnv* env, jobject obj, jobject arg0, jstring arg1, jobject arg2, jstring arg3, jobject arg4, jint arg5) {
  2987. ::cv::text::OCRBeamSearchDecoder* ptr = (::cv::text::OCRBeamSearchDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  2988. if (ptr == NULL) {
  2989. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  2990. return;
  2991. }
  2992. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  2993. ptr += position;
  2994. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  2995. if (ptr0 == NULL) {
  2996. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  2997. return;
  2998. }
  2999. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  3000. ptr0 += position0;
  3001. const char* ptr1 = JavaCPP_getStringBytes(env, arg1);
  3002. jlong size1 = 0;
  3003. void* owner1 = (void*)ptr1;
  3004. StringAdapter adapter1(ptr1, size1, owner1);
  3005. ::std::vector<cv::Rect>* ptr2 = arg2 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  3006. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  3007. ptr2 += position2;
  3008. const char* ptr3 = JavaCPP_getStringBytes(env, arg3);
  3009. jlong size3 = 0;
  3010. void* owner3 = (void*)ptr3;
  3011. VectorAdapter adapter3(ptr3, size3, owner3);
  3012. float* ptr4 = arg4 == NULL ? NULL : (float*)jlong_to_ptr(env->GetLongField(arg4, JavaCPP_addressFID));
  3013. jlong size4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_limitFID);
  3014. void* owner4 = JavaCPP_getPointerOwner(env, arg4);
  3015. jlong position4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_positionFID);
  3016. ptr4 += position4;
  3017. size4 -= position4;
  3018. VectorAdapter< float > adapter4(ptr4, size4, owner4);
  3019. jthrowable exc = NULL;
  3020. try {
  3021. ptr->run(*ptr0, (std::string&)adapter1, ptr2, (std::string&)adapter3, adapter4, arg5);
  3022. } catch (...) {
  3023. exc = JavaCPP_handleException(env, 18);
  3024. }
  3025.  
  3026. JavaCPP_releaseStringBytes(env, arg1, ptr1);
  3027. JavaCPP_releaseStringBytes(env, arg3, ptr3);
  3028. float* rptr4 = adapter4;
  3029. jlong rsize4 = (jlong)adapter4.size;
  3030. void* rowner4 = adapter4.owner;
  3031. if (rptr4 != ptr4) {
  3032. JavaCPP_initPointer(env, arg4, rptr4, rsize4, rowner4, &VectorAdapter< float >::deallocate);
  3033. } else {
  3034. env->SetLongField(arg4, JavaCPP_limitFID, rsize4 + position4);
  3035. }
  3036. if (exc != NULL) {
  3037. env->Throw(exc);
  3038. }
  3039. }
  3040. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_create__Lorg_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_00024ClassifierCallback_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2II(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jobject arg2, jobject arg3, jint arg4, jint arg5) {
  3041. ::cv::text::OCRBeamSearchDecoder::ClassifierCallback* ptr0 = arg0 == NULL ? NULL : (::cv::text::OCRBeamSearchDecoder::ClassifierCallback*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  3042. jlong size0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_limitFID);
  3043. void* owner0 = JavaCPP_getPointerOwner(env, arg0);
  3044. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  3045. ptr0 += position0;
  3046. size0 -= position0;
  3047. PtrAdapter< ::cv::text::OCRBeamSearchDecoder::ClassifierCallback > adapter0(ptr0, size0, owner0);
  3048. signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  3049. jlong size1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_limitFID);
  3050. void* owner1 = JavaCPP_getPointerOwner(env, arg1);
  3051. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  3052. ptr1 += position1;
  3053. size1 -= position1;
  3054. StringAdapter adapter1(ptr1, size1, owner1);
  3055. ::cv::Mat* ptr2 = arg2 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  3056. if (ptr2 == NULL) {
  3057. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 2 is NULL.");
  3058. return 0;
  3059. }
  3060. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  3061. ptr2 += position2;
  3062. ::cv::Mat* ptr3 = arg3 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  3063. if (ptr3 == NULL) {
  3064. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 3 is NULL.");
  3065. return 0;
  3066. }
  3067. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  3068. ptr3 += position3;
  3069. jobject rarg = NULL;
  3070. ::cv::text::OCRBeamSearchDecoder* rptr;
  3071. jthrowable exc = NULL;
  3072. try {
  3073. PtrAdapter< ::cv::text::OCRBeamSearchDecoder > radapter(::cv::text::OCRBeamSearchDecoder::create((cv::Ptr< ::cv::text::OCRBeamSearchDecoder::ClassifierCallback >)adapter0, (std::string&)adapter1, *ptr2, *ptr3, (cv::text::decoder_mode)arg4, arg5));
  3074. rptr = radapter;
  3075. jlong rcapacity = (jlong)radapter.size;
  3076. void* rowner = radapter.owner;
  3077. void (*deallocator)(void*) = &PtrAdapter< ::cv::text::OCRBeamSearchDecoder >::deallocate;
  3078. if (rptr != NULL) {
  3079. rarg = JavaCPP_createPointer(env, 20);
  3080. if (rarg != NULL) {
  3081. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  3082. }
  3083. }
  3084. } catch (...) {
  3085. exc = JavaCPP_handleException(env, 18);
  3086. }
  3087.  
  3088. ::cv::text::OCRBeamSearchDecoder::ClassifierCallback* rptr0 = adapter0;
  3089. jlong rsize0 = (jlong)adapter0.size;
  3090. void* rowner0 = adapter0.owner;
  3091. if (rptr0 != ptr0) {
  3092. JavaCPP_initPointer(env, arg0, rptr0, rsize0, rowner0, &PtrAdapter< ::cv::text::OCRBeamSearchDecoder::ClassifierCallback >::deallocate);
  3093. } else {
  3094. env->SetLongField(arg0, JavaCPP_limitFID, rsize0 + position0);
  3095. }
  3096. signed char* rptr1 = adapter1;
  3097. jlong rsize1 = (jlong)adapter1.size;
  3098. void* rowner1 = adapter1.owner;
  3099. if (rptr1 != ptr1) {
  3100. JavaCPP_initPointer(env, arg1, rptr1, rsize1, rowner1, &StringAdapter::deallocate);
  3101. } else {
  3102. env->SetLongField(arg1, JavaCPP_limitFID, rsize1 + position1);
  3103. }
  3104. if (exc != NULL) {
  3105. env->Throw(exc);
  3106. }
  3107. return rarg;
  3108. }
  3109. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_create__Lorg_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_00024ClassifierCallback_2Ljava_lang_String_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2(JNIEnv* env, jclass cls, jobject arg0, jstring arg1, jobject arg2, jobject arg3) {
  3110. ::cv::text::OCRBeamSearchDecoder::ClassifierCallback* ptr0 = arg0 == NULL ? NULL : (::cv::text::OCRBeamSearchDecoder::ClassifierCallback*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  3111. jlong size0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_limitFID);
  3112. void* owner0 = JavaCPP_getPointerOwner(env, arg0);
  3113. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  3114. ptr0 += position0;
  3115. size0 -= position0;
  3116. PtrAdapter< ::cv::text::OCRBeamSearchDecoder::ClassifierCallback > adapter0(ptr0, size0, owner0);
  3117. const char* ptr1 = JavaCPP_getStringBytes(env, arg1);
  3118. jlong size1 = 0;
  3119. void* owner1 = (void*)ptr1;
  3120. StringAdapter adapter1(ptr1, size1, owner1);
  3121. ::cv::Mat* ptr2 = arg2 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  3122. if (ptr2 == NULL) {
  3123. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 2 is NULL.");
  3124. return 0;
  3125. }
  3126. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  3127. ptr2 += position2;
  3128. ::cv::Mat* ptr3 = arg3 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  3129. if (ptr3 == NULL) {
  3130. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 3 is NULL.");
  3131. return 0;
  3132. }
  3133. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  3134. ptr3 += position3;
  3135. jobject rarg = NULL;
  3136. ::cv::text::OCRBeamSearchDecoder* rptr;
  3137. jthrowable exc = NULL;
  3138. try {
  3139. PtrAdapter< ::cv::text::OCRBeamSearchDecoder > radapter(::cv::text::OCRBeamSearchDecoder::create((cv::Ptr< ::cv::text::OCRBeamSearchDecoder::ClassifierCallback >)adapter0, (std::string&)adapter1, *ptr2, *ptr3));
  3140. rptr = radapter;
  3141. jlong rcapacity = (jlong)radapter.size;
  3142. void* rowner = radapter.owner;
  3143. void (*deallocator)(void*) = &PtrAdapter< ::cv::text::OCRBeamSearchDecoder >::deallocate;
  3144. if (rptr != NULL) {
  3145. rarg = JavaCPP_createPointer(env, 20);
  3146. if (rarg != NULL) {
  3147. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  3148. }
  3149. }
  3150. } catch (...) {
  3151. exc = JavaCPP_handleException(env, 18);
  3152. }
  3153.  
  3154. ::cv::text::OCRBeamSearchDecoder::ClassifierCallback* rptr0 = adapter0;
  3155. jlong rsize0 = (jlong)adapter0.size;
  3156. void* rowner0 = adapter0.owner;
  3157. if (rptr0 != ptr0) {
  3158. JavaCPP_initPointer(env, arg0, rptr0, rsize0, rowner0, &PtrAdapter< ::cv::text::OCRBeamSearchDecoder::ClassifierCallback >::deallocate);
  3159. } else {
  3160. env->SetLongField(arg0, JavaCPP_limitFID, rsize0 + position0);
  3161. }
  3162. JavaCPP_releaseStringBytes(env, arg1, ptr1);
  3163. if (exc != NULL) {
  3164. env->Throw(exc);
  3165. }
  3166. return rarg;
  3167. }
  3168. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_create__Lorg_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_00024ClassifierCallback_2Ljava_lang_String_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2II(JNIEnv* env, jclass cls, jobject arg0, jstring arg1, jobject arg2, jobject arg3, jint arg4, jint arg5) {
  3169. ::cv::text::OCRBeamSearchDecoder::ClassifierCallback* ptr0 = arg0 == NULL ? NULL : (::cv::text::OCRBeamSearchDecoder::ClassifierCallback*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  3170. jlong size0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_limitFID);
  3171. void* owner0 = JavaCPP_getPointerOwner(env, arg0);
  3172. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  3173. ptr0 += position0;
  3174. size0 -= position0;
  3175. PtrAdapter< ::cv::text::OCRBeamSearchDecoder::ClassifierCallback > adapter0(ptr0, size0, owner0);
  3176. const char* ptr1 = JavaCPP_getStringBytes(env, arg1);
  3177. jlong size1 = 0;
  3178. void* owner1 = (void*)ptr1;
  3179. StringAdapter adapter1(ptr1, size1, owner1);
  3180. ::cv::Mat* ptr2 = arg2 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  3181. if (ptr2 == NULL) {
  3182. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 2 is NULL.");
  3183. return 0;
  3184. }
  3185. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  3186. ptr2 += position2;
  3187. ::cv::Mat* ptr3 = arg3 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  3188. if (ptr3 == NULL) {
  3189. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 3 is NULL.");
  3190. return 0;
  3191. }
  3192. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  3193. ptr3 += position3;
  3194. jobject rarg = NULL;
  3195. ::cv::text::OCRBeamSearchDecoder* rptr;
  3196. jthrowable exc = NULL;
  3197. try {
  3198. PtrAdapter< ::cv::text::OCRBeamSearchDecoder > radapter(::cv::text::OCRBeamSearchDecoder::create((cv::Ptr< ::cv::text::OCRBeamSearchDecoder::ClassifierCallback >)adapter0, (std::string&)adapter1, *ptr2, *ptr3, (cv::text::decoder_mode)arg4, arg5));
  3199. rptr = radapter;
  3200. jlong rcapacity = (jlong)radapter.size;
  3201. void* rowner = radapter.owner;
  3202. void (*deallocator)(void*) = &PtrAdapter< ::cv::text::OCRBeamSearchDecoder >::deallocate;
  3203. if (rptr != NULL) {
  3204. rarg = JavaCPP_createPointer(env, 20);
  3205. if (rarg != NULL) {
  3206. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  3207. }
  3208. }
  3209. } catch (...) {
  3210. exc = JavaCPP_handleException(env, 18);
  3211. }
  3212.  
  3213. ::cv::text::OCRBeamSearchDecoder::ClassifierCallback* rptr0 = adapter0;
  3214. jlong rsize0 = (jlong)adapter0.size;
  3215. void* rowner0 = adapter0.owner;
  3216. if (rptr0 != ptr0) {
  3217. JavaCPP_initPointer(env, arg0, rptr0, rsize0, rowner0, &PtrAdapter< ::cv::text::OCRBeamSearchDecoder::ClassifierCallback >::deallocate);
  3218. } else {
  3219. env->SetLongField(arg0, JavaCPP_limitFID, rsize0 + position0);
  3220. }
  3221. JavaCPP_releaseStringBytes(env, arg1, ptr1);
  3222. if (exc != NULL) {
  3223. env->Throw(exc);
  3224. }
  3225. return rarg;
  3226. }
  3227. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_create__Lorg_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_00024ClassifierCallback_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jobject arg2, jobject arg3) {
  3228. ::cv::text::OCRBeamSearchDecoder::ClassifierCallback* ptr0 = arg0 == NULL ? NULL : (::cv::text::OCRBeamSearchDecoder::ClassifierCallback*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  3229. jlong size0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_limitFID);
  3230. void* owner0 = JavaCPP_getPointerOwner(env, arg0);
  3231. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  3232. ptr0 += position0;
  3233. size0 -= position0;
  3234. PtrAdapter< ::cv::text::OCRBeamSearchDecoder::ClassifierCallback > adapter0(ptr0, size0, owner0);
  3235. signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  3236. jlong size1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_limitFID);
  3237. void* owner1 = JavaCPP_getPointerOwner(env, arg1);
  3238. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  3239. ptr1 += position1;
  3240. size1 -= position1;
  3241. StringAdapter adapter1(ptr1, size1, owner1);
  3242. ::cv::Mat* ptr2 = arg2 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  3243. if (ptr2 == NULL) {
  3244. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 2 is NULL.");
  3245. return 0;
  3246. }
  3247. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  3248. ptr2 += position2;
  3249. ::cv::Mat* ptr3 = arg3 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  3250. if (ptr3 == NULL) {
  3251. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 3 is NULL.");
  3252. return 0;
  3253. }
  3254. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  3255. ptr3 += position3;
  3256. jobject rarg = NULL;
  3257. ::cv::text::OCRBeamSearchDecoder* rptr;
  3258. jthrowable exc = NULL;
  3259. try {
  3260. PtrAdapter< ::cv::text::OCRBeamSearchDecoder > radapter(::cv::text::OCRBeamSearchDecoder::create((cv::Ptr< ::cv::text::OCRBeamSearchDecoder::ClassifierCallback >)adapter0, (std::string&)adapter1, *ptr2, *ptr3));
  3261. rptr = radapter;
  3262. jlong rcapacity = (jlong)radapter.size;
  3263. void* rowner = radapter.owner;
  3264. void (*deallocator)(void*) = &PtrAdapter< ::cv::text::OCRBeamSearchDecoder >::deallocate;
  3265. if (rptr != NULL) {
  3266. rarg = JavaCPP_createPointer(env, 20);
  3267. if (rarg != NULL) {
  3268. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  3269. }
  3270. }
  3271. } catch (...) {
  3272. exc = JavaCPP_handleException(env, 18);
  3273. }
  3274.  
  3275. ::cv::text::OCRBeamSearchDecoder::ClassifierCallback* rptr0 = adapter0;
  3276. jlong rsize0 = (jlong)adapter0.size;
  3277. void* rowner0 = adapter0.owner;
  3278. if (rptr0 != ptr0) {
  3279. JavaCPP_initPointer(env, arg0, rptr0, rsize0, rowner0, &PtrAdapter< ::cv::text::OCRBeamSearchDecoder::ClassifierCallback >::deallocate);
  3280. } else {
  3281. env->SetLongField(arg0, JavaCPP_limitFID, rsize0 + position0);
  3282. }
  3283. signed char* rptr1 = adapter1;
  3284. jlong rsize1 = (jlong)adapter1.size;
  3285. void* rowner1 = adapter1.owner;
  3286. if (rptr1 != ptr1) {
  3287. JavaCPP_initPointer(env, arg1, rptr1, rsize1, rowner1, &StringAdapter::deallocate);
  3288. } else {
  3289. env->SetLongField(arg1, JavaCPP_limitFID, rsize1 + position1);
  3290. }
  3291. if (exc != NULL) {
  3292. env->Throw(exc);
  3293. }
  3294. return rarg;
  3295. }
  3296. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_allocate(JNIEnv* env, jobject obj) {
  3297. jthrowable exc = NULL;
  3298. try {
  3299. ::cv::text::OCRBeamSearchDecoder* rptr = new ::cv::text::OCRBeamSearchDecoder();
  3300. jlong rcapacity = 1;
  3301. JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_opencv_1text_00024OCRBeamSearchDecoder_deallocate);
  3302. } catch (...) {
  3303. exc = JavaCPP_handleException(env, 18);
  3304. }
  3305.  
  3306. if (exc != NULL) {
  3307. env->Throw(exc);
  3308. }
  3309. }
  3310.  
  3311. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_00024ClassifierCallback_eval__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Ljava_nio_IntBuffer_2Lorg_bytedeco_javacpp_opencv_1text_00024DoubleVector_2(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jobject arg2) {
  3312. ::cv::text::OCRHMMDecoder::ClassifierCallback* ptr = (::cv::text::OCRHMMDecoder::ClassifierCallback*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  3313. if (ptr == NULL) {
  3314. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  3315. return;
  3316. }
  3317. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  3318. ptr += position;
  3319. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  3320. if (ptr0 == NULL) {
  3321. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  3322. return;
  3323. }
  3324. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  3325. ptr0 += position0;
  3326. int* ptr1 = arg1 == NULL ? NULL : (int*)env->GetDirectBufferAddress(arg1);
  3327. jlong size1 = arg1 == NULL ? 0 : env->GetDirectBufferCapacity(arg1);
  3328. void* owner1 = (void*)ptr1;
  3329. jintArray arr1 = NULL;
  3330. if (arg1 != NULL && ptr1 == NULL) {
  3331. arr1 = (jintArray)env->CallObjectMethod(arg1, JavaCPP_arrayMID);
  3332. if (env->ExceptionOccurred() != NULL) {
  3333. env->ExceptionClear();
  3334. } else {
  3335. ptr1 = arr1 == NULL ? NULL : env->GetIntArrayElements(arr1, NULL);
  3336. size1 = env->GetArrayLength(arr1);
  3337. }
  3338. }
  3339. VectorAdapter< int > adapter1(ptr1, size1, owner1);
  3340. ::std::vector<double>* ptr2 = arg2 == NULL ? NULL : (::std::vector<double>*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  3341. if (ptr2 == NULL) {
  3342. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 2 is NULL.");
  3343. return;
  3344. }
  3345. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  3346. ptr2 += position2;
  3347. jthrowable exc = NULL;
  3348. try {
  3349. ptr->eval(*ptr0, adapter1, *ptr2);
  3350. } catch (...) {
  3351. exc = JavaCPP_handleException(env, 18);
  3352. }
  3353.  
  3354. int* rptr1 = adapter1;
  3355. void* rowner1 = adapter1.owner;
  3356. if (rptr1 != ptr1) {
  3357. VectorAdapter< int >::deallocate(rowner1);
  3358. }
  3359. if (arr1 != NULL) env->ReleaseIntArrayElements(arr1, (jint*)ptr1, 0);
  3360. if (exc != NULL) {
  3361. env->Throw(exc);
  3362. }
  3363. }
  3364. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_00024ClassifierCallback_eval__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_IntPointer_2Lorg_bytedeco_javacpp_opencv_1text_00024DoubleVector_2(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jobject arg2) {
  3365. ::cv::text::OCRHMMDecoder::ClassifierCallback* ptr = (::cv::text::OCRHMMDecoder::ClassifierCallback*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  3366. if (ptr == NULL) {
  3367. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  3368. return;
  3369. }
  3370. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  3371. ptr += position;
  3372. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  3373. if (ptr0 == NULL) {
  3374. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  3375. return;
  3376. }
  3377. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  3378. ptr0 += position0;
  3379. int* ptr1 = arg1 == NULL ? NULL : (int*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  3380. jlong size1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_limitFID);
  3381. void* owner1 = JavaCPP_getPointerOwner(env, arg1);
  3382. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  3383. ptr1 += position1;
  3384. size1 -= position1;
  3385. VectorAdapter< int > adapter1(ptr1, size1, owner1);
  3386. ::std::vector<double>* ptr2 = arg2 == NULL ? NULL : (::std::vector<double>*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  3387. if (ptr2 == NULL) {
  3388. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 2 is NULL.");
  3389. return;
  3390. }
  3391. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  3392. ptr2 += position2;
  3393. jthrowable exc = NULL;
  3394. try {
  3395. ptr->eval(*ptr0, adapter1, *ptr2);
  3396. } catch (...) {
  3397. exc = JavaCPP_handleException(env, 18);
  3398. }
  3399.  
  3400. int* rptr1 = adapter1;
  3401. jlong rsize1 = (jlong)adapter1.size;
  3402. void* rowner1 = adapter1.owner;
  3403. if (rptr1 != ptr1) {
  3404. JavaCPP_initPointer(env, arg1, rptr1, rsize1, rowner1, &VectorAdapter< int >::deallocate);
  3405. } else {
  3406. env->SetLongField(arg1, JavaCPP_limitFID, rsize1 + position1);
  3407. }
  3408. if (exc != NULL) {
  3409. env->Throw(exc);
  3410. }
  3411. }
  3412. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_00024ClassifierCallback_eval__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2_3ILorg_bytedeco_javacpp_opencv_1text_00024DoubleVector_2(JNIEnv* env, jobject obj, jobject arg0, jintArray arg1, jobject arg2) {
  3413. ::cv::text::OCRHMMDecoder::ClassifierCallback* ptr = (::cv::text::OCRHMMDecoder::ClassifierCallback*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  3414. if (ptr == NULL) {
  3415. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  3416. return;
  3417. }
  3418. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  3419. ptr += position;
  3420. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  3421. if (ptr0 == NULL) {
  3422. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  3423. return;
  3424. }
  3425. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  3426. ptr0 += position0;
  3427. int* ptr1 = arg1 == NULL ? NULL : env->GetIntArrayElements(arg1, NULL);
  3428. jlong size1 = arg1 == NULL ? 0 : env->GetArrayLength(arg1);
  3429. void* owner1 = (void*)ptr1;
  3430. VectorAdapter< int > adapter1(ptr1, size1, owner1);
  3431. ::std::vector<double>* ptr2 = arg2 == NULL ? NULL : (::std::vector<double>*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  3432. if (ptr2 == NULL) {
  3433. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 2 is NULL.");
  3434. return;
  3435. }
  3436. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  3437. ptr2 += position2;
  3438. jthrowable exc = NULL;
  3439. try {
  3440. ptr->eval(*ptr0, adapter1, *ptr2);
  3441. } catch (...) {
  3442. exc = JavaCPP_handleException(env, 18);
  3443. }
  3444.  
  3445. int* rptr1 = adapter1;
  3446. void* rowner1 = adapter1.owner;
  3447. if (rptr1 != ptr1) {
  3448. VectorAdapter< int >::deallocate(rowner1);
  3449. }
  3450. if (arg1 != NULL) env->ReleaseIntArrayElements(arg1, (jint*)ptr1, 0);
  3451. if (exc != NULL) {
  3452. env->Throw(exc);
  3453. }
  3454. }
  3455. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_00024ClassifierCallback_allocateArray(JNIEnv* env, jobject obj, jlong arg0) {
  3456. jthrowable exc = NULL;
  3457. try {
  3458. ::cv::text::OCRHMMDecoder::ClassifierCallback* rptr = new ::cv::text::OCRHMMDecoder::ClassifierCallback[arg0];
  3459. jlong rcapacity = arg0;
  3460. JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_00024ClassifierCallback_deallocateArray);
  3461. } catch (...) {
  3462. exc = JavaCPP_handleException(env, 18);
  3463. }
  3464.  
  3465. if (exc != NULL) {
  3466. env->Throw(exc);
  3467. }
  3468. }
  3469. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_00024ClassifierCallback_allocate(JNIEnv* env, jobject obj) {
  3470. jthrowable exc = NULL;
  3471. try {
  3472. ::cv::text::OCRHMMDecoder::ClassifierCallback* rptr = new ::cv::text::OCRHMMDecoder::ClassifierCallback();
  3473. jlong rcapacity = 1;
  3474. JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_00024ClassifierCallback_deallocate);
  3475. } catch (...) {
  3476. exc = JavaCPP_handleException(env, 18);
  3477. }
  3478.  
  3479. if (exc != NULL) {
  3480. env->Throw(exc);
  3481. }
  3482. }
  3483.  
  3484. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_allocateArray(JNIEnv* env, jobject obj, jlong arg0) {
  3485. jthrowable exc = NULL;
  3486. try {
  3487. ::cv::text::OCRHMMDecoder* rptr = new ::cv::text::OCRHMMDecoder[arg0];
  3488. jlong rcapacity = arg0;
  3489. JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_deallocateArray);
  3490. } catch (...) {
  3491. exc = JavaCPP_handleException(env, 18);
  3492. }
  3493.  
  3494. if (exc != NULL) {
  3495. env->Throw(exc);
  3496. }
  3497. }
  3498. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Lorg_bytedeco_javacpp_BytePointer_2Ljava_nio_FloatBuffer_2I(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jobject arg2, jobject arg3, jobject arg4, jobject arg5, jint arg6) {
  3499. ::cv::text::OCRHMMDecoder* ptr = (::cv::text::OCRHMMDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  3500. if (ptr == NULL) {
  3501. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  3502. return;
  3503. }
  3504. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  3505. ptr += position;
  3506. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  3507. if (ptr0 == NULL) {
  3508. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  3509. return;
  3510. }
  3511. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  3512. ptr0 += position0;
  3513. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  3514. if (ptr1 == NULL) {
  3515. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  3516. return;
  3517. }
  3518. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  3519. ptr1 += position1;
  3520. signed char* ptr2 = arg2 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  3521. jlong size2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_limitFID);
  3522. void* owner2 = JavaCPP_getPointerOwner(env, arg2);
  3523. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  3524. ptr2 += position2;
  3525. size2 -= position2;
  3526. StringAdapter adapter2(ptr2, size2, owner2);
  3527. ::std::vector<cv::Rect>* ptr3 = arg3 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  3528. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  3529. ptr3 += position3;
  3530. signed char* ptr4 = arg4 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg4, JavaCPP_addressFID));
  3531. jlong size4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_limitFID);
  3532. void* owner4 = JavaCPP_getPointerOwner(env, arg4);
  3533. jlong position4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_positionFID);
  3534. ptr4 += position4;
  3535. size4 -= position4;
  3536. VectorAdapter adapter4(ptr4, size4, owner4);
  3537. float* ptr5 = arg5 == NULL ? NULL : (float*)env->GetDirectBufferAddress(arg5);
  3538. jlong size5 = arg5 == NULL ? 0 : env->GetDirectBufferCapacity(arg5);
  3539. void* owner5 = (void*)ptr5;
  3540. jfloatArray arr5 = NULL;
  3541. if (arg5 != NULL && ptr5 == NULL) {
  3542. arr5 = (jfloatArray)env->CallObjectMethod(arg5, JavaCPP_arrayMID);
  3543. if (env->ExceptionOccurred() != NULL) {
  3544. env->ExceptionClear();
  3545. } else {
  3546. ptr5 = arr5 == NULL ? NULL : env->GetFloatArrayElements(arr5, NULL);
  3547. size5 = env->GetArrayLength(arr5);
  3548. }
  3549. }
  3550. VectorAdapter< float > adapter5(ptr5, size5, owner5);
  3551. jthrowable exc = NULL;
  3552. try {
  3553. ptr->run(*ptr0, *ptr1, (std::string&)adapter2, ptr3, (std::string&)adapter4, adapter5, arg6);
  3554. } catch (...) {
  3555. exc = JavaCPP_handleException(env, 18);
  3556. }
  3557.  
  3558. signed char* rptr2 = adapter2;
  3559. jlong rsize2 = (jlong)adapter2.size;
  3560. void* rowner2 = adapter2.owner;
  3561. if (rptr2 != ptr2) {
  3562. JavaCPP_initPointer(env, arg2, rptr2, rsize2, rowner2, &StringAdapter::deallocate);
  3563. } else {
  3564. env->SetLongField(arg2, JavaCPP_limitFID, rsize2 + position2);
  3565. }
  3566. signed char* rptr4 = adapter4;
  3567. jlong rsize4 = (jlong)adapter4.size;
  3568. void* rowner4 = adapter4.owner;
  3569. if (rptr4 != ptr4) {
  3570. JavaCPP_initPointer(env, arg4, rptr4, rsize4, rowner4, &VectorAdapter::deallocate);
  3571. } else {
  3572. env->SetLongField(arg4, JavaCPP_limitFID, rsize4 + position4);
  3573. }
  3574. float* rptr5 = adapter5;
  3575. void* rowner5 = adapter5.owner;
  3576. if (rptr5 != ptr5) {
  3577. VectorAdapter< float >::deallocate(rowner5);
  3578. }
  3579. if (arr5 != NULL) env->ReleaseFloatArrayElements(arr5, (jfloat*)ptr5, 0);
  3580. if (exc != NULL) {
  3581. env->Throw(exc);
  3582. }
  3583. }
  3584. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Ljava_lang_String_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Ljava_lang_String_2Lorg_bytedeco_javacpp_FloatPointer_2I(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jstring arg2, jobject arg3, jstring arg4, jobject arg5, jint arg6) {
  3585. ::cv::text::OCRHMMDecoder* ptr = (::cv::text::OCRHMMDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  3586. if (ptr == NULL) {
  3587. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  3588. return;
  3589. }
  3590. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  3591. ptr += position;
  3592. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  3593. if (ptr0 == NULL) {
  3594. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  3595. return;
  3596. }
  3597. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  3598. ptr0 += position0;
  3599. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  3600. if (ptr1 == NULL) {
  3601. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  3602. return;
  3603. }
  3604. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  3605. ptr1 += position1;
  3606. const char* ptr2 = JavaCPP_getStringBytes(env, arg2);
  3607. jlong size2 = 0;
  3608. void* owner2 = (void*)ptr2;
  3609. StringAdapter adapter2(ptr2, size2, owner2);
  3610. ::std::vector<cv::Rect>* ptr3 = arg3 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  3611. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  3612. ptr3 += position3;
  3613. const char* ptr4 = JavaCPP_getStringBytes(env, arg4);
  3614. jlong size4 = 0;
  3615. void* owner4 = (void*)ptr4;
  3616. VectorAdapter adapter4(ptr4, size4, owner4);
  3617. float* ptr5 = arg5 == NULL ? NULL : (float*)jlong_to_ptr(env->GetLongField(arg5, JavaCPP_addressFID));
  3618. jlong size5 = arg5 == NULL ? 0 : env->GetLongField(arg5, JavaCPP_limitFID);
  3619. void* owner5 = JavaCPP_getPointerOwner(env, arg5);
  3620. jlong position5 = arg5 == NULL ? 0 : env->GetLongField(arg5, JavaCPP_positionFID);
  3621. ptr5 += position5;
  3622. size5 -= position5;
  3623. VectorAdapter< float > adapter5(ptr5, size5, owner5);
  3624. jthrowable exc = NULL;
  3625. try {
  3626. ptr->run(*ptr0, *ptr1, (std::string&)adapter2, ptr3, (std::string&)adapter4, adapter5, arg6);
  3627. } catch (...) {
  3628. exc = JavaCPP_handleException(env, 18);
  3629. }
  3630.  
  3631. JavaCPP_releaseStringBytes(env, arg2, ptr2);
  3632. JavaCPP_releaseStringBytes(env, arg4, ptr4);
  3633. float* rptr5 = adapter5;
  3634. jlong rsize5 = (jlong)adapter5.size;
  3635. void* rowner5 = adapter5.owner;
  3636. if (rptr5 != ptr5) {
  3637. JavaCPP_initPointer(env, arg5, rptr5, rsize5, rowner5, &VectorAdapter< float >::deallocate);
  3638. } else {
  3639. env->SetLongField(arg5, JavaCPP_limitFID, rsize5 + position5);
  3640. }
  3641. if (exc != NULL) {
  3642. env->Throw(exc);
  3643. }
  3644. }
  3645. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Ljava_lang_String_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Ljava_lang_String_2Ljava_nio_FloatBuffer_2I(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jstring arg2, jobject arg3, jstring arg4, jobject arg5, jint arg6) {
  3646. ::cv::text::OCRHMMDecoder* ptr = (::cv::text::OCRHMMDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  3647. if (ptr == NULL) {
  3648. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  3649. return;
  3650. }
  3651. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  3652. ptr += position;
  3653. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  3654. if (ptr0 == NULL) {
  3655. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  3656. return;
  3657. }
  3658. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  3659. ptr0 += position0;
  3660. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  3661. if (ptr1 == NULL) {
  3662. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  3663. return;
  3664. }
  3665. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  3666. ptr1 += position1;
  3667. const char* ptr2 = JavaCPP_getStringBytes(env, arg2);
  3668. jlong size2 = 0;
  3669. void* owner2 = (void*)ptr2;
  3670. StringAdapter adapter2(ptr2, size2, owner2);
  3671. ::std::vector<cv::Rect>* ptr3 = arg3 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  3672. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  3673. ptr3 += position3;
  3674. const char* ptr4 = JavaCPP_getStringBytes(env, arg4);
  3675. jlong size4 = 0;
  3676. void* owner4 = (void*)ptr4;
  3677. VectorAdapter adapter4(ptr4, size4, owner4);
  3678. float* ptr5 = arg5 == NULL ? NULL : (float*)env->GetDirectBufferAddress(arg5);
  3679. jlong size5 = arg5 == NULL ? 0 : env->GetDirectBufferCapacity(arg5);
  3680. void* owner5 = (void*)ptr5;
  3681. jfloatArray arr5 = NULL;
  3682. if (arg5 != NULL && ptr5 == NULL) {
  3683. arr5 = (jfloatArray)env->CallObjectMethod(arg5, JavaCPP_arrayMID);
  3684. if (env->ExceptionOccurred() != NULL) {
  3685. env->ExceptionClear();
  3686. } else {
  3687. ptr5 = arr5 == NULL ? NULL : env->GetFloatArrayElements(arr5, NULL);
  3688. size5 = env->GetArrayLength(arr5);
  3689. }
  3690. }
  3691. VectorAdapter< float > adapter5(ptr5, size5, owner5);
  3692. jthrowable exc = NULL;
  3693. try {
  3694. ptr->run(*ptr0, *ptr1, (std::string&)adapter2, ptr3, (std::string&)adapter4, adapter5, arg6);
  3695. } catch (...) {
  3696. exc = JavaCPP_handleException(env, 18);
  3697. }
  3698.  
  3699. JavaCPP_releaseStringBytes(env, arg2, ptr2);
  3700. JavaCPP_releaseStringBytes(env, arg4, ptr4);
  3701. float* rptr5 = adapter5;
  3702. void* rowner5 = adapter5.owner;
  3703. if (rptr5 != ptr5) {
  3704. VectorAdapter< float >::deallocate(rowner5);
  3705. }
  3706. if (arr5 != NULL) env->ReleaseFloatArrayElements(arr5, (jfloat*)ptr5, 0);
  3707. if (exc != NULL) {
  3708. env->Throw(exc);
  3709. }
  3710. }
  3711. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Ljava_lang_String_2(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jstring arg2) {
  3712. ::cv::text::OCRHMMDecoder* ptr = (::cv::text::OCRHMMDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  3713. if (ptr == NULL) {
  3714. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  3715. return;
  3716. }
  3717. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  3718. ptr += position;
  3719. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  3720. if (ptr0 == NULL) {
  3721. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  3722. return;
  3723. }
  3724. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  3725. ptr0 += position0;
  3726. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  3727. if (ptr1 == NULL) {
  3728. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  3729. return;
  3730. }
  3731. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  3732. ptr1 += position1;
  3733. const char* ptr2 = JavaCPP_getStringBytes(env, arg2);
  3734. jlong size2 = 0;
  3735. void* owner2 = (void*)ptr2;
  3736. StringAdapter adapter2(ptr2, size2, owner2);
  3737. jthrowable exc = NULL;
  3738. try {
  3739. ptr->run(*ptr0, *ptr1, (std::string&)adapter2);
  3740. } catch (...) {
  3741. exc = JavaCPP_handleException(env, 18);
  3742. }
  3743.  
  3744. JavaCPP_releaseStringBytes(env, arg2, ptr2);
  3745. if (exc != NULL) {
  3746. env->Throw(exc);
  3747. }
  3748. }
  3749. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_BytePointer_2(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jobject arg2) {
  3750. ::cv::text::OCRHMMDecoder* ptr = (::cv::text::OCRHMMDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  3751. if (ptr == NULL) {
  3752. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  3753. return;
  3754. }
  3755. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  3756. ptr += position;
  3757. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  3758. if (ptr0 == NULL) {
  3759. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  3760. return;
  3761. }
  3762. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  3763. ptr0 += position0;
  3764. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  3765. if (ptr1 == NULL) {
  3766. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  3767. return;
  3768. }
  3769. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  3770. ptr1 += position1;
  3771. signed char* ptr2 = arg2 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  3772. jlong size2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_limitFID);
  3773. void* owner2 = JavaCPP_getPointerOwner(env, arg2);
  3774. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  3775. ptr2 += position2;
  3776. size2 -= position2;
  3777. StringAdapter adapter2(ptr2, size2, owner2);
  3778. jthrowable exc = NULL;
  3779. try {
  3780. ptr->run(*ptr0, *ptr1, (std::string&)adapter2);
  3781. } catch (...) {
  3782. exc = JavaCPP_handleException(env, 18);
  3783. }
  3784.  
  3785. signed char* rptr2 = adapter2;
  3786. jlong rsize2 = (jlong)adapter2.size;
  3787. void* rowner2 = adapter2.owner;
  3788. if (rptr2 != ptr2) {
  3789. JavaCPP_initPointer(env, arg2, rptr2, rsize2, rowner2, &StringAdapter::deallocate);
  3790. } else {
  3791. env->SetLongField(arg2, JavaCPP_limitFID, rsize2 + position2);
  3792. }
  3793. if (exc != NULL) {
  3794. env->Throw(exc);
  3795. }
  3796. }
  3797. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2I(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jint arg2) {
  3798. ::cv::text::OCRHMMDecoder* ptr = (::cv::text::OCRHMMDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  3799. if (ptr == NULL) {
  3800. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  3801. return 0;
  3802. }
  3803. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  3804. ptr += position;
  3805. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  3806. if (ptr0 == NULL) {
  3807. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  3808. return 0;
  3809. }
  3810. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  3811. ptr0 += position0;
  3812. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  3813. if (ptr1 == NULL) {
  3814. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  3815. return 0;
  3816. }
  3817. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  3818. ptr1 += position1;
  3819. jobject rarg = NULL;
  3820. signed char* rptr;
  3821. jthrowable exc = NULL;
  3822. try {
  3823. StrAdapter radapter(ptr->run(*ptr0, *ptr1, arg2));
  3824. rptr = radapter;
  3825. jlong rcapacity = (jlong)radapter.size;
  3826. void* rowner = radapter.owner;
  3827. void (*deallocator)(void*) = &StrAdapter::deallocate;
  3828. if (rptr != NULL) {
  3829. rarg = JavaCPP_createPointer(env, 1);
  3830. if (rarg != NULL) {
  3831. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  3832. }
  3833. }
  3834. } catch (...) {
  3835. exc = JavaCPP_handleException(env, 18);
  3836. }
  3837.  
  3838. if (exc != NULL) {
  3839. env->Throw(exc);
  3840. }
  3841. return rarg;
  3842. }
  3843. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2II(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jint arg2, jint arg3) {
  3844. ::cv::text::OCRHMMDecoder* ptr = (::cv::text::OCRHMMDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  3845. if (ptr == NULL) {
  3846. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  3847. return 0;
  3848. }
  3849. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  3850. ptr += position;
  3851. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  3852. if (ptr0 == NULL) {
  3853. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  3854. return 0;
  3855. }
  3856. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  3857. ptr0 += position0;
  3858. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  3859. if (ptr1 == NULL) {
  3860. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  3861. return 0;
  3862. }
  3863. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  3864. ptr1 += position1;
  3865. jobject rarg = NULL;
  3866. signed char* rptr;
  3867. jthrowable exc = NULL;
  3868. try {
  3869. StrAdapter radapter(ptr->run(*ptr0, *ptr1, arg2, arg3));
  3870. rptr = radapter;
  3871. jlong rcapacity = (jlong)radapter.size;
  3872. void* rowner = radapter.owner;
  3873. void (*deallocator)(void*) = &StrAdapter::deallocate;
  3874. if (rptr != NULL) {
  3875. rarg = JavaCPP_createPointer(env, 1);
  3876. if (rarg != NULL) {
  3877. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  3878. }
  3879. }
  3880. } catch (...) {
  3881. exc = JavaCPP_handleException(env, 18);
  3882. }
  3883.  
  3884. if (exc != NULL) {
  3885. env->Throw(exc);
  3886. }
  3887. return rarg;
  3888. }
  3889. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2I(JNIEnv* env, jobject obj, jobject arg0, jint arg1) {
  3890. ::cv::text::OCRHMMDecoder* ptr = (::cv::text::OCRHMMDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  3891. if (ptr == NULL) {
  3892. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  3893. return 0;
  3894. }
  3895. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  3896. ptr += position;
  3897. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  3898. if (ptr0 == NULL) {
  3899. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  3900. return 0;
  3901. }
  3902. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  3903. ptr0 += position0;
  3904. jobject rarg = NULL;
  3905. signed char* rptr;
  3906. jthrowable exc = NULL;
  3907. try {
  3908. StrAdapter radapter(ptr->run(*ptr0, arg1));
  3909. rptr = radapter;
  3910. jlong rcapacity = (jlong)radapter.size;
  3911. void* rowner = radapter.owner;
  3912. void (*deallocator)(void*) = &StrAdapter::deallocate;
  3913. if (rptr != NULL) {
  3914. rarg = JavaCPP_createPointer(env, 1);
  3915. if (rarg != NULL) {
  3916. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  3917. }
  3918. }
  3919. } catch (...) {
  3920. exc = JavaCPP_handleException(env, 18);
  3921. }
  3922.  
  3923. if (exc != NULL) {
  3924. env->Throw(exc);
  3925. }
  3926. return rarg;
  3927. }
  3928. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2II(JNIEnv* env, jobject obj, jobject arg0, jint arg1, jint arg2) {
  3929. ::cv::text::OCRHMMDecoder* ptr = (::cv::text::OCRHMMDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  3930. if (ptr == NULL) {
  3931. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  3932. return 0;
  3933. }
  3934. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  3935. ptr += position;
  3936. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  3937. if (ptr0 == NULL) {
  3938. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  3939. return 0;
  3940. }
  3941. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  3942. ptr0 += position0;
  3943. jobject rarg = NULL;
  3944. signed char* rptr;
  3945. jthrowable exc = NULL;
  3946. try {
  3947. StrAdapter radapter(ptr->run(*ptr0, arg1, arg2));
  3948. rptr = radapter;
  3949. jlong rcapacity = (jlong)radapter.size;
  3950. void* rowner = radapter.owner;
  3951. void (*deallocator)(void*) = &StrAdapter::deallocate;
  3952. if (rptr != NULL) {
  3953. rarg = JavaCPP_createPointer(env, 1);
  3954. if (rarg != NULL) {
  3955. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  3956. }
  3957. }
  3958. } catch (...) {
  3959. exc = JavaCPP_handleException(env, 18);
  3960. }
  3961.  
  3962. if (exc != NULL) {
  3963. env->Throw(exc);
  3964. }
  3965. return rarg;
  3966. }
  3967. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Ljava_lang_String_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Ljava_lang_String_2_3FI(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jstring arg2, jobject arg3, jstring arg4, jfloatArray arg5, jint arg6) {
  3968. ::cv::text::OCRHMMDecoder* ptr = (::cv::text::OCRHMMDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  3969. if (ptr == NULL) {
  3970. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  3971. return;
  3972. }
  3973. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  3974. ptr += position;
  3975. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  3976. if (ptr0 == NULL) {
  3977. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  3978. return;
  3979. }
  3980. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  3981. ptr0 += position0;
  3982. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  3983. if (ptr1 == NULL) {
  3984. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  3985. return;
  3986. }
  3987. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  3988. ptr1 += position1;
  3989. const char* ptr2 = JavaCPP_getStringBytes(env, arg2);
  3990. jlong size2 = 0;
  3991. void* owner2 = (void*)ptr2;
  3992. StringAdapter adapter2(ptr2, size2, owner2);
  3993. ::std::vector<cv::Rect>* ptr3 = arg3 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  3994. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  3995. ptr3 += position3;
  3996. const char* ptr4 = JavaCPP_getStringBytes(env, arg4);
  3997. jlong size4 = 0;
  3998. void* owner4 = (void*)ptr4;
  3999. VectorAdapter adapter4(ptr4, size4, owner4);
  4000. float* ptr5 = arg5 == NULL ? NULL : env->GetFloatArrayElements(arg5, NULL);
  4001. jlong size5 = arg5 == NULL ? 0 : env->GetArrayLength(arg5);
  4002. void* owner5 = (void*)ptr5;
  4003. VectorAdapter< float > adapter5(ptr5, size5, owner5);
  4004. jthrowable exc = NULL;
  4005. try {
  4006. ptr->run(*ptr0, *ptr1, (std::string&)adapter2, ptr3, (std::string&)adapter4, adapter5, arg6);
  4007. } catch (...) {
  4008. exc = JavaCPP_handleException(env, 18);
  4009. }
  4010.  
  4011. JavaCPP_releaseStringBytes(env, arg2, ptr2);
  4012. JavaCPP_releaseStringBytes(env, arg4, ptr4);
  4013. float* rptr5 = adapter5;
  4014. void* rowner5 = adapter5.owner;
  4015. if (rptr5 != ptr5) {
  4016. VectorAdapter< float >::deallocate(rowner5);
  4017. }
  4018. if (arg5 != NULL) env->ReleaseFloatArrayElements(arg5, (jfloat*)ptr5, 0);
  4019. if (exc != NULL) {
  4020. env->Throw(exc);
  4021. }
  4022. }
  4023. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Lorg_bytedeco_javacpp_BytePointer_2_3FI(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jobject arg2, jobject arg3, jfloatArray arg4, jint arg5) {
  4024. ::cv::text::OCRHMMDecoder* ptr = (::cv::text::OCRHMMDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  4025. if (ptr == NULL) {
  4026. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  4027. return;
  4028. }
  4029. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  4030. ptr += position;
  4031. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  4032. if (ptr0 == NULL) {
  4033. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  4034. return;
  4035. }
  4036. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  4037. ptr0 += position0;
  4038. signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  4039. jlong size1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_limitFID);
  4040. void* owner1 = JavaCPP_getPointerOwner(env, arg1);
  4041. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  4042. ptr1 += position1;
  4043. size1 -= position1;
  4044. StringAdapter adapter1(ptr1, size1, owner1);
  4045. ::std::vector<cv::Rect>* ptr2 = arg2 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  4046. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  4047. ptr2 += position2;
  4048. signed char* ptr3 = arg3 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  4049. jlong size3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_limitFID);
  4050. void* owner3 = JavaCPP_getPointerOwner(env, arg3);
  4051. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  4052. ptr3 += position3;
  4053. size3 -= position3;
  4054. VectorAdapter adapter3(ptr3, size3, owner3);
  4055. float* ptr4 = arg4 == NULL ? NULL : env->GetFloatArrayElements(arg4, NULL);
  4056. jlong size4 = arg4 == NULL ? 0 : env->GetArrayLength(arg4);
  4057. void* owner4 = (void*)ptr4;
  4058. VectorAdapter< float > adapter4(ptr4, size4, owner4);
  4059. jthrowable exc = NULL;
  4060. try {
  4061. ptr->run(*ptr0, (std::string&)adapter1, ptr2, (std::string&)adapter3, adapter4, arg5);
  4062. } catch (...) {
  4063. exc = JavaCPP_handleException(env, 18);
  4064. }
  4065.  
  4066. signed char* rptr1 = adapter1;
  4067. jlong rsize1 = (jlong)adapter1.size;
  4068. void* rowner1 = adapter1.owner;
  4069. if (rptr1 != ptr1) {
  4070. JavaCPP_initPointer(env, arg1, rptr1, rsize1, rowner1, &StringAdapter::deallocate);
  4071. } else {
  4072. env->SetLongField(arg1, JavaCPP_limitFID, rsize1 + position1);
  4073. }
  4074. signed char* rptr3 = adapter3;
  4075. jlong rsize3 = (jlong)adapter3.size;
  4076. void* rowner3 = adapter3.owner;
  4077. if (rptr3 != ptr3) {
  4078. JavaCPP_initPointer(env, arg3, rptr3, rsize3, rowner3, &VectorAdapter::deallocate);
  4079. } else {
  4080. env->SetLongField(arg3, JavaCPP_limitFID, rsize3 + position3);
  4081. }
  4082. float* rptr4 = adapter4;
  4083. void* rowner4 = adapter4.owner;
  4084. if (rptr4 != ptr4) {
  4085. VectorAdapter< float >::deallocate(rowner4);
  4086. }
  4087. if (arg4 != NULL) env->ReleaseFloatArrayElements(arg4, (jfloat*)ptr4, 0);
  4088. if (exc != NULL) {
  4089. env->Throw(exc);
  4090. }
  4091. }
  4092. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Ljava_lang_String_2(JNIEnv* env, jobject obj, jobject arg0, jstring arg1) {
  4093. ::cv::text::OCRHMMDecoder* ptr = (::cv::text::OCRHMMDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  4094. if (ptr == NULL) {
  4095. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  4096. return;
  4097. }
  4098. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  4099. ptr += position;
  4100. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  4101. if (ptr0 == NULL) {
  4102. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  4103. return;
  4104. }
  4105. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  4106. ptr0 += position0;
  4107. const char* ptr1 = JavaCPP_getStringBytes(env, arg1);
  4108. jlong size1 = 0;
  4109. void* owner1 = (void*)ptr1;
  4110. StringAdapter adapter1(ptr1, size1, owner1);
  4111. jthrowable exc = NULL;
  4112. try {
  4113. ptr->run(*ptr0, (std::string&)adapter1);
  4114. } catch (...) {
  4115. exc = JavaCPP_handleException(env, 18);
  4116. }
  4117.  
  4118. JavaCPP_releaseStringBytes(env, arg1, ptr1);
  4119. if (exc != NULL) {
  4120. env->Throw(exc);
  4121. }
  4122. }
  4123. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Ljava_lang_String_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Ljava_lang_String_2Ljava_nio_FloatBuffer_2I(JNIEnv* env, jobject obj, jobject arg0, jstring arg1, jobject arg2, jstring arg3, jobject arg4, jint arg5) {
  4124. ::cv::text::OCRHMMDecoder* ptr = (::cv::text::OCRHMMDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  4125. if (ptr == NULL) {
  4126. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  4127. return;
  4128. }
  4129. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  4130. ptr += position;
  4131. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  4132. if (ptr0 == NULL) {
  4133. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  4134. return;
  4135. }
  4136. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  4137. ptr0 += position0;
  4138. const char* ptr1 = JavaCPP_getStringBytes(env, arg1);
  4139. jlong size1 = 0;
  4140. void* owner1 = (void*)ptr1;
  4141. StringAdapter adapter1(ptr1, size1, owner1);
  4142. ::std::vector<cv::Rect>* ptr2 = arg2 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  4143. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  4144. ptr2 += position2;
  4145. const char* ptr3 = JavaCPP_getStringBytes(env, arg3);
  4146. jlong size3 = 0;
  4147. void* owner3 = (void*)ptr3;
  4148. VectorAdapter adapter3(ptr3, size3, owner3);
  4149. float* ptr4 = arg4 == NULL ? NULL : (float*)env->GetDirectBufferAddress(arg4);
  4150. jlong size4 = arg4 == NULL ? 0 : env->GetDirectBufferCapacity(arg4);
  4151. void* owner4 = (void*)ptr4;
  4152. jfloatArray arr4 = NULL;
  4153. if (arg4 != NULL && ptr4 == NULL) {
  4154. arr4 = (jfloatArray)env->CallObjectMethod(arg4, JavaCPP_arrayMID);
  4155. if (env->ExceptionOccurred() != NULL) {
  4156. env->ExceptionClear();
  4157. } else {
  4158. ptr4 = arr4 == NULL ? NULL : env->GetFloatArrayElements(arr4, NULL);
  4159. size4 = env->GetArrayLength(arr4);
  4160. }
  4161. }
  4162. VectorAdapter< float > adapter4(ptr4, size4, owner4);
  4163. jthrowable exc = NULL;
  4164. try {
  4165. ptr->run(*ptr0, (std::string&)adapter1, ptr2, (std::string&)adapter3, adapter4, arg5);
  4166. } catch (...) {
  4167. exc = JavaCPP_handleException(env, 18);
  4168. }
  4169.  
  4170. JavaCPP_releaseStringBytes(env, arg1, ptr1);
  4171. JavaCPP_releaseStringBytes(env, arg3, ptr3);
  4172. float* rptr4 = adapter4;
  4173. void* rowner4 = adapter4.owner;
  4174. if (rptr4 != ptr4) {
  4175. VectorAdapter< float >::deallocate(rowner4);
  4176. }
  4177. if (arr4 != NULL) env->ReleaseFloatArrayElements(arr4, (jfloat*)ptr4, 0);
  4178. if (exc != NULL) {
  4179. env->Throw(exc);
  4180. }
  4181. }
  4182. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_BytePointer_2(JNIEnv* env, jobject obj, jobject arg0, jobject arg1) {
  4183. ::cv::text::OCRHMMDecoder* ptr = (::cv::text::OCRHMMDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  4184. if (ptr == NULL) {
  4185. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  4186. return;
  4187. }
  4188. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  4189. ptr += position;
  4190. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  4191. if (ptr0 == NULL) {
  4192. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  4193. return;
  4194. }
  4195. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  4196. ptr0 += position0;
  4197. signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  4198. jlong size1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_limitFID);
  4199. void* owner1 = JavaCPP_getPointerOwner(env, arg1);
  4200. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  4201. ptr1 += position1;
  4202. size1 -= position1;
  4203. StringAdapter adapter1(ptr1, size1, owner1);
  4204. jthrowable exc = NULL;
  4205. try {
  4206. ptr->run(*ptr0, (std::string&)adapter1);
  4207. } catch (...) {
  4208. exc = JavaCPP_handleException(env, 18);
  4209. }
  4210.  
  4211. signed char* rptr1 = adapter1;
  4212. jlong rsize1 = (jlong)adapter1.size;
  4213. void* rowner1 = adapter1.owner;
  4214. if (rptr1 != ptr1) {
  4215. JavaCPP_initPointer(env, arg1, rptr1, rsize1, rowner1, &StringAdapter::deallocate);
  4216. } else {
  4217. env->SetLongField(arg1, JavaCPP_limitFID, rsize1 + position1);
  4218. }
  4219. if (exc != NULL) {
  4220. env->Throw(exc);
  4221. }
  4222. }
  4223. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_FloatPointer_2I(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jobject arg2, jobject arg3, jobject arg4, jint arg5) {
  4224. ::cv::text::OCRHMMDecoder* ptr = (::cv::text::OCRHMMDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  4225. if (ptr == NULL) {
  4226. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  4227. return;
  4228. }
  4229. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  4230. ptr += position;
  4231. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  4232. if (ptr0 == NULL) {
  4233. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  4234. return;
  4235. }
  4236. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  4237. ptr0 += position0;
  4238. signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  4239. jlong size1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_limitFID);
  4240. void* owner1 = JavaCPP_getPointerOwner(env, arg1);
  4241. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  4242. ptr1 += position1;
  4243. size1 -= position1;
  4244. StringAdapter adapter1(ptr1, size1, owner1);
  4245. ::std::vector<cv::Rect>* ptr2 = arg2 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  4246. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  4247. ptr2 += position2;
  4248. signed char* ptr3 = arg3 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  4249. jlong size3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_limitFID);
  4250. void* owner3 = JavaCPP_getPointerOwner(env, arg3);
  4251. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  4252. ptr3 += position3;
  4253. size3 -= position3;
  4254. VectorAdapter adapter3(ptr3, size3, owner3);
  4255. float* ptr4 = arg4 == NULL ? NULL : (float*)jlong_to_ptr(env->GetLongField(arg4, JavaCPP_addressFID));
  4256. jlong size4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_limitFID);
  4257. void* owner4 = JavaCPP_getPointerOwner(env, arg4);
  4258. jlong position4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_positionFID);
  4259. ptr4 += position4;
  4260. size4 -= position4;
  4261. VectorAdapter< float > adapter4(ptr4, size4, owner4);
  4262. jthrowable exc = NULL;
  4263. try {
  4264. ptr->run(*ptr0, (std::string&)adapter1, ptr2, (std::string&)adapter3, adapter4, arg5);
  4265. } catch (...) {
  4266. exc = JavaCPP_handleException(env, 18);
  4267. }
  4268.  
  4269. signed char* rptr1 = adapter1;
  4270. jlong rsize1 = (jlong)adapter1.size;
  4271. void* rowner1 = adapter1.owner;
  4272. if (rptr1 != ptr1) {
  4273. JavaCPP_initPointer(env, arg1, rptr1, rsize1, rowner1, &StringAdapter::deallocate);
  4274. } else {
  4275. env->SetLongField(arg1, JavaCPP_limitFID, rsize1 + position1);
  4276. }
  4277. signed char* rptr3 = adapter3;
  4278. jlong rsize3 = (jlong)adapter3.size;
  4279. void* rowner3 = adapter3.owner;
  4280. if (rptr3 != ptr3) {
  4281. JavaCPP_initPointer(env, arg3, rptr3, rsize3, rowner3, &VectorAdapter::deallocate);
  4282. } else {
  4283. env->SetLongField(arg3, JavaCPP_limitFID, rsize3 + position3);
  4284. }
  4285. float* rptr4 = adapter4;
  4286. jlong rsize4 = (jlong)adapter4.size;
  4287. void* rowner4 = adapter4.owner;
  4288. if (rptr4 != ptr4) {
  4289. JavaCPP_initPointer(env, arg4, rptr4, rsize4, rowner4, &VectorAdapter< float >::deallocate);
  4290. } else {
  4291. env->SetLongField(arg4, JavaCPP_limitFID, rsize4 + position4);
  4292. }
  4293. if (exc != NULL) {
  4294. env->Throw(exc);
  4295. }
  4296. }
  4297. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Lorg_bytedeco_javacpp_BytePointer_2_3FI(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jobject arg2, jobject arg3, jobject arg4, jfloatArray arg5, jint arg6) {
  4298. ::cv::text::OCRHMMDecoder* ptr = (::cv::text::OCRHMMDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  4299. if (ptr == NULL) {
  4300. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  4301. return;
  4302. }
  4303. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  4304. ptr += position;
  4305. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  4306. if (ptr0 == NULL) {
  4307. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  4308. return;
  4309. }
  4310. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  4311. ptr0 += position0;
  4312. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  4313. if (ptr1 == NULL) {
  4314. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  4315. return;
  4316. }
  4317. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  4318. ptr1 += position1;
  4319. signed char* ptr2 = arg2 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  4320. jlong size2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_limitFID);
  4321. void* owner2 = JavaCPP_getPointerOwner(env, arg2);
  4322. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  4323. ptr2 += position2;
  4324. size2 -= position2;
  4325. StringAdapter adapter2(ptr2, size2, owner2);
  4326. ::std::vector<cv::Rect>* ptr3 = arg3 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  4327. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  4328. ptr3 += position3;
  4329. signed char* ptr4 = arg4 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg4, JavaCPP_addressFID));
  4330. jlong size4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_limitFID);
  4331. void* owner4 = JavaCPP_getPointerOwner(env, arg4);
  4332. jlong position4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_positionFID);
  4333. ptr4 += position4;
  4334. size4 -= position4;
  4335. VectorAdapter adapter4(ptr4, size4, owner4);
  4336. float* ptr5 = arg5 == NULL ? NULL : env->GetFloatArrayElements(arg5, NULL);
  4337. jlong size5 = arg5 == NULL ? 0 : env->GetArrayLength(arg5);
  4338. void* owner5 = (void*)ptr5;
  4339. VectorAdapter< float > adapter5(ptr5, size5, owner5);
  4340. jthrowable exc = NULL;
  4341. try {
  4342. ptr->run(*ptr0, *ptr1, (std::string&)adapter2, ptr3, (std::string&)adapter4, adapter5, arg6);
  4343. } catch (...) {
  4344. exc = JavaCPP_handleException(env, 18);
  4345. }
  4346.  
  4347. signed char* rptr2 = adapter2;
  4348. jlong rsize2 = (jlong)adapter2.size;
  4349. void* rowner2 = adapter2.owner;
  4350. if (rptr2 != ptr2) {
  4351. JavaCPP_initPointer(env, arg2, rptr2, rsize2, rowner2, &StringAdapter::deallocate);
  4352. } else {
  4353. env->SetLongField(arg2, JavaCPP_limitFID, rsize2 + position2);
  4354. }
  4355. signed char* rptr4 = adapter4;
  4356. jlong rsize4 = (jlong)adapter4.size;
  4357. void* rowner4 = adapter4.owner;
  4358. if (rptr4 != ptr4) {
  4359. JavaCPP_initPointer(env, arg4, rptr4, rsize4, rowner4, &VectorAdapter::deallocate);
  4360. } else {
  4361. env->SetLongField(arg4, JavaCPP_limitFID, rsize4 + position4);
  4362. }
  4363. float* rptr5 = adapter5;
  4364. void* rowner5 = adapter5.owner;
  4365. if (rptr5 != ptr5) {
  4366. VectorAdapter< float >::deallocate(rowner5);
  4367. }
  4368. if (arg5 != NULL) env->ReleaseFloatArrayElements(arg5, (jfloat*)ptr5, 0);
  4369. if (exc != NULL) {
  4370. env->Throw(exc);
  4371. }
  4372. }
  4373. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_FloatPointer_2I(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jobject arg2, jobject arg3, jobject arg4, jobject arg5, jint arg6) {
  4374. ::cv::text::OCRHMMDecoder* ptr = (::cv::text::OCRHMMDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  4375. if (ptr == NULL) {
  4376. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  4377. return;
  4378. }
  4379. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  4380. ptr += position;
  4381. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  4382. if (ptr0 == NULL) {
  4383. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  4384. return;
  4385. }
  4386. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  4387. ptr0 += position0;
  4388. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  4389. if (ptr1 == NULL) {
  4390. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  4391. return;
  4392. }
  4393. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  4394. ptr1 += position1;
  4395. signed char* ptr2 = arg2 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  4396. jlong size2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_limitFID);
  4397. void* owner2 = JavaCPP_getPointerOwner(env, arg2);
  4398. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  4399. ptr2 += position2;
  4400. size2 -= position2;
  4401. StringAdapter adapter2(ptr2, size2, owner2);
  4402. ::std::vector<cv::Rect>* ptr3 = arg3 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  4403. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  4404. ptr3 += position3;
  4405. signed char* ptr4 = arg4 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg4, JavaCPP_addressFID));
  4406. jlong size4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_limitFID);
  4407. void* owner4 = JavaCPP_getPointerOwner(env, arg4);
  4408. jlong position4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_positionFID);
  4409. ptr4 += position4;
  4410. size4 -= position4;
  4411. VectorAdapter adapter4(ptr4, size4, owner4);
  4412. float* ptr5 = arg5 == NULL ? NULL : (float*)jlong_to_ptr(env->GetLongField(arg5, JavaCPP_addressFID));
  4413. jlong size5 = arg5 == NULL ? 0 : env->GetLongField(arg5, JavaCPP_limitFID);
  4414. void* owner5 = JavaCPP_getPointerOwner(env, arg5);
  4415. jlong position5 = arg5 == NULL ? 0 : env->GetLongField(arg5, JavaCPP_positionFID);
  4416. ptr5 += position5;
  4417. size5 -= position5;
  4418. VectorAdapter< float > adapter5(ptr5, size5, owner5);
  4419. jthrowable exc = NULL;
  4420. try {
  4421. ptr->run(*ptr0, *ptr1, (std::string&)adapter2, ptr3, (std::string&)adapter4, adapter5, arg6);
  4422. } catch (...) {
  4423. exc = JavaCPP_handleException(env, 18);
  4424. }
  4425.  
  4426. signed char* rptr2 = adapter2;
  4427. jlong rsize2 = (jlong)adapter2.size;
  4428. void* rowner2 = adapter2.owner;
  4429. if (rptr2 != ptr2) {
  4430. JavaCPP_initPointer(env, arg2, rptr2, rsize2, rowner2, &StringAdapter::deallocate);
  4431. } else {
  4432. env->SetLongField(arg2, JavaCPP_limitFID, rsize2 + position2);
  4433. }
  4434. signed char* rptr4 = adapter4;
  4435. jlong rsize4 = (jlong)adapter4.size;
  4436. void* rowner4 = adapter4.owner;
  4437. if (rptr4 != ptr4) {
  4438. JavaCPP_initPointer(env, arg4, rptr4, rsize4, rowner4, &VectorAdapter::deallocate);
  4439. } else {
  4440. env->SetLongField(arg4, JavaCPP_limitFID, rsize4 + position4);
  4441. }
  4442. float* rptr5 = adapter5;
  4443. jlong rsize5 = (jlong)adapter5.size;
  4444. void* rowner5 = adapter5.owner;
  4445. if (rptr5 != ptr5) {
  4446. JavaCPP_initPointer(env, arg5, rptr5, rsize5, rowner5, &VectorAdapter< float >::deallocate);
  4447. } else {
  4448. env->SetLongField(arg5, JavaCPP_limitFID, rsize5 + position5);
  4449. }
  4450. if (exc != NULL) {
  4451. env->Throw(exc);
  4452. }
  4453. }
  4454. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Ljava_lang_String_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Ljava_lang_String_2_3FI(JNIEnv* env, jobject obj, jobject arg0, jstring arg1, jobject arg2, jstring arg3, jfloatArray arg4, jint arg5) {
  4455. ::cv::text::OCRHMMDecoder* ptr = (::cv::text::OCRHMMDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  4456. if (ptr == NULL) {
  4457. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  4458. return;
  4459. }
  4460. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  4461. ptr += position;
  4462. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  4463. if (ptr0 == NULL) {
  4464. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  4465. return;
  4466. }
  4467. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  4468. ptr0 += position0;
  4469. const char* ptr1 = JavaCPP_getStringBytes(env, arg1);
  4470. jlong size1 = 0;
  4471. void* owner1 = (void*)ptr1;
  4472. StringAdapter adapter1(ptr1, size1, owner1);
  4473. ::std::vector<cv::Rect>* ptr2 = arg2 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  4474. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  4475. ptr2 += position2;
  4476. const char* ptr3 = JavaCPP_getStringBytes(env, arg3);
  4477. jlong size3 = 0;
  4478. void* owner3 = (void*)ptr3;
  4479. VectorAdapter adapter3(ptr3, size3, owner3);
  4480. float* ptr4 = arg4 == NULL ? NULL : env->GetFloatArrayElements(arg4, NULL);
  4481. jlong size4 = arg4 == NULL ? 0 : env->GetArrayLength(arg4);
  4482. void* owner4 = (void*)ptr4;
  4483. VectorAdapter< float > adapter4(ptr4, size4, owner4);
  4484. jthrowable exc = NULL;
  4485. try {
  4486. ptr->run(*ptr0, (std::string&)adapter1, ptr2, (std::string&)adapter3, adapter4, arg5);
  4487. } catch (...) {
  4488. exc = JavaCPP_handleException(env, 18);
  4489. }
  4490.  
  4491. JavaCPP_releaseStringBytes(env, arg1, ptr1);
  4492. JavaCPP_releaseStringBytes(env, arg3, ptr3);
  4493. float* rptr4 = adapter4;
  4494. void* rowner4 = adapter4.owner;
  4495. if (rptr4 != ptr4) {
  4496. VectorAdapter< float >::deallocate(rowner4);
  4497. }
  4498. if (arg4 != NULL) env->ReleaseFloatArrayElements(arg4, (jfloat*)ptr4, 0);
  4499. if (exc != NULL) {
  4500. env->Throw(exc);
  4501. }
  4502. }
  4503. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Lorg_bytedeco_javacpp_BytePointer_2Ljava_nio_FloatBuffer_2I(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jobject arg2, jobject arg3, jobject arg4, jint arg5) {
  4504. ::cv::text::OCRHMMDecoder* ptr = (::cv::text::OCRHMMDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  4505. if (ptr == NULL) {
  4506. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  4507. return;
  4508. }
  4509. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  4510. ptr += position;
  4511. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  4512. if (ptr0 == NULL) {
  4513. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  4514. return;
  4515. }
  4516. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  4517. ptr0 += position0;
  4518. signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  4519. jlong size1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_limitFID);
  4520. void* owner1 = JavaCPP_getPointerOwner(env, arg1);
  4521. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  4522. ptr1 += position1;
  4523. size1 -= position1;
  4524. StringAdapter adapter1(ptr1, size1, owner1);
  4525. ::std::vector<cv::Rect>* ptr2 = arg2 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  4526. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  4527. ptr2 += position2;
  4528. signed char* ptr3 = arg3 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  4529. jlong size3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_limitFID);
  4530. void* owner3 = JavaCPP_getPointerOwner(env, arg3);
  4531. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  4532. ptr3 += position3;
  4533. size3 -= position3;
  4534. VectorAdapter adapter3(ptr3, size3, owner3);
  4535. float* ptr4 = arg4 == NULL ? NULL : (float*)env->GetDirectBufferAddress(arg4);
  4536. jlong size4 = arg4 == NULL ? 0 : env->GetDirectBufferCapacity(arg4);
  4537. void* owner4 = (void*)ptr4;
  4538. jfloatArray arr4 = NULL;
  4539. if (arg4 != NULL && ptr4 == NULL) {
  4540. arr4 = (jfloatArray)env->CallObjectMethod(arg4, JavaCPP_arrayMID);
  4541. if (env->ExceptionOccurred() != NULL) {
  4542. env->ExceptionClear();
  4543. } else {
  4544. ptr4 = arr4 == NULL ? NULL : env->GetFloatArrayElements(arr4, NULL);
  4545. size4 = env->GetArrayLength(arr4);
  4546. }
  4547. }
  4548. VectorAdapter< float > adapter4(ptr4, size4, owner4);
  4549. jthrowable exc = NULL;
  4550. try {
  4551. ptr->run(*ptr0, (std::string&)adapter1, ptr2, (std::string&)adapter3, adapter4, arg5);
  4552. } catch (...) {
  4553. exc = JavaCPP_handleException(env, 18);
  4554. }
  4555.  
  4556. signed char* rptr1 = adapter1;
  4557. jlong rsize1 = (jlong)adapter1.size;
  4558. void* rowner1 = adapter1.owner;
  4559. if (rptr1 != ptr1) {
  4560. JavaCPP_initPointer(env, arg1, rptr1, rsize1, rowner1, &StringAdapter::deallocate);
  4561. } else {
  4562. env->SetLongField(arg1, JavaCPP_limitFID, rsize1 + position1);
  4563. }
  4564. signed char* rptr3 = adapter3;
  4565. jlong rsize3 = (jlong)adapter3.size;
  4566. void* rowner3 = adapter3.owner;
  4567. if (rptr3 != ptr3) {
  4568. JavaCPP_initPointer(env, arg3, rptr3, rsize3, rowner3, &VectorAdapter::deallocate);
  4569. } else {
  4570. env->SetLongField(arg3, JavaCPP_limitFID, rsize3 + position3);
  4571. }
  4572. float* rptr4 = adapter4;
  4573. void* rowner4 = adapter4.owner;
  4574. if (rptr4 != ptr4) {
  4575. VectorAdapter< float >::deallocate(rowner4);
  4576. }
  4577. if (arr4 != NULL) env->ReleaseFloatArrayElements(arr4, (jfloat*)ptr4, 0);
  4578. if (exc != NULL) {
  4579. env->Throw(exc);
  4580. }
  4581. }
  4582. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Ljava_lang_String_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Ljava_lang_String_2Lorg_bytedeco_javacpp_FloatPointer_2I(JNIEnv* env, jobject obj, jobject arg0, jstring arg1, jobject arg2, jstring arg3, jobject arg4, jint arg5) {
  4583. ::cv::text::OCRHMMDecoder* ptr = (::cv::text::OCRHMMDecoder*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  4584. if (ptr == NULL) {
  4585. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  4586. return;
  4587. }
  4588. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  4589. ptr += position;
  4590. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  4591. if (ptr0 == NULL) {
  4592. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  4593. return;
  4594. }
  4595. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  4596. ptr0 += position0;
  4597. const char* ptr1 = JavaCPP_getStringBytes(env, arg1);
  4598. jlong size1 = 0;
  4599. void* owner1 = (void*)ptr1;
  4600. StringAdapter adapter1(ptr1, size1, owner1);
  4601. ::std::vector<cv::Rect>* ptr2 = arg2 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  4602. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  4603. ptr2 += position2;
  4604. const char* ptr3 = JavaCPP_getStringBytes(env, arg3);
  4605. jlong size3 = 0;
  4606. void* owner3 = (void*)ptr3;
  4607. VectorAdapter adapter3(ptr3, size3, owner3);
  4608. float* ptr4 = arg4 == NULL ? NULL : (float*)jlong_to_ptr(env->GetLongField(arg4, JavaCPP_addressFID));
  4609. jlong size4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_limitFID);
  4610. void* owner4 = JavaCPP_getPointerOwner(env, arg4);
  4611. jlong position4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_positionFID);
  4612. ptr4 += position4;
  4613. size4 -= position4;
  4614. VectorAdapter< float > adapter4(ptr4, size4, owner4);
  4615. jthrowable exc = NULL;
  4616. try {
  4617. ptr->run(*ptr0, (std::string&)adapter1, ptr2, (std::string&)adapter3, adapter4, arg5);
  4618. } catch (...) {
  4619. exc = JavaCPP_handleException(env, 18);
  4620. }
  4621.  
  4622. JavaCPP_releaseStringBytes(env, arg1, ptr1);
  4623. JavaCPP_releaseStringBytes(env, arg3, ptr3);
  4624. float* rptr4 = adapter4;
  4625. jlong rsize4 = (jlong)adapter4.size;
  4626. void* rowner4 = adapter4.owner;
  4627. if (rptr4 != ptr4) {
  4628. JavaCPP_initPointer(env, arg4, rptr4, rsize4, rowner4, &VectorAdapter< float >::deallocate);
  4629. } else {
  4630. env->SetLongField(arg4, JavaCPP_limitFID, rsize4 + position4);
  4631. }
  4632. if (exc != NULL) {
  4633. env->Throw(exc);
  4634. }
  4635. }
  4636. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_create__Lorg_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_00024ClassifierCallback_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2I(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jobject arg2, jobject arg3, jint arg4) {
  4637. ::cv::text::OCRHMMDecoder::ClassifierCallback* ptr0 = arg0 == NULL ? NULL : (::cv::text::OCRHMMDecoder::ClassifierCallback*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  4638. jlong size0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_limitFID);
  4639. void* owner0 = JavaCPP_getPointerOwner(env, arg0);
  4640. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  4641. ptr0 += position0;
  4642. size0 -= position0;
  4643. PtrAdapter< ::cv::text::OCRHMMDecoder::ClassifierCallback > adapter0(ptr0, size0, owner0);
  4644. signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  4645. jlong size1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_limitFID);
  4646. void* owner1 = JavaCPP_getPointerOwner(env, arg1);
  4647. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  4648. ptr1 += position1;
  4649. size1 -= position1;
  4650. StringAdapter adapter1(ptr1, size1, owner1);
  4651. ::cv::Mat* ptr2 = arg2 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  4652. if (ptr2 == NULL) {
  4653. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 2 is NULL.");
  4654. return 0;
  4655. }
  4656. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  4657. ptr2 += position2;
  4658. ::cv::Mat* ptr3 = arg3 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  4659. if (ptr3 == NULL) {
  4660. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 3 is NULL.");
  4661. return 0;
  4662. }
  4663. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  4664. ptr3 += position3;
  4665. jobject rarg = NULL;
  4666. ::cv::text::OCRHMMDecoder* rptr;
  4667. jthrowable exc = NULL;
  4668. try {
  4669. PtrAdapter< ::cv::text::OCRHMMDecoder > radapter(::cv::text::OCRHMMDecoder::create((cv::Ptr< ::cv::text::OCRHMMDecoder::ClassifierCallback >)adapter0, (std::string&)adapter1, *ptr2, *ptr3, (cv::text::decoder_mode)arg4));
  4670. rptr = radapter;
  4671. jlong rcapacity = (jlong)radapter.size;
  4672. void* rowner = radapter.owner;
  4673. void (*deallocator)(void*) = &PtrAdapter< ::cv::text::OCRHMMDecoder >::deallocate;
  4674. if (rptr != NULL) {
  4675. rarg = JavaCPP_createPointer(env, 22);
  4676. if (rarg != NULL) {
  4677. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  4678. }
  4679. }
  4680. } catch (...) {
  4681. exc = JavaCPP_handleException(env, 18);
  4682. }
  4683.  
  4684. ::cv::text::OCRHMMDecoder::ClassifierCallback* rptr0 = adapter0;
  4685. jlong rsize0 = (jlong)adapter0.size;
  4686. void* rowner0 = adapter0.owner;
  4687. if (rptr0 != ptr0) {
  4688. JavaCPP_initPointer(env, arg0, rptr0, rsize0, rowner0, &PtrAdapter< ::cv::text::OCRHMMDecoder::ClassifierCallback >::deallocate);
  4689. } else {
  4690. env->SetLongField(arg0, JavaCPP_limitFID, rsize0 + position0);
  4691. }
  4692. signed char* rptr1 = adapter1;
  4693. jlong rsize1 = (jlong)adapter1.size;
  4694. void* rowner1 = adapter1.owner;
  4695. if (rptr1 != ptr1) {
  4696. JavaCPP_initPointer(env, arg1, rptr1, rsize1, rowner1, &StringAdapter::deallocate);
  4697. } else {
  4698. env->SetLongField(arg1, JavaCPP_limitFID, rsize1 + position1);
  4699. }
  4700. if (exc != NULL) {
  4701. env->Throw(exc);
  4702. }
  4703. return rarg;
  4704. }
  4705. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_create__Lorg_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_00024ClassifierCallback_2Ljava_lang_String_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2(JNIEnv* env, jclass cls, jobject arg0, jstring arg1, jobject arg2, jobject arg3) {
  4706. ::cv::text::OCRHMMDecoder::ClassifierCallback* ptr0 = arg0 == NULL ? NULL : (::cv::text::OCRHMMDecoder::ClassifierCallback*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  4707. jlong size0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_limitFID);
  4708. void* owner0 = JavaCPP_getPointerOwner(env, arg0);
  4709. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  4710. ptr0 += position0;
  4711. size0 -= position0;
  4712. PtrAdapter< ::cv::text::OCRHMMDecoder::ClassifierCallback > adapter0(ptr0, size0, owner0);
  4713. const char* ptr1 = JavaCPP_getStringBytes(env, arg1);
  4714. jlong size1 = 0;
  4715. void* owner1 = (void*)ptr1;
  4716. StringAdapter adapter1(ptr1, size1, owner1);
  4717. ::cv::Mat* ptr2 = arg2 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  4718. if (ptr2 == NULL) {
  4719. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 2 is NULL.");
  4720. return 0;
  4721. }
  4722. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  4723. ptr2 += position2;
  4724. ::cv::Mat* ptr3 = arg3 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  4725. if (ptr3 == NULL) {
  4726. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 3 is NULL.");
  4727. return 0;
  4728. }
  4729. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  4730. ptr3 += position3;
  4731. jobject rarg = NULL;
  4732. ::cv::text::OCRHMMDecoder* rptr;
  4733. jthrowable exc = NULL;
  4734. try {
  4735. PtrAdapter< ::cv::text::OCRHMMDecoder > radapter(::cv::text::OCRHMMDecoder::create((cv::Ptr< ::cv::text::OCRHMMDecoder::ClassifierCallback >)adapter0, (std::string&)adapter1, *ptr2, *ptr3));
  4736. rptr = radapter;
  4737. jlong rcapacity = (jlong)radapter.size;
  4738. void* rowner = radapter.owner;
  4739. void (*deallocator)(void*) = &PtrAdapter< ::cv::text::OCRHMMDecoder >::deallocate;
  4740. if (rptr != NULL) {
  4741. rarg = JavaCPP_createPointer(env, 22);
  4742. if (rarg != NULL) {
  4743. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  4744. }
  4745. }
  4746. } catch (...) {
  4747. exc = JavaCPP_handleException(env, 18);
  4748. }
  4749.  
  4750. ::cv::text::OCRHMMDecoder::ClassifierCallback* rptr0 = adapter0;
  4751. jlong rsize0 = (jlong)adapter0.size;
  4752. void* rowner0 = adapter0.owner;
  4753. if (rptr0 != ptr0) {
  4754. JavaCPP_initPointer(env, arg0, rptr0, rsize0, rowner0, &PtrAdapter< ::cv::text::OCRHMMDecoder::ClassifierCallback >::deallocate);
  4755. } else {
  4756. env->SetLongField(arg0, JavaCPP_limitFID, rsize0 + position0);
  4757. }
  4758. JavaCPP_releaseStringBytes(env, arg1, ptr1);
  4759. if (exc != NULL) {
  4760. env->Throw(exc);
  4761. }
  4762. return rarg;
  4763. }
  4764. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_create__Lorg_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_00024ClassifierCallback_2Ljava_lang_String_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2I(JNIEnv* env, jclass cls, jobject arg0, jstring arg1, jobject arg2, jobject arg3, jint arg4) {
  4765. ::cv::text::OCRHMMDecoder::ClassifierCallback* ptr0 = arg0 == NULL ? NULL : (::cv::text::OCRHMMDecoder::ClassifierCallback*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  4766. jlong size0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_limitFID);
  4767. void* owner0 = JavaCPP_getPointerOwner(env, arg0);
  4768. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  4769. ptr0 += position0;
  4770. size0 -= position0;
  4771. PtrAdapter< ::cv::text::OCRHMMDecoder::ClassifierCallback > adapter0(ptr0, size0, owner0);
  4772. const char* ptr1 = JavaCPP_getStringBytes(env, arg1);
  4773. jlong size1 = 0;
  4774. void* owner1 = (void*)ptr1;
  4775. StringAdapter adapter1(ptr1, size1, owner1);
  4776. ::cv::Mat* ptr2 = arg2 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  4777. if (ptr2 == NULL) {
  4778. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 2 is NULL.");
  4779. return 0;
  4780. }
  4781. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  4782. ptr2 += position2;
  4783. ::cv::Mat* ptr3 = arg3 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  4784. if (ptr3 == NULL) {
  4785. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 3 is NULL.");
  4786. return 0;
  4787. }
  4788. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  4789. ptr3 += position3;
  4790. jobject rarg = NULL;
  4791. ::cv::text::OCRHMMDecoder* rptr;
  4792. jthrowable exc = NULL;
  4793. try {
  4794. PtrAdapter< ::cv::text::OCRHMMDecoder > radapter(::cv::text::OCRHMMDecoder::create((cv::Ptr< ::cv::text::OCRHMMDecoder::ClassifierCallback >)adapter0, (std::string&)adapter1, *ptr2, *ptr3, (cv::text::decoder_mode)arg4));
  4795. rptr = radapter;
  4796. jlong rcapacity = (jlong)radapter.size;
  4797. void* rowner = radapter.owner;
  4798. void (*deallocator)(void*) = &PtrAdapter< ::cv::text::OCRHMMDecoder >::deallocate;
  4799. if (rptr != NULL) {
  4800. rarg = JavaCPP_createPointer(env, 22);
  4801. if (rarg != NULL) {
  4802. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  4803. }
  4804. }
  4805. } catch (...) {
  4806. exc = JavaCPP_handleException(env, 18);
  4807. }
  4808.  
  4809. ::cv::text::OCRHMMDecoder::ClassifierCallback* rptr0 = adapter0;
  4810. jlong rsize0 = (jlong)adapter0.size;
  4811. void* rowner0 = adapter0.owner;
  4812. if (rptr0 != ptr0) {
  4813. JavaCPP_initPointer(env, arg0, rptr0, rsize0, rowner0, &PtrAdapter< ::cv::text::OCRHMMDecoder::ClassifierCallback >::deallocate);
  4814. } else {
  4815. env->SetLongField(arg0, JavaCPP_limitFID, rsize0 + position0);
  4816. }
  4817. JavaCPP_releaseStringBytes(env, arg1, ptr1);
  4818. if (exc != NULL) {
  4819. env->Throw(exc);
  4820. }
  4821. return rarg;
  4822. }
  4823. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_create__Lorg_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_00024ClassifierCallback_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jobject arg2, jobject arg3) {
  4824. ::cv::text::OCRHMMDecoder::ClassifierCallback* ptr0 = arg0 == NULL ? NULL : (::cv::text::OCRHMMDecoder::ClassifierCallback*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  4825. jlong size0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_limitFID);
  4826. void* owner0 = JavaCPP_getPointerOwner(env, arg0);
  4827. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  4828. ptr0 += position0;
  4829. size0 -= position0;
  4830. PtrAdapter< ::cv::text::OCRHMMDecoder::ClassifierCallback > adapter0(ptr0, size0, owner0);
  4831. signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  4832. jlong size1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_limitFID);
  4833. void* owner1 = JavaCPP_getPointerOwner(env, arg1);
  4834. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  4835. ptr1 += position1;
  4836. size1 -= position1;
  4837. StringAdapter adapter1(ptr1, size1, owner1);
  4838. ::cv::Mat* ptr2 = arg2 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  4839. if (ptr2 == NULL) {
  4840. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 2 is NULL.");
  4841. return 0;
  4842. }
  4843. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  4844. ptr2 += position2;
  4845. ::cv::Mat* ptr3 = arg3 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  4846. if (ptr3 == NULL) {
  4847. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 3 is NULL.");
  4848. return 0;
  4849. }
  4850. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  4851. ptr3 += position3;
  4852. jobject rarg = NULL;
  4853. ::cv::text::OCRHMMDecoder* rptr;
  4854. jthrowable exc = NULL;
  4855. try {
  4856. PtrAdapter< ::cv::text::OCRHMMDecoder > radapter(::cv::text::OCRHMMDecoder::create((cv::Ptr< ::cv::text::OCRHMMDecoder::ClassifierCallback >)adapter0, (std::string&)adapter1, *ptr2, *ptr3));
  4857. rptr = radapter;
  4858. jlong rcapacity = (jlong)radapter.size;
  4859. void* rowner = radapter.owner;
  4860. void (*deallocator)(void*) = &PtrAdapter< ::cv::text::OCRHMMDecoder >::deallocate;
  4861. if (rptr != NULL) {
  4862. rarg = JavaCPP_createPointer(env, 22);
  4863. if (rarg != NULL) {
  4864. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  4865. }
  4866. }
  4867. } catch (...) {
  4868. exc = JavaCPP_handleException(env, 18);
  4869. }
  4870.  
  4871. ::cv::text::OCRHMMDecoder::ClassifierCallback* rptr0 = adapter0;
  4872. jlong rsize0 = (jlong)adapter0.size;
  4873. void* rowner0 = adapter0.owner;
  4874. if (rptr0 != ptr0) {
  4875. JavaCPP_initPointer(env, arg0, rptr0, rsize0, rowner0, &PtrAdapter< ::cv::text::OCRHMMDecoder::ClassifierCallback >::deallocate);
  4876. } else {
  4877. env->SetLongField(arg0, JavaCPP_limitFID, rsize0 + position0);
  4878. }
  4879. signed char* rptr1 = adapter1;
  4880. jlong rsize1 = (jlong)adapter1.size;
  4881. void* rowner1 = adapter1.owner;
  4882. if (rptr1 != ptr1) {
  4883. JavaCPP_initPointer(env, arg1, rptr1, rsize1, rowner1, &StringAdapter::deallocate);
  4884. } else {
  4885. env->SetLongField(arg1, JavaCPP_limitFID, rsize1 + position1);
  4886. }
  4887. if (exc != NULL) {
  4888. env->Throw(exc);
  4889. }
  4890. return rarg;
  4891. }
  4892. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_allocate(JNIEnv* env, jobject obj) {
  4893. jthrowable exc = NULL;
  4894. try {
  4895. ::cv::text::OCRHMMDecoder* rptr = new ::cv::text::OCRHMMDecoder();
  4896. jlong rcapacity = 1;
  4897. JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_opencv_1text_00024OCRHMMDecoder_deallocate);
  4898. } catch (...) {
  4899. exc = JavaCPP_handleException(env, 18);
  4900. }
  4901.  
  4902. if (exc != NULL) {
  4903. env->Throw(exc);
  4904. }
  4905. }
  4906.  
  4907. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRTesseract_setWhiteList__Lorg_bytedeco_javacpp_BytePointer_2(JNIEnv* env, jobject obj, jobject arg0) {
  4908. ::cv::text::OCRTesseract* ptr = (::cv::text::OCRTesseract*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  4909. if (ptr == NULL) {
  4910. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  4911. return;
  4912. }
  4913. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  4914. ptr += position;
  4915. signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  4916. jlong size0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_limitFID);
  4917. void* owner0 = JavaCPP_getPointerOwner(env, arg0);
  4918. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  4919. ptr0 += position0;
  4920. size0 -= position0;
  4921. StrAdapter adapter0(ptr0, size0, owner0);
  4922. jthrowable exc = NULL;
  4923. try {
  4924. ptr->setWhiteList((cv::String&)adapter0);
  4925. } catch (...) {
  4926. exc = JavaCPP_handleException(env, 18);
  4927. }
  4928.  
  4929. signed char* rptr0 = adapter0;
  4930. jlong rsize0 = (jlong)adapter0.size;
  4931. void* rowner0 = adapter0.owner;
  4932. if (rptr0 != ptr0) {
  4933. JavaCPP_initPointer(env, arg0, rptr0, rsize0, rowner0, &StrAdapter::deallocate);
  4934. } else {
  4935. env->SetLongField(arg0, JavaCPP_limitFID, rsize0 + position0);
  4936. }
  4937. if (exc != NULL) {
  4938. env->Throw(exc);
  4939. }
  4940. }
  4941. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRTesseract_setWhiteList__Ljava_lang_String_2(JNIEnv* env, jobject obj, jstring arg0) {
  4942. ::cv::text::OCRTesseract* ptr = (::cv::text::OCRTesseract*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  4943. if (ptr == NULL) {
  4944. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  4945. return;
  4946. }
  4947. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  4948. ptr += position;
  4949. const char* ptr0 = JavaCPP_getStringBytes(env, arg0);
  4950. jlong size0 = 0;
  4951. void* owner0 = (void*)ptr0;
  4952. StrAdapter adapter0(ptr0, size0, owner0);
  4953. jthrowable exc = NULL;
  4954. try {
  4955. ptr->setWhiteList((cv::String&)adapter0);
  4956. } catch (...) {
  4957. exc = JavaCPP_handleException(env, 18);
  4958. }
  4959.  
  4960. JavaCPP_releaseStringBytes(env, arg0, ptr0);
  4961. if (exc != NULL) {
  4962. env->Throw(exc);
  4963. }
  4964. }
  4965. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRTesseract_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2I(JNIEnv* env, jobject obj, jobject arg0, jint arg1) {
  4966. ::cv::text::OCRTesseract* ptr = (::cv::text::OCRTesseract*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  4967. if (ptr == NULL) {
  4968. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  4969. return 0;
  4970. }
  4971. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  4972. ptr += position;
  4973. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  4974. if (ptr0 == NULL) {
  4975. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  4976. return 0;
  4977. }
  4978. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  4979. ptr0 += position0;
  4980. jobject rarg = NULL;
  4981. signed char* rptr;
  4982. jthrowable exc = NULL;
  4983. try {
  4984. StrAdapter radapter(ptr->run(*ptr0, arg1));
  4985. rptr = radapter;
  4986. jlong rcapacity = (jlong)radapter.size;
  4987. void* rowner = radapter.owner;
  4988. void (*deallocator)(void*) = &StrAdapter::deallocate;
  4989. if (rptr != NULL) {
  4990. rarg = JavaCPP_createPointer(env, 1);
  4991. if (rarg != NULL) {
  4992. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  4993. }
  4994. }
  4995. } catch (...) {
  4996. exc = JavaCPP_handleException(env, 18);
  4997. }
  4998.  
  4999. if (exc != NULL) {
  5000. env->Throw(exc);
  5001. }
  5002. return rarg;
  5003. }
  5004. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRTesseract_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2II(JNIEnv* env, jobject obj, jobject arg0, jint arg1, jint arg2) {
  5005. ::cv::text::OCRTesseract* ptr = (::cv::text::OCRTesseract*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  5006. if (ptr == NULL) {
  5007. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  5008. return 0;
  5009. }
  5010. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  5011. ptr += position;
  5012. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  5013. if (ptr0 == NULL) {
  5014. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  5015. return 0;
  5016. }
  5017. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  5018. ptr0 += position0;
  5019. jobject rarg = NULL;
  5020. signed char* rptr;
  5021. jthrowable exc = NULL;
  5022. try {
  5023. StrAdapter radapter(ptr->run(*ptr0, arg1, arg2));
  5024. rptr = radapter;
  5025. jlong rcapacity = (jlong)radapter.size;
  5026. void* rowner = radapter.owner;
  5027. void (*deallocator)(void*) = &StrAdapter::deallocate;
  5028. if (rptr != NULL) {
  5029. rarg = JavaCPP_createPointer(env, 1);
  5030. if (rarg != NULL) {
  5031. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  5032. }
  5033. }
  5034. } catch (...) {
  5035. exc = JavaCPP_handleException(env, 18);
  5036. }
  5037.  
  5038. if (exc != NULL) {
  5039. env->Throw(exc);
  5040. }
  5041. return rarg;
  5042. }
  5043. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRTesseract_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Ljava_lang_String_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Ljava_lang_String_2_3FI(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jstring arg2, jobject arg3, jstring arg4, jfloatArray arg5, jint arg6) {
  5044. ::cv::text::OCRTesseract* ptr = (::cv::text::OCRTesseract*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  5045. if (ptr == NULL) {
  5046. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  5047. return;
  5048. }
  5049. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  5050. ptr += position;
  5051. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  5052. if (ptr0 == NULL) {
  5053. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  5054. return;
  5055. }
  5056. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  5057. ptr0 += position0;
  5058. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  5059. if (ptr1 == NULL) {
  5060. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  5061. return;
  5062. }
  5063. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  5064. ptr1 += position1;
  5065. const char* ptr2 = JavaCPP_getStringBytes(env, arg2);
  5066. jlong size2 = 0;
  5067. void* owner2 = (void*)ptr2;
  5068. StringAdapter adapter2(ptr2, size2, owner2);
  5069. ::std::vector<cv::Rect>* ptr3 = arg3 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  5070. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  5071. ptr3 += position3;
  5072. const char* ptr4 = JavaCPP_getStringBytes(env, arg4);
  5073. jlong size4 = 0;
  5074. void* owner4 = (void*)ptr4;
  5075. VectorAdapter adapter4(ptr4, size4, owner4);
  5076. float* ptr5 = arg5 == NULL ? NULL : env->GetFloatArrayElements(arg5, NULL);
  5077. jlong size5 = arg5 == NULL ? 0 : env->GetArrayLength(arg5);
  5078. void* owner5 = (void*)ptr5;
  5079. VectorAdapter< float > adapter5(ptr5, size5, owner5);
  5080. jthrowable exc = NULL;
  5081. try {
  5082. ptr->run(*ptr0, *ptr1, (std::string&)adapter2, ptr3, (std::string&)adapter4, adapter5, arg6);
  5083. } catch (...) {
  5084. exc = JavaCPP_handleException(env, 18);
  5085. }
  5086.  
  5087. JavaCPP_releaseStringBytes(env, arg2, ptr2);
  5088. JavaCPP_releaseStringBytes(env, arg4, ptr4);
  5089. float* rptr5 = adapter5;
  5090. void* rowner5 = adapter5.owner;
  5091. if (rptr5 != ptr5) {
  5092. VectorAdapter< float >::deallocate(rowner5);
  5093. }
  5094. if (arg5 != NULL) env->ReleaseFloatArrayElements(arg5, (jfloat*)ptr5, 0);
  5095. if (exc != NULL) {
  5096. env->Throw(exc);
  5097. }
  5098. }
  5099. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRTesseract_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Lorg_bytedeco_javacpp_BytePointer_2Ljava_nio_FloatBuffer_2I(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jobject arg2, jobject arg3, jobject arg4, jobject arg5, jint arg6) {
  5100. ::cv::text::OCRTesseract* ptr = (::cv::text::OCRTesseract*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  5101. if (ptr == NULL) {
  5102. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  5103. return;
  5104. }
  5105. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  5106. ptr += position;
  5107. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  5108. if (ptr0 == NULL) {
  5109. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  5110. return;
  5111. }
  5112. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  5113. ptr0 += position0;
  5114. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  5115. if (ptr1 == NULL) {
  5116. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  5117. return;
  5118. }
  5119. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  5120. ptr1 += position1;
  5121. signed char* ptr2 = arg2 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  5122. jlong size2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_limitFID);
  5123. void* owner2 = JavaCPP_getPointerOwner(env, arg2);
  5124. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  5125. ptr2 += position2;
  5126. size2 -= position2;
  5127. StringAdapter adapter2(ptr2, size2, owner2);
  5128. ::std::vector<cv::Rect>* ptr3 = arg3 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  5129. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  5130. ptr3 += position3;
  5131. signed char* ptr4 = arg4 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg4, JavaCPP_addressFID));
  5132. jlong size4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_limitFID);
  5133. void* owner4 = JavaCPP_getPointerOwner(env, arg4);
  5134. jlong position4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_positionFID);
  5135. ptr4 += position4;
  5136. size4 -= position4;
  5137. VectorAdapter adapter4(ptr4, size4, owner4);
  5138. float* ptr5 = arg5 == NULL ? NULL : (float*)env->GetDirectBufferAddress(arg5);
  5139. jlong size5 = arg5 == NULL ? 0 : env->GetDirectBufferCapacity(arg5);
  5140. void* owner5 = (void*)ptr5;
  5141. jfloatArray arr5 = NULL;
  5142. if (arg5 != NULL && ptr5 == NULL) {
  5143. arr5 = (jfloatArray)env->CallObjectMethod(arg5, JavaCPP_arrayMID);
  5144. if (env->ExceptionOccurred() != NULL) {
  5145. env->ExceptionClear();
  5146. } else {
  5147. ptr5 = arr5 == NULL ? NULL : env->GetFloatArrayElements(arr5, NULL);
  5148. size5 = env->GetArrayLength(arr5);
  5149. }
  5150. }
  5151. VectorAdapter< float > adapter5(ptr5, size5, owner5);
  5152. jthrowable exc = NULL;
  5153. try {
  5154. ptr->run(*ptr0, *ptr1, (std::string&)adapter2, ptr3, (std::string&)adapter4, adapter5, arg6);
  5155. } catch (...) {
  5156. exc = JavaCPP_handleException(env, 18);
  5157. }
  5158.  
  5159. signed char* rptr2 = adapter2;
  5160. jlong rsize2 = (jlong)adapter2.size;
  5161. void* rowner2 = adapter2.owner;
  5162. if (rptr2 != ptr2) {
  5163. JavaCPP_initPointer(env, arg2, rptr2, rsize2, rowner2, &StringAdapter::deallocate);
  5164. } else {
  5165. env->SetLongField(arg2, JavaCPP_limitFID, rsize2 + position2);
  5166. }
  5167. signed char* rptr4 = adapter4;
  5168. jlong rsize4 = (jlong)adapter4.size;
  5169. void* rowner4 = adapter4.owner;
  5170. if (rptr4 != ptr4) {
  5171. JavaCPP_initPointer(env, arg4, rptr4, rsize4, rowner4, &VectorAdapter::deallocate);
  5172. } else {
  5173. env->SetLongField(arg4, JavaCPP_limitFID, rsize4 + position4);
  5174. }
  5175. float* rptr5 = adapter5;
  5176. void* rowner5 = adapter5.owner;
  5177. if (rptr5 != ptr5) {
  5178. VectorAdapter< float >::deallocate(rowner5);
  5179. }
  5180. if (arr5 != NULL) env->ReleaseFloatArrayElements(arr5, (jfloat*)ptr5, 0);
  5181. if (exc != NULL) {
  5182. env->Throw(exc);
  5183. }
  5184. }
  5185. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRTesseract_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Ljava_lang_String_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Ljava_lang_String_2Lorg_bytedeco_javacpp_FloatPointer_2I(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jstring arg2, jobject arg3, jstring arg4, jobject arg5, jint arg6) {
  5186. ::cv::text::OCRTesseract* ptr = (::cv::text::OCRTesseract*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  5187. if (ptr == NULL) {
  5188. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  5189. return;
  5190. }
  5191. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  5192. ptr += position;
  5193. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  5194. if (ptr0 == NULL) {
  5195. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  5196. return;
  5197. }
  5198. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  5199. ptr0 += position0;
  5200. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  5201. if (ptr1 == NULL) {
  5202. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  5203. return;
  5204. }
  5205. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  5206. ptr1 += position1;
  5207. const char* ptr2 = JavaCPP_getStringBytes(env, arg2);
  5208. jlong size2 = 0;
  5209. void* owner2 = (void*)ptr2;
  5210. StringAdapter adapter2(ptr2, size2, owner2);
  5211. ::std::vector<cv::Rect>* ptr3 = arg3 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  5212. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  5213. ptr3 += position3;
  5214. const char* ptr4 = JavaCPP_getStringBytes(env, arg4);
  5215. jlong size4 = 0;
  5216. void* owner4 = (void*)ptr4;
  5217. VectorAdapter adapter4(ptr4, size4, owner4);
  5218. float* ptr5 = arg5 == NULL ? NULL : (float*)jlong_to_ptr(env->GetLongField(arg5, JavaCPP_addressFID));
  5219. jlong size5 = arg5 == NULL ? 0 : env->GetLongField(arg5, JavaCPP_limitFID);
  5220. void* owner5 = JavaCPP_getPointerOwner(env, arg5);
  5221. jlong position5 = arg5 == NULL ? 0 : env->GetLongField(arg5, JavaCPP_positionFID);
  5222. ptr5 += position5;
  5223. size5 -= position5;
  5224. VectorAdapter< float > adapter5(ptr5, size5, owner5);
  5225. jthrowable exc = NULL;
  5226. try {
  5227. ptr->run(*ptr0, *ptr1, (std::string&)adapter2, ptr3, (std::string&)adapter4, adapter5, arg6);
  5228. } catch (...) {
  5229. exc = JavaCPP_handleException(env, 18);
  5230. }
  5231.  
  5232. JavaCPP_releaseStringBytes(env, arg2, ptr2);
  5233. JavaCPP_releaseStringBytes(env, arg4, ptr4);
  5234. float* rptr5 = adapter5;
  5235. jlong rsize5 = (jlong)adapter5.size;
  5236. void* rowner5 = adapter5.owner;
  5237. if (rptr5 != ptr5) {
  5238. JavaCPP_initPointer(env, arg5, rptr5, rsize5, rowner5, &VectorAdapter< float >::deallocate);
  5239. } else {
  5240. env->SetLongField(arg5, JavaCPP_limitFID, rsize5 + position5);
  5241. }
  5242. if (exc != NULL) {
  5243. env->Throw(exc);
  5244. }
  5245. }
  5246. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRTesseract_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Lorg_bytedeco_javacpp_BytePointer_2_3FI(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jobject arg2, jobject arg3, jobject arg4, jfloatArray arg5, jint arg6) {
  5247. ::cv::text::OCRTesseract* ptr = (::cv::text::OCRTesseract*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  5248. if (ptr == NULL) {
  5249. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  5250. return;
  5251. }
  5252. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  5253. ptr += position;
  5254. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  5255. if (ptr0 == NULL) {
  5256. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  5257. return;
  5258. }
  5259. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  5260. ptr0 += position0;
  5261. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  5262. if (ptr1 == NULL) {
  5263. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  5264. return;
  5265. }
  5266. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  5267. ptr1 += position1;
  5268. signed char* ptr2 = arg2 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  5269. jlong size2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_limitFID);
  5270. void* owner2 = JavaCPP_getPointerOwner(env, arg2);
  5271. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  5272. ptr2 += position2;
  5273. size2 -= position2;
  5274. StringAdapter adapter2(ptr2, size2, owner2);
  5275. ::std::vector<cv::Rect>* ptr3 = arg3 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  5276. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  5277. ptr3 += position3;
  5278. signed char* ptr4 = arg4 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg4, JavaCPP_addressFID));
  5279. jlong size4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_limitFID);
  5280. void* owner4 = JavaCPP_getPointerOwner(env, arg4);
  5281. jlong position4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_positionFID);
  5282. ptr4 += position4;
  5283. size4 -= position4;
  5284. VectorAdapter adapter4(ptr4, size4, owner4);
  5285. float* ptr5 = arg5 == NULL ? NULL : env->GetFloatArrayElements(arg5, NULL);
  5286. jlong size5 = arg5 == NULL ? 0 : env->GetArrayLength(arg5);
  5287. void* owner5 = (void*)ptr5;
  5288. VectorAdapter< float > adapter5(ptr5, size5, owner5);
  5289. jthrowable exc = NULL;
  5290. try {
  5291. ptr->run(*ptr0, *ptr1, (std::string&)adapter2, ptr3, (std::string&)adapter4, adapter5, arg6);
  5292. } catch (...) {
  5293. exc = JavaCPP_handleException(env, 18);
  5294. }
  5295.  
  5296. signed char* rptr2 = adapter2;
  5297. jlong rsize2 = (jlong)adapter2.size;
  5298. void* rowner2 = adapter2.owner;
  5299. if (rptr2 != ptr2) {
  5300. JavaCPP_initPointer(env, arg2, rptr2, rsize2, rowner2, &StringAdapter::deallocate);
  5301. } else {
  5302. env->SetLongField(arg2, JavaCPP_limitFID, rsize2 + position2);
  5303. }
  5304. signed char* rptr4 = adapter4;
  5305. jlong rsize4 = (jlong)adapter4.size;
  5306. void* rowner4 = adapter4.owner;
  5307. if (rptr4 != ptr4) {
  5308. JavaCPP_initPointer(env, arg4, rptr4, rsize4, rowner4, &VectorAdapter::deallocate);
  5309. } else {
  5310. env->SetLongField(arg4, JavaCPP_limitFID, rsize4 + position4);
  5311. }
  5312. float* rptr5 = adapter5;
  5313. void* rowner5 = adapter5.owner;
  5314. if (rptr5 != ptr5) {
  5315. VectorAdapter< float >::deallocate(rowner5);
  5316. }
  5317. if (arg5 != NULL) env->ReleaseFloatArrayElements(arg5, (jfloat*)ptr5, 0);
  5318. if (exc != NULL) {
  5319. env->Throw(exc);
  5320. }
  5321. }
  5322. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRTesseract_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_FloatPointer_2I(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jobject arg2, jobject arg3, jobject arg4, jint arg5) {
  5323. ::cv::text::OCRTesseract* ptr = (::cv::text::OCRTesseract*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  5324. if (ptr == NULL) {
  5325. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  5326. return;
  5327. }
  5328. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  5329. ptr += position;
  5330. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  5331. if (ptr0 == NULL) {
  5332. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  5333. return;
  5334. }
  5335. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  5336. ptr0 += position0;
  5337. signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  5338. jlong size1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_limitFID);
  5339. void* owner1 = JavaCPP_getPointerOwner(env, arg1);
  5340. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  5341. ptr1 += position1;
  5342. size1 -= position1;
  5343. StringAdapter adapter1(ptr1, size1, owner1);
  5344. ::std::vector<cv::Rect>* ptr2 = arg2 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  5345. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  5346. ptr2 += position2;
  5347. signed char* ptr3 = arg3 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  5348. jlong size3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_limitFID);
  5349. void* owner3 = JavaCPP_getPointerOwner(env, arg3);
  5350. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  5351. ptr3 += position3;
  5352. size3 -= position3;
  5353. VectorAdapter adapter3(ptr3, size3, owner3);
  5354. float* ptr4 = arg4 == NULL ? NULL : (float*)jlong_to_ptr(env->GetLongField(arg4, JavaCPP_addressFID));
  5355. jlong size4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_limitFID);
  5356. void* owner4 = JavaCPP_getPointerOwner(env, arg4);
  5357. jlong position4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_positionFID);
  5358. ptr4 += position4;
  5359. size4 -= position4;
  5360. VectorAdapter< float > adapter4(ptr4, size4, owner4);
  5361. jthrowable exc = NULL;
  5362. try {
  5363. ptr->run(*ptr0, (std::string&)adapter1, ptr2, (std::string&)adapter3, adapter4, arg5);
  5364. } catch (...) {
  5365. exc = JavaCPP_handleException(env, 18);
  5366. }
  5367.  
  5368. signed char* rptr1 = adapter1;
  5369. jlong rsize1 = (jlong)adapter1.size;
  5370. void* rowner1 = adapter1.owner;
  5371. if (rptr1 != ptr1) {
  5372. JavaCPP_initPointer(env, arg1, rptr1, rsize1, rowner1, &StringAdapter::deallocate);
  5373. } else {
  5374. env->SetLongField(arg1, JavaCPP_limitFID, rsize1 + position1);
  5375. }
  5376. signed char* rptr3 = adapter3;
  5377. jlong rsize3 = (jlong)adapter3.size;
  5378. void* rowner3 = adapter3.owner;
  5379. if (rptr3 != ptr3) {
  5380. JavaCPP_initPointer(env, arg3, rptr3, rsize3, rowner3, &VectorAdapter::deallocate);
  5381. } else {
  5382. env->SetLongField(arg3, JavaCPP_limitFID, rsize3 + position3);
  5383. }
  5384. float* rptr4 = adapter4;
  5385. jlong rsize4 = (jlong)adapter4.size;
  5386. void* rowner4 = adapter4.owner;
  5387. if (rptr4 != ptr4) {
  5388. JavaCPP_initPointer(env, arg4, rptr4, rsize4, rowner4, &VectorAdapter< float >::deallocate);
  5389. } else {
  5390. env->SetLongField(arg4, JavaCPP_limitFID, rsize4 + position4);
  5391. }
  5392. if (exc != NULL) {
  5393. env->Throw(exc);
  5394. }
  5395. }
  5396. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRTesseract_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_BytePointer_2(JNIEnv* env, jobject obj, jobject arg0, jobject arg1) {
  5397. ::cv::text::OCRTesseract* ptr = (::cv::text::OCRTesseract*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  5398. if (ptr == NULL) {
  5399. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  5400. return;
  5401. }
  5402. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  5403. ptr += position;
  5404. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  5405. if (ptr0 == NULL) {
  5406. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  5407. return;
  5408. }
  5409. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  5410. ptr0 += position0;
  5411. signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  5412. jlong size1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_limitFID);
  5413. void* owner1 = JavaCPP_getPointerOwner(env, arg1);
  5414. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  5415. ptr1 += position1;
  5416. size1 -= position1;
  5417. StringAdapter adapter1(ptr1, size1, owner1);
  5418. jthrowable exc = NULL;
  5419. try {
  5420. ptr->run(*ptr0, (std::string&)adapter1);
  5421. } catch (...) {
  5422. exc = JavaCPP_handleException(env, 18);
  5423. }
  5424.  
  5425. signed char* rptr1 = adapter1;
  5426. jlong rsize1 = (jlong)adapter1.size;
  5427. void* rowner1 = adapter1.owner;
  5428. if (rptr1 != ptr1) {
  5429. JavaCPP_initPointer(env, arg1, rptr1, rsize1, rowner1, &StringAdapter::deallocate);
  5430. } else {
  5431. env->SetLongField(arg1, JavaCPP_limitFID, rsize1 + position1);
  5432. }
  5433. if (exc != NULL) {
  5434. env->Throw(exc);
  5435. }
  5436. }
  5437. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRTesseract_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2I(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jint arg2) {
  5438. ::cv::text::OCRTesseract* ptr = (::cv::text::OCRTesseract*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  5439. if (ptr == NULL) {
  5440. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  5441. return 0;
  5442. }
  5443. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  5444. ptr += position;
  5445. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  5446. if (ptr0 == NULL) {
  5447. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  5448. return 0;
  5449. }
  5450. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  5451. ptr0 += position0;
  5452. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  5453. if (ptr1 == NULL) {
  5454. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  5455. return 0;
  5456. }
  5457. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  5458. ptr1 += position1;
  5459. jobject rarg = NULL;
  5460. signed char* rptr;
  5461. jthrowable exc = NULL;
  5462. try {
  5463. StrAdapter radapter(ptr->run(*ptr0, *ptr1, arg2));
  5464. rptr = radapter;
  5465. jlong rcapacity = (jlong)radapter.size;
  5466. void* rowner = radapter.owner;
  5467. void (*deallocator)(void*) = &StrAdapter::deallocate;
  5468. if (rptr != NULL) {
  5469. rarg = JavaCPP_createPointer(env, 1);
  5470. if (rarg != NULL) {
  5471. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  5472. }
  5473. }
  5474. } catch (...) {
  5475. exc = JavaCPP_handleException(env, 18);
  5476. }
  5477.  
  5478. if (exc != NULL) {
  5479. env->Throw(exc);
  5480. }
  5481. return rarg;
  5482. }
  5483. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRTesseract_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2II(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jint arg2, jint arg3) {
  5484. ::cv::text::OCRTesseract* ptr = (::cv::text::OCRTesseract*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  5485. if (ptr == NULL) {
  5486. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  5487. return 0;
  5488. }
  5489. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  5490. ptr += position;
  5491. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  5492. if (ptr0 == NULL) {
  5493. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  5494. return 0;
  5495. }
  5496. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  5497. ptr0 += position0;
  5498. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  5499. if (ptr1 == NULL) {
  5500. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  5501. return 0;
  5502. }
  5503. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  5504. ptr1 += position1;
  5505. jobject rarg = NULL;
  5506. signed char* rptr;
  5507. jthrowable exc = NULL;
  5508. try {
  5509. StrAdapter radapter(ptr->run(*ptr0, *ptr1, arg2, arg3));
  5510. rptr = radapter;
  5511. jlong rcapacity = (jlong)radapter.size;
  5512. void* rowner = radapter.owner;
  5513. void (*deallocator)(void*) = &StrAdapter::deallocate;
  5514. if (rptr != NULL) {
  5515. rarg = JavaCPP_createPointer(env, 1);
  5516. if (rarg != NULL) {
  5517. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  5518. }
  5519. }
  5520. } catch (...) {
  5521. exc = JavaCPP_handleException(env, 18);
  5522. }
  5523.  
  5524. if (exc != NULL) {
  5525. env->Throw(exc);
  5526. }
  5527. return rarg;
  5528. }
  5529. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRTesseract_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Ljava_lang_String_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Ljava_lang_String_2_3FI(JNIEnv* env, jobject obj, jobject arg0, jstring arg1, jobject arg2, jstring arg3, jfloatArray arg4, jint arg5) {
  5530. ::cv::text::OCRTesseract* ptr = (::cv::text::OCRTesseract*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  5531. if (ptr == NULL) {
  5532. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  5533. return;
  5534. }
  5535. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  5536. ptr += position;
  5537. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  5538. if (ptr0 == NULL) {
  5539. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  5540. return;
  5541. }
  5542. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  5543. ptr0 += position0;
  5544. const char* ptr1 = JavaCPP_getStringBytes(env, arg1);
  5545. jlong size1 = 0;
  5546. void* owner1 = (void*)ptr1;
  5547. StringAdapter adapter1(ptr1, size1, owner1);
  5548. ::std::vector<cv::Rect>* ptr2 = arg2 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  5549. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  5550. ptr2 += position2;
  5551. const char* ptr3 = JavaCPP_getStringBytes(env, arg3);
  5552. jlong size3 = 0;
  5553. void* owner3 = (void*)ptr3;
  5554. VectorAdapter adapter3(ptr3, size3, owner3);
  5555. float* ptr4 = arg4 == NULL ? NULL : env->GetFloatArrayElements(arg4, NULL);
  5556. jlong size4 = arg4 == NULL ? 0 : env->GetArrayLength(arg4);
  5557. void* owner4 = (void*)ptr4;
  5558. VectorAdapter< float > adapter4(ptr4, size4, owner4);
  5559. jthrowable exc = NULL;
  5560. try {
  5561. ptr->run(*ptr0, (std::string&)adapter1, ptr2, (std::string&)adapter3, adapter4, arg5);
  5562. } catch (...) {
  5563. exc = JavaCPP_handleException(env, 18);
  5564. }
  5565.  
  5566. JavaCPP_releaseStringBytes(env, arg1, ptr1);
  5567. JavaCPP_releaseStringBytes(env, arg3, ptr3);
  5568. float* rptr4 = adapter4;
  5569. void* rowner4 = adapter4.owner;
  5570. if (rptr4 != ptr4) {
  5571. VectorAdapter< float >::deallocate(rowner4);
  5572. }
  5573. if (arg4 != NULL) env->ReleaseFloatArrayElements(arg4, (jfloat*)ptr4, 0);
  5574. if (exc != NULL) {
  5575. env->Throw(exc);
  5576. }
  5577. }
  5578. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRTesseract_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Lorg_bytedeco_javacpp_BytePointer_2Ljava_nio_FloatBuffer_2I(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jobject arg2, jobject arg3, jobject arg4, jint arg5) {
  5579. ::cv::text::OCRTesseract* ptr = (::cv::text::OCRTesseract*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  5580. if (ptr == NULL) {
  5581. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  5582. return;
  5583. }
  5584. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  5585. ptr += position;
  5586. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  5587. if (ptr0 == NULL) {
  5588. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  5589. return;
  5590. }
  5591. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  5592. ptr0 += position0;
  5593. signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  5594. jlong size1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_limitFID);
  5595. void* owner1 = JavaCPP_getPointerOwner(env, arg1);
  5596. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  5597. ptr1 += position1;
  5598. size1 -= position1;
  5599. StringAdapter adapter1(ptr1, size1, owner1);
  5600. ::std::vector<cv::Rect>* ptr2 = arg2 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  5601. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  5602. ptr2 += position2;
  5603. signed char* ptr3 = arg3 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  5604. jlong size3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_limitFID);
  5605. void* owner3 = JavaCPP_getPointerOwner(env, arg3);
  5606. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  5607. ptr3 += position3;
  5608. size3 -= position3;
  5609. VectorAdapter adapter3(ptr3, size3, owner3);
  5610. float* ptr4 = arg4 == NULL ? NULL : (float*)env->GetDirectBufferAddress(arg4);
  5611. jlong size4 = arg4 == NULL ? 0 : env->GetDirectBufferCapacity(arg4);
  5612. void* owner4 = (void*)ptr4;
  5613. jfloatArray arr4 = NULL;
  5614. if (arg4 != NULL && ptr4 == NULL) {
  5615. arr4 = (jfloatArray)env->CallObjectMethod(arg4, JavaCPP_arrayMID);
  5616. if (env->ExceptionOccurred() != NULL) {
  5617. env->ExceptionClear();
  5618. } else {
  5619. ptr4 = arr4 == NULL ? NULL : env->GetFloatArrayElements(arr4, NULL);
  5620. size4 = env->GetArrayLength(arr4);
  5621. }
  5622. }
  5623. VectorAdapter< float > adapter4(ptr4, size4, owner4);
  5624. jthrowable exc = NULL;
  5625. try {
  5626. ptr->run(*ptr0, (std::string&)adapter1, ptr2, (std::string&)adapter3, adapter4, arg5);
  5627. } catch (...) {
  5628. exc = JavaCPP_handleException(env, 18);
  5629. }
  5630.  
  5631. signed char* rptr1 = adapter1;
  5632. jlong rsize1 = (jlong)adapter1.size;
  5633. void* rowner1 = adapter1.owner;
  5634. if (rptr1 != ptr1) {
  5635. JavaCPP_initPointer(env, arg1, rptr1, rsize1, rowner1, &StringAdapter::deallocate);
  5636. } else {
  5637. env->SetLongField(arg1, JavaCPP_limitFID, rsize1 + position1);
  5638. }
  5639. signed char* rptr3 = adapter3;
  5640. jlong rsize3 = (jlong)adapter3.size;
  5641. void* rowner3 = adapter3.owner;
  5642. if (rptr3 != ptr3) {
  5643. JavaCPP_initPointer(env, arg3, rptr3, rsize3, rowner3, &VectorAdapter::deallocate);
  5644. } else {
  5645. env->SetLongField(arg3, JavaCPP_limitFID, rsize3 + position3);
  5646. }
  5647. float* rptr4 = adapter4;
  5648. void* rowner4 = adapter4.owner;
  5649. if (rptr4 != ptr4) {
  5650. VectorAdapter< float >::deallocate(rowner4);
  5651. }
  5652. if (arr4 != NULL) env->ReleaseFloatArrayElements(arr4, (jfloat*)ptr4, 0);
  5653. if (exc != NULL) {
  5654. env->Throw(exc);
  5655. }
  5656. }
  5657. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRTesseract_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Ljava_lang_String_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Ljava_lang_String_2Lorg_bytedeco_javacpp_FloatPointer_2I(JNIEnv* env, jobject obj, jobject arg0, jstring arg1, jobject arg2, jstring arg3, jobject arg4, jint arg5) {
  5658. ::cv::text::OCRTesseract* ptr = (::cv::text::OCRTesseract*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  5659. if (ptr == NULL) {
  5660. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  5661. return;
  5662. }
  5663. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  5664. ptr += position;
  5665. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  5666. if (ptr0 == NULL) {
  5667. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  5668. return;
  5669. }
  5670. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  5671. ptr0 += position0;
  5672. const char* ptr1 = JavaCPP_getStringBytes(env, arg1);
  5673. jlong size1 = 0;
  5674. void* owner1 = (void*)ptr1;
  5675. StringAdapter adapter1(ptr1, size1, owner1);
  5676. ::std::vector<cv::Rect>* ptr2 = arg2 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  5677. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  5678. ptr2 += position2;
  5679. const char* ptr3 = JavaCPP_getStringBytes(env, arg3);
  5680. jlong size3 = 0;
  5681. void* owner3 = (void*)ptr3;
  5682. VectorAdapter adapter3(ptr3, size3, owner3);
  5683. float* ptr4 = arg4 == NULL ? NULL : (float*)jlong_to_ptr(env->GetLongField(arg4, JavaCPP_addressFID));
  5684. jlong size4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_limitFID);
  5685. void* owner4 = JavaCPP_getPointerOwner(env, arg4);
  5686. jlong position4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_positionFID);
  5687. ptr4 += position4;
  5688. size4 -= position4;
  5689. VectorAdapter< float > adapter4(ptr4, size4, owner4);
  5690. jthrowable exc = NULL;
  5691. try {
  5692. ptr->run(*ptr0, (std::string&)adapter1, ptr2, (std::string&)adapter3, adapter4, arg5);
  5693. } catch (...) {
  5694. exc = JavaCPP_handleException(env, 18);
  5695. }
  5696.  
  5697. JavaCPP_releaseStringBytes(env, arg1, ptr1);
  5698. JavaCPP_releaseStringBytes(env, arg3, ptr3);
  5699. float* rptr4 = adapter4;
  5700. jlong rsize4 = (jlong)adapter4.size;
  5701. void* rowner4 = adapter4.owner;
  5702. if (rptr4 != ptr4) {
  5703. JavaCPP_initPointer(env, arg4, rptr4, rsize4, rowner4, &VectorAdapter< float >::deallocate);
  5704. } else {
  5705. env->SetLongField(arg4, JavaCPP_limitFID, rsize4 + position4);
  5706. }
  5707. if (exc != NULL) {
  5708. env->Throw(exc);
  5709. }
  5710. }
  5711. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRTesseract_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Lorg_bytedeco_javacpp_BytePointer_2_3FI(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jobject arg2, jobject arg3, jfloatArray arg4, jint arg5) {
  5712. ::cv::text::OCRTesseract* ptr = (::cv::text::OCRTesseract*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  5713. if (ptr == NULL) {
  5714. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  5715. return;
  5716. }
  5717. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  5718. ptr += position;
  5719. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  5720. if (ptr0 == NULL) {
  5721. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  5722. return;
  5723. }
  5724. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  5725. ptr0 += position0;
  5726. signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  5727. jlong size1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_limitFID);
  5728. void* owner1 = JavaCPP_getPointerOwner(env, arg1);
  5729. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  5730. ptr1 += position1;
  5731. size1 -= position1;
  5732. StringAdapter adapter1(ptr1, size1, owner1);
  5733. ::std::vector<cv::Rect>* ptr2 = arg2 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  5734. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  5735. ptr2 += position2;
  5736. signed char* ptr3 = arg3 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  5737. jlong size3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_limitFID);
  5738. void* owner3 = JavaCPP_getPointerOwner(env, arg3);
  5739. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  5740. ptr3 += position3;
  5741. size3 -= position3;
  5742. VectorAdapter adapter3(ptr3, size3, owner3);
  5743. float* ptr4 = arg4 == NULL ? NULL : env->GetFloatArrayElements(arg4, NULL);
  5744. jlong size4 = arg4 == NULL ? 0 : env->GetArrayLength(arg4);
  5745. void* owner4 = (void*)ptr4;
  5746. VectorAdapter< float > adapter4(ptr4, size4, owner4);
  5747. jthrowable exc = NULL;
  5748. try {
  5749. ptr->run(*ptr0, (std::string&)adapter1, ptr2, (std::string&)adapter3, adapter4, arg5);
  5750. } catch (...) {
  5751. exc = JavaCPP_handleException(env, 18);
  5752. }
  5753.  
  5754. signed char* rptr1 = adapter1;
  5755. jlong rsize1 = (jlong)adapter1.size;
  5756. void* rowner1 = adapter1.owner;
  5757. if (rptr1 != ptr1) {
  5758. JavaCPP_initPointer(env, arg1, rptr1, rsize1, rowner1, &StringAdapter::deallocate);
  5759. } else {
  5760. env->SetLongField(arg1, JavaCPP_limitFID, rsize1 + position1);
  5761. }
  5762. signed char* rptr3 = adapter3;
  5763. jlong rsize3 = (jlong)adapter3.size;
  5764. void* rowner3 = adapter3.owner;
  5765. if (rptr3 != ptr3) {
  5766. JavaCPP_initPointer(env, arg3, rptr3, rsize3, rowner3, &VectorAdapter::deallocate);
  5767. } else {
  5768. env->SetLongField(arg3, JavaCPP_limitFID, rsize3 + position3);
  5769. }
  5770. float* rptr4 = adapter4;
  5771. void* rowner4 = adapter4.owner;
  5772. if (rptr4 != ptr4) {
  5773. VectorAdapter< float >::deallocate(rowner4);
  5774. }
  5775. if (arg4 != NULL) env->ReleaseFloatArrayElements(arg4, (jfloat*)ptr4, 0);
  5776. if (exc != NULL) {
  5777. env->Throw(exc);
  5778. }
  5779. }
  5780. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRTesseract_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Ljava_lang_String_2(JNIEnv* env, jobject obj, jobject arg0, jstring arg1) {
  5781. ::cv::text::OCRTesseract* ptr = (::cv::text::OCRTesseract*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  5782. if (ptr == NULL) {
  5783. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  5784. return;
  5785. }
  5786. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  5787. ptr += position;
  5788. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  5789. if (ptr0 == NULL) {
  5790. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  5791. return;
  5792. }
  5793. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  5794. ptr0 += position0;
  5795. const char* ptr1 = JavaCPP_getStringBytes(env, arg1);
  5796. jlong size1 = 0;
  5797. void* owner1 = (void*)ptr1;
  5798. StringAdapter adapter1(ptr1, size1, owner1);
  5799. jthrowable exc = NULL;
  5800. try {
  5801. ptr->run(*ptr0, (std::string&)adapter1);
  5802. } catch (...) {
  5803. exc = JavaCPP_handleException(env, 18);
  5804. }
  5805.  
  5806. JavaCPP_releaseStringBytes(env, arg1, ptr1);
  5807. if (exc != NULL) {
  5808. env->Throw(exc);
  5809. }
  5810. }
  5811. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRTesseract_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Ljava_lang_String_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Ljava_lang_String_2Ljava_nio_FloatBuffer_2I(JNIEnv* env, jobject obj, jobject arg0, jstring arg1, jobject arg2, jstring arg3, jobject arg4, jint arg5) {
  5812. ::cv::text::OCRTesseract* ptr = (::cv::text::OCRTesseract*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  5813. if (ptr == NULL) {
  5814. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  5815. return;
  5816. }
  5817. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  5818. ptr += position;
  5819. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  5820. if (ptr0 == NULL) {
  5821. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  5822. return;
  5823. }
  5824. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  5825. ptr0 += position0;
  5826. const char* ptr1 = JavaCPP_getStringBytes(env, arg1);
  5827. jlong size1 = 0;
  5828. void* owner1 = (void*)ptr1;
  5829. StringAdapter adapter1(ptr1, size1, owner1);
  5830. ::std::vector<cv::Rect>* ptr2 = arg2 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  5831. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  5832. ptr2 += position2;
  5833. const char* ptr3 = JavaCPP_getStringBytes(env, arg3);
  5834. jlong size3 = 0;
  5835. void* owner3 = (void*)ptr3;
  5836. VectorAdapter adapter3(ptr3, size3, owner3);
  5837. float* ptr4 = arg4 == NULL ? NULL : (float*)env->GetDirectBufferAddress(arg4);
  5838. jlong size4 = arg4 == NULL ? 0 : env->GetDirectBufferCapacity(arg4);
  5839. void* owner4 = (void*)ptr4;
  5840. jfloatArray arr4 = NULL;
  5841. if (arg4 != NULL && ptr4 == NULL) {
  5842. arr4 = (jfloatArray)env->CallObjectMethod(arg4, JavaCPP_arrayMID);
  5843. if (env->ExceptionOccurred() != NULL) {
  5844. env->ExceptionClear();
  5845. } else {
  5846. ptr4 = arr4 == NULL ? NULL : env->GetFloatArrayElements(arr4, NULL);
  5847. size4 = env->GetArrayLength(arr4);
  5848. }
  5849. }
  5850. VectorAdapter< float > adapter4(ptr4, size4, owner4);
  5851. jthrowable exc = NULL;
  5852. try {
  5853. ptr->run(*ptr0, (std::string&)adapter1, ptr2, (std::string&)adapter3, adapter4, arg5);
  5854. } catch (...) {
  5855. exc = JavaCPP_handleException(env, 18);
  5856. }
  5857.  
  5858. JavaCPP_releaseStringBytes(env, arg1, ptr1);
  5859. JavaCPP_releaseStringBytes(env, arg3, ptr3);
  5860. float* rptr4 = adapter4;
  5861. void* rowner4 = adapter4.owner;
  5862. if (rptr4 != ptr4) {
  5863. VectorAdapter< float >::deallocate(rowner4);
  5864. }
  5865. if (arr4 != NULL) env->ReleaseFloatArrayElements(arr4, (jfloat*)ptr4, 0);
  5866. if (exc != NULL) {
  5867. env->Throw(exc);
  5868. }
  5869. }
  5870. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRTesseract_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Ljava_lang_String_2(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jstring arg2) {
  5871. ::cv::text::OCRTesseract* ptr = (::cv::text::OCRTesseract*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  5872. if (ptr == NULL) {
  5873. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  5874. return;
  5875. }
  5876. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  5877. ptr += position;
  5878. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  5879. if (ptr0 == NULL) {
  5880. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  5881. return;
  5882. }
  5883. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  5884. ptr0 += position0;
  5885. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  5886. if (ptr1 == NULL) {
  5887. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  5888. return;
  5889. }
  5890. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  5891. ptr1 += position1;
  5892. const char* ptr2 = JavaCPP_getStringBytes(env, arg2);
  5893. jlong size2 = 0;
  5894. void* owner2 = (void*)ptr2;
  5895. StringAdapter adapter2(ptr2, size2, owner2);
  5896. jthrowable exc = NULL;
  5897. try {
  5898. ptr->run(*ptr0, *ptr1, (std::string&)adapter2);
  5899. } catch (...) {
  5900. exc = JavaCPP_handleException(env, 18);
  5901. }
  5902.  
  5903. JavaCPP_releaseStringBytes(env, arg2, ptr2);
  5904. if (exc != NULL) {
  5905. env->Throw(exc);
  5906. }
  5907. }
  5908. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRTesseract_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Ljava_lang_String_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Ljava_lang_String_2Ljava_nio_FloatBuffer_2I(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jstring arg2, jobject arg3, jstring arg4, jobject arg5, jint arg6) {
  5909. ::cv::text::OCRTesseract* ptr = (::cv::text::OCRTesseract*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  5910. if (ptr == NULL) {
  5911. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  5912. return;
  5913. }
  5914. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  5915. ptr += position;
  5916. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  5917. if (ptr0 == NULL) {
  5918. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  5919. return;
  5920. }
  5921. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  5922. ptr0 += position0;
  5923. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  5924. if (ptr1 == NULL) {
  5925. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  5926. return;
  5927. }
  5928. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  5929. ptr1 += position1;
  5930. const char* ptr2 = JavaCPP_getStringBytes(env, arg2);
  5931. jlong size2 = 0;
  5932. void* owner2 = (void*)ptr2;
  5933. StringAdapter adapter2(ptr2, size2, owner2);
  5934. ::std::vector<cv::Rect>* ptr3 = arg3 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  5935. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  5936. ptr3 += position3;
  5937. const char* ptr4 = JavaCPP_getStringBytes(env, arg4);
  5938. jlong size4 = 0;
  5939. void* owner4 = (void*)ptr4;
  5940. VectorAdapter adapter4(ptr4, size4, owner4);
  5941. float* ptr5 = arg5 == NULL ? NULL : (float*)env->GetDirectBufferAddress(arg5);
  5942. jlong size5 = arg5 == NULL ? 0 : env->GetDirectBufferCapacity(arg5);
  5943. void* owner5 = (void*)ptr5;
  5944. jfloatArray arr5 = NULL;
  5945. if (arg5 != NULL && ptr5 == NULL) {
  5946. arr5 = (jfloatArray)env->CallObjectMethod(arg5, JavaCPP_arrayMID);
  5947. if (env->ExceptionOccurred() != NULL) {
  5948. env->ExceptionClear();
  5949. } else {
  5950. ptr5 = arr5 == NULL ? NULL : env->GetFloatArrayElements(arr5, NULL);
  5951. size5 = env->GetArrayLength(arr5);
  5952. }
  5953. }
  5954. VectorAdapter< float > adapter5(ptr5, size5, owner5);
  5955. jthrowable exc = NULL;
  5956. try {
  5957. ptr->run(*ptr0, *ptr1, (std::string&)adapter2, ptr3, (std::string&)adapter4, adapter5, arg6);
  5958. } catch (...) {
  5959. exc = JavaCPP_handleException(env, 18);
  5960. }
  5961.  
  5962. JavaCPP_releaseStringBytes(env, arg2, ptr2);
  5963. JavaCPP_releaseStringBytes(env, arg4, ptr4);
  5964. float* rptr5 = adapter5;
  5965. void* rowner5 = adapter5.owner;
  5966. if (rptr5 != ptr5) {
  5967. VectorAdapter< float >::deallocate(rowner5);
  5968. }
  5969. if (arr5 != NULL) env->ReleaseFloatArrayElements(arr5, (jfloat*)ptr5, 0);
  5970. if (exc != NULL) {
  5971. env->Throw(exc);
  5972. }
  5973. }
  5974. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRTesseract_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_BytePointer_2(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jobject arg2) {
  5975. ::cv::text::OCRTesseract* ptr = (::cv::text::OCRTesseract*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  5976. if (ptr == NULL) {
  5977. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  5978. return;
  5979. }
  5980. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  5981. ptr += position;
  5982. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  5983. if (ptr0 == NULL) {
  5984. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  5985. return;
  5986. }
  5987. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  5988. ptr0 += position0;
  5989. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  5990. if (ptr1 == NULL) {
  5991. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  5992. return;
  5993. }
  5994. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  5995. ptr1 += position1;
  5996. signed char* ptr2 = arg2 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  5997. jlong size2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_limitFID);
  5998. void* owner2 = JavaCPP_getPointerOwner(env, arg2);
  5999. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  6000. ptr2 += position2;
  6001. size2 -= position2;
  6002. StringAdapter adapter2(ptr2, size2, owner2);
  6003. jthrowable exc = NULL;
  6004. try {
  6005. ptr->run(*ptr0, *ptr1, (std::string&)adapter2);
  6006. } catch (...) {
  6007. exc = JavaCPP_handleException(env, 18);
  6008. }
  6009.  
  6010. signed char* rptr2 = adapter2;
  6011. jlong rsize2 = (jlong)adapter2.size;
  6012. void* rowner2 = adapter2.owner;
  6013. if (rptr2 != ptr2) {
  6014. JavaCPP_initPointer(env, arg2, rptr2, rsize2, rowner2, &StringAdapter::deallocate);
  6015. } else {
  6016. env->SetLongField(arg2, JavaCPP_limitFID, rsize2 + position2);
  6017. }
  6018. if (exc != NULL) {
  6019. env->Throw(exc);
  6020. }
  6021. }
  6022. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRTesseract_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_FloatPointer_2I(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jobject arg2, jobject arg3, jobject arg4, jobject arg5, jint arg6) {
  6023. ::cv::text::OCRTesseract* ptr = (::cv::text::OCRTesseract*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  6024. if (ptr == NULL) {
  6025. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  6026. return;
  6027. }
  6028. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  6029. ptr += position;
  6030. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  6031. if (ptr0 == NULL) {
  6032. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  6033. return;
  6034. }
  6035. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  6036. ptr0 += position0;
  6037. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  6038. if (ptr1 == NULL) {
  6039. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  6040. return;
  6041. }
  6042. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  6043. ptr1 += position1;
  6044. signed char* ptr2 = arg2 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  6045. jlong size2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_limitFID);
  6046. void* owner2 = JavaCPP_getPointerOwner(env, arg2);
  6047. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  6048. ptr2 += position2;
  6049. size2 -= position2;
  6050. StringAdapter adapter2(ptr2, size2, owner2);
  6051. ::std::vector<cv::Rect>* ptr3 = arg3 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  6052. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  6053. ptr3 += position3;
  6054. signed char* ptr4 = arg4 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg4, JavaCPP_addressFID));
  6055. jlong size4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_limitFID);
  6056. void* owner4 = JavaCPP_getPointerOwner(env, arg4);
  6057. jlong position4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_positionFID);
  6058. ptr4 += position4;
  6059. size4 -= position4;
  6060. VectorAdapter adapter4(ptr4, size4, owner4);
  6061. float* ptr5 = arg5 == NULL ? NULL : (float*)jlong_to_ptr(env->GetLongField(arg5, JavaCPP_addressFID));
  6062. jlong size5 = arg5 == NULL ? 0 : env->GetLongField(arg5, JavaCPP_limitFID);
  6063. void* owner5 = JavaCPP_getPointerOwner(env, arg5);
  6064. jlong position5 = arg5 == NULL ? 0 : env->GetLongField(arg5, JavaCPP_positionFID);
  6065. ptr5 += position5;
  6066. size5 -= position5;
  6067. VectorAdapter< float > adapter5(ptr5, size5, owner5);
  6068. jthrowable exc = NULL;
  6069. try {
  6070. ptr->run(*ptr0, *ptr1, (std::string&)adapter2, ptr3, (std::string&)adapter4, adapter5, arg6);
  6071. } catch (...) {
  6072. exc = JavaCPP_handleException(env, 18);
  6073. }
  6074.  
  6075. signed char* rptr2 = adapter2;
  6076. jlong rsize2 = (jlong)adapter2.size;
  6077. void* rowner2 = adapter2.owner;
  6078. if (rptr2 != ptr2) {
  6079. JavaCPP_initPointer(env, arg2, rptr2, rsize2, rowner2, &StringAdapter::deallocate);
  6080. } else {
  6081. env->SetLongField(arg2, JavaCPP_limitFID, rsize2 + position2);
  6082. }
  6083. signed char* rptr4 = adapter4;
  6084. jlong rsize4 = (jlong)adapter4.size;
  6085. void* rowner4 = adapter4.owner;
  6086. if (rptr4 != ptr4) {
  6087. JavaCPP_initPointer(env, arg4, rptr4, rsize4, rowner4, &VectorAdapter::deallocate);
  6088. } else {
  6089. env->SetLongField(arg4, JavaCPP_limitFID, rsize4 + position4);
  6090. }
  6091. float* rptr5 = adapter5;
  6092. jlong rsize5 = (jlong)adapter5.size;
  6093. void* rowner5 = adapter5.owner;
  6094. if (rptr5 != ptr5) {
  6095. JavaCPP_initPointer(env, arg5, rptr5, rsize5, rowner5, &VectorAdapter< float >::deallocate);
  6096. } else {
  6097. env->SetLongField(arg5, JavaCPP_limitFID, rsize5 + position5);
  6098. }
  6099. if (exc != NULL) {
  6100. env->Throw(exc);
  6101. }
  6102. }
  6103. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRTesseract_create__Ljava_lang_String_2Ljava_lang_String_2Ljava_lang_String_2II(JNIEnv* env, jclass cls, jstring arg0, jstring arg1, jstring arg2, jint arg3, jint arg4) {
  6104. const char* ptr0 = JavaCPP_getStringBytes(env, arg0);
  6105. const char* ptr1 = JavaCPP_getStringBytes(env, arg1);
  6106. const char* ptr2 = JavaCPP_getStringBytes(env, arg2);
  6107. jobject rarg = NULL;
  6108. ::cv::text::OCRTesseract* rptr;
  6109. jthrowable exc = NULL;
  6110. try {
  6111. PtrAdapter< ::cv::text::OCRTesseract > radapter(::cv::text::OCRTesseract::create(ptr0, ptr1, ptr2, arg3, arg4));
  6112. rptr = radapter;
  6113. jlong rcapacity = (jlong)radapter.size;
  6114. void* rowner = radapter.owner;
  6115. void (*deallocator)(void*) = &PtrAdapter< ::cv::text::OCRTesseract >::deallocate;
  6116. if (rptr != NULL) {
  6117. rarg = JavaCPP_createPointer(env, 23);
  6118. if (rarg != NULL) {
  6119. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  6120. }
  6121. }
  6122. } catch (...) {
  6123. exc = JavaCPP_handleException(env, 18);
  6124. }
  6125.  
  6126. JavaCPP_releaseStringBytes(env, arg0, ptr0);
  6127. JavaCPP_releaseStringBytes(env, arg1, ptr1);
  6128. JavaCPP_releaseStringBytes(env, arg2, ptr2);
  6129. if (exc != NULL) {
  6130. env->Throw(exc);
  6131. }
  6132. return rarg;
  6133. }
  6134. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRTesseract_create__Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_BytePointer_2II(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jobject arg2, jint arg3, jint arg4) {
  6135. signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  6136. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  6137. ptr0 += position0;
  6138. signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  6139. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  6140. ptr1 += position1;
  6141. signed char* ptr2 = arg2 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  6142. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  6143. ptr2 += position2;
  6144. jobject rarg = NULL;
  6145. ::cv::text::OCRTesseract* rptr;
  6146. jthrowable exc = NULL;
  6147. try {
  6148. PtrAdapter< ::cv::text::OCRTesseract > radapter(::cv::text::OCRTesseract::create((const char*)ptr0, (const char*)ptr1, (const char*)ptr2, arg3, arg4));
  6149. rptr = radapter;
  6150. jlong rcapacity = (jlong)radapter.size;
  6151. void* rowner = radapter.owner;
  6152. void (*deallocator)(void*) = &PtrAdapter< ::cv::text::OCRTesseract >::deallocate;
  6153. if (rptr != NULL) {
  6154. rarg = JavaCPP_createPointer(env, 23);
  6155. if (rarg != NULL) {
  6156. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  6157. }
  6158. }
  6159. } catch (...) {
  6160. exc = JavaCPP_handleException(env, 18);
  6161. }
  6162.  
  6163. if (exc != NULL) {
  6164. env->Throw(exc);
  6165. }
  6166. return rarg;
  6167. }
  6168. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024OCRTesseract_create__(JNIEnv* env, jclass cls) {
  6169. jobject rarg = NULL;
  6170. ::cv::text::OCRTesseract* rptr;
  6171. jthrowable exc = NULL;
  6172. try {
  6173. PtrAdapter< ::cv::text::OCRTesseract > radapter(::cv::text::OCRTesseract::create());
  6174. rptr = radapter;
  6175. jlong rcapacity = (jlong)radapter.size;
  6176. void* rowner = radapter.owner;
  6177. void (*deallocator)(void*) = &PtrAdapter< ::cv::text::OCRTesseract >::deallocate;
  6178. if (rptr != NULL) {
  6179. rarg = JavaCPP_createPointer(env, 23);
  6180. if (rarg != NULL) {
  6181. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  6182. }
  6183. }
  6184. } catch (...) {
  6185. exc = JavaCPP_handleException(env, 18);
  6186. }
  6187.  
  6188. if (exc != NULL) {
  6189. env->Throw(exc);
  6190. }
  6191. return rarg;
  6192. }
  6193.  
  6194. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024BaseOCR_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Lorg_bytedeco_javacpp_BytePointer_2_3FI(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jobject arg2, jobject arg3, jobject arg4, jfloatArray arg5, jint arg6) {
  6195. ::cv::text::BaseOCR* ptr = (::cv::text::BaseOCR*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  6196. if (ptr == NULL) {
  6197. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  6198. return;
  6199. }
  6200. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  6201. ptr += position;
  6202. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  6203. if (ptr0 == NULL) {
  6204. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  6205. return;
  6206. }
  6207. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  6208. ptr0 += position0;
  6209. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  6210. if (ptr1 == NULL) {
  6211. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  6212. return;
  6213. }
  6214. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  6215. ptr1 += position1;
  6216. signed char* ptr2 = arg2 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  6217. jlong size2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_limitFID);
  6218. void* owner2 = JavaCPP_getPointerOwner(env, arg2);
  6219. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  6220. ptr2 += position2;
  6221. size2 -= position2;
  6222. StringAdapter adapter2(ptr2, size2, owner2);
  6223. ::std::vector<cv::Rect>* ptr3 = arg3 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  6224. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  6225. ptr3 += position3;
  6226. signed char* ptr4 = arg4 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg4, JavaCPP_addressFID));
  6227. jlong size4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_limitFID);
  6228. void* owner4 = JavaCPP_getPointerOwner(env, arg4);
  6229. jlong position4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_positionFID);
  6230. ptr4 += position4;
  6231. size4 -= position4;
  6232. VectorAdapter adapter4(ptr4, size4, owner4);
  6233. float* ptr5 = arg5 == NULL ? NULL : env->GetFloatArrayElements(arg5, NULL);
  6234. jlong size5 = arg5 == NULL ? 0 : env->GetArrayLength(arg5);
  6235. void* owner5 = (void*)ptr5;
  6236. VectorAdapter< float > adapter5(ptr5, size5, owner5);
  6237. jthrowable exc = NULL;
  6238. try {
  6239. ptr->run(*ptr0, *ptr1, (std::string&)adapter2, ptr3, (std::string&)adapter4, adapter5, arg6);
  6240. } catch (...) {
  6241. exc = JavaCPP_handleException(env, 18);
  6242. }
  6243.  
  6244. signed char* rptr2 = adapter2;
  6245. jlong rsize2 = (jlong)adapter2.size;
  6246. void* rowner2 = adapter2.owner;
  6247. if (rptr2 != ptr2) {
  6248. JavaCPP_initPointer(env, arg2, rptr2, rsize2, rowner2, &StringAdapter::deallocate);
  6249. } else {
  6250. env->SetLongField(arg2, JavaCPP_limitFID, rsize2 + position2);
  6251. }
  6252. signed char* rptr4 = adapter4;
  6253. jlong rsize4 = (jlong)adapter4.size;
  6254. void* rowner4 = adapter4.owner;
  6255. if (rptr4 != ptr4) {
  6256. JavaCPP_initPointer(env, arg4, rptr4, rsize4, rowner4, &VectorAdapter::deallocate);
  6257. } else {
  6258. env->SetLongField(arg4, JavaCPP_limitFID, rsize4 + position4);
  6259. }
  6260. float* rptr5 = adapter5;
  6261. void* rowner5 = adapter5.owner;
  6262. if (rptr5 != ptr5) {
  6263. VectorAdapter< float >::deallocate(rowner5);
  6264. }
  6265. if (arg5 != NULL) env->ReleaseFloatArrayElements(arg5, (jfloat*)ptr5, 0);
  6266. if (exc != NULL) {
  6267. env->Throw(exc);
  6268. }
  6269. }
  6270. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024BaseOCR_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Ljava_lang_String_2(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jstring arg2) {
  6271. ::cv::text::BaseOCR* ptr = (::cv::text::BaseOCR*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  6272. if (ptr == NULL) {
  6273. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  6274. return;
  6275. }
  6276. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  6277. ptr += position;
  6278. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  6279. if (ptr0 == NULL) {
  6280. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  6281. return;
  6282. }
  6283. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  6284. ptr0 += position0;
  6285. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  6286. if (ptr1 == NULL) {
  6287. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  6288. return;
  6289. }
  6290. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  6291. ptr1 += position1;
  6292. const char* ptr2 = JavaCPP_getStringBytes(env, arg2);
  6293. jlong size2 = 0;
  6294. void* owner2 = (void*)ptr2;
  6295. StringAdapter adapter2(ptr2, size2, owner2);
  6296. jthrowable exc = NULL;
  6297. try {
  6298. ptr->run(*ptr0, *ptr1, (std::string&)adapter2);
  6299. } catch (...) {
  6300. exc = JavaCPP_handleException(env, 18);
  6301. }
  6302.  
  6303. JavaCPP_releaseStringBytes(env, arg2, ptr2);
  6304. if (exc != NULL) {
  6305. env->Throw(exc);
  6306. }
  6307. }
  6308. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024BaseOCR_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Ljava_lang_String_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Ljava_lang_String_2Ljava_nio_FloatBuffer_2I(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jstring arg2, jobject arg3, jstring arg4, jobject arg5, jint arg6) {
  6309. ::cv::text::BaseOCR* ptr = (::cv::text::BaseOCR*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  6310. if (ptr == NULL) {
  6311. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  6312. return;
  6313. }
  6314. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  6315. ptr += position;
  6316. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  6317. if (ptr0 == NULL) {
  6318. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  6319. return;
  6320. }
  6321. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  6322. ptr0 += position0;
  6323. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  6324. if (ptr1 == NULL) {
  6325. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  6326. return;
  6327. }
  6328. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  6329. ptr1 += position1;
  6330. const char* ptr2 = JavaCPP_getStringBytes(env, arg2);
  6331. jlong size2 = 0;
  6332. void* owner2 = (void*)ptr2;
  6333. StringAdapter adapter2(ptr2, size2, owner2);
  6334. ::std::vector<cv::Rect>* ptr3 = arg3 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  6335. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  6336. ptr3 += position3;
  6337. const char* ptr4 = JavaCPP_getStringBytes(env, arg4);
  6338. jlong size4 = 0;
  6339. void* owner4 = (void*)ptr4;
  6340. VectorAdapter adapter4(ptr4, size4, owner4);
  6341. float* ptr5 = arg5 == NULL ? NULL : (float*)env->GetDirectBufferAddress(arg5);
  6342. jlong size5 = arg5 == NULL ? 0 : env->GetDirectBufferCapacity(arg5);
  6343. void* owner5 = (void*)ptr5;
  6344. jfloatArray arr5 = NULL;
  6345. if (arg5 != NULL && ptr5 == NULL) {
  6346. arr5 = (jfloatArray)env->CallObjectMethod(arg5, JavaCPP_arrayMID);
  6347. if (env->ExceptionOccurred() != NULL) {
  6348. env->ExceptionClear();
  6349. } else {
  6350. ptr5 = arr5 == NULL ? NULL : env->GetFloatArrayElements(arr5, NULL);
  6351. size5 = env->GetArrayLength(arr5);
  6352. }
  6353. }
  6354. VectorAdapter< float > adapter5(ptr5, size5, owner5);
  6355. jthrowable exc = NULL;
  6356. try {
  6357. ptr->run(*ptr0, *ptr1, (std::string&)adapter2, ptr3, (std::string&)adapter4, adapter5, arg6);
  6358. } catch (...) {
  6359. exc = JavaCPP_handleException(env, 18);
  6360. }
  6361.  
  6362. JavaCPP_releaseStringBytes(env, arg2, ptr2);
  6363. JavaCPP_releaseStringBytes(env, arg4, ptr4);
  6364. float* rptr5 = adapter5;
  6365. void* rowner5 = adapter5.owner;
  6366. if (rptr5 != ptr5) {
  6367. VectorAdapter< float >::deallocate(rowner5);
  6368. }
  6369. if (arr5 != NULL) env->ReleaseFloatArrayElements(arr5, (jfloat*)ptr5, 0);
  6370. if (exc != NULL) {
  6371. env->Throw(exc);
  6372. }
  6373. }
  6374. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024BaseOCR_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_BytePointer_2(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jobject arg2) {
  6375. ::cv::text::BaseOCR* ptr = (::cv::text::BaseOCR*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  6376. if (ptr == NULL) {
  6377. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  6378. return;
  6379. }
  6380. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  6381. ptr += position;
  6382. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  6383. if (ptr0 == NULL) {
  6384. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  6385. return;
  6386. }
  6387. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  6388. ptr0 += position0;
  6389. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  6390. if (ptr1 == NULL) {
  6391. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  6392. return;
  6393. }
  6394. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  6395. ptr1 += position1;
  6396. signed char* ptr2 = arg2 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  6397. jlong size2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_limitFID);
  6398. void* owner2 = JavaCPP_getPointerOwner(env, arg2);
  6399. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  6400. ptr2 += position2;
  6401. size2 -= position2;
  6402. StringAdapter adapter2(ptr2, size2, owner2);
  6403. jthrowable exc = NULL;
  6404. try {
  6405. ptr->run(*ptr0, *ptr1, (std::string&)adapter2);
  6406. } catch (...) {
  6407. exc = JavaCPP_handleException(env, 18);
  6408. }
  6409.  
  6410. signed char* rptr2 = adapter2;
  6411. jlong rsize2 = (jlong)adapter2.size;
  6412. void* rowner2 = adapter2.owner;
  6413. if (rptr2 != ptr2) {
  6414. JavaCPP_initPointer(env, arg2, rptr2, rsize2, rowner2, &StringAdapter::deallocate);
  6415. } else {
  6416. env->SetLongField(arg2, JavaCPP_limitFID, rsize2 + position2);
  6417. }
  6418. if (exc != NULL) {
  6419. env->Throw(exc);
  6420. }
  6421. }
  6422. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024BaseOCR_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_FloatPointer_2I(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jobject arg2, jobject arg3, jobject arg4, jobject arg5, jint arg6) {
  6423. ::cv::text::BaseOCR* ptr = (::cv::text::BaseOCR*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  6424. if (ptr == NULL) {
  6425. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  6426. return;
  6427. }
  6428. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  6429. ptr += position;
  6430. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  6431. if (ptr0 == NULL) {
  6432. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  6433. return;
  6434. }
  6435. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  6436. ptr0 += position0;
  6437. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  6438. if (ptr1 == NULL) {
  6439. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  6440. return;
  6441. }
  6442. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  6443. ptr1 += position1;
  6444. signed char* ptr2 = arg2 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  6445. jlong size2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_limitFID);
  6446. void* owner2 = JavaCPP_getPointerOwner(env, arg2);
  6447. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  6448. ptr2 += position2;
  6449. size2 -= position2;
  6450. StringAdapter adapter2(ptr2, size2, owner2);
  6451. ::std::vector<cv::Rect>* ptr3 = arg3 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  6452. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  6453. ptr3 += position3;
  6454. signed char* ptr4 = arg4 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg4, JavaCPP_addressFID));
  6455. jlong size4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_limitFID);
  6456. void* owner4 = JavaCPP_getPointerOwner(env, arg4);
  6457. jlong position4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_positionFID);
  6458. ptr4 += position4;
  6459. size4 -= position4;
  6460. VectorAdapter adapter4(ptr4, size4, owner4);
  6461. float* ptr5 = arg5 == NULL ? NULL : (float*)jlong_to_ptr(env->GetLongField(arg5, JavaCPP_addressFID));
  6462. jlong size5 = arg5 == NULL ? 0 : env->GetLongField(arg5, JavaCPP_limitFID);
  6463. void* owner5 = JavaCPP_getPointerOwner(env, arg5);
  6464. jlong position5 = arg5 == NULL ? 0 : env->GetLongField(arg5, JavaCPP_positionFID);
  6465. ptr5 += position5;
  6466. size5 -= position5;
  6467. VectorAdapter< float > adapter5(ptr5, size5, owner5);
  6468. jthrowable exc = NULL;
  6469. try {
  6470. ptr->run(*ptr0, *ptr1, (std::string&)adapter2, ptr3, (std::string&)adapter4, adapter5, arg6);
  6471. } catch (...) {
  6472. exc = JavaCPP_handleException(env, 18);
  6473. }
  6474.  
  6475. signed char* rptr2 = adapter2;
  6476. jlong rsize2 = (jlong)adapter2.size;
  6477. void* rowner2 = adapter2.owner;
  6478. if (rptr2 != ptr2) {
  6479. JavaCPP_initPointer(env, arg2, rptr2, rsize2, rowner2, &StringAdapter::deallocate);
  6480. } else {
  6481. env->SetLongField(arg2, JavaCPP_limitFID, rsize2 + position2);
  6482. }
  6483. signed char* rptr4 = adapter4;
  6484. jlong rsize4 = (jlong)adapter4.size;
  6485. void* rowner4 = adapter4.owner;
  6486. if (rptr4 != ptr4) {
  6487. JavaCPP_initPointer(env, arg4, rptr4, rsize4, rowner4, &VectorAdapter::deallocate);
  6488. } else {
  6489. env->SetLongField(arg4, JavaCPP_limitFID, rsize4 + position4);
  6490. }
  6491. float* rptr5 = adapter5;
  6492. jlong rsize5 = (jlong)adapter5.size;
  6493. void* rowner5 = adapter5.owner;
  6494. if (rptr5 != ptr5) {
  6495. JavaCPP_initPointer(env, arg5, rptr5, rsize5, rowner5, &VectorAdapter< float >::deallocate);
  6496. } else {
  6497. env->SetLongField(arg5, JavaCPP_limitFID, rsize5 + position5);
  6498. }
  6499. if (exc != NULL) {
  6500. env->Throw(exc);
  6501. }
  6502. }
  6503. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024BaseOCR_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Ljava_lang_String_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Ljava_lang_String_2_3FI(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jstring arg2, jobject arg3, jstring arg4, jfloatArray arg5, jint arg6) {
  6504. ::cv::text::BaseOCR* ptr = (::cv::text::BaseOCR*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  6505. if (ptr == NULL) {
  6506. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  6507. return;
  6508. }
  6509. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  6510. ptr += position;
  6511. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  6512. if (ptr0 == NULL) {
  6513. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  6514. return;
  6515. }
  6516. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  6517. ptr0 += position0;
  6518. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  6519. if (ptr1 == NULL) {
  6520. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  6521. return;
  6522. }
  6523. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  6524. ptr1 += position1;
  6525. const char* ptr2 = JavaCPP_getStringBytes(env, arg2);
  6526. jlong size2 = 0;
  6527. void* owner2 = (void*)ptr2;
  6528. StringAdapter adapter2(ptr2, size2, owner2);
  6529. ::std::vector<cv::Rect>* ptr3 = arg3 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  6530. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  6531. ptr3 += position3;
  6532. const char* ptr4 = JavaCPP_getStringBytes(env, arg4);
  6533. jlong size4 = 0;
  6534. void* owner4 = (void*)ptr4;
  6535. VectorAdapter adapter4(ptr4, size4, owner4);
  6536. float* ptr5 = arg5 == NULL ? NULL : env->GetFloatArrayElements(arg5, NULL);
  6537. jlong size5 = arg5 == NULL ? 0 : env->GetArrayLength(arg5);
  6538. void* owner5 = (void*)ptr5;
  6539. VectorAdapter< float > adapter5(ptr5, size5, owner5);
  6540. jthrowable exc = NULL;
  6541. try {
  6542. ptr->run(*ptr0, *ptr1, (std::string&)adapter2, ptr3, (std::string&)adapter4, adapter5, arg6);
  6543. } catch (...) {
  6544. exc = JavaCPP_handleException(env, 18);
  6545. }
  6546.  
  6547. JavaCPP_releaseStringBytes(env, arg2, ptr2);
  6548. JavaCPP_releaseStringBytes(env, arg4, ptr4);
  6549. float* rptr5 = adapter5;
  6550. void* rowner5 = adapter5.owner;
  6551. if (rptr5 != ptr5) {
  6552. VectorAdapter< float >::deallocate(rowner5);
  6553. }
  6554. if (arg5 != NULL) env->ReleaseFloatArrayElements(arg5, (jfloat*)ptr5, 0);
  6555. if (exc != NULL) {
  6556. env->Throw(exc);
  6557. }
  6558. }
  6559. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024BaseOCR_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Lorg_bytedeco_javacpp_BytePointer_2Ljava_nio_FloatBuffer_2I(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jobject arg2, jobject arg3, jobject arg4, jobject arg5, jint arg6) {
  6560. ::cv::text::BaseOCR* ptr = (::cv::text::BaseOCR*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  6561. if (ptr == NULL) {
  6562. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  6563. return;
  6564. }
  6565. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  6566. ptr += position;
  6567. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  6568. if (ptr0 == NULL) {
  6569. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  6570. return;
  6571. }
  6572. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  6573. ptr0 += position0;
  6574. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  6575. if (ptr1 == NULL) {
  6576. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  6577. return;
  6578. }
  6579. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  6580. ptr1 += position1;
  6581. signed char* ptr2 = arg2 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  6582. jlong size2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_limitFID);
  6583. void* owner2 = JavaCPP_getPointerOwner(env, arg2);
  6584. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  6585. ptr2 += position2;
  6586. size2 -= position2;
  6587. StringAdapter adapter2(ptr2, size2, owner2);
  6588. ::std::vector<cv::Rect>* ptr3 = arg3 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  6589. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  6590. ptr3 += position3;
  6591. signed char* ptr4 = arg4 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg4, JavaCPP_addressFID));
  6592. jlong size4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_limitFID);
  6593. void* owner4 = JavaCPP_getPointerOwner(env, arg4);
  6594. jlong position4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_positionFID);
  6595. ptr4 += position4;
  6596. size4 -= position4;
  6597. VectorAdapter adapter4(ptr4, size4, owner4);
  6598. float* ptr5 = arg5 == NULL ? NULL : (float*)env->GetDirectBufferAddress(arg5);
  6599. jlong size5 = arg5 == NULL ? 0 : env->GetDirectBufferCapacity(arg5);
  6600. void* owner5 = (void*)ptr5;
  6601. jfloatArray arr5 = NULL;
  6602. if (arg5 != NULL && ptr5 == NULL) {
  6603. arr5 = (jfloatArray)env->CallObjectMethod(arg5, JavaCPP_arrayMID);
  6604. if (env->ExceptionOccurred() != NULL) {
  6605. env->ExceptionClear();
  6606. } else {
  6607. ptr5 = arr5 == NULL ? NULL : env->GetFloatArrayElements(arr5, NULL);
  6608. size5 = env->GetArrayLength(arr5);
  6609. }
  6610. }
  6611. VectorAdapter< float > adapter5(ptr5, size5, owner5);
  6612. jthrowable exc = NULL;
  6613. try {
  6614. ptr->run(*ptr0, *ptr1, (std::string&)adapter2, ptr3, (std::string&)adapter4, adapter5, arg6);
  6615. } catch (...) {
  6616. exc = JavaCPP_handleException(env, 18);
  6617. }
  6618.  
  6619. signed char* rptr2 = adapter2;
  6620. jlong rsize2 = (jlong)adapter2.size;
  6621. void* rowner2 = adapter2.owner;
  6622. if (rptr2 != ptr2) {
  6623. JavaCPP_initPointer(env, arg2, rptr2, rsize2, rowner2, &StringAdapter::deallocate);
  6624. } else {
  6625. env->SetLongField(arg2, JavaCPP_limitFID, rsize2 + position2);
  6626. }
  6627. signed char* rptr4 = adapter4;
  6628. jlong rsize4 = (jlong)adapter4.size;
  6629. void* rowner4 = adapter4.owner;
  6630. if (rptr4 != ptr4) {
  6631. JavaCPP_initPointer(env, arg4, rptr4, rsize4, rowner4, &VectorAdapter::deallocate);
  6632. } else {
  6633. env->SetLongField(arg4, JavaCPP_limitFID, rsize4 + position4);
  6634. }
  6635. float* rptr5 = adapter5;
  6636. void* rowner5 = adapter5.owner;
  6637. if (rptr5 != ptr5) {
  6638. VectorAdapter< float >::deallocate(rowner5);
  6639. }
  6640. if (arr5 != NULL) env->ReleaseFloatArrayElements(arr5, (jfloat*)ptr5, 0);
  6641. if (exc != NULL) {
  6642. env->Throw(exc);
  6643. }
  6644. }
  6645. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024BaseOCR_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Ljava_lang_String_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Ljava_lang_String_2Lorg_bytedeco_javacpp_FloatPointer_2I(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jstring arg2, jobject arg3, jstring arg4, jobject arg5, jint arg6) {
  6646. ::cv::text::BaseOCR* ptr = (::cv::text::BaseOCR*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  6647. if (ptr == NULL) {
  6648. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  6649. return;
  6650. }
  6651. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  6652. ptr += position;
  6653. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  6654. if (ptr0 == NULL) {
  6655. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  6656. return;
  6657. }
  6658. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  6659. ptr0 += position0;
  6660. ::cv::Mat* ptr1 = arg1 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  6661. if (ptr1 == NULL) {
  6662. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  6663. return;
  6664. }
  6665. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  6666. ptr1 += position1;
  6667. const char* ptr2 = JavaCPP_getStringBytes(env, arg2);
  6668. jlong size2 = 0;
  6669. void* owner2 = (void*)ptr2;
  6670. StringAdapter adapter2(ptr2, size2, owner2);
  6671. ::std::vector<cv::Rect>* ptr3 = arg3 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  6672. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  6673. ptr3 += position3;
  6674. const char* ptr4 = JavaCPP_getStringBytes(env, arg4);
  6675. jlong size4 = 0;
  6676. void* owner4 = (void*)ptr4;
  6677. VectorAdapter adapter4(ptr4, size4, owner4);
  6678. float* ptr5 = arg5 == NULL ? NULL : (float*)jlong_to_ptr(env->GetLongField(arg5, JavaCPP_addressFID));
  6679. jlong size5 = arg5 == NULL ? 0 : env->GetLongField(arg5, JavaCPP_limitFID);
  6680. void* owner5 = JavaCPP_getPointerOwner(env, arg5);
  6681. jlong position5 = arg5 == NULL ? 0 : env->GetLongField(arg5, JavaCPP_positionFID);
  6682. ptr5 += position5;
  6683. size5 -= position5;
  6684. VectorAdapter< float > adapter5(ptr5, size5, owner5);
  6685. jthrowable exc = NULL;
  6686. try {
  6687. ptr->run(*ptr0, *ptr1, (std::string&)adapter2, ptr3, (std::string&)adapter4, adapter5, arg6);
  6688. } catch (...) {
  6689. exc = JavaCPP_handleException(env, 18);
  6690. }
  6691.  
  6692. JavaCPP_releaseStringBytes(env, arg2, ptr2);
  6693. JavaCPP_releaseStringBytes(env, arg4, ptr4);
  6694. float* rptr5 = adapter5;
  6695. jlong rsize5 = (jlong)adapter5.size;
  6696. void* rowner5 = adapter5.owner;
  6697. if (rptr5 != ptr5) {
  6698. JavaCPP_initPointer(env, arg5, rptr5, rsize5, rowner5, &VectorAdapter< float >::deallocate);
  6699. } else {
  6700. env->SetLongField(arg5, JavaCPP_limitFID, rsize5 + position5);
  6701. }
  6702. if (exc != NULL) {
  6703. env->Throw(exc);
  6704. }
  6705. }
  6706. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024BaseOCR_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Lorg_bytedeco_javacpp_BytePointer_2_3FI(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jobject arg2, jobject arg3, jfloatArray arg4, jint arg5) {
  6707. ::cv::text::BaseOCR* ptr = (::cv::text::BaseOCR*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  6708. if (ptr == NULL) {
  6709. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  6710. return;
  6711. }
  6712. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  6713. ptr += position;
  6714. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  6715. if (ptr0 == NULL) {
  6716. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  6717. return;
  6718. }
  6719. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  6720. ptr0 += position0;
  6721. signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  6722. jlong size1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_limitFID);
  6723. void* owner1 = JavaCPP_getPointerOwner(env, arg1);
  6724. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  6725. ptr1 += position1;
  6726. size1 -= position1;
  6727. StringAdapter adapter1(ptr1, size1, owner1);
  6728. ::std::vector<cv::Rect>* ptr2 = arg2 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  6729. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  6730. ptr2 += position2;
  6731. signed char* ptr3 = arg3 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  6732. jlong size3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_limitFID);
  6733. void* owner3 = JavaCPP_getPointerOwner(env, arg3);
  6734. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  6735. ptr3 += position3;
  6736. size3 -= position3;
  6737. VectorAdapter adapter3(ptr3, size3, owner3);
  6738. float* ptr4 = arg4 == NULL ? NULL : env->GetFloatArrayElements(arg4, NULL);
  6739. jlong size4 = arg4 == NULL ? 0 : env->GetArrayLength(arg4);
  6740. void* owner4 = (void*)ptr4;
  6741. VectorAdapter< float > adapter4(ptr4, size4, owner4);
  6742. jthrowable exc = NULL;
  6743. try {
  6744. ptr->run(*ptr0, (std::string&)adapter1, ptr2, (std::string&)adapter3, adapter4, arg5);
  6745. } catch (...) {
  6746. exc = JavaCPP_handleException(env, 18);
  6747. }
  6748.  
  6749. signed char* rptr1 = adapter1;
  6750. jlong rsize1 = (jlong)adapter1.size;
  6751. void* rowner1 = adapter1.owner;
  6752. if (rptr1 != ptr1) {
  6753. JavaCPP_initPointer(env, arg1, rptr1, rsize1, rowner1, &StringAdapter::deallocate);
  6754. } else {
  6755. env->SetLongField(arg1, JavaCPP_limitFID, rsize1 + position1);
  6756. }
  6757. signed char* rptr3 = adapter3;
  6758. jlong rsize3 = (jlong)adapter3.size;
  6759. void* rowner3 = adapter3.owner;
  6760. if (rptr3 != ptr3) {
  6761. JavaCPP_initPointer(env, arg3, rptr3, rsize3, rowner3, &VectorAdapter::deallocate);
  6762. } else {
  6763. env->SetLongField(arg3, JavaCPP_limitFID, rsize3 + position3);
  6764. }
  6765. float* rptr4 = adapter4;
  6766. void* rowner4 = adapter4.owner;
  6767. if (rptr4 != ptr4) {
  6768. VectorAdapter< float >::deallocate(rowner4);
  6769. }
  6770. if (arg4 != NULL) env->ReleaseFloatArrayElements(arg4, (jfloat*)ptr4, 0);
  6771. if (exc != NULL) {
  6772. env->Throw(exc);
  6773. }
  6774. }
  6775. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024BaseOCR_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Ljava_lang_String_2(JNIEnv* env, jobject obj, jobject arg0, jstring arg1) {
  6776. ::cv::text::BaseOCR* ptr = (::cv::text::BaseOCR*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  6777. if (ptr == NULL) {
  6778. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  6779. return;
  6780. }
  6781. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  6782. ptr += position;
  6783. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  6784. if (ptr0 == NULL) {
  6785. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  6786. return;
  6787. }
  6788. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  6789. ptr0 += position0;
  6790. const char* ptr1 = JavaCPP_getStringBytes(env, arg1);
  6791. jlong size1 = 0;
  6792. void* owner1 = (void*)ptr1;
  6793. StringAdapter adapter1(ptr1, size1, owner1);
  6794. jthrowable exc = NULL;
  6795. try {
  6796. ptr->run(*ptr0, (std::string&)adapter1);
  6797. } catch (...) {
  6798. exc = JavaCPP_handleException(env, 18);
  6799. }
  6800.  
  6801. JavaCPP_releaseStringBytes(env, arg1, ptr1);
  6802. if (exc != NULL) {
  6803. env->Throw(exc);
  6804. }
  6805. }
  6806. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024BaseOCR_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Ljava_lang_String_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Ljava_lang_String_2Ljava_nio_FloatBuffer_2I(JNIEnv* env, jobject obj, jobject arg0, jstring arg1, jobject arg2, jstring arg3, jobject arg4, jint arg5) {
  6807. ::cv::text::BaseOCR* ptr = (::cv::text::BaseOCR*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  6808. if (ptr == NULL) {
  6809. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  6810. return;
  6811. }
  6812. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  6813. ptr += position;
  6814. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  6815. if (ptr0 == NULL) {
  6816. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  6817. return;
  6818. }
  6819. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  6820. ptr0 += position0;
  6821. const char* ptr1 = JavaCPP_getStringBytes(env, arg1);
  6822. jlong size1 = 0;
  6823. void* owner1 = (void*)ptr1;
  6824. StringAdapter adapter1(ptr1, size1, owner1);
  6825. ::std::vector<cv::Rect>* ptr2 = arg2 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  6826. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  6827. ptr2 += position2;
  6828. const char* ptr3 = JavaCPP_getStringBytes(env, arg3);
  6829. jlong size3 = 0;
  6830. void* owner3 = (void*)ptr3;
  6831. VectorAdapter adapter3(ptr3, size3, owner3);
  6832. float* ptr4 = arg4 == NULL ? NULL : (float*)env->GetDirectBufferAddress(arg4);
  6833. jlong size4 = arg4 == NULL ? 0 : env->GetDirectBufferCapacity(arg4);
  6834. void* owner4 = (void*)ptr4;
  6835. jfloatArray arr4 = NULL;
  6836. if (arg4 != NULL && ptr4 == NULL) {
  6837. arr4 = (jfloatArray)env->CallObjectMethod(arg4, JavaCPP_arrayMID);
  6838. if (env->ExceptionOccurred() != NULL) {
  6839. env->ExceptionClear();
  6840. } else {
  6841. ptr4 = arr4 == NULL ? NULL : env->GetFloatArrayElements(arr4, NULL);
  6842. size4 = env->GetArrayLength(arr4);
  6843. }
  6844. }
  6845. VectorAdapter< float > adapter4(ptr4, size4, owner4);
  6846. jthrowable exc = NULL;
  6847. try {
  6848. ptr->run(*ptr0, (std::string&)adapter1, ptr2, (std::string&)adapter3, adapter4, arg5);
  6849. } catch (...) {
  6850. exc = JavaCPP_handleException(env, 18);
  6851. }
  6852.  
  6853. JavaCPP_releaseStringBytes(env, arg1, ptr1);
  6854. JavaCPP_releaseStringBytes(env, arg3, ptr3);
  6855. float* rptr4 = adapter4;
  6856. void* rowner4 = adapter4.owner;
  6857. if (rptr4 != ptr4) {
  6858. VectorAdapter< float >::deallocate(rowner4);
  6859. }
  6860. if (arr4 != NULL) env->ReleaseFloatArrayElements(arr4, (jfloat*)ptr4, 0);
  6861. if (exc != NULL) {
  6862. env->Throw(exc);
  6863. }
  6864. }
  6865. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024BaseOCR_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_BytePointer_2(JNIEnv* env, jobject obj, jobject arg0, jobject arg1) {
  6866. ::cv::text::BaseOCR* ptr = (::cv::text::BaseOCR*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  6867. if (ptr == NULL) {
  6868. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  6869. return;
  6870. }
  6871. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  6872. ptr += position;
  6873. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  6874. if (ptr0 == NULL) {
  6875. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  6876. return;
  6877. }
  6878. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  6879. ptr0 += position0;
  6880. signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  6881. jlong size1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_limitFID);
  6882. void* owner1 = JavaCPP_getPointerOwner(env, arg1);
  6883. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  6884. ptr1 += position1;
  6885. size1 -= position1;
  6886. StringAdapter adapter1(ptr1, size1, owner1);
  6887. jthrowable exc = NULL;
  6888. try {
  6889. ptr->run(*ptr0, (std::string&)adapter1);
  6890. } catch (...) {
  6891. exc = JavaCPP_handleException(env, 18);
  6892. }
  6893.  
  6894. signed char* rptr1 = adapter1;
  6895. jlong rsize1 = (jlong)adapter1.size;
  6896. void* rowner1 = adapter1.owner;
  6897. if (rptr1 != ptr1) {
  6898. JavaCPP_initPointer(env, arg1, rptr1, rsize1, rowner1, &StringAdapter::deallocate);
  6899. } else {
  6900. env->SetLongField(arg1, JavaCPP_limitFID, rsize1 + position1);
  6901. }
  6902. if (exc != NULL) {
  6903. env->Throw(exc);
  6904. }
  6905. }
  6906. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024BaseOCR_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_FloatPointer_2I(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jobject arg2, jobject arg3, jobject arg4, jint arg5) {
  6907. ::cv::text::BaseOCR* ptr = (::cv::text::BaseOCR*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  6908. if (ptr == NULL) {
  6909. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  6910. return;
  6911. }
  6912. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  6913. ptr += position;
  6914. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  6915. if (ptr0 == NULL) {
  6916. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  6917. return;
  6918. }
  6919. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  6920. ptr0 += position0;
  6921. signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  6922. jlong size1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_limitFID);
  6923. void* owner1 = JavaCPP_getPointerOwner(env, arg1);
  6924. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  6925. ptr1 += position1;
  6926. size1 -= position1;
  6927. StringAdapter adapter1(ptr1, size1, owner1);
  6928. ::std::vector<cv::Rect>* ptr2 = arg2 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  6929. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  6930. ptr2 += position2;
  6931. signed char* ptr3 = arg3 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  6932. jlong size3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_limitFID);
  6933. void* owner3 = JavaCPP_getPointerOwner(env, arg3);
  6934. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  6935. ptr3 += position3;
  6936. size3 -= position3;
  6937. VectorAdapter adapter3(ptr3, size3, owner3);
  6938. float* ptr4 = arg4 == NULL ? NULL : (float*)jlong_to_ptr(env->GetLongField(arg4, JavaCPP_addressFID));
  6939. jlong size4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_limitFID);
  6940. void* owner4 = JavaCPP_getPointerOwner(env, arg4);
  6941. jlong position4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_positionFID);
  6942. ptr4 += position4;
  6943. size4 -= position4;
  6944. VectorAdapter< float > adapter4(ptr4, size4, owner4);
  6945. jthrowable exc = NULL;
  6946. try {
  6947. ptr->run(*ptr0, (std::string&)adapter1, ptr2, (std::string&)adapter3, adapter4, arg5);
  6948. } catch (...) {
  6949. exc = JavaCPP_handleException(env, 18);
  6950. }
  6951.  
  6952. signed char* rptr1 = adapter1;
  6953. jlong rsize1 = (jlong)adapter1.size;
  6954. void* rowner1 = adapter1.owner;
  6955. if (rptr1 != ptr1) {
  6956. JavaCPP_initPointer(env, arg1, rptr1, rsize1, rowner1, &StringAdapter::deallocate);
  6957. } else {
  6958. env->SetLongField(arg1, JavaCPP_limitFID, rsize1 + position1);
  6959. }
  6960. signed char* rptr3 = adapter3;
  6961. jlong rsize3 = (jlong)adapter3.size;
  6962. void* rowner3 = adapter3.owner;
  6963. if (rptr3 != ptr3) {
  6964. JavaCPP_initPointer(env, arg3, rptr3, rsize3, rowner3, &VectorAdapter::deallocate);
  6965. } else {
  6966. env->SetLongField(arg3, JavaCPP_limitFID, rsize3 + position3);
  6967. }
  6968. float* rptr4 = adapter4;
  6969. jlong rsize4 = (jlong)adapter4.size;
  6970. void* rowner4 = adapter4.owner;
  6971. if (rptr4 != ptr4) {
  6972. JavaCPP_initPointer(env, arg4, rptr4, rsize4, rowner4, &VectorAdapter< float >::deallocate);
  6973. } else {
  6974. env->SetLongField(arg4, JavaCPP_limitFID, rsize4 + position4);
  6975. }
  6976. if (exc != NULL) {
  6977. env->Throw(exc);
  6978. }
  6979. }
  6980. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024BaseOCR_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Ljava_lang_String_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Ljava_lang_String_2_3FI(JNIEnv* env, jobject obj, jobject arg0, jstring arg1, jobject arg2, jstring arg3, jfloatArray arg4, jint arg5) {
  6981. ::cv::text::BaseOCR* ptr = (::cv::text::BaseOCR*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  6982. if (ptr == NULL) {
  6983. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  6984. return;
  6985. }
  6986. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  6987. ptr += position;
  6988. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  6989. if (ptr0 == NULL) {
  6990. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  6991. return;
  6992. }
  6993. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  6994. ptr0 += position0;
  6995. const char* ptr1 = JavaCPP_getStringBytes(env, arg1);
  6996. jlong size1 = 0;
  6997. void* owner1 = (void*)ptr1;
  6998. StringAdapter adapter1(ptr1, size1, owner1);
  6999. ::std::vector<cv::Rect>* ptr2 = arg2 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  7000. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  7001. ptr2 += position2;
  7002. const char* ptr3 = JavaCPP_getStringBytes(env, arg3);
  7003. jlong size3 = 0;
  7004. void* owner3 = (void*)ptr3;
  7005. VectorAdapter adapter3(ptr3, size3, owner3);
  7006. float* ptr4 = arg4 == NULL ? NULL : env->GetFloatArrayElements(arg4, NULL);
  7007. jlong size4 = arg4 == NULL ? 0 : env->GetArrayLength(arg4);
  7008. void* owner4 = (void*)ptr4;
  7009. VectorAdapter< float > adapter4(ptr4, size4, owner4);
  7010. jthrowable exc = NULL;
  7011. try {
  7012. ptr->run(*ptr0, (std::string&)adapter1, ptr2, (std::string&)adapter3, adapter4, arg5);
  7013. } catch (...) {
  7014. exc = JavaCPP_handleException(env, 18);
  7015. }
  7016.  
  7017. JavaCPP_releaseStringBytes(env, arg1, ptr1);
  7018. JavaCPP_releaseStringBytes(env, arg3, ptr3);
  7019. float* rptr4 = adapter4;
  7020. void* rowner4 = adapter4.owner;
  7021. if (rptr4 != ptr4) {
  7022. VectorAdapter< float >::deallocate(rowner4);
  7023. }
  7024. if (arg4 != NULL) env->ReleaseFloatArrayElements(arg4, (jfloat*)ptr4, 0);
  7025. if (exc != NULL) {
  7026. env->Throw(exc);
  7027. }
  7028. }
  7029. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024BaseOCR_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Lorg_bytedeco_javacpp_BytePointer_2Ljava_nio_FloatBuffer_2I(JNIEnv* env, jobject obj, jobject arg0, jobject arg1, jobject arg2, jobject arg3, jobject arg4, jint arg5) {
  7030. ::cv::text::BaseOCR* ptr = (::cv::text::BaseOCR*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7031. if (ptr == NULL) {
  7032. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7033. return;
  7034. }
  7035. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7036. ptr += position;
  7037. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  7038. if (ptr0 == NULL) {
  7039. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  7040. return;
  7041. }
  7042. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  7043. ptr0 += position0;
  7044. signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  7045. jlong size1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_limitFID);
  7046. void* owner1 = JavaCPP_getPointerOwner(env, arg1);
  7047. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  7048. ptr1 += position1;
  7049. size1 -= position1;
  7050. StringAdapter adapter1(ptr1, size1, owner1);
  7051. ::std::vector<cv::Rect>* ptr2 = arg2 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  7052. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  7053. ptr2 += position2;
  7054. signed char* ptr3 = arg3 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  7055. jlong size3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_limitFID);
  7056. void* owner3 = JavaCPP_getPointerOwner(env, arg3);
  7057. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  7058. ptr3 += position3;
  7059. size3 -= position3;
  7060. VectorAdapter adapter3(ptr3, size3, owner3);
  7061. float* ptr4 = arg4 == NULL ? NULL : (float*)env->GetDirectBufferAddress(arg4);
  7062. jlong size4 = arg4 == NULL ? 0 : env->GetDirectBufferCapacity(arg4);
  7063. void* owner4 = (void*)ptr4;
  7064. jfloatArray arr4 = NULL;
  7065. if (arg4 != NULL && ptr4 == NULL) {
  7066. arr4 = (jfloatArray)env->CallObjectMethod(arg4, JavaCPP_arrayMID);
  7067. if (env->ExceptionOccurred() != NULL) {
  7068. env->ExceptionClear();
  7069. } else {
  7070. ptr4 = arr4 == NULL ? NULL : env->GetFloatArrayElements(arr4, NULL);
  7071. size4 = env->GetArrayLength(arr4);
  7072. }
  7073. }
  7074. VectorAdapter< float > adapter4(ptr4, size4, owner4);
  7075. jthrowable exc = NULL;
  7076. try {
  7077. ptr->run(*ptr0, (std::string&)adapter1, ptr2, (std::string&)adapter3, adapter4, arg5);
  7078. } catch (...) {
  7079. exc = JavaCPP_handleException(env, 18);
  7080. }
  7081.  
  7082. signed char* rptr1 = adapter1;
  7083. jlong rsize1 = (jlong)adapter1.size;
  7084. void* rowner1 = adapter1.owner;
  7085. if (rptr1 != ptr1) {
  7086. JavaCPP_initPointer(env, arg1, rptr1, rsize1, rowner1, &StringAdapter::deallocate);
  7087. } else {
  7088. env->SetLongField(arg1, JavaCPP_limitFID, rsize1 + position1);
  7089. }
  7090. signed char* rptr3 = adapter3;
  7091. jlong rsize3 = (jlong)adapter3.size;
  7092. void* rowner3 = adapter3.owner;
  7093. if (rptr3 != ptr3) {
  7094. JavaCPP_initPointer(env, arg3, rptr3, rsize3, rowner3, &VectorAdapter::deallocate);
  7095. } else {
  7096. env->SetLongField(arg3, JavaCPP_limitFID, rsize3 + position3);
  7097. }
  7098. float* rptr4 = adapter4;
  7099. void* rowner4 = adapter4.owner;
  7100. if (rptr4 != ptr4) {
  7101. VectorAdapter< float >::deallocate(rowner4);
  7102. }
  7103. if (arr4 != NULL) env->ReleaseFloatArrayElements(arr4, (jfloat*)ptr4, 0);
  7104. if (exc != NULL) {
  7105. env->Throw(exc);
  7106. }
  7107. }
  7108. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024BaseOCR_run__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Ljava_lang_String_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2Ljava_lang_String_2Lorg_bytedeco_javacpp_FloatPointer_2I(JNIEnv* env, jobject obj, jobject arg0, jstring arg1, jobject arg2, jstring arg3, jobject arg4, jint arg5) {
  7109. ::cv::text::BaseOCR* ptr = (::cv::text::BaseOCR*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7110. if (ptr == NULL) {
  7111. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7112. return;
  7113. }
  7114. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7115. ptr += position;
  7116. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  7117. if (ptr0 == NULL) {
  7118. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  7119. return;
  7120. }
  7121. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  7122. ptr0 += position0;
  7123. const char* ptr1 = JavaCPP_getStringBytes(env, arg1);
  7124. jlong size1 = 0;
  7125. void* owner1 = (void*)ptr1;
  7126. StringAdapter adapter1(ptr1, size1, owner1);
  7127. ::std::vector<cv::Rect>* ptr2 = arg2 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  7128. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  7129. ptr2 += position2;
  7130. const char* ptr3 = JavaCPP_getStringBytes(env, arg3);
  7131. jlong size3 = 0;
  7132. void* owner3 = (void*)ptr3;
  7133. VectorAdapter adapter3(ptr3, size3, owner3);
  7134. float* ptr4 = arg4 == NULL ? NULL : (float*)jlong_to_ptr(env->GetLongField(arg4, JavaCPP_addressFID));
  7135. jlong size4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_limitFID);
  7136. void* owner4 = JavaCPP_getPointerOwner(env, arg4);
  7137. jlong position4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_positionFID);
  7138. ptr4 += position4;
  7139. size4 -= position4;
  7140. VectorAdapter< float > adapter4(ptr4, size4, owner4);
  7141. jthrowable exc = NULL;
  7142. try {
  7143. ptr->run(*ptr0, (std::string&)adapter1, ptr2, (std::string&)adapter3, adapter4, arg5);
  7144. } catch (...) {
  7145. exc = JavaCPP_handleException(env, 18);
  7146. }
  7147.  
  7148. JavaCPP_releaseStringBytes(env, arg1, ptr1);
  7149. JavaCPP_releaseStringBytes(env, arg3, ptr3);
  7150. float* rptr4 = adapter4;
  7151. jlong rsize4 = (jlong)adapter4.size;
  7152. void* rowner4 = adapter4.owner;
  7153. if (rptr4 != ptr4) {
  7154. JavaCPP_initPointer(env, arg4, rptr4, rsize4, rowner4, &VectorAdapter< float >::deallocate);
  7155. } else {
  7156. env->SetLongField(arg4, JavaCPP_limitFID, rsize4 + position4);
  7157. }
  7158. if (exc != NULL) {
  7159. env->Throw(exc);
  7160. }
  7161. }
  7162.  
  7163. JNIEXPORT jdouble JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERFilter_00024Callback_eval(JNIEnv* env, jobject obj, jobject arg0) {
  7164. ::cv::text::ERFilter::Callback* ptr = (::cv::text::ERFilter::Callback*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7165. if (ptr == NULL) {
  7166. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7167. return 0;
  7168. }
  7169. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7170. ptr += position;
  7171. ::cv::text::ERStat* ptr0 = arg0 == NULL ? NULL : (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  7172. if (ptr0 == NULL) {
  7173. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  7174. return 0;
  7175. }
  7176. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  7177. ptr0 += position0;
  7178. jdouble rarg = 0;
  7179. jthrowable exc = NULL;
  7180. try {
  7181. double rvalue = ptr->eval(*(const ::cv::text::ERStat*)ptr0);
  7182. rarg = (jdouble)rvalue;
  7183. } catch (...) {
  7184. exc = JavaCPP_handleException(env, 18);
  7185. }
  7186.  
  7187. if (exc != NULL) {
  7188. env->Throw(exc);
  7189. }
  7190. return rarg;
  7191. }
  7192.  
  7193. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERFilter_setCallback(JNIEnv* env, jobject obj, jobject arg0) {
  7194. ::cv::text::ERFilter* ptr = (::cv::text::ERFilter*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7195. if (ptr == NULL) {
  7196. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7197. return;
  7198. }
  7199. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7200. ptr += position;
  7201. ::cv::text::ERFilter::Callback* ptr0 = arg0 == NULL ? NULL : (::cv::text::ERFilter::Callback*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  7202. jlong size0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_limitFID);
  7203. void* owner0 = JavaCPP_getPointerOwner(env, arg0);
  7204. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  7205. ptr0 += position0;
  7206. size0 -= position0;
  7207. PtrAdapter< ::cv::text::ERFilter::Callback > adapter0(ptr0, size0, owner0);
  7208. jthrowable exc = NULL;
  7209. try {
  7210. ptr->setCallback((cv::Ptr< ::cv::text::ERFilter::Callback >)adapter0);
  7211. } catch (...) {
  7212. exc = JavaCPP_handleException(env, 18);
  7213. }
  7214.  
  7215. ::cv::text::ERFilter::Callback* rptr0 = adapter0;
  7216. jlong rsize0 = (jlong)adapter0.size;
  7217. void* rowner0 = adapter0.owner;
  7218. if (rptr0 != ptr0) {
  7219. JavaCPP_initPointer(env, arg0, rptr0, rsize0, rowner0, &PtrAdapter< ::cv::text::ERFilter::Callback >::deallocate);
  7220. } else {
  7221. env->SetLongField(arg0, JavaCPP_limitFID, rsize0 + position0);
  7222. }
  7223. if (exc != NULL) {
  7224. env->Throw(exc);
  7225. }
  7226. }
  7227. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERFilter_setMinProbability(JNIEnv* env, jobject obj, jfloat arg0) {
  7228. ::cv::text::ERFilter* ptr = (::cv::text::ERFilter*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7229. if (ptr == NULL) {
  7230. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7231. return;
  7232. }
  7233. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7234. ptr += position;
  7235. jthrowable exc = NULL;
  7236. try {
  7237. ptr->setMinProbability(arg0);
  7238. } catch (...) {
  7239. exc = JavaCPP_handleException(env, 18);
  7240. }
  7241.  
  7242. if (exc != NULL) {
  7243. env->Throw(exc);
  7244. }
  7245. }
  7246. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERFilter_setMinProbabilityDiff(JNIEnv* env, jobject obj, jfloat arg0) {
  7247. ::cv::text::ERFilter* ptr = (::cv::text::ERFilter*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7248. if (ptr == NULL) {
  7249. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7250. return;
  7251. }
  7252. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7253. ptr += position;
  7254. jthrowable exc = NULL;
  7255. try {
  7256. ptr->setMinProbabilityDiff(arg0);
  7257. } catch (...) {
  7258. exc = JavaCPP_handleException(env, 18);
  7259. }
  7260.  
  7261. if (exc != NULL) {
  7262. env->Throw(exc);
  7263. }
  7264. }
  7265. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERFilter_setNonMaxSuppression(JNIEnv* env, jobject obj, jboolean arg0) {
  7266. ::cv::text::ERFilter* ptr = (::cv::text::ERFilter*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7267. if (ptr == NULL) {
  7268. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7269. return;
  7270. }
  7271. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7272. ptr += position;
  7273. jthrowable exc = NULL;
  7274. try {
  7275. ptr->setNonMaxSuppression((bool)arg0);
  7276. } catch (...) {
  7277. exc = JavaCPP_handleException(env, 18);
  7278. }
  7279.  
  7280. if (exc != NULL) {
  7281. env->Throw(exc);
  7282. }
  7283. }
  7284. JNIEXPORT jint JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERFilter_getNumRejected(JNIEnv* env, jobject obj) {
  7285. ::cv::text::ERFilter* ptr = (::cv::text::ERFilter*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7286. if (ptr == NULL) {
  7287. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7288. return 0;
  7289. }
  7290. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7291. ptr += position;
  7292. jint rarg = 0;
  7293. jthrowable exc = NULL;
  7294. try {
  7295. int rvalue = ptr->getNumRejected();
  7296. rarg = (jint)rvalue;
  7297. } catch (...) {
  7298. exc = JavaCPP_handleException(env, 18);
  7299. }
  7300.  
  7301. if (exc != NULL) {
  7302. env->Throw(exc);
  7303. }
  7304. return rarg;
  7305. }
  7306. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERFilter_setThresholdDelta(JNIEnv* env, jobject obj, jint arg0) {
  7307. ::cv::text::ERFilter* ptr = (::cv::text::ERFilter*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7308. if (ptr == NULL) {
  7309. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7310. return;
  7311. }
  7312. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7313. ptr += position;
  7314. jthrowable exc = NULL;
  7315. try {
  7316. ptr->setThresholdDelta(arg0);
  7317. } catch (...) {
  7318. exc = JavaCPP_handleException(env, 18);
  7319. }
  7320.  
  7321. if (exc != NULL) {
  7322. env->Throw(exc);
  7323. }
  7324. }
  7325. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERFilter_setMinArea(JNIEnv* env, jobject obj, jfloat arg0) {
  7326. ::cv::text::ERFilter* ptr = (::cv::text::ERFilter*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7327. if (ptr == NULL) {
  7328. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7329. return;
  7330. }
  7331. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7332. ptr += position;
  7333. jthrowable exc = NULL;
  7334. try {
  7335. ptr->setMinArea(arg0);
  7336. } catch (...) {
  7337. exc = JavaCPP_handleException(env, 18);
  7338. }
  7339.  
  7340. if (exc != NULL) {
  7341. env->Throw(exc);
  7342. }
  7343. }
  7344. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERFilter_setMaxArea(JNIEnv* env, jobject obj, jfloat arg0) {
  7345. ::cv::text::ERFilter* ptr = (::cv::text::ERFilter*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7346. if (ptr == NULL) {
  7347. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7348. return;
  7349. }
  7350. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7351. ptr += position;
  7352. jthrowable exc = NULL;
  7353. try {
  7354. ptr->setMaxArea(arg0);
  7355. } catch (...) {
  7356. exc = JavaCPP_handleException(env, 18);
  7357. }
  7358.  
  7359. if (exc != NULL) {
  7360. env->Throw(exc);
  7361. }
  7362. }
  7363. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERFilter_run(JNIEnv* env, jobject obj, jobject arg0, jobject arg1) {
  7364. ::cv::text::ERFilter* ptr = (::cv::text::ERFilter*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7365. if (ptr == NULL) {
  7366. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7367. return;
  7368. }
  7369. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7370. ptr += position;
  7371. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  7372. if (ptr0 == NULL) {
  7373. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  7374. return;
  7375. }
  7376. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  7377. ptr0 += position0;
  7378. ::std::vector<cv::text::ERStat>* ptr1 = arg1 == NULL ? NULL : (::std::vector<cv::text::ERStat>*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  7379. if (ptr1 == NULL) {
  7380. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  7381. return;
  7382. }
  7383. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  7384. ptr1 += position1;
  7385. jthrowable exc = NULL;
  7386. try {
  7387. ptr->run(*ptr0, *ptr1);
  7388. } catch (...) {
  7389. exc = JavaCPP_handleException(env, 18);
  7390. }
  7391.  
  7392. if (exc != NULL) {
  7393. env->Throw(exc);
  7394. }
  7395. }
  7396.  
  7397. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_child__Lorg_bytedeco_javacpp_opencv_1text_00024ERStat_2(JNIEnv* env, jobject obj, jobject arg0) {
  7398. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7399. if (ptr == NULL) {
  7400. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7401. return 0;
  7402. }
  7403. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7404. ptr += position;
  7405. ::cv::text::ERStat* ptr0 = arg0 == NULL ? NULL : (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  7406. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  7407. ptr0 += position0;
  7408. jobject rarg = obj;
  7409. ptr->child = ptr0;
  7410. return rarg;
  7411. }
  7412. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_child__(JNIEnv* env, jobject obj) {
  7413. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7414. if (ptr == NULL) {
  7415. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7416. return 0;
  7417. }
  7418. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7419. ptr += position;
  7420. jobject rarg = NULL;
  7421. ::cv::text::ERStat* rptr;
  7422. rptr = ptr->child;
  7423. if (rptr == ptr) {
  7424. rarg = obj;
  7425. } else if (rptr != NULL) {
  7426. rarg = JavaCPP_createPointer(env, 24);
  7427. if (rarg != NULL) {
  7428. env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
  7429. }
  7430. }
  7431. return rarg;
  7432. }
  7433. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_level__I(JNIEnv* env, jobject obj, jint arg0) {
  7434. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7435. if (ptr == NULL) {
  7436. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7437. return 0;
  7438. }
  7439. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7440. ptr += position;
  7441. jobject rarg = obj;
  7442. ptr->level = arg0;
  7443. return rarg;
  7444. }
  7445. JNIEXPORT jint JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_level__(JNIEnv* env, jobject obj) {
  7446. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7447. if (ptr == NULL) {
  7448. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7449. return 0;
  7450. }
  7451. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7452. ptr += position;
  7453. jint rarg = 0;
  7454. int rvalue = ptr->level;
  7455. rarg = (jint)rvalue;
  7456. return rarg;
  7457. }
  7458. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_rect__(JNIEnv* env, jobject obj) {
  7459. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7460. if (ptr == NULL) {
  7461. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7462. return 0;
  7463. }
  7464. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7465. ptr += position;
  7466. jobject rarg = NULL;
  7467. ::cv::Rect_<int>* rptr;
  7468. rptr = &ptr->rect;
  7469. if (rptr != NULL) {
  7470. rarg = JavaCPP_createPointer(env, 25);
  7471. if (rarg != NULL) {
  7472. env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
  7473. }
  7474. }
  7475. return rarg;
  7476. }
  7477. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_rect__Lorg_bytedeco_javacpp_opencv_1core_00024Rect_2(JNIEnv* env, jobject obj, jobject arg0) {
  7478. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7479. if (ptr == NULL) {
  7480. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7481. return 0;
  7482. }
  7483. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7484. ptr += position;
  7485. ::cv::Rect_<int>* ptr0 = arg0 == NULL ? NULL : (::cv::Rect_<int>*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  7486. if (ptr0 == NULL) {
  7487. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  7488. return 0;
  7489. }
  7490. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  7491. ptr0 += position0;
  7492. jobject rarg = obj;
  7493. ptr->rect = *ptr0;
  7494. return rarg;
  7495. }
  7496. JNIEXPORT jint JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_area__(JNIEnv* env, jobject obj) {
  7497. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7498. if (ptr == NULL) {
  7499. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7500. return 0;
  7501. }
  7502. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7503. ptr += position;
  7504. jint rarg = 0;
  7505. int rvalue = ptr->area;
  7506. rarg = (jint)rvalue;
  7507. return rarg;
  7508. }
  7509. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_area__I(JNIEnv* env, jobject obj, jint arg0) {
  7510. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7511. if (ptr == NULL) {
  7512. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7513. return 0;
  7514. }
  7515. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7516. ptr += position;
  7517. jobject rarg = obj;
  7518. ptr->area = arg0;
  7519. return rarg;
  7520. }
  7521. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_allocateArray(JNIEnv* env, jobject obj, jlong arg0) {
  7522. jthrowable exc = NULL;
  7523. try {
  7524. ::cv::text::ERStat* rptr = new ::cv::text::ERStat[arg0];
  7525. jlong rcapacity = arg0;
  7526. JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_opencv_1text_00024ERStat_deallocateArray);
  7527. } catch (...) {
  7528. exc = JavaCPP_handleException(env, 18);
  7529. }
  7530.  
  7531. if (exc != NULL) {
  7532. env->Throw(exc);
  7533. }
  7534. }
  7535. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_med_1crossings__F(JNIEnv* env, jobject obj, jfloat arg0) {
  7536. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7537. if (ptr == NULL) {
  7538. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7539. return 0;
  7540. }
  7541. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7542. ptr += position;
  7543. jobject rarg = obj;
  7544. ptr->med_crossings = arg0;
  7545. return rarg;
  7546. }
  7547. JNIEXPORT jfloat JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_med_1crossings__(JNIEnv* env, jobject obj) {
  7548. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7549. if (ptr == NULL) {
  7550. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7551. return 0;
  7552. }
  7553. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7554. ptr += position;
  7555. jfloat rarg = 0;
  7556. float rvalue = ptr->med_crossings;
  7557. rarg = (jfloat)rvalue;
  7558. return rarg;
  7559. }
  7560. JNIEXPORT jfloat JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_hole_1area_1ratio__(JNIEnv* env, jobject obj) {
  7561. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7562. if (ptr == NULL) {
  7563. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7564. return 0;
  7565. }
  7566. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7567. ptr += position;
  7568. jfloat rarg = 0;
  7569. float rvalue = ptr->hole_area_ratio;
  7570. rarg = (jfloat)rvalue;
  7571. return rarg;
  7572. }
  7573. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_hole_1area_1ratio__F(JNIEnv* env, jobject obj, jfloat arg0) {
  7574. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7575. if (ptr == NULL) {
  7576. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7577. return 0;
  7578. }
  7579. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7580. ptr += position;
  7581. jobject rarg = obj;
  7582. ptr->hole_area_ratio = arg0;
  7583. return rarg;
  7584. }
  7585. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_num_1inflexion_1points__F(JNIEnv* env, jobject obj, jfloat arg0) {
  7586. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7587. if (ptr == NULL) {
  7588. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7589. return 0;
  7590. }
  7591. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7592. ptr += position;
  7593. jobject rarg = obj;
  7594. ptr->num_inflexion_points = arg0;
  7595. return rarg;
  7596. }
  7597. JNIEXPORT jfloat JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_num_1inflexion_1points__(JNIEnv* env, jobject obj) {
  7598. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7599. if (ptr == NULL) {
  7600. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7601. return 0;
  7602. }
  7603. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7604. ptr += position;
  7605. jfloat rarg = 0;
  7606. float rvalue = ptr->num_inflexion_points;
  7607. rarg = (jfloat)rvalue;
  7608. return rarg;
  7609. }
  7610. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_pixels__Lorg_bytedeco_javacpp_IntPointer_2(JNIEnv* env, jobject obj, jobject arg0) {
  7611. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7612. if (ptr == NULL) {
  7613. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7614. return 0;
  7615. }
  7616. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7617. ptr += position;
  7618. int* ptr0 = arg0 == NULL ? NULL : (int*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  7619. jlong size0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_limitFID);
  7620. void* owner0 = JavaCPP_getPointerOwner(env, arg0);
  7621. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  7622. ptr0 += position0;
  7623. size0 -= position0;
  7624. VectorAdapter< int > adapter0(ptr0, size0, owner0);
  7625. jobject rarg = obj;
  7626. ptr->pixels = adapter0;
  7627. return rarg;
  7628. }
  7629. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_pixels__(JNIEnv* env, jobject obj) {
  7630. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7631. if (ptr == NULL) {
  7632. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7633. return 0;
  7634. }
  7635. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7636. ptr += position;
  7637. jobject rarg = NULL;
  7638. int* rptr;
  7639. VectorAdapter< int > radapter(ptr->pixels);
  7640. rptr = radapter;
  7641. jlong rcapacity = (jlong)radapter.size;
  7642. void* rowner = radapter.owner;
  7643. void (*deallocator)(void*) = &VectorAdapter< int >::deallocate;
  7644. if (rptr != NULL) {
  7645. rarg = JavaCPP_createPointer(env, 3);
  7646. if (rarg != NULL) {
  7647. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  7648. }
  7649. }
  7650. return rarg;
  7651. }
  7652. JNIEXPORT jdouble JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_probability__(JNIEnv* env, jobject obj) {
  7653. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7654. if (ptr == NULL) {
  7655. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7656. return 0;
  7657. }
  7658. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7659. ptr += position;
  7660. jdouble rarg = 0;
  7661. double rvalue = ptr->probability;
  7662. rarg = (jdouble)rvalue;
  7663. return rarg;
  7664. }
  7665. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_probability__D(JNIEnv* env, jobject obj, jdouble arg0) {
  7666. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7667. if (ptr == NULL) {
  7668. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7669. return 0;
  7670. }
  7671. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7672. ptr += position;
  7673. jobject rarg = obj;
  7674. ptr->probability = arg0;
  7675. return rarg;
  7676. }
  7677. JNIEXPORT jboolean JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_local_1maxima__(JNIEnv* env, jobject obj) {
  7678. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7679. if (ptr == NULL) {
  7680. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7681. return 0;
  7682. }
  7683. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7684. ptr += position;
  7685. jboolean rarg = 0;
  7686. bool rvalue = (bool)ptr->local_maxima;
  7687. rarg = (jboolean)rvalue;
  7688. return rarg;
  7689. }
  7690. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_local_1maxima__Z(JNIEnv* env, jobject obj, jboolean arg0) {
  7691. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7692. if (ptr == NULL) {
  7693. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7694. return 0;
  7695. }
  7696. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7697. ptr += position;
  7698. jobject rarg = obj;
  7699. ptr->local_maxima = (bool)arg0;
  7700. return rarg;
  7701. }
  7702. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_max_1probability_1ancestor__(JNIEnv* env, jobject obj) {
  7703. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7704. if (ptr == NULL) {
  7705. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7706. return 0;
  7707. }
  7708. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7709. ptr += position;
  7710. jobject rarg = NULL;
  7711. ::cv::text::ERStat* rptr;
  7712. rptr = ptr->max_probability_ancestor;
  7713. if (rptr == ptr) {
  7714. rarg = obj;
  7715. } else if (rptr != NULL) {
  7716. rarg = JavaCPP_createPointer(env, 24);
  7717. if (rarg != NULL) {
  7718. env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
  7719. }
  7720. }
  7721. return rarg;
  7722. }
  7723. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_max_1probability_1ancestor__Lorg_bytedeco_javacpp_opencv_1text_00024ERStat_2(JNIEnv* env, jobject obj, jobject arg0) {
  7724. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7725. if (ptr == NULL) {
  7726. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7727. return 0;
  7728. }
  7729. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7730. ptr += position;
  7731. ::cv::text::ERStat* ptr0 = arg0 == NULL ? NULL : (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  7732. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  7733. ptr0 += position0;
  7734. jobject rarg = obj;
  7735. ptr->max_probability_ancestor = ptr0;
  7736. return rarg;
  7737. }
  7738. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_min_1probability_1ancestor__Lorg_bytedeco_javacpp_opencv_1text_00024ERStat_2(JNIEnv* env, jobject obj, jobject arg0) {
  7739. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7740. if (ptr == NULL) {
  7741. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7742. return 0;
  7743. }
  7744. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7745. ptr += position;
  7746. ::cv::text::ERStat* ptr0 = arg0 == NULL ? NULL : (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  7747. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  7748. ptr0 += position0;
  7749. jobject rarg = obj;
  7750. ptr->min_probability_ancestor = ptr0;
  7751. return rarg;
  7752. }
  7753. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_min_1probability_1ancestor__(JNIEnv* env, jobject obj) {
  7754. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7755. if (ptr == NULL) {
  7756. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7757. return 0;
  7758. }
  7759. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7760. ptr += position;
  7761. jobject rarg = NULL;
  7762. ::cv::text::ERStat* rptr;
  7763. rptr = ptr->min_probability_ancestor;
  7764. if (rptr == ptr) {
  7765. rarg = obj;
  7766. } else if (rptr != NULL) {
  7767. rarg = JavaCPP_createPointer(env, 24);
  7768. if (rarg != NULL) {
  7769. env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
  7770. }
  7771. }
  7772. return rarg;
  7773. }
  7774. JNIEXPORT jint JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_pixel__(JNIEnv* env, jobject obj) {
  7775. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7776. if (ptr == NULL) {
  7777. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7778. return 0;
  7779. }
  7780. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7781. ptr += position;
  7782. jint rarg = 0;
  7783. int rvalue = ptr->pixel;
  7784. rarg = (jint)rvalue;
  7785. return rarg;
  7786. }
  7787. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_pixel__I(JNIEnv* env, jobject obj, jint arg0) {
  7788. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7789. if (ptr == NULL) {
  7790. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7791. return 0;
  7792. }
  7793. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7794. ptr += position;
  7795. jobject rarg = obj;
  7796. ptr->pixel = arg0;
  7797. return rarg;
  7798. }
  7799. JNIEXPORT jint JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_perimeter__(JNIEnv* env, jobject obj) {
  7800. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7801. if (ptr == NULL) {
  7802. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7803. return 0;
  7804. }
  7805. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7806. ptr += position;
  7807. jint rarg = 0;
  7808. int rvalue = ptr->perimeter;
  7809. rarg = (jint)rvalue;
  7810. return rarg;
  7811. }
  7812. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_perimeter__I(JNIEnv* env, jobject obj, jint arg0) {
  7813. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7814. if (ptr == NULL) {
  7815. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7816. return 0;
  7817. }
  7818. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7819. ptr += position;
  7820. jobject rarg = obj;
  7821. ptr->perimeter = arg0;
  7822. return rarg;
  7823. }
  7824. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_euler__I(JNIEnv* env, jobject obj, jint arg0) {
  7825. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7826. if (ptr == NULL) {
  7827. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7828. return 0;
  7829. }
  7830. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7831. ptr += position;
  7832. jobject rarg = obj;
  7833. ptr->euler = arg0;
  7834. return rarg;
  7835. }
  7836. JNIEXPORT jint JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_euler__(JNIEnv* env, jobject obj) {
  7837. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7838. if (ptr == NULL) {
  7839. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7840. return 0;
  7841. }
  7842. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7843. ptr += position;
  7844. jint rarg = 0;
  7845. int rvalue = ptr->euler;
  7846. rarg = (jint)rvalue;
  7847. return rarg;
  7848. }
  7849. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_raw_1moments__(JNIEnv* env, jobject obj) {
  7850. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7851. if (ptr == NULL) {
  7852. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7853. return 0;
  7854. }
  7855. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7856. ptr += position;
  7857. jobject rarg = NULL;
  7858. double* rptr;
  7859. rptr = ptr->raw_moments;
  7860. if (rptr != NULL) {
  7861. rarg = JavaCPP_createPointer(env, 6);
  7862. if (rarg != NULL) {
  7863. env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
  7864. }
  7865. }
  7866. return rarg;
  7867. }
  7868. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_raw_1moments__ID(JNIEnv* env, jobject obj, jint arg0, jdouble arg1) {
  7869. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7870. if (ptr == NULL) {
  7871. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7872. return 0;
  7873. }
  7874. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7875. ptr += position;
  7876. jobject rarg = obj;
  7877. ptr->raw_moments[arg0] = arg1;
  7878. return rarg;
  7879. }
  7880. JNIEXPORT jdouble JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_raw_1moments__I(JNIEnv* env, jobject obj, jint arg0) {
  7881. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7882. if (ptr == NULL) {
  7883. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7884. return 0;
  7885. }
  7886. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7887. ptr += position;
  7888. jdouble rarg = 0;
  7889. double rvalue = ptr->raw_moments[arg0];
  7890. rarg = (jdouble)rvalue;
  7891. return rarg;
  7892. }
  7893. JNIEXPORT jdouble JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_central_1moments__I(JNIEnv* env, jobject obj, jint arg0) {
  7894. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7895. if (ptr == NULL) {
  7896. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7897. return 0;
  7898. }
  7899. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7900. ptr += position;
  7901. jdouble rarg = 0;
  7902. double rvalue = ptr->central_moments[arg0];
  7903. rarg = (jdouble)rvalue;
  7904. return rarg;
  7905. }
  7906. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_central_1moments__(JNIEnv* env, jobject obj) {
  7907. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7908. if (ptr == NULL) {
  7909. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7910. return 0;
  7911. }
  7912. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7913. ptr += position;
  7914. jobject rarg = NULL;
  7915. double* rptr;
  7916. rptr = ptr->central_moments;
  7917. if (rptr != NULL) {
  7918. rarg = JavaCPP_createPointer(env, 6);
  7919. if (rarg != NULL) {
  7920. env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
  7921. }
  7922. }
  7923. return rarg;
  7924. }
  7925. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_central_1moments__ID(JNIEnv* env, jobject obj, jint arg0, jdouble arg1) {
  7926. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7927. if (ptr == NULL) {
  7928. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7929. return 0;
  7930. }
  7931. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7932. ptr += position;
  7933. jobject rarg = obj;
  7934. ptr->central_moments[arg0] = arg1;
  7935. return rarg;
  7936. }
  7937. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_crossings__(JNIEnv* env, jobject obj) {
  7938. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7939. if (ptr == NULL) {
  7940. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7941. return 0;
  7942. }
  7943. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7944. ptr += position;
  7945. jobject rarg = NULL;
  7946. ::std::deque<int>* rptr;
  7947. rptr = ptr->crossings;
  7948. if (rptr != NULL) {
  7949. rarg = JavaCPP_createPointer(env, 26);
  7950. if (rarg != NULL) {
  7951. env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
  7952. }
  7953. }
  7954. return rarg;
  7955. }
  7956. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_crossings__Lorg_bytedeco_javacpp_opencv_1text_00024IntDeque_2(JNIEnv* env, jobject obj, jobject arg0) {
  7957. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7958. if (ptr == NULL) {
  7959. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7960. return 0;
  7961. }
  7962. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7963. ptr += position;
  7964. ::std::deque<int>* ptr0 = arg0 == NULL ? NULL : (::std::deque<int>*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  7965. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  7966. ptr0 += position0;
  7967. jobject rarg = obj;
  7968. ptr->crossings = ptr0;
  7969. return rarg;
  7970. }
  7971. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_convex_1hull_1ratio__F(JNIEnv* env, jobject obj, jfloat arg0) {
  7972. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7973. if (ptr == NULL) {
  7974. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7975. return 0;
  7976. }
  7977. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7978. ptr += position;
  7979. jobject rarg = obj;
  7980. ptr->convex_hull_ratio = arg0;
  7981. return rarg;
  7982. }
  7983. JNIEXPORT jfloat JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_convex_1hull_1ratio__(JNIEnv* env, jobject obj) {
  7984. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7985. if (ptr == NULL) {
  7986. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  7987. return 0;
  7988. }
  7989. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  7990. ptr += position;
  7991. jfloat rarg = 0;
  7992. float rvalue = ptr->convex_hull_ratio;
  7993. rarg = (jfloat)rvalue;
  7994. return rarg;
  7995. }
  7996. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_parent__Lorg_bytedeco_javacpp_opencv_1text_00024ERStat_2(JNIEnv* env, jobject obj, jobject arg0) {
  7997. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  7998. if (ptr == NULL) {
  7999. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  8000. return 0;
  8001. }
  8002. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  8003. ptr += position;
  8004. ::cv::text::ERStat* ptr0 = arg0 == NULL ? NULL : (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  8005. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  8006. ptr0 += position0;
  8007. jobject rarg = obj;
  8008. ptr->parent = ptr0;
  8009. return rarg;
  8010. }
  8011. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_parent__(JNIEnv* env, jobject obj) {
  8012. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  8013. if (ptr == NULL) {
  8014. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  8015. return 0;
  8016. }
  8017. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  8018. ptr += position;
  8019. jobject rarg = NULL;
  8020. ::cv::text::ERStat* rptr;
  8021. rptr = ptr->parent;
  8022. if (rptr == ptr) {
  8023. rarg = obj;
  8024. } else if (rptr != NULL) {
  8025. rarg = JavaCPP_createPointer(env, 24);
  8026. if (rarg != NULL) {
  8027. env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
  8028. }
  8029. }
  8030. return rarg;
  8031. }
  8032. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_next__Lorg_bytedeco_javacpp_opencv_1text_00024ERStat_2(JNIEnv* env, jobject obj, jobject arg0) {
  8033. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  8034. if (ptr == NULL) {
  8035. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  8036. return 0;
  8037. }
  8038. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  8039. ptr += position;
  8040. ::cv::text::ERStat* ptr0 = arg0 == NULL ? NULL : (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  8041. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  8042. ptr0 += position0;
  8043. jobject rarg = obj;
  8044. ptr->next = ptr0;
  8045. return rarg;
  8046. }
  8047. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_next__(JNIEnv* env, jobject obj) {
  8048. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  8049. if (ptr == NULL) {
  8050. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  8051. return 0;
  8052. }
  8053. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  8054. ptr += position;
  8055. jobject rarg = NULL;
  8056. ::cv::text::ERStat* rptr;
  8057. rptr = ptr->next;
  8058. if (rptr == ptr) {
  8059. rarg = obj;
  8060. } else if (rptr != NULL) {
  8061. rarg = JavaCPP_createPointer(env, 24);
  8062. if (rarg != NULL) {
  8063. env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
  8064. }
  8065. }
  8066. return rarg;
  8067. }
  8068. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_prev__(JNIEnv* env, jobject obj) {
  8069. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  8070. if (ptr == NULL) {
  8071. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  8072. return 0;
  8073. }
  8074. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  8075. ptr += position;
  8076. jobject rarg = NULL;
  8077. ::cv::text::ERStat* rptr;
  8078. rptr = ptr->prev;
  8079. if (rptr == ptr) {
  8080. rarg = obj;
  8081. } else if (rptr != NULL) {
  8082. rarg = JavaCPP_createPointer(env, 24);
  8083. if (rarg != NULL) {
  8084. env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
  8085. }
  8086. }
  8087. return rarg;
  8088. }
  8089. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_prev__Lorg_bytedeco_javacpp_opencv_1text_00024ERStat_2(JNIEnv* env, jobject obj, jobject arg0) {
  8090. ::cv::text::ERStat* ptr = (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  8091. if (ptr == NULL) {
  8092. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  8093. return 0;
  8094. }
  8095. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  8096. ptr += position;
  8097. ::cv::text::ERStat* ptr0 = arg0 == NULL ? NULL : (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  8098. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  8099. ptr0 += position0;
  8100. jobject rarg = obj;
  8101. ptr->prev = ptr0;
  8102. return rarg;
  8103. }
  8104. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_allocate__IIII(JNIEnv* env, jobject obj, jint arg0, jint arg1, jint arg2, jint arg3) {
  8105. jthrowable exc = NULL;
  8106. try {
  8107. ::cv::text::ERStat* rptr = new ::cv::text::ERStat(arg0, arg1, arg2, arg3);
  8108. jlong rcapacity = 1;
  8109. JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_opencv_1text_00024ERStat_deallocate);
  8110. } catch (...) {
  8111. exc = JavaCPP_handleException(env, 18);
  8112. }
  8113.  
  8114. if (exc != NULL) {
  8115. env->Throw(exc);
  8116. }
  8117. }
  8118. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStat_allocate__(JNIEnv* env, jobject obj) {
  8119. jthrowable exc = NULL;
  8120. try {
  8121. ::cv::text::ERStat* rptr = new ::cv::text::ERStat();
  8122. jlong rcapacity = 1;
  8123. JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_opencv_1text_00024ERStat_deallocate);
  8124. } catch (...) {
  8125. exc = JavaCPP_handleException(env, 18);
  8126. }
  8127.  
  8128. if (exc != NULL) {
  8129. env->Throw(exc);
  8130. }
  8131. }
  8132.  
  8133. JNIEXPORT jdouble JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024DoubleVector_get(JNIEnv* env, jobject obj, jlong arg0) {
  8134. ::std::vector<double>* ptr = (::std::vector<double>*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  8135. if (ptr == NULL) {
  8136. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  8137. return 0;
  8138. }
  8139. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  8140. ptr += position;
  8141. jdouble rarg = 0;
  8142. double rvalue = (*ptr)[(size_t)arg0];
  8143. rarg = (jdouble)rvalue;
  8144. return rarg;
  8145. }
  8146. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024DoubleVector_put__Lorg_bytedeco_javacpp_opencv_1text_00024DoubleVector_2(JNIEnv* env, jobject obj, jobject arg0) {
  8147. ::std::vector<double>* ptr = (::std::vector<double>*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  8148. if (ptr == NULL) {
  8149. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  8150. return 0;
  8151. }
  8152. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  8153. ptr += position;
  8154. ::std::vector<double>* ptr0 = arg0 == NULL ? NULL : (::std::vector<double>*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  8155. if (ptr0 == NULL) {
  8156. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  8157. return 0;
  8158. }
  8159. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  8160. ptr0 += position0;
  8161. jobject rarg = NULL;
  8162. ::std::vector<double>* rptr;
  8163. jthrowable exc = NULL;
  8164. try {
  8165. rptr = &((*ptr)=(*ptr0));
  8166. if (rptr == ptr) {
  8167. rarg = obj;
  8168. } else if (rptr != NULL) {
  8169. rarg = JavaCPP_createPointer(env, 27);
  8170. if (rarg != NULL) {
  8171. env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
  8172. }
  8173. }
  8174. } catch (...) {
  8175. exc = JavaCPP_handleException(env, 18);
  8176. }
  8177.  
  8178. if (exc != NULL) {
  8179. env->Throw(exc);
  8180. }
  8181. return rarg;
  8182. }
  8183. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024DoubleVector_put__JD(JNIEnv* env, jobject obj, jlong arg0, jdouble arg1) {
  8184. ::std::vector<double>* ptr = (::std::vector<double>*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  8185. if (ptr == NULL) {
  8186. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  8187. return 0;
  8188. }
  8189. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  8190. ptr += position;
  8191. jobject rarg = obj;
  8192. (*ptr)[(size_t)arg0] = arg1;
  8193. return rarg;
  8194. }
  8195. JNIEXPORT jlong JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024DoubleVector_size(JNIEnv* env, jobject obj) {
  8196. ::std::vector<double>* ptr = (::std::vector<double>*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  8197. if (ptr == NULL) {
  8198. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  8199. return 0;
  8200. }
  8201. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  8202. ptr += position;
  8203. jlong rarg = 0;
  8204. jthrowable exc = NULL;
  8205. try {
  8206. jlong rvalue = ptr->size();
  8207. rarg = (jlong)rvalue;
  8208. } catch (...) {
  8209. exc = JavaCPP_handleException(env, 18);
  8210. }
  8211.  
  8212. if (exc != NULL) {
  8213. env->Throw(exc);
  8214. }
  8215. return rarg;
  8216. }
  8217. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024DoubleVector_resize(JNIEnv* env, jobject obj, jlong arg0) {
  8218. ::std::vector<double>* ptr = (::std::vector<double>*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  8219. if (ptr == NULL) {
  8220. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  8221. return;
  8222. }
  8223. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  8224. ptr += position;
  8225. jthrowable exc = NULL;
  8226. try {
  8227. ptr->resize((size_t)arg0);
  8228. } catch (...) {
  8229. exc = JavaCPP_handleException(env, 18);
  8230. }
  8231.  
  8232. if (exc != NULL) {
  8233. env->Throw(exc);
  8234. }
  8235. }
  8236. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024DoubleVector_allocate__J(JNIEnv* env, jobject obj, jlong arg0) {
  8237. jthrowable exc = NULL;
  8238. try {
  8239. ::std::vector<double>* rptr = new ::std::vector<double>((size_t)arg0);
  8240. jlong rcapacity = 1;
  8241. JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_opencv_1text_00024DoubleVector_deallocate);
  8242. } catch (...) {
  8243. exc = JavaCPP_handleException(env, 18);
  8244. }
  8245.  
  8246. if (exc != NULL) {
  8247. env->Throw(exc);
  8248. }
  8249. }
  8250. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024DoubleVector_allocate__(JNIEnv* env, jobject obj) {
  8251. jthrowable exc = NULL;
  8252. try {
  8253. ::std::vector<double>* rptr = new ::std::vector<double>();
  8254. jlong rcapacity = 1;
  8255. JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_opencv_1text_00024DoubleVector_deallocate);
  8256. } catch (...) {
  8257. exc = JavaCPP_handleException(env, 18);
  8258. }
  8259.  
  8260. if (exc != NULL) {
  8261. env->Throw(exc);
  8262. }
  8263. }
  8264.  
  8265. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024Vec2iVector_get(JNIEnv* env, jobject obj, jlong arg0) {
  8266. ::std::vector<cv::Vec2i>* ptr = (::std::vector<cv::Vec2i>*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  8267. if (ptr == NULL) {
  8268. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  8269. return 0;
  8270. }
  8271. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  8272. ptr += position;
  8273. jobject rarg = NULL;
  8274. ::cv::Point_<int>* rptr;
  8275. rptr = &(*ptr)[(size_t)arg0];
  8276. if (rptr != NULL) {
  8277. rarg = JavaCPP_createPointer(env, 28);
  8278. if (rarg != NULL) {
  8279. env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
  8280. }
  8281. }
  8282. return rarg;
  8283. }
  8284. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024Vec2iVector_put__Lorg_bytedeco_javacpp_opencv_1text_00024Vec2iVector_2(JNIEnv* env, jobject obj, jobject arg0) {
  8285. ::std::vector<cv::Vec2i>* ptr = (::std::vector<cv::Vec2i>*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  8286. if (ptr == NULL) {
  8287. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  8288. return 0;
  8289. }
  8290. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  8291. ptr += position;
  8292. ::std::vector<cv::Vec2i>* ptr0 = arg0 == NULL ? NULL : (::std::vector<cv::Vec2i>*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  8293. if (ptr0 == NULL) {
  8294. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  8295. return 0;
  8296. }
  8297. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  8298. ptr0 += position0;
  8299. jobject rarg = NULL;
  8300. ::std::vector<cv::Vec2i>* rptr;
  8301. jthrowable exc = NULL;
  8302. try {
  8303. rptr = &((*ptr)=(*ptr0));
  8304. if (rptr == ptr) {
  8305. rarg = obj;
  8306. } else if (rptr != NULL) {
  8307. rarg = JavaCPP_createPointer(env, 29);
  8308. if (rarg != NULL) {
  8309. env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
  8310. }
  8311. }
  8312. } catch (...) {
  8313. exc = JavaCPP_handleException(env, 18);
  8314. }
  8315.  
  8316. if (exc != NULL) {
  8317. env->Throw(exc);
  8318. }
  8319. return rarg;
  8320. }
  8321. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024Vec2iVector_put__JLorg_bytedeco_javacpp_opencv_1core_00024Point_2(JNIEnv* env, jobject obj, jlong arg0, jobject arg1) {
  8322. ::std::vector<cv::Vec2i>* ptr = (::std::vector<cv::Vec2i>*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  8323. if (ptr == NULL) {
  8324. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  8325. return 0;
  8326. }
  8327. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  8328. ptr += position;
  8329. ::cv::Point_<int>* ptr1 = arg1 == NULL ? NULL : (::cv::Point_<int>*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  8330. if (ptr1 == NULL) {
  8331. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  8332. return 0;
  8333. }
  8334. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  8335. ptr1 += position1;
  8336. jobject rarg = obj;
  8337. (*ptr)[(size_t)arg0] = *ptr1;
  8338. return rarg;
  8339. }
  8340. JNIEXPORT jlong JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024Vec2iVector_size(JNIEnv* env, jobject obj) {
  8341. ::std::vector<cv::Vec2i>* ptr = (::std::vector<cv::Vec2i>*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  8342. if (ptr == NULL) {
  8343. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  8344. return 0;
  8345. }
  8346. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  8347. ptr += position;
  8348. jlong rarg = 0;
  8349. jthrowable exc = NULL;
  8350. try {
  8351. jlong rvalue = ptr->size();
  8352. rarg = (jlong)rvalue;
  8353. } catch (...) {
  8354. exc = JavaCPP_handleException(env, 18);
  8355. }
  8356.  
  8357. if (exc != NULL) {
  8358. env->Throw(exc);
  8359. }
  8360. return rarg;
  8361. }
  8362. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024Vec2iVector_resize(JNIEnv* env, jobject obj, jlong arg0) {
  8363. ::std::vector<cv::Vec2i>* ptr = (::std::vector<cv::Vec2i>*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  8364. if (ptr == NULL) {
  8365. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  8366. return;
  8367. }
  8368. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  8369. ptr += position;
  8370. jthrowable exc = NULL;
  8371. try {
  8372. ptr->resize((size_t)arg0);
  8373. } catch (...) {
  8374. exc = JavaCPP_handleException(env, 18);
  8375. }
  8376.  
  8377. if (exc != NULL) {
  8378. env->Throw(exc);
  8379. }
  8380. }
  8381. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024Vec2iVector_allocate__J(JNIEnv* env, jobject obj, jlong arg0) {
  8382. jthrowable exc = NULL;
  8383. try {
  8384. ::std::vector<cv::Vec2i>* rptr = new ::std::vector<cv::Vec2i>((size_t)arg0);
  8385. jlong rcapacity = 1;
  8386. JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_opencv_1text_00024Vec2iVector_deallocate);
  8387. } catch (...) {
  8388. exc = JavaCPP_handleException(env, 18);
  8389. }
  8390.  
  8391. if (exc != NULL) {
  8392. env->Throw(exc);
  8393. }
  8394. }
  8395. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024Vec2iVector_allocate__(JNIEnv* env, jobject obj) {
  8396. jthrowable exc = NULL;
  8397. try {
  8398. ::std::vector<cv::Vec2i>* rptr = new ::std::vector<cv::Vec2i>();
  8399. jlong rcapacity = 1;
  8400. JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_opencv_1text_00024Vec2iVector_deallocate);
  8401. } catch (...) {
  8402. exc = JavaCPP_handleException(env, 18);
  8403. }
  8404.  
  8405. if (exc != NULL) {
  8406. env->Throw(exc);
  8407. }
  8408. }
  8409.  
  8410. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStatVector_get(JNIEnv* env, jobject obj, jlong arg0) {
  8411. ::std::vector<cv::text::ERStat>* ptr = (::std::vector<cv::text::ERStat>*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  8412. if (ptr == NULL) {
  8413. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  8414. return 0;
  8415. }
  8416. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  8417. ptr += position;
  8418. jobject rarg = NULL;
  8419. ::cv::text::ERStat* rptr;
  8420. rptr = &(*ptr)[(size_t)arg0];
  8421. if (rptr != NULL) {
  8422. rarg = JavaCPP_createPointer(env, 24);
  8423. if (rarg != NULL) {
  8424. env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
  8425. }
  8426. }
  8427. return rarg;
  8428. }
  8429. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStatVector_put__Lorg_bytedeco_javacpp_opencv_1text_00024ERStatVector_2(JNIEnv* env, jobject obj, jobject arg0) {
  8430. ::std::vector<cv::text::ERStat>* ptr = (::std::vector<cv::text::ERStat>*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  8431. if (ptr == NULL) {
  8432. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  8433. return 0;
  8434. }
  8435. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  8436. ptr += position;
  8437. ::std::vector<cv::text::ERStat>* ptr0 = arg0 == NULL ? NULL : (::std::vector<cv::text::ERStat>*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  8438. if (ptr0 == NULL) {
  8439. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  8440. return 0;
  8441. }
  8442. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  8443. ptr0 += position0;
  8444. jobject rarg = NULL;
  8445. ::std::vector<cv::text::ERStat>* rptr;
  8446. jthrowable exc = NULL;
  8447. try {
  8448. rptr = &((*ptr)=(*ptr0));
  8449. if (rptr == ptr) {
  8450. rarg = obj;
  8451. } else if (rptr != NULL) {
  8452. rarg = JavaCPP_createPointer(env, 30);
  8453. if (rarg != NULL) {
  8454. env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
  8455. }
  8456. }
  8457. } catch (...) {
  8458. exc = JavaCPP_handleException(env, 18);
  8459. }
  8460.  
  8461. if (exc != NULL) {
  8462. env->Throw(exc);
  8463. }
  8464. return rarg;
  8465. }
  8466. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStatVector_put__JLorg_bytedeco_javacpp_opencv_1text_00024ERStat_2(JNIEnv* env, jobject obj, jlong arg0, jobject arg1) {
  8467. ::std::vector<cv::text::ERStat>* ptr = (::std::vector<cv::text::ERStat>*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  8468. if (ptr == NULL) {
  8469. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  8470. return 0;
  8471. }
  8472. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  8473. ptr += position;
  8474. ::cv::text::ERStat* ptr1 = arg1 == NULL ? NULL : (::cv::text::ERStat*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  8475. if (ptr1 == NULL) {
  8476. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  8477. return 0;
  8478. }
  8479. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  8480. ptr1 += position1;
  8481. jobject rarg = obj;
  8482. (*ptr)[(size_t)arg0] = *ptr1;
  8483. return rarg;
  8484. }
  8485. JNIEXPORT jlong JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStatVector_size(JNIEnv* env, jobject obj) {
  8486. ::std::vector<cv::text::ERStat>* ptr = (::std::vector<cv::text::ERStat>*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  8487. if (ptr == NULL) {
  8488. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  8489. return 0;
  8490. }
  8491. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  8492. ptr += position;
  8493. jlong rarg = 0;
  8494. jthrowable exc = NULL;
  8495. try {
  8496. jlong rvalue = ptr->size();
  8497. rarg = (jlong)rvalue;
  8498. } catch (...) {
  8499. exc = JavaCPP_handleException(env, 18);
  8500. }
  8501.  
  8502. if (exc != NULL) {
  8503. env->Throw(exc);
  8504. }
  8505. return rarg;
  8506. }
  8507. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStatVector_resize(JNIEnv* env, jobject obj, jlong arg0) {
  8508. ::std::vector<cv::text::ERStat>* ptr = (::std::vector<cv::text::ERStat>*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  8509. if (ptr == NULL) {
  8510. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  8511. return;
  8512. }
  8513. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  8514. ptr += position;
  8515. jthrowable exc = NULL;
  8516. try {
  8517. ptr->resize((size_t)arg0);
  8518. } catch (...) {
  8519. exc = JavaCPP_handleException(env, 18);
  8520. }
  8521.  
  8522. if (exc != NULL) {
  8523. env->Throw(exc);
  8524. }
  8525. }
  8526. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStatVector_allocate__J(JNIEnv* env, jobject obj, jlong arg0) {
  8527. jthrowable exc = NULL;
  8528. try {
  8529. ::std::vector<cv::text::ERStat>* rptr = new ::std::vector<cv::text::ERStat>((size_t)arg0);
  8530. jlong rcapacity = 1;
  8531. JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_opencv_1text_00024ERStatVector_deallocate);
  8532. } catch (...) {
  8533. exc = JavaCPP_handleException(env, 18);
  8534. }
  8535.  
  8536. if (exc != NULL) {
  8537. env->Throw(exc);
  8538. }
  8539. }
  8540. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024ERStatVector_allocate__(JNIEnv* env, jobject obj) {
  8541. jthrowable exc = NULL;
  8542. try {
  8543. ::std::vector<cv::text::ERStat>* rptr = new ::std::vector<cv::text::ERStat>();
  8544. jlong rcapacity = 1;
  8545. JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_opencv_1text_00024ERStatVector_deallocate);
  8546. } catch (...) {
  8547. exc = JavaCPP_handleException(env, 18);
  8548. }
  8549.  
  8550. if (exc != NULL) {
  8551. env->Throw(exc);
  8552. }
  8553. }
  8554.  
  8555. JNIEXPORT jint JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024IntVectorVector_get(JNIEnv* env, jobject obj, jlong arg0, jlong arg1) {
  8556. ::std::vector<std::vector<int> >* ptr = (::std::vector<std::vector<int> >*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  8557. if (ptr == NULL) {
  8558. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  8559. return 0;
  8560. }
  8561. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  8562. ptr += position;
  8563. jint rarg = 0;
  8564. int rvalue = (*ptr)[(size_t)arg0][(size_t)arg1];
  8565. rarg = (jint)rvalue;
  8566. return rarg;
  8567. }
  8568. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024IntVectorVector_put__JJI(JNIEnv* env, jobject obj, jlong arg0, jlong arg1, jint arg2) {
  8569. ::std::vector<std::vector<int> >* ptr = (::std::vector<std::vector<int> >*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  8570. if (ptr == NULL) {
  8571. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  8572. return 0;
  8573. }
  8574. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  8575. ptr += position;
  8576. jobject rarg = obj;
  8577. (*ptr)[(size_t)arg0][(size_t)arg1] = arg2;
  8578. return rarg;
  8579. }
  8580. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024IntVectorVector_put__Lorg_bytedeco_javacpp_opencv_1text_00024IntVectorVector_2(JNIEnv* env, jobject obj, jobject arg0) {
  8581. ::std::vector<std::vector<int> >* ptr = (::std::vector<std::vector<int> >*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  8582. if (ptr == NULL) {
  8583. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  8584. return 0;
  8585. }
  8586. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  8587. ptr += position;
  8588. ::std::vector<std::vector<int> >* ptr0 = arg0 == NULL ? NULL : (::std::vector<std::vector<int> >*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  8589. if (ptr0 == NULL) {
  8590. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  8591. return 0;
  8592. }
  8593. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  8594. ptr0 += position0;
  8595. jobject rarg = NULL;
  8596. ::std::vector<std::vector<int> >* rptr;
  8597. jthrowable exc = NULL;
  8598. try {
  8599. rptr = &((*ptr)=(*ptr0));
  8600. if (rptr == ptr) {
  8601. rarg = obj;
  8602. } else if (rptr != NULL) {
  8603. rarg = JavaCPP_createPointer(env, 31);
  8604. if (rarg != NULL) {
  8605. env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
  8606. }
  8607. }
  8608. } catch (...) {
  8609. exc = JavaCPP_handleException(env, 18);
  8610. }
  8611.  
  8612. if (exc != NULL) {
  8613. env->Throw(exc);
  8614. }
  8615. return rarg;
  8616. }
  8617. JNIEXPORT jlong JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024IntVectorVector_size__J(JNIEnv* env, jobject obj, jlong arg0) {
  8618. ::std::vector<std::vector<int> >* ptr = (::std::vector<std::vector<int> >*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  8619. if (ptr == NULL) {
  8620. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  8621. return 0;
  8622. }
  8623. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  8624. ptr += position;
  8625. jlong rarg = 0;
  8626. jthrowable exc = NULL;
  8627. try {
  8628. jlong rvalue = (*ptr)[(size_t)arg0].size();
  8629. rarg = (jlong)rvalue;
  8630. } catch (...) {
  8631. exc = JavaCPP_handleException(env, 18);
  8632. }
  8633.  
  8634. if (exc != NULL) {
  8635. env->Throw(exc);
  8636. }
  8637. return rarg;
  8638. }
  8639. JNIEXPORT jlong JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024IntVectorVector_size__(JNIEnv* env, jobject obj) {
  8640. ::std::vector<std::vector<int> >* ptr = (::std::vector<std::vector<int> >*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  8641. if (ptr == NULL) {
  8642. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  8643. return 0;
  8644. }
  8645. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  8646. ptr += position;
  8647. jlong rarg = 0;
  8648. jthrowable exc = NULL;
  8649. try {
  8650. jlong rvalue = ptr->size();
  8651. rarg = (jlong)rvalue;
  8652. } catch (...) {
  8653. exc = JavaCPP_handleException(env, 18);
  8654. }
  8655.  
  8656. if (exc != NULL) {
  8657. env->Throw(exc);
  8658. }
  8659. return rarg;
  8660. }
  8661. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024IntVectorVector_resize__JJ(JNIEnv* env, jobject obj, jlong arg0, jlong arg1) {
  8662. ::std::vector<std::vector<int> >* ptr = (::std::vector<std::vector<int> >*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  8663. if (ptr == NULL) {
  8664. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  8665. return;
  8666. }
  8667. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  8668. ptr += position;
  8669. jthrowable exc = NULL;
  8670. try {
  8671. (*ptr)[(size_t)arg0].resize((size_t)arg1);
  8672. } catch (...) {
  8673. exc = JavaCPP_handleException(env, 18);
  8674. }
  8675.  
  8676. if (exc != NULL) {
  8677. env->Throw(exc);
  8678. }
  8679. }
  8680. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024IntVectorVector_resize__J(JNIEnv* env, jobject obj, jlong arg0) {
  8681. ::std::vector<std::vector<int> >* ptr = (::std::vector<std::vector<int> >*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  8682. if (ptr == NULL) {
  8683. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  8684. return;
  8685. }
  8686. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  8687. ptr += position;
  8688. jthrowable exc = NULL;
  8689. try {
  8690. ptr->resize((size_t)arg0);
  8691. } catch (...) {
  8692. exc = JavaCPP_handleException(env, 18);
  8693. }
  8694.  
  8695. if (exc != NULL) {
  8696. env->Throw(exc);
  8697. }
  8698. }
  8699. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024IntVectorVector_allocate__J(JNIEnv* env, jobject obj, jlong arg0) {
  8700. jthrowable exc = NULL;
  8701. try {
  8702. ::std::vector<std::vector<int> >* rptr = new ::std::vector<std::vector<int> >((size_t)arg0);
  8703. jlong rcapacity = 1;
  8704. JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_opencv_1text_00024IntVectorVector_deallocate);
  8705. } catch (...) {
  8706. exc = JavaCPP_handleException(env, 18);
  8707. }
  8708.  
  8709. if (exc != NULL) {
  8710. env->Throw(exc);
  8711. }
  8712. }
  8713. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024IntVectorVector_allocate__(JNIEnv* env, jobject obj) {
  8714. jthrowable exc = NULL;
  8715. try {
  8716. ::std::vector<std::vector<int> >* rptr = new ::std::vector<std::vector<int> >();
  8717. jlong rcapacity = 1;
  8718. JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_opencv_1text_00024IntVectorVector_deallocate);
  8719. } catch (...) {
  8720. exc = JavaCPP_handleException(env, 18);
  8721. }
  8722.  
  8723. if (exc != NULL) {
  8724. env->Throw(exc);
  8725. }
  8726. }
  8727.  
  8728. JNIEXPORT jint JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024IntDeque_get(JNIEnv* env, jobject obj, jlong arg0) {
  8729. ::std::deque<int>* ptr = (::std::deque<int>*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  8730. if (ptr == NULL) {
  8731. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  8732. return 0;
  8733. }
  8734. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  8735. ptr += position;
  8736. jint rarg = 0;
  8737. int rvalue = (*ptr)[(size_t)arg0];
  8738. rarg = (jint)rvalue;
  8739. return rarg;
  8740. }
  8741. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024IntDeque_put__Lorg_bytedeco_javacpp_opencv_1text_00024IntDeque_2(JNIEnv* env, jobject obj, jobject arg0) {
  8742. ::std::deque<int>* ptr = (::std::deque<int>*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  8743. if (ptr == NULL) {
  8744. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  8745. return 0;
  8746. }
  8747. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  8748. ptr += position;
  8749. ::std::deque<int>* ptr0 = arg0 == NULL ? NULL : (::std::deque<int>*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  8750. if (ptr0 == NULL) {
  8751. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  8752. return 0;
  8753. }
  8754. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  8755. ptr0 += position0;
  8756. jobject rarg = NULL;
  8757. ::std::deque<int>* rptr;
  8758. jthrowable exc = NULL;
  8759. try {
  8760. rptr = &((*ptr)=(*ptr0));
  8761. if (rptr == ptr) {
  8762. rarg = obj;
  8763. } else if (rptr != NULL) {
  8764. rarg = JavaCPP_createPointer(env, 26);
  8765. if (rarg != NULL) {
  8766. env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
  8767. }
  8768. }
  8769. } catch (...) {
  8770. exc = JavaCPP_handleException(env, 18);
  8771. }
  8772.  
  8773. if (exc != NULL) {
  8774. env->Throw(exc);
  8775. }
  8776. return rarg;
  8777. }
  8778. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024IntDeque_put__JI(JNIEnv* env, jobject obj, jlong arg0, jint arg1) {
  8779. ::std::deque<int>* ptr = (::std::deque<int>*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  8780. if (ptr == NULL) {
  8781. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  8782. return 0;
  8783. }
  8784. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  8785. ptr += position;
  8786. jobject rarg = obj;
  8787. (*ptr)[(size_t)arg0] = arg1;
  8788. return rarg;
  8789. }
  8790. JNIEXPORT jlong JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024IntDeque_size(JNIEnv* env, jobject obj) {
  8791. ::std::deque<int>* ptr = (::std::deque<int>*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  8792. if (ptr == NULL) {
  8793. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  8794. return 0;
  8795. }
  8796. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  8797. ptr += position;
  8798. jlong rarg = 0;
  8799. jthrowable exc = NULL;
  8800. try {
  8801. jlong rvalue = ptr->size();
  8802. rarg = (jlong)rvalue;
  8803. } catch (...) {
  8804. exc = JavaCPP_handleException(env, 18);
  8805. }
  8806.  
  8807. if (exc != NULL) {
  8808. env->Throw(exc);
  8809. }
  8810. return rarg;
  8811. }
  8812. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024IntDeque_resize(JNIEnv* env, jobject obj, jlong arg0) {
  8813. ::std::deque<int>* ptr = (::std::deque<int>*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
  8814. if (ptr == NULL) {
  8815. env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL.");
  8816. return;
  8817. }
  8818. jlong position = env->GetLongField(obj, JavaCPP_positionFID);
  8819. ptr += position;
  8820. jthrowable exc = NULL;
  8821. try {
  8822. ptr->resize((size_t)arg0);
  8823. } catch (...) {
  8824. exc = JavaCPP_handleException(env, 18);
  8825. }
  8826.  
  8827. if (exc != NULL) {
  8828. env->Throw(exc);
  8829. }
  8830. }
  8831. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024IntDeque_allocate__J(JNIEnv* env, jobject obj, jlong arg0) {
  8832. jthrowable exc = NULL;
  8833. try {
  8834. ::std::deque<int>* rptr = new ::std::deque<int>((size_t)arg0);
  8835. jlong rcapacity = 1;
  8836. JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_opencv_1text_00024IntDeque_deallocate);
  8837. } catch (...) {
  8838. exc = JavaCPP_handleException(env, 18);
  8839. }
  8840.  
  8841. if (exc != NULL) {
  8842. env->Throw(exc);
  8843. }
  8844. }
  8845. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_00024IntDeque_allocate__(JNIEnv* env, jobject obj) {
  8846. jthrowable exc = NULL;
  8847. try {
  8848. ::std::deque<int>* rptr = new ::std::deque<int>();
  8849. jlong rcapacity = 1;
  8850. JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_opencv_1text_00024IntDeque_deallocate);
  8851. } catch (...) {
  8852. exc = JavaCPP_handleException(env, 18);
  8853. }
  8854.  
  8855. if (exc != NULL) {
  8856. env->Throw(exc);
  8857. }
  8858. }
  8859.  
  8860. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_createERFilterNM2__Lorg_bytedeco_javacpp_opencv_1text_00024ERFilter_00024Callback_2F(JNIEnv* env, jclass cls, jobject arg0, jfloat arg1) {
  8861. ::cv::text::ERFilter::Callback* ptr0 = arg0 == NULL ? NULL : (::cv::text::ERFilter::Callback*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  8862. jlong size0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_limitFID);
  8863. void* owner0 = JavaCPP_getPointerOwner(env, arg0);
  8864. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  8865. ptr0 += position0;
  8866. size0 -= position0;
  8867. PtrAdapter< ::cv::text::ERFilter::Callback > adapter0(ptr0, size0, owner0);
  8868. jobject rarg = NULL;
  8869. ::cv::text::ERFilter* rptr;
  8870. jthrowable exc = NULL;
  8871. try {
  8872. PtrAdapter< ::cv::text::ERFilter > radapter(cv::text::createERFilterNM2((cv::Ptr< ::cv::text::ERFilter::Callback >)adapter0, arg1));
  8873. rptr = radapter;
  8874. jlong rcapacity = (jlong)radapter.size;
  8875. void* rowner = radapter.owner;
  8876. void (*deallocator)(void*) = &PtrAdapter< ::cv::text::ERFilter >::deallocate;
  8877. if (rptr != NULL) {
  8878. rarg = JavaCPP_createPointer(env, 32);
  8879. if (rarg != NULL) {
  8880. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  8881. }
  8882. }
  8883. } catch (...) {
  8884. exc = JavaCPP_handleException(env, 18);
  8885. }
  8886.  
  8887. ::cv::text::ERFilter::Callback* rptr0 = adapter0;
  8888. jlong rsize0 = (jlong)adapter0.size;
  8889. void* rowner0 = adapter0.owner;
  8890. if (rptr0 != ptr0) {
  8891. JavaCPP_initPointer(env, arg0, rptr0, rsize0, rowner0, &PtrAdapter< ::cv::text::ERFilter::Callback >::deallocate);
  8892. } else {
  8893. env->SetLongField(arg0, JavaCPP_limitFID, rsize0 + position0);
  8894. }
  8895. if (exc != NULL) {
  8896. env->Throw(exc);
  8897. }
  8898. return rarg;
  8899. }
  8900. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_createERFilterNM2__Lorg_bytedeco_javacpp_opencv_1text_00024ERFilter_00024Callback_2(JNIEnv* env, jclass cls, jobject arg0) {
  8901. ::cv::text::ERFilter::Callback* ptr0 = arg0 == NULL ? NULL : (::cv::text::ERFilter::Callback*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  8902. jlong size0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_limitFID);
  8903. void* owner0 = JavaCPP_getPointerOwner(env, arg0);
  8904. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  8905. ptr0 += position0;
  8906. size0 -= position0;
  8907. PtrAdapter< ::cv::text::ERFilter::Callback > adapter0(ptr0, size0, owner0);
  8908. jobject rarg = NULL;
  8909. ::cv::text::ERFilter* rptr;
  8910. jthrowable exc = NULL;
  8911. try {
  8912. PtrAdapter< ::cv::text::ERFilter > radapter(cv::text::createERFilterNM2((cv::Ptr< ::cv::text::ERFilter::Callback >)adapter0));
  8913. rptr = radapter;
  8914. jlong rcapacity = (jlong)radapter.size;
  8915. void* rowner = radapter.owner;
  8916. void (*deallocator)(void*) = &PtrAdapter< ::cv::text::ERFilter >::deallocate;
  8917. if (rptr != NULL) {
  8918. rarg = JavaCPP_createPointer(env, 32);
  8919. if (rarg != NULL) {
  8920. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  8921. }
  8922. }
  8923. } catch (...) {
  8924. exc = JavaCPP_handleException(env, 18);
  8925. }
  8926.  
  8927. ::cv::text::ERFilter::Callback* rptr0 = adapter0;
  8928. jlong rsize0 = (jlong)adapter0.size;
  8929. void* rowner0 = adapter0.owner;
  8930. if (rptr0 != ptr0) {
  8931. JavaCPP_initPointer(env, arg0, rptr0, rsize0, rowner0, &PtrAdapter< ::cv::text::ERFilter::Callback >::deallocate);
  8932. } else {
  8933. env->SetLongField(arg0, JavaCPP_limitFID, rsize0 + position0);
  8934. }
  8935. if (exc != NULL) {
  8936. env->Throw(exc);
  8937. }
  8938. return rarg;
  8939. }
  8940. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_loadClassifierNM1__Lorg_bytedeco_javacpp_BytePointer_2(JNIEnv* env, jclass cls, jobject arg0) {
  8941. signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  8942. jlong size0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_limitFID);
  8943. void* owner0 = JavaCPP_getPointerOwner(env, arg0);
  8944. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  8945. ptr0 += position0;
  8946. size0 -= position0;
  8947. StringAdapter adapter0(ptr0, size0, owner0);
  8948. jobject rarg = NULL;
  8949. ::cv::text::ERFilter::Callback* rptr;
  8950. jthrowable exc = NULL;
  8951. try {
  8952. PtrAdapter< ::cv::text::ERFilter::Callback > radapter(cv::text::loadClassifierNM1((std::string&)adapter0));
  8953. rptr = radapter;
  8954. jlong rcapacity = (jlong)radapter.size;
  8955. void* rowner = radapter.owner;
  8956. void (*deallocator)(void*) = &PtrAdapter< ::cv::text::ERFilter::Callback >::deallocate;
  8957. if (rptr != NULL) {
  8958. rarg = JavaCPP_createPointer(env, 33);
  8959. if (rarg != NULL) {
  8960. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  8961. }
  8962. }
  8963. } catch (...) {
  8964. exc = JavaCPP_handleException(env, 18);
  8965. }
  8966.  
  8967. signed char* rptr0 = adapter0;
  8968. jlong rsize0 = (jlong)adapter0.size;
  8969. void* rowner0 = adapter0.owner;
  8970. if (rptr0 != ptr0) {
  8971. JavaCPP_initPointer(env, arg0, rptr0, rsize0, rowner0, &StringAdapter::deallocate);
  8972. } else {
  8973. env->SetLongField(arg0, JavaCPP_limitFID, rsize0 + position0);
  8974. }
  8975. if (exc != NULL) {
  8976. env->Throw(exc);
  8977. }
  8978. return rarg;
  8979. }
  8980. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_loadClassifierNM1__Ljava_lang_String_2(JNIEnv* env, jclass cls, jstring arg0) {
  8981. const char* ptr0 = JavaCPP_getStringBytes(env, arg0);
  8982. jlong size0 = 0;
  8983. void* owner0 = (void*)ptr0;
  8984. StringAdapter adapter0(ptr0, size0, owner0);
  8985. jobject rarg = NULL;
  8986. ::cv::text::ERFilter::Callback* rptr;
  8987. jthrowable exc = NULL;
  8988. try {
  8989. PtrAdapter< ::cv::text::ERFilter::Callback > radapter(cv::text::loadClassifierNM1((std::string&)adapter0));
  8990. rptr = radapter;
  8991. jlong rcapacity = (jlong)radapter.size;
  8992. void* rowner = radapter.owner;
  8993. void (*deallocator)(void*) = &PtrAdapter< ::cv::text::ERFilter::Callback >::deallocate;
  8994. if (rptr != NULL) {
  8995. rarg = JavaCPP_createPointer(env, 33);
  8996. if (rarg != NULL) {
  8997. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  8998. }
  8999. }
  9000. } catch (...) {
  9001. exc = JavaCPP_handleException(env, 18);
  9002. }
  9003.  
  9004. JavaCPP_releaseStringBytes(env, arg0, ptr0);
  9005. if (exc != NULL) {
  9006. env->Throw(exc);
  9007. }
  9008. return rarg;
  9009. }
  9010. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_loadClassifierNM2__Lorg_bytedeco_javacpp_BytePointer_2(JNIEnv* env, jclass cls, jobject arg0) {
  9011. signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  9012. jlong size0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_limitFID);
  9013. void* owner0 = JavaCPP_getPointerOwner(env, arg0);
  9014. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  9015. ptr0 += position0;
  9016. size0 -= position0;
  9017. StringAdapter adapter0(ptr0, size0, owner0);
  9018. jobject rarg = NULL;
  9019. ::cv::text::ERFilter::Callback* rptr;
  9020. jthrowable exc = NULL;
  9021. try {
  9022. PtrAdapter< ::cv::text::ERFilter::Callback > radapter(cv::text::loadClassifierNM2((std::string&)adapter0));
  9023. rptr = radapter;
  9024. jlong rcapacity = (jlong)radapter.size;
  9025. void* rowner = radapter.owner;
  9026. void (*deallocator)(void*) = &PtrAdapter< ::cv::text::ERFilter::Callback >::deallocate;
  9027. if (rptr != NULL) {
  9028. rarg = JavaCPP_createPointer(env, 33);
  9029. if (rarg != NULL) {
  9030. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  9031. }
  9032. }
  9033. } catch (...) {
  9034. exc = JavaCPP_handleException(env, 18);
  9035. }
  9036.  
  9037. signed char* rptr0 = adapter0;
  9038. jlong rsize0 = (jlong)adapter0.size;
  9039. void* rowner0 = adapter0.owner;
  9040. if (rptr0 != ptr0) {
  9041. JavaCPP_initPointer(env, arg0, rptr0, rsize0, rowner0, &StringAdapter::deallocate);
  9042. } else {
  9043. env->SetLongField(arg0, JavaCPP_limitFID, rsize0 + position0);
  9044. }
  9045. if (exc != NULL) {
  9046. env->Throw(exc);
  9047. }
  9048. return rarg;
  9049. }
  9050. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_loadClassifierNM2__Ljava_lang_String_2(JNIEnv* env, jclass cls, jstring arg0) {
  9051. const char* ptr0 = JavaCPP_getStringBytes(env, arg0);
  9052. jlong size0 = 0;
  9053. void* owner0 = (void*)ptr0;
  9054. StringAdapter adapter0(ptr0, size0, owner0);
  9055. jobject rarg = NULL;
  9056. ::cv::text::ERFilter::Callback* rptr;
  9057. jthrowable exc = NULL;
  9058. try {
  9059. PtrAdapter< ::cv::text::ERFilter::Callback > radapter(cv::text::loadClassifierNM2((std::string&)adapter0));
  9060. rptr = radapter;
  9061. jlong rcapacity = (jlong)radapter.size;
  9062. void* rowner = radapter.owner;
  9063. void (*deallocator)(void*) = &PtrAdapter< ::cv::text::ERFilter::Callback >::deallocate;
  9064. if (rptr != NULL) {
  9065. rarg = JavaCPP_createPointer(env, 33);
  9066. if (rarg != NULL) {
  9067. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  9068. }
  9069. }
  9070. } catch (...) {
  9071. exc = JavaCPP_handleException(env, 18);
  9072. }
  9073.  
  9074. JavaCPP_releaseStringBytes(env, arg0, ptr0);
  9075. if (exc != NULL) {
  9076. env->Throw(exc);
  9077. }
  9078. return rarg;
  9079. }
  9080. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_computeNMChannels__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024MatVector_2I(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jint arg2) {
  9081. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  9082. if (ptr0 == NULL) {
  9083. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  9084. return;
  9085. }
  9086. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  9087. ptr0 += position0;
  9088. ::std::vector<cv::Mat>* ptr1 = arg1 == NULL ? NULL : (::std::vector<cv::Mat>*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  9089. if (ptr1 == NULL) {
  9090. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  9091. return;
  9092. }
  9093. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  9094. ptr1 += position1;
  9095. jthrowable exc = NULL;
  9096. try {
  9097. cv::text::computeNMChannels(*ptr0, *ptr1, arg2);
  9098. } catch (...) {
  9099. exc = JavaCPP_handleException(env, 18);
  9100. }
  9101.  
  9102. if (exc != NULL) {
  9103. env->Throw(exc);
  9104. }
  9105. }
  9106. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_computeNMChannels__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024MatVector_2(JNIEnv* env, jclass cls, jobject arg0, jobject arg1) {
  9107. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  9108. if (ptr0 == NULL) {
  9109. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  9110. return;
  9111. }
  9112. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  9113. ptr0 += position0;
  9114. ::std::vector<cv::Mat>* ptr1 = arg1 == NULL ? NULL : (::std::vector<cv::Mat>*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  9115. if (ptr1 == NULL) {
  9116. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  9117. return;
  9118. }
  9119. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  9120. ptr1 += position1;
  9121. jthrowable exc = NULL;
  9122. try {
  9123. cv::text::computeNMChannels(*ptr0, *ptr1);
  9124. } catch (...) {
  9125. exc = JavaCPP_handleException(env, 18);
  9126. }
  9127.  
  9128. if (exc != NULL) {
  9129. env->Throw(exc);
  9130. }
  9131. }
  9132. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_MSERsToERStats(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jobject arg2) {
  9133. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  9134. if (ptr0 == NULL) {
  9135. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  9136. return;
  9137. }
  9138. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  9139. ptr0 += position0;
  9140. ::std::vector<std::vector<cv::Point> >* ptr1 = arg1 == NULL ? NULL : (::std::vector<std::vector<cv::Point> >*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  9141. if (ptr1 == NULL) {
  9142. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  9143. return;
  9144. }
  9145. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  9146. ptr1 += position1;
  9147. ::std::vector<cv::text::ERStat>* ptr2 = arg2 == NULL ? NULL : (::std::vector<cv::text::ERStat>*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  9148. jlong size2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_limitFID);
  9149. void* owner2 = JavaCPP_getPointerOwner(env, arg2);
  9150. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  9151. ptr2 += position2;
  9152. size2 -= position2;
  9153. VectorAdapter< ::std::vector<cv::text::ERStat> > adapter2(ptr2, size2, owner2);
  9154. jthrowable exc = NULL;
  9155. try {
  9156. cv::text::MSERsToERStats(*ptr0, *ptr1, adapter2);
  9157. } catch (...) {
  9158. exc = JavaCPP_handleException(env, 18);
  9159. }
  9160.  
  9161. ::std::vector<cv::text::ERStat>* rptr2 = adapter2;
  9162. jlong rsize2 = (jlong)adapter2.size;
  9163. void* rowner2 = adapter2.owner;
  9164. if (rptr2 != ptr2) {
  9165. JavaCPP_initPointer(env, arg2, rptr2, rsize2, rowner2, &VectorAdapter< ::std::vector<cv::text::ERStat> >::deallocate);
  9166. } else {
  9167. env->SetLongField(arg2, JavaCPP_limitFID, rsize2 + position2);
  9168. }
  9169. if (exc != NULL) {
  9170. env->Throw(exc);
  9171. }
  9172. }
  9173. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_loadOCRHMMClassifierNM__Lorg_bytedeco_javacpp_BytePointer_2(JNIEnv* env, jclass cls, jobject arg0) {
  9174. signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  9175. jlong size0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_limitFID);
  9176. void* owner0 = JavaCPP_getPointerOwner(env, arg0);
  9177. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  9178. ptr0 += position0;
  9179. size0 -= position0;
  9180. StrAdapter adapter0(ptr0, size0, owner0);
  9181. jobject rarg = NULL;
  9182. ::cv::text::OCRHMMDecoder::ClassifierCallback* rptr;
  9183. jthrowable exc = NULL;
  9184. try {
  9185. PtrAdapter< ::cv::text::OCRHMMDecoder::ClassifierCallback > radapter(cv::text::loadOCRHMMClassifierNM((cv::String&)adapter0));
  9186. rptr = radapter;
  9187. jlong rcapacity = (jlong)radapter.size;
  9188. void* rowner = radapter.owner;
  9189. void (*deallocator)(void*) = &PtrAdapter< ::cv::text::OCRHMMDecoder::ClassifierCallback >::deallocate;
  9190. if (rptr != NULL) {
  9191. rarg = JavaCPP_createPointer(env, 21);
  9192. if (rarg != NULL) {
  9193. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  9194. }
  9195. }
  9196. } catch (...) {
  9197. exc = JavaCPP_handleException(env, 18);
  9198. }
  9199.  
  9200. signed char* rptr0 = adapter0;
  9201. jlong rsize0 = (jlong)adapter0.size;
  9202. void* rowner0 = adapter0.owner;
  9203. if (rptr0 != ptr0) {
  9204. JavaCPP_initPointer(env, arg0, rptr0, rsize0, rowner0, &StrAdapter::deallocate);
  9205. } else {
  9206. env->SetLongField(arg0, JavaCPP_limitFID, rsize0 + position0);
  9207. }
  9208. if (exc != NULL) {
  9209. env->Throw(exc);
  9210. }
  9211. return rarg;
  9212. }
  9213. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_loadOCRHMMClassifierNM__Ljava_lang_String_2(JNIEnv* env, jclass cls, jstring arg0) {
  9214. const char* ptr0 = JavaCPP_getStringBytes(env, arg0);
  9215. jlong size0 = 0;
  9216. void* owner0 = (void*)ptr0;
  9217. StrAdapter adapter0(ptr0, size0, owner0);
  9218. jobject rarg = NULL;
  9219. ::cv::text::OCRHMMDecoder::ClassifierCallback* rptr;
  9220. jthrowable exc = NULL;
  9221. try {
  9222. PtrAdapter< ::cv::text::OCRHMMDecoder::ClassifierCallback > radapter(cv::text::loadOCRHMMClassifierNM((cv::String&)adapter0));
  9223. rptr = radapter;
  9224. jlong rcapacity = (jlong)radapter.size;
  9225. void* rowner = radapter.owner;
  9226. void (*deallocator)(void*) = &PtrAdapter< ::cv::text::OCRHMMDecoder::ClassifierCallback >::deallocate;
  9227. if (rptr != NULL) {
  9228. rarg = JavaCPP_createPointer(env, 21);
  9229. if (rarg != NULL) {
  9230. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  9231. }
  9232. }
  9233. } catch (...) {
  9234. exc = JavaCPP_handleException(env, 18);
  9235. }
  9236.  
  9237. JavaCPP_releaseStringBytes(env, arg0, ptr0);
  9238. if (exc != NULL) {
  9239. env->Throw(exc);
  9240. }
  9241. return rarg;
  9242. }
  9243. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_loadOCRHMMClassifierCNN__Lorg_bytedeco_javacpp_BytePointer_2(JNIEnv* env, jclass cls, jobject arg0) {
  9244. signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  9245. jlong size0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_limitFID);
  9246. void* owner0 = JavaCPP_getPointerOwner(env, arg0);
  9247. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  9248. ptr0 += position0;
  9249. size0 -= position0;
  9250. StrAdapter adapter0(ptr0, size0, owner0);
  9251. jobject rarg = NULL;
  9252. ::cv::text::OCRHMMDecoder::ClassifierCallback* rptr;
  9253. jthrowable exc = NULL;
  9254. try {
  9255. PtrAdapter< ::cv::text::OCRHMMDecoder::ClassifierCallback > radapter(cv::text::loadOCRHMMClassifierCNN((cv::String&)adapter0));
  9256. rptr = radapter;
  9257. jlong rcapacity = (jlong)radapter.size;
  9258. void* rowner = radapter.owner;
  9259. void (*deallocator)(void*) = &PtrAdapter< ::cv::text::OCRHMMDecoder::ClassifierCallback >::deallocate;
  9260. if (rptr != NULL) {
  9261. rarg = JavaCPP_createPointer(env, 21);
  9262. if (rarg != NULL) {
  9263. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  9264. }
  9265. }
  9266. } catch (...) {
  9267. exc = JavaCPP_handleException(env, 18);
  9268. }
  9269.  
  9270. signed char* rptr0 = adapter0;
  9271. jlong rsize0 = (jlong)adapter0.size;
  9272. void* rowner0 = adapter0.owner;
  9273. if (rptr0 != ptr0) {
  9274. JavaCPP_initPointer(env, arg0, rptr0, rsize0, rowner0, &StrAdapter::deallocate);
  9275. } else {
  9276. env->SetLongField(arg0, JavaCPP_limitFID, rsize0 + position0);
  9277. }
  9278. if (exc != NULL) {
  9279. env->Throw(exc);
  9280. }
  9281. return rarg;
  9282. }
  9283. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_loadOCRHMMClassifierCNN__Ljava_lang_String_2(JNIEnv* env, jclass cls, jstring arg0) {
  9284. const char* ptr0 = JavaCPP_getStringBytes(env, arg0);
  9285. jlong size0 = 0;
  9286. void* owner0 = (void*)ptr0;
  9287. StrAdapter adapter0(ptr0, size0, owner0);
  9288. jobject rarg = NULL;
  9289. ::cv::text::OCRHMMDecoder::ClassifierCallback* rptr;
  9290. jthrowable exc = NULL;
  9291. try {
  9292. PtrAdapter< ::cv::text::OCRHMMDecoder::ClassifierCallback > radapter(cv::text::loadOCRHMMClassifierCNN((cv::String&)adapter0));
  9293. rptr = radapter;
  9294. jlong rcapacity = (jlong)radapter.size;
  9295. void* rowner = radapter.owner;
  9296. void (*deallocator)(void*) = &PtrAdapter< ::cv::text::OCRHMMDecoder::ClassifierCallback >::deallocate;
  9297. if (rptr != NULL) {
  9298. rarg = JavaCPP_createPointer(env, 21);
  9299. if (rarg != NULL) {
  9300. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  9301. }
  9302. }
  9303. } catch (...) {
  9304. exc = JavaCPP_handleException(env, 18);
  9305. }
  9306.  
  9307. JavaCPP_releaseStringBytes(env, arg0, ptr0);
  9308. if (exc != NULL) {
  9309. env->Throw(exc);
  9310. }
  9311. return rarg;
  9312. }
  9313. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_createOCRHMMTransitionsTable__Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_opencv_1core_00024StringVector_2(JNIEnv* env, jclass cls, jobject arg0, jobject arg1) {
  9314. signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  9315. jlong size0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_limitFID);
  9316. void* owner0 = JavaCPP_getPointerOwner(env, arg0);
  9317. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  9318. ptr0 += position0;
  9319. size0 -= position0;
  9320. StrAdapter adapter0(ptr0, size0, owner0);
  9321. ::std::vector<cv::String>* ptr1 = arg1 == NULL ? NULL : (::std::vector<cv::String>*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  9322. if (ptr1 == NULL) {
  9323. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  9324. return 0;
  9325. }
  9326. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  9327. ptr1 += position1;
  9328. jobject rarg = NULL;
  9329. ::cv::Mat* rptr;
  9330. jthrowable exc = NULL;
  9331. try {
  9332. rptr = new ::cv::Mat(cv::text::createOCRHMMTransitionsTable((cv::String&)adapter0, *ptr1));
  9333. jlong rcapacity = 1;
  9334. void* rowner = (void*)rptr;
  9335. void (*deallocator)(void*) = &JavaCPP_org_bytedeco_javacpp_opencv_1core_00024Mat_deallocate;
  9336. if (rptr != NULL) {
  9337. rarg = JavaCPP_createPointer(env, 34);
  9338. if (rarg != NULL) {
  9339. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  9340. }
  9341. }
  9342. } catch (...) {
  9343. exc = JavaCPP_handleException(env, 18);
  9344. }
  9345.  
  9346. signed char* rptr0 = adapter0;
  9347. jlong rsize0 = (jlong)adapter0.size;
  9348. void* rowner0 = adapter0.owner;
  9349. if (rptr0 != ptr0) {
  9350. JavaCPP_initPointer(env, arg0, rptr0, rsize0, rowner0, &StrAdapter::deallocate);
  9351. } else {
  9352. env->SetLongField(arg0, JavaCPP_limitFID, rsize0 + position0);
  9353. }
  9354. if (exc != NULL) {
  9355. env->Throw(exc);
  9356. }
  9357. return rarg;
  9358. }
  9359. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_createOCRHMMTransitionsTable__Ljava_lang_String_2Ljava_lang_String_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2(JNIEnv* env, jclass cls, jstring arg0, jstring arg1, jobject arg2) {
  9360. const char* ptr0 = JavaCPP_getStringBytes(env, arg0);
  9361. jlong size0 = 0;
  9362. void* owner0 = (void*)ptr0;
  9363. StringAdapter adapter0(ptr0, size0, owner0);
  9364. const char* ptr1 = JavaCPP_getStringBytes(env, arg1);
  9365. jlong size1 = 0;
  9366. void* owner1 = (void*)ptr1;
  9367. VectorAdapter adapter1(ptr1, size1, owner1);
  9368. ::cv::Mat* ptr2 = arg2 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  9369. if (ptr2 == NULL) {
  9370. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 2 is NULL.");
  9371. return;
  9372. }
  9373. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  9374. ptr2 += position2;
  9375. jthrowable exc = NULL;
  9376. try {
  9377. cv::text::createOCRHMMTransitionsTable((std::string&)adapter0, (std::string&)adapter1, *ptr2);
  9378. } catch (...) {
  9379. exc = JavaCPP_handleException(env, 18);
  9380. }
  9381.  
  9382. JavaCPP_releaseStringBytes(env, arg0, ptr0);
  9383. JavaCPP_releaseStringBytes(env, arg1, ptr1);
  9384. if (exc != NULL) {
  9385. env->Throw(exc);
  9386. }
  9387. }
  9388. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_createOCRHMMTransitionsTable__Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_BytePointer_2Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jobject arg2) {
  9389. signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  9390. jlong size0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_limitFID);
  9391. void* owner0 = JavaCPP_getPointerOwner(env, arg0);
  9392. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  9393. ptr0 += position0;
  9394. size0 -= position0;
  9395. StringAdapter adapter0(ptr0, size0, owner0);
  9396. signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  9397. jlong size1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_limitFID);
  9398. void* owner1 = JavaCPP_getPointerOwner(env, arg1);
  9399. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  9400. ptr1 += position1;
  9401. size1 -= position1;
  9402. VectorAdapter adapter1(ptr1, size1, owner1);
  9403. ::cv::Mat* ptr2 = arg2 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  9404. if (ptr2 == NULL) {
  9405. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 2 is NULL.");
  9406. return;
  9407. }
  9408. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  9409. ptr2 += position2;
  9410. jthrowable exc = NULL;
  9411. try {
  9412. cv::text::createOCRHMMTransitionsTable((std::string&)adapter0, (std::string&)adapter1, *ptr2);
  9413. } catch (...) {
  9414. exc = JavaCPP_handleException(env, 18);
  9415. }
  9416.  
  9417. signed char* rptr0 = adapter0;
  9418. jlong rsize0 = (jlong)adapter0.size;
  9419. void* rowner0 = adapter0.owner;
  9420. if (rptr0 != ptr0) {
  9421. JavaCPP_initPointer(env, arg0, rptr0, rsize0, rowner0, &StringAdapter::deallocate);
  9422. } else {
  9423. env->SetLongField(arg0, JavaCPP_limitFID, rsize0 + position0);
  9424. }
  9425. signed char* rptr1 = adapter1;
  9426. jlong rsize1 = (jlong)adapter1.size;
  9427. void* rowner1 = adapter1.owner;
  9428. if (rptr1 != ptr1) {
  9429. JavaCPP_initPointer(env, arg1, rptr1, rsize1, rowner1, &VectorAdapter::deallocate);
  9430. } else {
  9431. env->SetLongField(arg1, JavaCPP_limitFID, rsize1 + position1);
  9432. }
  9433. if (exc != NULL) {
  9434. env->Throw(exc);
  9435. }
  9436. }
  9437. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_createOCRHMMTransitionsTable__Ljava_lang_String_2Lorg_bytedeco_javacpp_opencv_1core_00024StringVector_2(JNIEnv* env, jclass cls, jstring arg0, jobject arg1) {
  9438. const char* ptr0 = JavaCPP_getStringBytes(env, arg0);
  9439. jlong size0 = 0;
  9440. void* owner0 = (void*)ptr0;
  9441. StrAdapter adapter0(ptr0, size0, owner0);
  9442. ::std::vector<cv::String>* ptr1 = arg1 == NULL ? NULL : (::std::vector<cv::String>*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  9443. if (ptr1 == NULL) {
  9444. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  9445. return 0;
  9446. }
  9447. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  9448. ptr1 += position1;
  9449. jobject rarg = NULL;
  9450. ::cv::Mat* rptr;
  9451. jthrowable exc = NULL;
  9452. try {
  9453. rptr = new ::cv::Mat(cv::text::createOCRHMMTransitionsTable((cv::String&)adapter0, *ptr1));
  9454. jlong rcapacity = 1;
  9455. void* rowner = (void*)rptr;
  9456. void (*deallocator)(void*) = &JavaCPP_org_bytedeco_javacpp_opencv_1core_00024Mat_deallocate;
  9457. if (rptr != NULL) {
  9458. rarg = JavaCPP_createPointer(env, 34);
  9459. if (rarg != NULL) {
  9460. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  9461. }
  9462. }
  9463. } catch (...) {
  9464. exc = JavaCPP_handleException(env, 18);
  9465. }
  9466.  
  9467. JavaCPP_releaseStringBytes(env, arg0, ptr0);
  9468. if (exc != NULL) {
  9469. env->Throw(exc);
  9470. }
  9471. return rarg;
  9472. }
  9473. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_loadOCRBeamSearchClassifierCNN__Ljava_lang_String_2(JNIEnv* env, jclass cls, jstring arg0) {
  9474. const char* ptr0 = JavaCPP_getStringBytes(env, arg0);
  9475. jlong size0 = 0;
  9476. void* owner0 = (void*)ptr0;
  9477. StrAdapter adapter0(ptr0, size0, owner0);
  9478. jobject rarg = NULL;
  9479. ::cv::text::OCRBeamSearchDecoder::ClassifierCallback* rptr;
  9480. jthrowable exc = NULL;
  9481. try {
  9482. PtrAdapter< ::cv::text::OCRBeamSearchDecoder::ClassifierCallback > radapter(cv::text::loadOCRBeamSearchClassifierCNN((cv::String&)adapter0));
  9483. rptr = radapter;
  9484. jlong rcapacity = (jlong)radapter.size;
  9485. void* rowner = radapter.owner;
  9486. void (*deallocator)(void*) = &PtrAdapter< ::cv::text::OCRBeamSearchDecoder::ClassifierCallback >::deallocate;
  9487. if (rptr != NULL) {
  9488. rarg = JavaCPP_createPointer(env, 19);
  9489. if (rarg != NULL) {
  9490. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  9491. }
  9492. }
  9493. } catch (...) {
  9494. exc = JavaCPP_handleException(env, 18);
  9495. }
  9496.  
  9497. JavaCPP_releaseStringBytes(env, arg0, ptr0);
  9498. if (exc != NULL) {
  9499. env->Throw(exc);
  9500. }
  9501. return rarg;
  9502. }
  9503. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_loadOCRBeamSearchClassifierCNN__Lorg_bytedeco_javacpp_BytePointer_2(JNIEnv* env, jclass cls, jobject arg0) {
  9504. signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  9505. jlong size0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_limitFID);
  9506. void* owner0 = JavaCPP_getPointerOwner(env, arg0);
  9507. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  9508. ptr0 += position0;
  9509. size0 -= position0;
  9510. StrAdapter adapter0(ptr0, size0, owner0);
  9511. jobject rarg = NULL;
  9512. ::cv::text::OCRBeamSearchDecoder::ClassifierCallback* rptr;
  9513. jthrowable exc = NULL;
  9514. try {
  9515. PtrAdapter< ::cv::text::OCRBeamSearchDecoder::ClassifierCallback > radapter(cv::text::loadOCRBeamSearchClassifierCNN((cv::String&)adapter0));
  9516. rptr = radapter;
  9517. jlong rcapacity = (jlong)radapter.size;
  9518. void* rowner = radapter.owner;
  9519. void (*deallocator)(void*) = &PtrAdapter< ::cv::text::OCRBeamSearchDecoder::ClassifierCallback >::deallocate;
  9520. if (rptr != NULL) {
  9521. rarg = JavaCPP_createPointer(env, 19);
  9522. if (rarg != NULL) {
  9523. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  9524. }
  9525. }
  9526. } catch (...) {
  9527. exc = JavaCPP_handleException(env, 18);
  9528. }
  9529.  
  9530. signed char* rptr0 = adapter0;
  9531. jlong rsize0 = (jlong)adapter0.size;
  9532. void* rowner0 = adapter0.owner;
  9533. if (rptr0 != ptr0) {
  9534. JavaCPP_initPointer(env, arg0, rptr0, rsize0, rowner0, &StrAdapter::deallocate);
  9535. } else {
  9536. env->SetLongField(arg0, JavaCPP_limitFID, rsize0 + position0);
  9537. }
  9538. if (exc != NULL) {
  9539. env->Throw(exc);
  9540. }
  9541. return rarg;
  9542. }
  9543. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_createERFilterNM1__Lorg_bytedeco_javacpp_opencv_1text_00024ERFilter_00024Callback_2IFFFZF(JNIEnv* env, jclass cls, jobject arg0, jint arg1, jfloat arg2, jfloat arg3, jfloat arg4, jboolean arg5, jfloat arg6) {
  9544. ::cv::text::ERFilter::Callback* ptr0 = arg0 == NULL ? NULL : (::cv::text::ERFilter::Callback*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  9545. jlong size0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_limitFID);
  9546. void* owner0 = JavaCPP_getPointerOwner(env, arg0);
  9547. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  9548. ptr0 += position0;
  9549. size0 -= position0;
  9550. PtrAdapter< ::cv::text::ERFilter::Callback > adapter0(ptr0, size0, owner0);
  9551. jobject rarg = NULL;
  9552. ::cv::text::ERFilter* rptr;
  9553. jthrowable exc = NULL;
  9554. try {
  9555. PtrAdapter< ::cv::text::ERFilter > radapter(cv::text::createERFilterNM1((cv::Ptr< ::cv::text::ERFilter::Callback >)adapter0, arg1, arg2, arg3, arg4, (bool)arg5, arg6));
  9556. rptr = radapter;
  9557. jlong rcapacity = (jlong)radapter.size;
  9558. void* rowner = radapter.owner;
  9559. void (*deallocator)(void*) = &PtrAdapter< ::cv::text::ERFilter >::deallocate;
  9560. if (rptr != NULL) {
  9561. rarg = JavaCPP_createPointer(env, 32);
  9562. if (rarg != NULL) {
  9563. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  9564. }
  9565. }
  9566. } catch (...) {
  9567. exc = JavaCPP_handleException(env, 18);
  9568. }
  9569.  
  9570. ::cv::text::ERFilter::Callback* rptr0 = adapter0;
  9571. jlong rsize0 = (jlong)adapter0.size;
  9572. void* rowner0 = adapter0.owner;
  9573. if (rptr0 != ptr0) {
  9574. JavaCPP_initPointer(env, arg0, rptr0, rsize0, rowner0, &PtrAdapter< ::cv::text::ERFilter::Callback >::deallocate);
  9575. } else {
  9576. env->SetLongField(arg0, JavaCPP_limitFID, rsize0 + position0);
  9577. }
  9578. if (exc != NULL) {
  9579. env->Throw(exc);
  9580. }
  9581. return rarg;
  9582. }
  9583. JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_opencv_1text_createERFilterNM1__Lorg_bytedeco_javacpp_opencv_1text_00024ERFilter_00024Callback_2(JNIEnv* env, jclass cls, jobject arg0) {
  9584. ::cv::text::ERFilter::Callback* ptr0 = arg0 == NULL ? NULL : (::cv::text::ERFilter::Callback*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  9585. jlong size0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_limitFID);
  9586. void* owner0 = JavaCPP_getPointerOwner(env, arg0);
  9587. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  9588. ptr0 += position0;
  9589. size0 -= position0;
  9590. PtrAdapter< ::cv::text::ERFilter::Callback > adapter0(ptr0, size0, owner0);
  9591. jobject rarg = NULL;
  9592. ::cv::text::ERFilter* rptr;
  9593. jthrowable exc = NULL;
  9594. try {
  9595. PtrAdapter< ::cv::text::ERFilter > radapter(cv::text::createERFilterNM1((cv::Ptr< ::cv::text::ERFilter::Callback >)adapter0));
  9596. rptr = radapter;
  9597. jlong rcapacity = (jlong)radapter.size;
  9598. void* rowner = radapter.owner;
  9599. void (*deallocator)(void*) = &PtrAdapter< ::cv::text::ERFilter >::deallocate;
  9600. if (rptr != NULL) {
  9601. rarg = JavaCPP_createPointer(env, 32);
  9602. if (rarg != NULL) {
  9603. JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator);
  9604. }
  9605. }
  9606. } catch (...) {
  9607. exc = JavaCPP_handleException(env, 18);
  9608. }
  9609.  
  9610. ::cv::text::ERFilter::Callback* rptr0 = adapter0;
  9611. jlong rsize0 = (jlong)adapter0.size;
  9612. void* rowner0 = adapter0.owner;
  9613. if (rptr0 != ptr0) {
  9614. JavaCPP_initPointer(env, arg0, rptr0, rsize0, rowner0, &PtrAdapter< ::cv::text::ERFilter::Callback >::deallocate);
  9615. } else {
  9616. env->SetLongField(arg0, JavaCPP_limitFID, rsize0 + position0);
  9617. }
  9618. if (exc != NULL) {
  9619. env->Throw(exc);
  9620. }
  9621. return rarg;
  9622. }
  9623. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_erGrouping__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024MatVector_2Lorg_bytedeco_javacpp_opencv_1text_00024ERStatVector_2Lorg_bytedeco_javacpp_opencv_1text_00024Vec2iVector_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2ILjava_lang_String_2F(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jobject arg2, jobject arg3, jobject arg4, jint arg5, jstring arg6, jfloat arg7) {
  9624. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  9625. if (ptr0 == NULL) {
  9626. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  9627. return;
  9628. }
  9629. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  9630. ptr0 += position0;
  9631. ::std::vector<cv::Mat>* ptr1 = arg1 == NULL ? NULL : (::std::vector<cv::Mat>*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  9632. if (ptr1 == NULL) {
  9633. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  9634. return;
  9635. }
  9636. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  9637. ptr1 += position1;
  9638. ::std::vector<cv::text::ERStat>* ptr2 = arg2 == NULL ? NULL : (::std::vector<cv::text::ERStat>*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  9639. jlong size2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_limitFID);
  9640. void* owner2 = JavaCPP_getPointerOwner(env, arg2);
  9641. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  9642. ptr2 += position2;
  9643. size2 -= position2;
  9644. VectorAdapter< ::std::vector<cv::text::ERStat> > adapter2(ptr2, size2, owner2);
  9645. ::std::vector<cv::Vec2i>* ptr3 = arg3 == NULL ? NULL : (::std::vector<cv::Vec2i>*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  9646. jlong size3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_limitFID);
  9647. void* owner3 = JavaCPP_getPointerOwner(env, arg3);
  9648. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  9649. ptr3 += position3;
  9650. size3 -= position3;
  9651. VectorAdapter< ::std::vector<cv::Vec2i> > adapter3(ptr3, size3, owner3);
  9652. ::std::vector<cv::Rect>* ptr4 = arg4 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg4, JavaCPP_addressFID));
  9653. if (ptr4 == NULL) {
  9654. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 4 is NULL.");
  9655. return;
  9656. }
  9657. jlong position4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_positionFID);
  9658. ptr4 += position4;
  9659. const char* ptr6 = JavaCPP_getStringBytes(env, arg6);
  9660. jlong size6 = 0;
  9661. void* owner6 = (void*)ptr6;
  9662. StringAdapter adapter6(ptr6, size6, owner6);
  9663. jthrowable exc = NULL;
  9664. try {
  9665. cv::text::erGrouping(*ptr0, *ptr1, adapter2, adapter3, *ptr4, arg5, (std::string&)adapter6, arg7);
  9666. } catch (...) {
  9667. exc = JavaCPP_handleException(env, 18);
  9668. }
  9669.  
  9670. ::std::vector<cv::text::ERStat>* rptr2 = adapter2;
  9671. jlong rsize2 = (jlong)adapter2.size;
  9672. void* rowner2 = adapter2.owner;
  9673. if (rptr2 != ptr2) {
  9674. JavaCPP_initPointer(env, arg2, rptr2, rsize2, rowner2, &VectorAdapter< ::std::vector<cv::text::ERStat> >::deallocate);
  9675. } else {
  9676. env->SetLongField(arg2, JavaCPP_limitFID, rsize2 + position2);
  9677. }
  9678. ::std::vector<cv::Vec2i>* rptr3 = adapter3;
  9679. jlong rsize3 = (jlong)adapter3.size;
  9680. void* rowner3 = adapter3.owner;
  9681. if (rptr3 != ptr3) {
  9682. JavaCPP_initPointer(env, arg3, rptr3, rsize3, rowner3, &VectorAdapter< ::std::vector<cv::Vec2i> >::deallocate);
  9683. } else {
  9684. env->SetLongField(arg3, JavaCPP_limitFID, rsize3 + position3);
  9685. }
  9686. JavaCPP_releaseStringBytes(env, arg6, ptr6);
  9687. if (exc != NULL) {
  9688. env->Throw(exc);
  9689. }
  9690. }
  9691. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_erGrouping__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024MatVector_2Lorg_bytedeco_javacpp_opencv_1text_00024ERStatVector_2Lorg_bytedeco_javacpp_opencv_1text_00024Vec2iVector_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jobject arg2, jobject arg3, jobject arg4) {
  9692. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  9693. if (ptr0 == NULL) {
  9694. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  9695. return;
  9696. }
  9697. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  9698. ptr0 += position0;
  9699. ::std::vector<cv::Mat>* ptr1 = arg1 == NULL ? NULL : (::std::vector<cv::Mat>*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  9700. if (ptr1 == NULL) {
  9701. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  9702. return;
  9703. }
  9704. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  9705. ptr1 += position1;
  9706. ::std::vector<cv::text::ERStat>* ptr2 = arg2 == NULL ? NULL : (::std::vector<cv::text::ERStat>*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  9707. jlong size2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_limitFID);
  9708. void* owner2 = JavaCPP_getPointerOwner(env, arg2);
  9709. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  9710. ptr2 += position2;
  9711. size2 -= position2;
  9712. VectorAdapter< ::std::vector<cv::text::ERStat> > adapter2(ptr2, size2, owner2);
  9713. ::std::vector<cv::Vec2i>* ptr3 = arg3 == NULL ? NULL : (::std::vector<cv::Vec2i>*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  9714. jlong size3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_limitFID);
  9715. void* owner3 = JavaCPP_getPointerOwner(env, arg3);
  9716. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  9717. ptr3 += position3;
  9718. size3 -= position3;
  9719. VectorAdapter< ::std::vector<cv::Vec2i> > adapter3(ptr3, size3, owner3);
  9720. ::std::vector<cv::Rect>* ptr4 = arg4 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg4, JavaCPP_addressFID));
  9721. if (ptr4 == NULL) {
  9722. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 4 is NULL.");
  9723. return;
  9724. }
  9725. jlong position4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_positionFID);
  9726. ptr4 += position4;
  9727. jthrowable exc = NULL;
  9728. try {
  9729. cv::text::erGrouping(*ptr0, *ptr1, adapter2, adapter3, *ptr4);
  9730. } catch (...) {
  9731. exc = JavaCPP_handleException(env, 18);
  9732. }
  9733.  
  9734. ::std::vector<cv::text::ERStat>* rptr2 = adapter2;
  9735. jlong rsize2 = (jlong)adapter2.size;
  9736. void* rowner2 = adapter2.owner;
  9737. if (rptr2 != ptr2) {
  9738. JavaCPP_initPointer(env, arg2, rptr2, rsize2, rowner2, &VectorAdapter< ::std::vector<cv::text::ERStat> >::deallocate);
  9739. } else {
  9740. env->SetLongField(arg2, JavaCPP_limitFID, rsize2 + position2);
  9741. }
  9742. ::std::vector<cv::Vec2i>* rptr3 = adapter3;
  9743. jlong rsize3 = (jlong)adapter3.size;
  9744. void* rowner3 = adapter3.owner;
  9745. if (rptr3 != ptr3) {
  9746. JavaCPP_initPointer(env, arg3, rptr3, rsize3, rowner3, &VectorAdapter< ::std::vector<cv::Vec2i> >::deallocate);
  9747. } else {
  9748. env->SetLongField(arg3, JavaCPP_limitFID, rsize3 + position3);
  9749. }
  9750. if (exc != NULL) {
  9751. env->Throw(exc);
  9752. }
  9753. }
  9754. JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_opencv_1text_erGrouping__Lorg_bytedeco_javacpp_opencv_1core_00024Mat_2Lorg_bytedeco_javacpp_opencv_1core_00024MatVector_2Lorg_bytedeco_javacpp_opencv_1text_00024ERStatVector_2Lorg_bytedeco_javacpp_opencv_1text_00024Vec2iVector_2Lorg_bytedeco_javacpp_opencv_1core_00024RectVector_2ILorg_bytedeco_javacpp_BytePointer_2F(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jobject arg2, jobject arg3, jobject arg4, jint arg5, jobject arg6, jfloat arg7) {
  9755. ::cv::Mat* ptr0 = arg0 == NULL ? NULL : (::cv::Mat*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
  9756. if (ptr0 == NULL) {
  9757. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 0 is NULL.");
  9758. return;
  9759. }
  9760. jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID);
  9761. ptr0 += position0;
  9762. ::std::vector<cv::Mat>* ptr1 = arg1 == NULL ? NULL : (::std::vector<cv::Mat>*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
  9763. if (ptr1 == NULL) {
  9764. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 1 is NULL.");
  9765. return;
  9766. }
  9767. jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID);
  9768. ptr1 += position1;
  9769. ::std::vector<cv::text::ERStat>* ptr2 = arg2 == NULL ? NULL : (::std::vector<cv::text::ERStat>*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
  9770. jlong size2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_limitFID);
  9771. void* owner2 = JavaCPP_getPointerOwner(env, arg2);
  9772. jlong position2 = arg2 == NULL ? 0 : env->GetLongField(arg2, JavaCPP_positionFID);
  9773. ptr2 += position2;
  9774. size2 -= position2;
  9775. VectorAdapter< ::std::vector<cv::text::ERStat> > adapter2(ptr2, size2, owner2);
  9776. ::std::vector<cv::Vec2i>* ptr3 = arg3 == NULL ? NULL : (::std::vector<cv::Vec2i>*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
  9777. jlong size3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_limitFID);
  9778. void* owner3 = JavaCPP_getPointerOwner(env, arg3);
  9779. jlong position3 = arg3 == NULL ? 0 : env->GetLongField(arg3, JavaCPP_positionFID);
  9780. ptr3 += position3;
  9781. size3 -= position3;
  9782. VectorAdapter< ::std::vector<cv::Vec2i> > adapter3(ptr3, size3, owner3);
  9783. ::std::vector<cv::Rect>* ptr4 = arg4 == NULL ? NULL : (::std::vector<cv::Rect>*)jlong_to_ptr(env->GetLongField(arg4, JavaCPP_addressFID));
  9784. if (ptr4 == NULL) {
  9785. env->ThrowNew(JavaCPP_getClass(env, 17), "Pointer address of argument 4 is NULL.");
  9786. return;
  9787. }
  9788. jlong position4 = arg4 == NULL ? 0 : env->GetLongField(arg4, JavaCPP_positionFID);
  9789. ptr4 += position4;
  9790. signed char* ptr6 = arg6 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg6, JavaCPP_addressFID));
  9791. jlong size6 = arg6 == NULL ? 0 : env->GetLongField(arg6, JavaCPP_limitFID);
  9792. void* owner6 = JavaCPP_getPointerOwner(env, arg6);
  9793. jlong position6 = arg6 == NULL ? 0 : env->GetLongField(arg6, JavaCPP_positionFID);
  9794. ptr6 += position6;
  9795. size6 -= position6;
  9796. StringAdapter adapter6(ptr6, size6, owner6);
  9797. jthrowable exc = NULL;
  9798. try {
  9799. cv::text::erGrouping(*ptr0, *ptr1, adapter2, adapter3, *ptr4, arg5, (std::string&)adapter6, arg7);
  9800. } catch (...) {
  9801. exc = JavaCPP_handleException(env, 18);
  9802. }
  9803.  
  9804. ::std::vector<cv::text::ERStat>* rptr2 = adapter2;
  9805. jlong rsize2 = (jlong)adapter2.size;
  9806. void* rowner2 = adapter2.owner;
  9807. if (rptr2 != ptr2) {
  9808. JavaCPP_initPointer(env, arg2, rptr2, rsize2, rowner2, &VectorAdapter< ::std::vector<cv::text::ERStat> >::deallocate);
  9809. } else {
  9810. env->SetLongField(arg2, JavaCPP_limitFID, rsize2 + position2);
  9811. }
  9812. ::std::vector<cv::Vec2i>* rptr3 = adapter3;
  9813. jlong rsize3 = (jlong)adapter3.size;
  9814. void* rowner3 = adapter3.owner;
  9815. if (rptr3 != ptr3) {
  9816. JavaCPP_initPointer(env, arg3, rptr3, rsize3, rowner3, &VectorAdapter< ::std::vector<cv::Vec2i> >::deallocate);
  9817. } else {
  9818. env->SetLongField(arg3, JavaCPP_limitFID, rsize3 + position3);
  9819. }
  9820. signed char* rptr6 = adapter6;
  9821. jlong rsize6 = (jlong)adapter6.size;
  9822. void* rowner6 = adapter6.owner;
  9823. if (rptr6 != ptr6) {
  9824. JavaCPP_initPointer(env, arg6, rptr6, rsize6, rowner6, &StringAdapter::deallocate);
  9825. } else {
  9826. env->SetLongField(arg6, JavaCPP_limitFID, rsize6 + position6);
  9827. }
  9828. if (exc != NULL) {
  9829. env->Throw(exc);
  9830. }
  9831. }
  9832.  
  9833. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!