diff --git a/modules/java/CMakeLists.txt b/modules/java/CMakeLists.txt index 63e0e65e02..10bb559c94 100644 --- a/modules/java/CMakeLists.txt +++ b/modules/java/CMakeLists.txt @@ -41,6 +41,8 @@ file(GLOB handwrittren_aidl_sources "${CMAKE_CURRENT_SOURCE_DIR}/generator/src/ if(NOT ANDROID) ocv_list_filterout(handwrittren_java_sources "/(engine|android)\\\\+") ocv_list_filterout(handwrittren_aidl_sources "/(engine|android)\\\\+") + ocv_list_filterout(handwrittren_java_sources "VideoCapture") + ocv_list_filterout(handwrittren_cpp_sources "VideoCapture") else() file(GLOB_RECURSE handwrittren_lib_project_files_rel RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}/android_lib/" "${CMAKE_CURRENT_SOURCE_DIR}/android_lib/*") list(REMOVE_ITEM handwrittren_lib_project_files_rel "${ANDROID_MANIFEST_FILE}") @@ -100,9 +102,15 @@ foreach(module ${OPENCV_JAVA_MODULES}) # first run of gen_java.py (to get list of generated files) file(REMOVE_RECURSE "${CMAKE_CURRENT_BINARY_DIR}/gen_java_out/") file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/gen_java_out") - execute_process(COMMAND ${PYTHON_EXECUTABLE} "${scripts_gen_java}" "${scripts_hdr_parser}" ${module} ${opencv_public_headers_${module}} + if (ANDROID) + execute_process(COMMAND ${PYTHON_EXECUTABLE} "${scripts_gen_java}" "${scripts_hdr_parser}" "-android" ${module} ${opencv_public_headers_${module}} WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/gen_java_out" OUTPUT_QUIET ERROR_QUIET) + else() + execute_process(COMMAND ${PYTHON_EXECUTABLE} "${scripts_gen_java}" "${scripts_hdr_parser}" ${module} ${opencv_public_headers_${module}} + WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/gen_java_out" + OUTPUT_QUIET ERROR_QUIET) + endif() unset(generated_java_sources_${module}) file(GLOB_RECURSE generated_java_sources_${module} RELATIVE "${CMAKE_CURRENT_BINARY_DIR}/gen_java_out/" "${CMAKE_CURRENT_BINARY_DIR}/gen_java_out/*.java") ocv_list_add_prefix(generated_java_sources_${module} "${CMAKE_CURRENT_BINARY_DIR}/") @@ -123,11 +131,19 @@ endforeach() set(step1_depends "${scripts_gen_java}" "${scripts_hdr_parser}" ${opencv_public_headers}) foreach(module ${OPENCV_JAVA_MODULES}) # second run of gen_java.py (at build time) - add_custom_command(OUTPUT ${generated_java_sources_${module}} "${CMAKE_CURRENT_BINARY_DIR}/${module}.cpp" + if (ANDROID) + add_custom_command(OUTPUT ${generated_java_sources_${module}} "${CMAKE_CURRENT_BINARY_DIR}/${module}.cpp" + COMMAND ${PYTHON_EXECUTABLE} "${scripts_gen_java}" "${scripts_hdr_parser}" "-android" ${module} ${opencv_public_headers_${module}} + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} + DEPENDS "${scripts_gen_java}" "${scripts_hdr_parser}" ${opencv_public_headers_${module}} + ) + else() + add_custom_command(OUTPUT ${generated_java_sources_${module}} "${CMAKE_CURRENT_BINARY_DIR}/${module}.cpp" COMMAND ${PYTHON_EXECUTABLE} "${scripts_gen_java}" "${scripts_hdr_parser}" ${module} ${opencv_public_headers_${module}} WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} DEPENDS "${scripts_gen_java}" "${scripts_hdr_parser}" ${opencv_public_headers_${module}} ) + endif() endforeach() # step 2: generate javadoc comments diff --git a/modules/java/generator/gen_java.py b/modules/java/generator/gen_java.py index 226efc0b42..123daf70b8 100755 --- a/modules/java/generator/gen_java.py +++ b/modules/java/generator/gen_java.py @@ -1492,8 +1492,15 @@ if __name__ == "__main__": hdr_parser_path = os.path.dirname(hdr_parser_path) sys.path.append(hdr_parser_path) import hdr_parser - module = sys.argv[2] - srcfiles = sys.argv[3:] + if (sys.argv[2] == "-android"): + class_ignore_list += ("VideoCapture",) + ManualFuncs.pop("VideoCapture") + module = sys.argv[3] + srcfiles = sys.argv[4:] + else: + module = sys.argv[2] + srcfiles = sys.argv[3:] + #print "Generating module '" + module + "' from headers:\n\t" + "\n\t".join(srcfiles) generator = JavaWrapperGenerator() generator.gen(srcfiles, module, dstdir) diff --git a/modules/java/generator/src/cpp/VideoCapture.cpp b/modules/java/generator/src/cpp/VideoCapture.cpp new file mode 100644 index 0000000000..5b9266660f --- /dev/null +++ b/modules/java/generator/src/cpp/VideoCapture.cpp @@ -0,0 +1,435 @@ +#define LOG_TAG "org.opencv.highgui.VideoCapture" +#include "common.h" + +#include "opencv2/opencv_modules.hpp" +#ifdef HAVE_OPENCV_HIGHGUI + +#include "opencv2/highgui/highgui_c.h" +#include "opencv2/highgui/highgui.hpp" +using namespace cv; + + +extern "C" { + +// +// VideoCapture::VideoCapture() +// + +JNIEXPORT jlong JNICALL Java_org_opencv_highgui_VideoCapture_n_1VideoCapture__ + (JNIEnv* env, jclass); + +JNIEXPORT jlong JNICALL Java_org_opencv_highgui_VideoCapture_n_1VideoCapture__ + (JNIEnv* env, jclass) +{ + try { + LOGD("highgui::VideoCapture_n_1VideoCapture__()"); + + VideoCapture* _retval_ = new VideoCapture( ); + + return (jlong) _retval_; + } catch(cv::Exception e) { + LOGD("highgui::VideoCapture_n_1VideoCapture__() catched cv::Exception: %s", e.what()); + jclass je = env->FindClass("org/opencv/core/CvException"); + if(!je) je = env->FindClass("java/lang/Exception"); + env->ThrowNew(je, e.what()); + return 0; + } catch (...) { + LOGD("highgui::VideoCapture_n_1VideoCapture__() catched unknown exception (...)"); + jclass je = env->FindClass("java/lang/Exception"); + env->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1VideoCapture__()}"); + return 0; + } +} + + +// +// VideoCapture::VideoCapture(int device) +// + +JNIEXPORT jlong JNICALL Java_org_opencv_highgui_VideoCapture_n_1VideoCapture__I + (JNIEnv* env, jclass, jint device); + +JNIEXPORT jlong JNICALL Java_org_opencv_highgui_VideoCapture_n_1VideoCapture__I + (JNIEnv* env, jclass, jint device) +{ + try { + LOGD("highgui::VideoCapture_n_1VideoCapture__I()"); + + VideoCapture* _retval_ = new VideoCapture( device ); + + return (jlong) _retval_; + } catch(cv::Exception e) { + LOGD("highgui::VideoCapture_n_1VideoCapture__I() catched cv::Exception: %s", e.what()); + jclass je = env->FindClass("org/opencv/core/CvException"); + if(!je) je = env->FindClass("java/lang/Exception"); + env->ThrowNew(je, e.what()); + return 0; + } catch (...) { + LOGD("highgui::VideoCapture_n_1VideoCapture__I() catched unknown exception (...)"); + jclass je = env->FindClass("java/lang/Exception"); + env->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1VideoCapture__I()}"); + return 0; + } +} + + + +// +// double VideoCapture::get(int propId) +// + +JNIEXPORT jdouble JNICALL Java_org_opencv_highgui_VideoCapture_n_1get + (JNIEnv* env, jclass, jlong self, jint propId); + +JNIEXPORT jdouble JNICALL Java_org_opencv_highgui_VideoCapture_n_1get + (JNIEnv* env, jclass, jlong self, jint propId) +{ + try { + LOGD("highgui::VideoCapture_n_1get()"); + VideoCapture* me = (VideoCapture*) self; //TODO: check for NULL + double _retval_ = me->get( propId ); + + return _retval_; + } catch(cv::Exception e) { + LOGD("highgui::VideoCapture_n_1get() catched cv::Exception: %s", e.what()); + jclass je = env->FindClass("org/opencv/core/CvException"); + if(!je) je = env->FindClass("java/lang/Exception"); + env->ThrowNew(je, e.what()); + return 0; + } catch (...) { + LOGD("highgui::VideoCapture_n_1get() catched unknown exception (...)"); + jclass je = env->FindClass("java/lang/Exception"); + env->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1get()}"); + return 0; + } +} + + + +// +// bool VideoCapture::grab() +// + +JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1grab + (JNIEnv* env, jclass, jlong self); + +JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1grab + (JNIEnv* env, jclass, jlong self) +{ + try { + LOGD("highgui::VideoCapture_n_1grab()"); + VideoCapture* me = (VideoCapture*) self; //TODO: check for NULL + bool _retval_ = me->grab( ); + + return _retval_; + } catch(cv::Exception e) { + LOGD("highgui::VideoCapture_n_1grab() catched cv::Exception: %s", e.what()); + jclass je = env->FindClass("org/opencv/core/CvException"); + if(!je) je = env->FindClass("java/lang/Exception"); + env->ThrowNew(je, e.what()); + return 0; + } catch (...) { + LOGD("highgui::VideoCapture_n_1grab() catched unknown exception (...)"); + jclass je = env->FindClass("java/lang/Exception"); + env->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1grab()}"); + return 0; + } +} + + + +// +// bool VideoCapture::isOpened() +// + +JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1isOpened + (JNIEnv* env, jclass, jlong self); + +JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1isOpened + (JNIEnv* env, jclass, jlong self) +{ + try { + LOGD("highgui::VideoCapture_n_1isOpened()"); + VideoCapture* me = (VideoCapture*) self; //TODO: check for NULL + bool _retval_ = me->isOpened( ); + + return _retval_; + } catch(cv::Exception e) { + LOGD("highgui::VideoCapture_n_1isOpened() catched cv::Exception: %s", e.what()); + jclass je = env->FindClass("org/opencv/core/CvException"); + if(!je) je = env->FindClass("java/lang/Exception"); + env->ThrowNew(je, e.what()); + return 0; + } catch (...) { + LOGD("highgui::VideoCapture_n_1isOpened() catched unknown exception (...)"); + jclass je = env->FindClass("java/lang/Exception"); + env->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1isOpened()}"); + return 0; + } +} + + +// +// bool VideoCapture::open(int device) +// + +JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1open__JI + (JNIEnv* env, jclass, jlong self, jint device); + +JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1open__JI + (JNIEnv* env, jclass, jlong self, jint device) +{ + try { + LOGD("highgui::VideoCapture_n_1open__JI()"); + VideoCapture* me = (VideoCapture*) self; //TODO: check for NULL + bool _retval_ = me->open( device ); + + return _retval_; + } catch(cv::Exception e) { + LOGD("highgui::VideoCapture_n_1open__JI() catched cv::Exception: %s", e.what()); + jclass je = env->FindClass("org/opencv/core/CvException"); + if(!je) je = env->FindClass("java/lang/Exception"); + env->ThrowNew(je, e.what()); + return 0; + } catch (...) { + LOGD("highgui::VideoCapture_n_1open__JI() catched unknown exception (...)"); + jclass je = env->FindClass("java/lang/Exception"); + env->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1open__JI()}"); + return 0; + } +} + + + +// +// bool VideoCapture::read(Mat image) +// + +JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1read + (JNIEnv* env, jclass, jlong self, jlong image_nativeObj); + +JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1read + (JNIEnv* env, jclass, jlong self, jlong image_nativeObj) +{ + try { + LOGD("highgui::VideoCapture_n_1read()"); + VideoCapture* me = (VideoCapture*) self; //TODO: check for NULL + Mat& image = *((Mat*)image_nativeObj); + bool _retval_ = me->read( image ); + + return _retval_; + } catch(cv::Exception e) { + LOGD("highgui::VideoCapture_n_1read() catched cv::Exception: %s", e.what()); + jclass je = env->FindClass("org/opencv/core/CvException"); + if(!je) je = env->FindClass("java/lang/Exception"); + env->ThrowNew(je, e.what()); + return 0; + } catch (...) { + LOGD("highgui::VideoCapture_n_1read() catched unknown exception (...)"); + jclass je = env->FindClass("java/lang/Exception"); + env->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1read()}"); + return 0; + } +} + + + +// +// void VideoCapture::release() +// + +JNIEXPORT void JNICALL Java_org_opencv_highgui_VideoCapture_n_1release + (JNIEnv* env, jclass, jlong self); + +JNIEXPORT void JNICALL Java_org_opencv_highgui_VideoCapture_n_1release + (JNIEnv* env, jclass, jlong self) +{ + try { + + LOGD("highgui::VideoCapture_n_1release()"); + + VideoCapture* me = (VideoCapture*) self; //TODO: check for NULL + me->release( ); + + return; + } catch(cv::Exception e) { + + LOGD("highgui::VideoCapture_n_1release() catched cv::Exception: %s", e.what()); + + jclass je = env->FindClass("org/opencv/core/CvException"); + if(!je) je = env->FindClass("java/lang/Exception"); + env->ThrowNew(je, e.what()); + return; + } catch (...) { + + LOGD("highgui::VideoCapture_n_1release() catched unknown exception (...)"); + + jclass je = env->FindClass("java/lang/Exception"); + env->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1release()}"); + return; + } +} + + + +// +// bool VideoCapture::retrieve(Mat image, int channel = 0) +// + +JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1retrieve__JJI + (JNIEnv* env, jclass, jlong self, jlong image_nativeObj, jint channel); + +JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1retrieve__JJI + (JNIEnv* env, jclass, jlong self, jlong image_nativeObj, jint channel) +{ + try { + + LOGD("highgui::VideoCapture_n_1retrieve__JJI()"); + + VideoCapture* me = (VideoCapture*) self; //TODO: check for NULL + Mat& image = *((Mat*)image_nativeObj); + bool _retval_ = me->retrieve( image, channel ); + + return _retval_; + } catch(cv::Exception e) { + + LOGD("highgui::VideoCapture_n_1retrieve__JJI() catched cv::Exception: %s", e.what()); + + jclass je = env->FindClass("org/opencv/core/CvException"); + if(!je) je = env->FindClass("java/lang/Exception"); + env->ThrowNew(je, e.what()); + return 0; + } catch (...) { + + LOGD("highgui::VideoCapture_n_1retrieve__JJI() catched unknown exception (...)"); + + jclass je = env->FindClass("java/lang/Exception"); + env->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1retrieve__JJI()}"); + return 0; + } +} + + + +JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1retrieve__JJ + (JNIEnv* env, jclass, jlong self, jlong image_nativeObj); + +JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1retrieve__JJ + (JNIEnv* env, jclass, jlong self, jlong image_nativeObj) +{ + try { + + LOGD("highgui::VideoCapture_n_1retrieve__JJ()"); + + VideoCapture* me = (VideoCapture*) self; //TODO: check for NULL + Mat& image = *((Mat*)image_nativeObj); + bool _retval_ = me->retrieve( image ); + + return _retval_; + } catch(cv::Exception e) { + + LOGD("highgui::VideoCapture_n_1retrieve__JJ() catched cv::Exception: %s", e.what()); + + jclass je = env->FindClass("org/opencv/core/CvException"); + if(!je) je = env->FindClass("java/lang/Exception"); + env->ThrowNew(je, e.what()); + return 0; + } catch (...) { + + LOGD("highgui::VideoCapture_n_1retrieve__JJ() catched unknown exception (...)"); + + jclass je = env->FindClass("java/lang/Exception"); + env->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1retrieve__JJ()}"); + return 0; + } +} + + + +// +// bool VideoCapture::set(int propId, double value) +// + +JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1set + (JNIEnv* env, jclass, jlong self, jint propId, jdouble value); + +JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1set + (JNIEnv* env, jclass, jlong self, jint propId, jdouble value) +{ + try { + + LOGD("highgui::VideoCapture_n_1set()"); + + VideoCapture* me = (VideoCapture*) self; //TODO: check for NULL + bool _retval_ = me->set( propId, value ); + + return _retval_; + } catch(cv::Exception e) { + + LOGD("highgui::VideoCapture_n_1set() catched cv::Exception: %s", e.what()); + + jclass je = env->FindClass("org/opencv/core/CvException"); + if(!je) je = env->FindClass("java/lang/Exception"); + env->ThrowNew(je, e.what()); + return 0; + } catch (...) { + + LOGD("highgui::VideoCapture_n_1set() catched unknown exception (...)"); + + jclass je = env->FindClass("java/lang/Exception"); + env->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1set()}"); + return 0; + } +} + +JNIEXPORT jstring JNICALL Java_org_opencv_highgui_VideoCapture_n_1getSupportedPreviewSizes + (JNIEnv *env, jclass, jlong self); + +JNIEXPORT jstring JNICALL Java_org_opencv_highgui_VideoCapture_n_1getSupportedPreviewSizes + (JNIEnv *env, jclass, jlong self) +{ + try { + + LOGD("highgui::VideoCapture_n_1set()"); + + VideoCapture* me = (VideoCapture*) self; //TODO: check for NULL + union {double prop; const char* name;} u; + u.prop = me->get(CV_CAP_PROP_SUPPORTED_PREVIEW_SIZES_STRING); + return env->NewStringUTF(u.name); + } catch(cv::Exception e) { + + LOGD("highgui::VideoCapture_n_1getSupportedPreviewSizes() catched cv::Exception: %s", e.what()); + + jclass je = env->FindClass("org/opencv/core/CvException"); + if(!je) je = env->FindClass("java/lang/Exception"); + env->ThrowNew(je, e.what()); + return env->NewStringUTF(""); + } catch (...) { + + LOGD("highgui::VideoCapture_n_1getSupportedPreviewSizes() catched unknown exception (...)"); + + jclass je = env->FindClass("java/lang/Exception"); + env->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1getSupportedPreviewSizes()}"); + return env->NewStringUTF(""); + } +} + + + +// +// native support for java finalize() +// static void VideoCapture::n_delete( __int64 self ) +// + +JNIEXPORT void JNICALL Java_org_opencv_highgui_VideoCapture_n_1delete + (JNIEnv*, jclass, jlong self); + +JNIEXPORT void JNICALL Java_org_opencv_highgui_VideoCapture_n_1delete + (JNIEnv*, jclass, jlong self) +{ + delete (VideoCapture*) self; +} + +} // extern "C" + +#endif // HAVE_OPENCV_HIGHGUI \ No newline at end of file diff --git a/modules/java/generator/src/cpp/videocap_compat.cpp b/modules/java/generator/src/cpp/videocap_compat.cpp deleted file mode 100644 index 4c4e64bf84..0000000000 --- a/modules/java/generator/src/cpp/videocap_compat.cpp +++ /dev/null @@ -1,173 +0,0 @@ -// emulating the 'old' JNI names existed before the VideoCapture wrapping became automatic - -#define LOG_TAG "org.opencv.highgui.VideoCapture" -#include "common.h" - -#include "opencv2/opencv_modules.hpp" -#ifdef HAVE_OPENCV_HIGHGUI - -#include "opencv2/core/version.hpp" - -#if (CV_VERSION_EPOCH == 2) && (CV_VERSION_MAJOR == 4) -extern "C" { - -JNIEXPORT jlong JNICALL Java_org_opencv_highgui_VideoCapture_n_1VideoCapture__ - (JNIEnv* env, jclass c); - -JNIEXPORT jlong JNICALL Java_org_opencv_highgui_VideoCapture_VideoCapture_10 (JNIEnv*, jclass); - -JNIEXPORT jlong JNICALL Java_org_opencv_highgui_VideoCapture_n_1VideoCapture__ - (JNIEnv* env, jclass c) -{ - return Java_org_opencv_highgui_VideoCapture_VideoCapture_10(env, c); -} - - -JNIEXPORT jlong JNICALL Java_org_opencv_highgui_VideoCapture_n_1VideoCapture__I - (JNIEnv* env, jclass c, jint device); - -JNIEXPORT jlong JNICALL Java_org_opencv_highgui_VideoCapture_VideoCapture_12 (JNIEnv*, jclass, jint); - -JNIEXPORT jlong JNICALL Java_org_opencv_highgui_VideoCapture_n_1VideoCapture__I - (JNIEnv* env, jclass c, jint device) -{ - return Java_org_opencv_highgui_VideoCapture_VideoCapture_12(env, c, device); -} - - -JNIEXPORT jdouble JNICALL Java_org_opencv_highgui_VideoCapture_n_1get - (JNIEnv* env, jclass c, jlong self, jint propId); - -JNIEXPORT jdouble JNICALL Java_org_opencv_highgui_VideoCapture_get_10 (JNIEnv*, jclass, jlong, jint); - -JNIEXPORT jdouble JNICALL Java_org_opencv_highgui_VideoCapture_n_1get - (JNIEnv* env, jclass c, jlong self, jint propId) -{ - return Java_org_opencv_highgui_VideoCapture_get_10(env, c, self, propId); -} - - -JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1grab - (JNIEnv* env, jclass c, jlong self); - -JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_grab_10 (JNIEnv*, jclass, jlong); - -JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1grab - (JNIEnv* env, jclass c, jlong self) -{ - return Java_org_opencv_highgui_VideoCapture_grab_10(env, c, self); -} - - -JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1isOpened - (JNIEnv* env, jclass c, jlong self); - -JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_isOpened_10 (JNIEnv*, jclass, jlong); - -JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1isOpened - (JNIEnv* env, jclass c, jlong self) -{ - return Java_org_opencv_highgui_VideoCapture_isOpened_10(env, c, self); -} - - -JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1open__JI - (JNIEnv* env, jclass c, jlong self, jint device); - -JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_open_11 (JNIEnv*, jclass, jlong, jint); - -JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1open__JI - (JNIEnv* env, jclass c, jlong self, jint device) -{ - return Java_org_opencv_highgui_VideoCapture_open_11(env, c, self, device); -} - - -JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1read - (JNIEnv* env, jclass c, jlong self, jlong image_nativeObj); - -JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_read_10 (JNIEnv*, jclass, jlong, jlong); - -JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1read - (JNIEnv* env, jclass c, jlong self, jlong image_nativeObj) -{ - return Java_org_opencv_highgui_VideoCapture_read_10(env, c, self, image_nativeObj); -} - - -JNIEXPORT void JNICALL Java_org_opencv_highgui_VideoCapture_n_1release - (JNIEnv* env, jclass c, jlong self); - -JNIEXPORT void JNICALL Java_org_opencv_highgui_VideoCapture_release_10 (JNIEnv*, jclass, jlong); - -JNIEXPORT void JNICALL Java_org_opencv_highgui_VideoCapture_n_1release - (JNIEnv* env, jclass c, jlong self) -{ - Java_org_opencv_highgui_VideoCapture_release_10(env, c, self); -} - - -JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1retrieve__JJI - (JNIEnv* env, jclass c, jlong self, jlong image_nativeObj, jint channel); - -JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_retrieve_10 (JNIEnv*, jclass, jlong, jlong, jint); - -JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1retrieve__JJI - (JNIEnv* env, jclass c, jlong self, jlong image_nativeObj, jint channel) -{ - return Java_org_opencv_highgui_VideoCapture_retrieve_10(env, c, self, image_nativeObj, channel); -} - - -JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1retrieve__JJ - (JNIEnv* env, jclass c, jlong self, jlong image_nativeObj); - -JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_retrieve_11 (JNIEnv*, jclass, jlong, jlong); - -JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1retrieve__JJ - (JNIEnv* env, jclass c, jlong self, jlong image_nativeObj) -{ - return Java_org_opencv_highgui_VideoCapture_retrieve_11(env, c, self, image_nativeObj); -} - - -JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1set - (JNIEnv* env, jclass c, jlong self, jint propId, jdouble value); - -JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_set_10 (JNIEnv*, jclass, jlong, jint, jdouble); - -JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1set - (JNIEnv* env, jclass c, jlong self, jint propId, jdouble value) -{ - return Java_org_opencv_highgui_VideoCapture_set_10(env, c, self, propId, value); -} - - -JNIEXPORT jstring JNICALL Java_org_opencv_highgui_VideoCapture_n_1getSupportedPreviewSizes - (JNIEnv *env, jclass c, jlong self); - -JNIEXPORT jstring JNICALL Java_org_opencv_highgui_VideoCapture_getSupportedPreviewSizes_10 - (JNIEnv *env, jclass, jlong self); - -JNIEXPORT jstring JNICALL Java_org_opencv_highgui_VideoCapture_n_1getSupportedPreviewSizes - (JNIEnv *env, jclass c, jlong self) -{ - return Java_org_opencv_highgui_VideoCapture_getSupportedPreviewSizes_10(env, c, self); -} - - -JNIEXPORT void JNICALL Java_org_opencv_highgui_VideoCapture_n_1delete - (JNIEnv *env, jclass c, jlong self); - -JNIEXPORT void JNICALL Java_org_opencv_highgui_VideoCapture_delete(JNIEnv*, jclass, jlong); - -JNIEXPORT void JNICALL Java_org_opencv_highgui_VideoCapture_n_1delete - (JNIEnv *env, jclass c, jlong self) -{ - Java_org_opencv_highgui_VideoCapture_delete(env, c, self); -} - - -} // extern "C" -#endif // (CV_VERSION_EPOCH == 2) && (CV_VERSION_MAJOR == 4) -#endif // HAVE_OPENCV_HIGHGUI diff --git a/modules/java/generator/src/java/highgui+VideoCapture.java b/modules/java/generator/src/java/highgui+VideoCapture.java new file mode 100644 index 0000000000..6f3b03540d --- /dev/null +++ b/modules/java/generator/src/java/highgui+VideoCapture.java @@ -0,0 +1,240 @@ +package org.opencv.highgui; + +import java.util.List; +import java.util.LinkedList; + +import org.opencv.core.Mat; +import org.opencv.core.Size; + +// C++: class VideoCapture +//javadoc: VideoCapture +public class VideoCapture { + + protected final long nativeObj; + + protected VideoCapture(long addr) { + nativeObj = addr; + } + + // + // C++: VideoCapture::VideoCapture() + // + + // javadoc: VideoCapture::VideoCapture() + public VideoCapture() + { + + nativeObj = n_VideoCapture(); + + return; + } + + // + // C++: VideoCapture::VideoCapture(int device) + // + + // javadoc: VideoCapture::VideoCapture(device) + public VideoCapture(int device) + { + + nativeObj = n_VideoCapture(device); + + return; + } + + // + // C++: double VideoCapture::get(int propId) + // + +/** + * Returns the specified "VideoCapture" property. + * + * Note: When querying a property that is not supported by the backend used by + * the "VideoCapture" class, value 0 is returned. + * + * @param propId property identifier; it can be one of the following: + * * CV_CAP_PROP_FRAME_WIDTH width of the frames in the video stream. + * * CV_CAP_PROP_FRAME_HEIGHT height of the frames in the video stream. + * + * @see org.opencv.highgui.VideoCapture.get + */ + public double get(int propId) + { + + double retVal = n_get(nativeObj, propId); + + return retVal; + } + + public List getSupportedPreviewSizes() + { + String[] sizes_str = n_getSupportedPreviewSizes(nativeObj).split(","); + List sizes = new LinkedList(); + + for (String str : sizes_str) { + String[] wh = str.split("x"); + sizes.add(new Size(Double.parseDouble(wh[0]), Double.parseDouble(wh[1]))); + } + + return sizes; + } + + // + // C++: bool VideoCapture::grab() + // + + // javadoc: VideoCapture::grab() + public boolean grab() + { + + boolean retVal = n_grab(nativeObj); + + return retVal; + } + + // + // C++: bool VideoCapture::isOpened() + // + + // javadoc: VideoCapture::isOpened() + public boolean isOpened() + { + + boolean retVal = n_isOpened(nativeObj); + + return retVal; + } + + // + // C++: bool VideoCapture::open(int device) + // + + // javadoc: VideoCapture::open(device) + public boolean open(int device) + { + + boolean retVal = n_open(nativeObj, device); + + return retVal; + } + + // + // C++: bool VideoCapture::read(Mat image) + // + + // javadoc: VideoCapture::read(image) + public boolean read(Mat image) + { + + boolean retVal = n_read(nativeObj, image.nativeObj); + + return retVal; + } + + // + // C++: void VideoCapture::release() + // + + // javadoc: VideoCapture::release() + public void release() + { + + n_release(nativeObj); + + return; + } + + // + // C++: bool VideoCapture::retrieve(Mat image, int channel = 0) + // + + // javadoc: VideoCapture::retrieve(image, channel) + public boolean retrieve(Mat image, int channel) + { + + boolean retVal = n_retrieve(nativeObj, image.nativeObj, channel); + + return retVal; + } + + // javadoc: VideoCapture::retrieve(image) + public boolean retrieve(Mat image) + { + + boolean retVal = n_retrieve(nativeObj, image.nativeObj); + + return retVal; + } + + // + // C++: bool VideoCapture::set(int propId, double value) + // + +/** + * Sets a property in the "VideoCapture". + * + * @param propId property identifier; it can be one of the following: + * * CV_CAP_PROP_FRAME_WIDTH width of the frames in the video stream. + * * CV_CAP_PROP_FRAME_HEIGHT height of the frames in the video stream. + * @param value value of the property. + * + * @see org.opencv.highgui.VideoCapture.set + */ + public boolean set(int propId, double value) + { + + boolean retVal = n_set(nativeObj, propId, value); + + return retVal; + } + + @Override + protected void finalize() throws Throwable { + n_delete(nativeObj); + super.finalize(); + } + + // C++: VideoCapture::VideoCapture() + private static native long n_VideoCapture(); + + // C++: VideoCapture::VideoCapture(string filename) + private static native long n_VideoCapture(java.lang.String filename); + + // C++: VideoCapture::VideoCapture(int device) + private static native long n_VideoCapture(int device); + + // C++: double VideoCapture::get(int propId) + private static native double n_get(long nativeObj, int propId); + + // C++: bool VideoCapture::grab() + private static native boolean n_grab(long nativeObj); + + // C++: bool VideoCapture::isOpened() + private static native boolean n_isOpened(long nativeObj); + + // C++: bool VideoCapture::open(string filename) + private static native boolean n_open(long nativeObj, java.lang.String filename); + + // C++: bool VideoCapture::open(int device) + private static native boolean n_open(long nativeObj, int device); + + // C++: bool VideoCapture::read(Mat image) + private static native boolean n_read(long nativeObj, long image_nativeObj); + + // C++: void VideoCapture::release() + private static native void n_release(long nativeObj); + + // C++: bool VideoCapture::retrieve(Mat image, int channel = 0) + private static native boolean n_retrieve(long nativeObj, long image_nativeObj, int channel); + + private static native boolean n_retrieve(long nativeObj, long image_nativeObj); + + // C++: bool VideoCapture::set(int propId, double value) + private static native boolean n_set(long nativeObj, int propId, double value); + + private static native String n_getSupportedPreviewSizes(long nativeObj); + + // native support for java finalize() + private static native void n_delete(long nativeObj); + +}