[Android] Update ppseg jni via new api and optimize jni vis func (#734)

* [Android] Update ppseg jni via new api and optimize jni vis funcs

* delete local refs

java/android/app/src/main/java/com/baidu/paddle/fastdeploy/app/examples/segmentation/SegmentationMainActivity.java

@@ -250,12 +250,10 @@ public class SegmentationMainActivity extends Activity implements View.OnClickLi
         }
 
         boolean modified = false;
-
-        long tc = System.currentTimeMillis();
-
         SegmentationResult result = new SegmentationResult();
         result.setCxxBufferFlag(true);
 
+        long tc = System.currentTimeMillis();
         predictor.predict(ARGB8888ImageBitmap, result);
         timeElapsed += (System.currentTimeMillis() - tc);
 

java/android/fastdeploy/src/main/cpp/fastdeploy_jni/vision/results_jni.cc

@@ -859,6 +859,13 @@ bool AllocateSegmentationResultFromJava(
     return false;
   }
 
+  // mInitialized boolean:         Z
+  jboolean j_seg_initialized =
+      env->GetBooleanField(j_seg_result_obj, j_seg_initialized_id_cc);
+  if (j_seg_initialized == JNI_FALSE) {
+    return false;
+  }
+
   // If 'mEnableCxxBuffer' set as true, then, we only Allocate from
   // cxx context to cxx result. Some users may want to use this
   // method to boost the performance of segmentation.
@@ -872,32 +879,23 @@ bool AllocateSegmentationResultFromJava(
     }
     // Allocate from cxx context to cxx result
     auto c_cxx_buffer = reinterpret_cast<vision::SegmentationResult *>(j_cxx_buffer);
-    // TODO: May use 'swap' to exchange the administrative privileges ?
+
-    // c_result_ptr->shape.swap(c_cxx_buffer->shape);
+    // (*c_result_ptr) = std::move(*c_cxx_buffer);
-    // c_result_ptr->label_map.swap(c_cxx_buffer->label_map);
+    c_result_ptr->shape = c_cxx_buffer->shape;
-    // c_result_ptr->contain_score_map = c_cxx_buffer->contain_score_map;
+    const size_t label_len = c_cxx_buffer->label_map.size();
-    // if (c_cxx_buffer->contain_score_map) {
+    c_result_ptr->label_map.resize(label_len);
-    //   c_result_ptr->score_map.swap(c_cxx_buffer->score_map);
+    std::memcpy(c_result_ptr->label_map.data(), c_cxx_buffer->label_map.data(),
-    // }
+                label_len * sizeof(uint8_t));
-    c_result_ptr->shape.assign(
-        c_cxx_buffer->shape.begin(), c_cxx_buffer->shape.end());
-    c_result_ptr->label_map.assign(
-        c_cxx_buffer->label_map.begin(), c_cxx_buffer->label_map.end());
     c_result_ptr->contain_score_map = c_cxx_buffer->contain_score_map;
     if (c_cxx_buffer->contain_score_map) {
-      c_result_ptr->score_map.assign(
+      const size_t score_len = c_cxx_buffer->score_map.size();
-          c_cxx_buffer->score_map.begin(), c_cxx_buffer->score_map.end());
+      c_result_ptr->score_map.resize(score_len);
+      std::memcpy(c_result_ptr->score_map.data(), c_cxx_buffer->score_map.data(),
+                  score_len * sizeof(float));
     }
     return true;
   }
 
-  // mInitialized boolean:         Z
-  jboolean j_seg_initialized =
-      env->GetBooleanField(j_seg_result_obj, j_seg_initialized_id_cc);
-  if (j_seg_initialized == JNI_FALSE) {
-    return false;
-  }
-
   jbyteArray j_seg_label_map_byte_arr = reinterpret_cast<jbyteArray>(
       env->GetObjectField(j_seg_result_obj, j_seg_label_map_id_cc));
   jlongArray j_seg_shape_long_arr = reinterpret_cast<jlongArray>(

java/android/fastdeploy/src/main/cpp/fastdeploy_jni/vision/segmentation/paddleseg_model_jni.cc

@@ -49,7 +49,7 @@ Java_com_baidu_paddle_fastdeploy_vision_segmentation_PaddleSegModel_bindNative(
   jboolean j_is_vertical_screen = env->GetBooleanField(
       thiz, j_is_vertical_screen_id);
   bool c_is_vertical_screen = static_cast<jboolean>(j_is_vertical_screen);
-  c_model_ptr->is_vertical_screen = c_is_vertical_screen;
+  c_model_ptr->GetPreprocessor().SetIsVerticalScreen(c_is_vertical_screen);
   env->DeleteLocalRef(j_ppseg_clazz);
 
   vision::EnableFlyCV();

java/android/fastdeploy/src/main/cpp/fastdeploy_jni/vision/visualize_jni.cc

@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 #include <jni.h>  // NOLINT
+#include "fastdeploy_jni/perf_jni.h"  // NOLINT
 #include "fastdeploy_jni/bitmap_jni.h"  // NOLINT
 #include "fastdeploy_jni/convert_jni.h" // NOLINT
 #include "fastdeploy_jni/vision/results_jni.h"  // NOLINT
@@ -19,16 +20,21 @@
 namespace fni = fastdeploy::jni;
 namespace vision = fastdeploy::vision;
 
-#ifdef __cplusplus
+namespace fastdeploy {
-extern "C" {
+namespace jni {
-#endif
 
-/// VisClassification
+/// Some visualize helpers.
-JNIEXPORT jboolean JNICALL
+jboolean VisClassificationFromJava(
-Java_com_baidu_paddle_fastdeploy_vision_Visualize_visClassificationNative(
+    JNIEnv *env, jobject argb8888_bitmap,
-    JNIEnv *env, jclass clazz, jobject argb8888_bitmap,
     jobject result, jfloat score_threshold, jfloat font_size,
     jobjectArray labels) {
+  const jclass j_cls_result_clazz = env->FindClass(
+      "com/baidu/paddle/fastdeploy/vision/ClassifyResult");
+  if (!env->IsInstanceOf(result, j_cls_result_clazz)) {
+    env->DeleteLocalRef(j_cls_result_clazz);
+    return JNI_FALSE;
+  }
+  env->DeleteLocalRef(j_cls_result_clazz);
   vision::ClassifyResult c_result;
   if (!fni::AllocateCxxResultFromJava(
       env, result, reinterpret_cast<void *>(&c_result),
@@ -56,19 +62,23 @@ Java_com_baidu_paddle_fastdeploy_vision_Visualize_visClassificationNative(
   return JNI_TRUE;
 }
 
-/// VisDetection
+jboolean VisDetectionFromJava(
-JNIEXPORT jboolean JNICALL
+    JNIEnv *env, jobject argb8888_bitmap,
-Java_com_baidu_paddle_fastdeploy_vision_Visualize_visDetectionNative(
-    JNIEnv *env, jclass clazz, jobject argb8888_bitmap,
     jobject result, jfloat score_threshold, jint line_size,
     jfloat font_size, jobjectArray labels) {
+  const jclass j_det_result_clazz = env->FindClass(
+      "com/baidu/paddle/fastdeploy/vision/DetectionResult");
+  if (!env->IsInstanceOf(result, j_det_result_clazz)) {
+    env->DeleteLocalRef(j_det_result_clazz);
+    return JNI_FALSE;
+  }
+  env->DeleteLocalRef(j_det_result_clazz);
   vision::DetectionResult c_result;
   if (!fni::AllocateCxxResultFromJava(
       env, result, reinterpret_cast<void *>(&c_result),
       vision::ResultType::DETECTION)) {
     return JNI_FALSE;
   }
-
   // Get labels from Java [n]
   auto c_labels = fni::ConvertTo<std::vector<std::string>>(env, labels);
 
@@ -90,11 +100,15 @@ Java_com_baidu_paddle_fastdeploy_vision_Visualize_visDetectionNative(
   return JNI_TRUE;
 }
 
-/// VisOcr
+jboolean VisOcrFromJava(
-JNIEXPORT jboolean JNICALL
+    JNIEnv *env, jobject argb8888_bitmap, jobject result) {
-Java_com_baidu_paddle_fastdeploy_vision_Visualize_visOcrNative(
+  const jclass j_ocr_result_clazz = env->FindClass(
-    JNIEnv *env, jclass clazz, jobject argb8888_bitmap,
+      "com/baidu/paddle/fastdeploy/vision/OCRResult");
-    jobject result) {
+  if (!env->IsInstanceOf(result, j_ocr_result_clazz)) {
+    env->DeleteLocalRef(j_ocr_result_clazz);
+    return JNI_FALSE;
+  }
+  env->DeleteLocalRef(j_ocr_result_clazz);
   vision::OCRResult c_result;
   if (!fni::AllocateCxxResultFromJava(
       env, result, reinterpret_cast<void *>(&c_result),
@@ -113,17 +127,22 @@ Java_com_baidu_paddle_fastdeploy_vision_Visualize_visOcrNative(
   return JNI_TRUE;
 }
 
-JNIEXPORT jboolean JNICALL
+jboolean VisSegmentationFromJava(
-Java_com_baidu_paddle_fastdeploy_vision_Visualize_visSegmentationNative(
+    JNIEnv *env, jobject argb8888_bitmap, jobject result, jfloat weight) {
-    JNIEnv *env, jclass clazz, jobject argb8888_bitmap,
+  const jclass j_seg_result_clazz = env->FindClass(
-    jobject result, jfloat weight) {
+      "com/baidu/paddle/fastdeploy/vision/SegmentationResult");
+  if (!env->IsInstanceOf(result, j_seg_result_clazz)) {
+    env->DeleteLocalRef(j_seg_result_clazz);
+    return JNI_FALSE;
+  }
+  env->DeleteLocalRef(j_seg_result_clazz);
+  // Allocate from Java result, may cost some times.
   vision::SegmentationResult c_result;
   if (!fni::AllocateCxxResultFromJava(
       env, result, reinterpret_cast<void *>(&c_result),
       vision::ResultType::SEGMENTATION)) {
     return JNI_FALSE;
   }
-
   cv::Mat c_bgr;
   if (!fni::ARGB888Bitmap2BGR(env, argb8888_bitmap, &c_bgr)) {
     return JNI_FALSE;
@@ -135,17 +154,66 @@ Java_com_baidu_paddle_fastdeploy_vision_Visualize_visSegmentationNative(
   return JNI_TRUE;
 }
 
-JNIEXPORT jboolean JNICALL
+jboolean VisSegmentationFromCxxBuffer(
-Java_com_baidu_paddle_fastdeploy_vision_Visualize_visFaceDetectionNative(
+    JNIEnv *env, jobject argb8888_bitmap, jobject result, jfloat weight) {
-    JNIEnv *env, jclass clazz, jobject argb8888_bitmap,
+  const jclass j_seg_result_clazz = env->FindClass(
+      "com/baidu/paddle/fastdeploy/vision/SegmentationResult");
+  if (!env->IsInstanceOf(result, j_seg_result_clazz)) {
+    env->DeleteLocalRef(j_seg_result_clazz);
+    return JNI_FALSE;
+  }
+  const jfieldID j_enable_cxx_buffer_id = env->GetFieldID(
+      j_seg_result_clazz, "mEnableCxxBuffer", "Z");
+  const jfieldID  j_cxx_buffer_id = env->GetFieldID(
+      j_seg_result_clazz, "mCxxBuffer", "J");
+  const jfieldID j_seg_initialized_id = env->GetFieldID(
+      j_seg_result_clazz, "mInitialized", "Z");
+  jboolean j_enable_cxx_buffer =
+      env->GetBooleanField(result, j_enable_cxx_buffer_id);
+  jboolean j_seg_initialized =
+      env->GetBooleanField(result, j_seg_initialized_id);
+
+  env->DeleteLocalRef(j_seg_result_clazz);
+  if (j_seg_initialized == JNI_FALSE) {
+    return JNI_FALSE;
+  }
+  // Use CxxBuffer directly without any copy.
+  if (j_enable_cxx_buffer == JNI_TRUE) {
+    jlong j_cxx_buffer = env->GetLongField(result, j_cxx_buffer_id);
+    if (j_cxx_buffer == 0) {
+      return JNI_FALSE;
+    }
+    // Allocate from cxx context to cxx result
+    auto c_cxx_buffer = reinterpret_cast<vision::SegmentationResult *>(j_cxx_buffer);
+    cv::Mat c_bgr;
+    if (!fni::ARGB888Bitmap2BGR(env, argb8888_bitmap, &c_bgr)) {
+      return JNI_FALSE;
+    }
+    auto c_vis_im = vision::VisSegmentation(c_bgr, *c_cxx_buffer, weight);
+    if (!fni::BGR2ARGB888Bitmap(env, argb8888_bitmap, c_vis_im)) {
+      return JNI_FALSE;
+    }
+    return JNI_TRUE;
+  }
+  return JNI_FALSE;
+}
+
+jboolean VisFaceDetectionFromJava(
+    JNIEnv *env, jobject argb8888_bitmap,
     jobject result, jint line_size, jfloat font_size) {
+  const jclass j_face_det_result_clazz = env->FindClass(
+      "com/baidu/paddle/fastdeploy/vision/FaceDetectionResult");
+  if (!env->IsInstanceOf(result, j_face_det_result_clazz)) {
+    env->DeleteLocalRef(j_face_det_result_clazz);
+    return JNI_FALSE;
+  }
+  env->DeleteLocalRef(j_face_det_result_clazz);
   vision::FaceDetectionResult c_result;
   if (!fni::AllocateCxxResultFromJava(
       env, result, reinterpret_cast<void *>(&c_result),
       vision::ResultType::FACE_DETECTION)) {
     return JNI_FALSE;
   }
-
   cv::Mat c_bgr;
   if (!fni::ARGB888Bitmap2BGR(env, argb8888_bitmap, &c_bgr)) {
     return JNI_FALSE;
@@ -157,6 +225,64 @@ Java_com_baidu_paddle_fastdeploy_vision_Visualize_visFaceDetectionNative(
   return JNI_TRUE;
 }
 
+}  // jni
+}  // fastdeploy
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// VisClassification
+JNIEXPORT jboolean JNICALL
+Java_com_baidu_paddle_fastdeploy_vision_Visualize_visClassificationNative(
+    JNIEnv *env, jclass clazz, jobject argb8888_bitmap,
+    jobject result, jfloat score_threshold, jfloat font_size,
+    jobjectArray labels) {
+  return fni::VisClassificationFromJava(env, argb8888_bitmap, result,
+                                        score_threshold, font_size, labels);
+}
+
+/// VisDetection
+JNIEXPORT jboolean JNICALL
+Java_com_baidu_paddle_fastdeploy_vision_Visualize_visDetectionNative(
+    JNIEnv *env, jclass clazz, jobject argb8888_bitmap,
+    jobject result, jfloat score_threshold, jint line_size,
+    jfloat font_size, jobjectArray labels) {
+  return fni::VisDetectionFromJava(env, argb8888_bitmap, result, score_threshold,
+                                   line_size, font_size, labels);
+}
+
+/// VisOcr
+JNIEXPORT jboolean JNICALL
+Java_com_baidu_paddle_fastdeploy_vision_Visualize_visOcrNative(
+    JNIEnv *env, jclass clazz, jobject argb8888_bitmap,
+    jobject result) {
+  return fni::VisOcrFromJava(env, argb8888_bitmap, result);
+}
+
+/// VisSegmentation
+JNIEXPORT jboolean JNICALL
+Java_com_baidu_paddle_fastdeploy_vision_Visualize_visSegmentationNative(
+    JNIEnv *env, jclass clazz, jobject argb8888_bitmap,
+    jobject result, jfloat weight) {
+  // First, try visualize segmentation result via CxxBuffer.
+  if (fni::VisSegmentationFromCxxBuffer(
+      env, argb8888_bitmap, result, weight)) {
+    return JNI_TRUE;
+  }
+  // Then, try visualize segmentation from Java result(may cost some times).
+  return fni::VisSegmentationFromJava(env, argb8888_bitmap, result, weight);
+}
+
+/// VisFaceDetection
+JNIEXPORT jboolean JNICALL
+Java_com_baidu_paddle_fastdeploy_vision_Visualize_visFaceDetectionNative(
+    JNIEnv *env, jclass clazz, jobject argb8888_bitmap,
+    jobject result, jint line_size, jfloat font_size) {
+  return fni::VisFaceDetectionFromJava(env, argb8888_bitmap, result,
+                                       line_size, font_size);
+}
+
 #ifdef __cplusplus
 }
 #endif