Hu Chunming / village_ascend_arm

  #include "com_objecteye_nativeinterface_vehicle_VehicleNativeInterface.h"
  #include "sy_common.h"
  #include "sy_errorinfo.h"
  #include "iostream"
  #include "map"
  #include <string>
  #include <string.h>

  #include <chrono>

  #include <mutex>

  
  #include "../src/village_pic_interface.h"
  
  #include "opencv2/imgcodecs/legacy/constants_c.h"
  #include "opencv2/imgproc/types_c.h"
  #include <opencv2/opencv.hpp>
  #include "base64.h"
  

  //dvpp����
  #include "dvpp_process.h"
  #include "utils.h"

  #include "logger.hpp"

  //#include "img_codec.h"
  
  double msecond() {

      chrono::time_point<chrono::system_clock, chrono::milliseconds> tpMicro
          = chrono::time_point_cast<chrono::milliseconds>(chrono::system_clock::now());
      return tpMicro.time_since_epoch().count();

  }
  
  
  string Decode(const char* data, int size)
  {
      const char DecodeTable[] =
      {
          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
          62, // '+'
          0, 0, 0,
          63, // '/'
          52, 53, 54, 55, 56, 57, 58, 59, 60, 61, // '0'-'9'
          0, 0, 0, 0, 0, 0, 0,
          0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
          13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, // 'A'-'Z'
          0, 0, 0, 0, 0, 0,
          26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
          39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, // 'a'-'z'
      };
  
      int outSize = 0;
      int nValue;
      int i= 0;
      string outStr = "";
      while (i < size)
      {
          if (*data != '\r' && *data != '\n')
          {
              nValue = DecodeTable[*data++] << 18;
              nValue += DecodeTable[*data++] << 12;
              outStr += (nValue & 0x00FF0000) >> 16;
              outSize++;
              if (*data != '=')
              {
                  nValue += DecodeTable[*data++] << 6;
                  outStr += (nValue & 0x0000FF00) >> 8;
                  outSize++;
                  if (*data != '=')
                  {
                      nValue += DecodeTable[*data++];
                      outStr += nValue & 0x000000FF;
                      outSize++;
                  }
              }
              i += 4;
          }
          else
          {
              data++;
              i++;
          }
      }
  
      return outStr;
  }
  
  
  using namespace std;
  #define SUCCESS 0 //�ɹ�
  #define FAILED -1 //ʧ��
  /**
   * ��������
   * */
  sy_format getImgByteType(int type);

  
  /**
   * ȫ�ֱ���
   * */
  sy_command global_vehicle_detect_config;          		  //�Ƿ����������(һ�������)
  sy_command global_vehicle_recg_config;                    //�Ƿ���������ʶ��
  sy_command global_vehicle_recg_supplement_config;         //�Ƿ���������ʶ�𲹳�ʶ��(��ͷ��βlogo���ʶ��+����15����)
  sy_command global_vehicle_plate_det_recg_config;          //�Ƿ��������Ƽ��ʶ��
  sy_command global_vehicle_color_config;                   //�Ƿ�����������ɫʶ��
  sy_command global_vehicle_pendant_det_config;             //�Ƿ�������������ʶ��
  sy_command global_vehicle_illegal_config;                 //�Ƿ�������Υ����Ϊ���
  sy_command global_vehicle_feature_config;                 //�Ƿ���������������ȡ
  //sy_command global_vehicle_special_config;                 //�Ƿ���������Ʒ�೵��ʶ��
  //sy_command global_vehicle_image_quality_config;           //�Ƿ���������ͼ��������ʶ��
  sy_command global_vehicle_motor_tricycle_analysis_config; //�Ƿ�����Ħ�г��Ƿ�����/Ħ�г���ʻ���Ƿ��ͷ��/ũ�ó��Ƿ�����
  //sy_command global_vehicle_motor_hs_output_config;         //�Ƿ�����Ħ�г�δ��ͷ�����ͷ������
  //sy_command global_vehicle_stain_vp_config;                //�Ƿ������ڵ�����ʶ��
  //sy_command global_vehicle_muck_truck_cover_config;        //�Ƿ������������Ǹ�ʶ��(ǰ�᣺����vehicle_special_config)
  sy_command global_vehicle_manned_config;            //�Ƿ������������ֳ�����ʶ��
  //sy_command global_vehicle_pose_config;                    //�Ƿ�����pose���   //20210618 atlas
  
  int gpu_id;

  DvppProcess* dvpp = nullptr;
  aclrtContext ctx = nullptr;
  aclrtStream stream = nullptr;
  
  std::mutex m_single_mtx;

  
  /*
   * Class:     com_objecteye_nativeinterface_vehicle_VehicleNativeInterface
   * Method:    va_init
   * Signature: ([JLcom/objecteye/pojo/vehicle/VehicleAnalysisParam;)I
   */
  JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_vehicle_VehicleNativeInterface_init(JNIEnv *env, jobject obj, jlongArray handle, jobject vehicleAnalysisParam)
  {
      //getFieldID
      //�㷨���ò���
      jclass cls_vehcileAnalysisParam = env->GetObjectClass(vehicleAnalysisParam);
  

      jfieldID fid_sdk_path = env->GetFieldID(cls_vehcileAnalysisParam, "sdk_path", "Ljava/lang/String;");

      jfieldID fid_gpuid = env->GetFieldID(cls_vehcileAnalysisParam, "gpuId", "I");
  

      jfieldID fid_aiEngineParam_logLevel = env->GetFieldID(cls_vehcileAnalysisParam, "logLevel", "I");
      jfieldID fid_aiEngineParam_logPath = env->GetFieldID(cls_vehcileAnalysisParam, "logPath", "Ljava/lang/String;");
      jfieldID fid_aiEngineParam_logDays = env->GetFieldID(cls_vehcileAnalysisParam, "logDays", "I");
      jfieldID fid_aiEngineParam_logMem = env->GetFieldID(cls_vehcileAnalysisParam, "logMem", "D");
  

      jstring str_sdk_path = (jstring)env->GetObjectField(vehicleAnalysisParam, fid_sdk_path);
      const char *sdk_path = env->GetStringUTFChars(str_sdk_path, JNI_FALSE);

      jint gpuid = env->GetIntField(vehicleAnalysisParam, fid_gpuid);
  	

      //log
      jstring str_aiEngineParam_logPath = (jstring)env->GetObjectField(vehicleAnalysisParam, fid_aiEngineParam_logPath);
      const char* aiEngineParam_logPath = env->GetStringUTFChars(str_aiEngineParam_logPath, JNI_FALSE);
      jint aiEngineParam_logDays = env->GetIntField(vehicleAnalysisParam, fid_aiEngineParam_logDays);
      jdouble aiEngineParam_logMem = env->GetDoubleField(vehicleAnalysisParam, fid_aiEngineParam_logMem);
      jint aiEngineParam_logLevel = env->GetIntField(vehicleAnalysisParam, fid_aiEngineParam_logLevel);
  

      void *vaHandle = NULL;
      VillageParam param;
      param.dev_id = gpuid;

      param.sdk_path = sdk_path;

      param.log_level = aiEngineParam_logLevel;
      param.log_path = aiEngineParam_logPath;
      param.log_days = aiEngineParam_logDays;
      param.log_mem = aiEngineParam_logMem;
  

  
      string log_path = param.log_path + "/jni.log";
      set_default_logger(LogLevel(param.log_level), "PicAnalysis", log_path.c_str(), param.log_mem, param.log_days);
  
      LOG_INFO("jni dev_id:{}", param.dev_id);
      LOG_INFO("jni sdk_path:{}", param.sdk_path.c_str());
      LOG_INFO("jni log_level:{}", param.log_level);
      LOG_INFO("jni log_path:{}", param.log_path.c_str());
      LOG_INFO("jni log_days:{}", param.log_days);
      LOG_INFO("jni log_mem:{}", param.log_mem);

      int ret = village_pic_init(&vaHandle, param);

   	if (ret != SUCCESS) {

  		LOG_ERROR("jni village_pic_init failed.");

  		return ret;
  	}

  	
      if (ret == SUCCESS)
      {
          global_vehicle_detect_config = SY_CONFIG_OPEN;
          global_vehicle_recg_config = SY_CONFIG_OPEN;
          global_vehicle_recg_supplement_config = SY_CONFIG_OPEN;
          global_vehicle_plate_det_recg_config = SY_CONFIG_OPEN;
          global_vehicle_pendant_det_config = SY_CONFIG_OPEN;
          global_vehicle_motor_tricycle_analysis_config = SY_CONFIG_OPEN;
          global_vehicle_manned_config = SY_CONFIG_OPEN;

          global_vehicle_illegal_config = SY_CONFIG_OPEN;

          global_vehicle_feature_config = SY_CONFIG_CLOSE;
          global_vehicle_color_config = SY_CONFIG_CLOSE;
  
          jlong temp[1];
          temp[0] = (jlong)vaHandle;
          env->SetLongArrayRegion(handle, 0, 1, temp);
      }

      env->ReleaseStringUTFChars(str_sdk_path, sdk_path);

      env->ReleaseStringUTFChars(str_aiEngineParam_logPath, aiEngineParam_logPath);

  	ACL_CALL(aclrtCreateContext(&ctx, gpu_id), ACL_ERROR_NONE, FAILED);
  	ACL_CALL(aclrtSetCurrentContext(ctx), ACL_ERROR_NONE, FAILED);

  	ACL_CALL(aclrtCreateStream(&stream), ACL_ERROR_NONE, FAILED);
  	
  	dvpp = new DvppProcess();
  	dvpp->InitResource(stream);

      LOG_ERROR("jni init succeed.");

      return ret;

  }
  

   /*
   * Class:     com_objecteye_nativeinterface_vehicle_VehicleNativeInterface
   * Method:     batch
   * Signature: (J[Lcom/objecteye/pojo/common/SyImgParam;II[Lcom/objecteye/pojo/vehicle/VehicleAnalysisResultParam;)I
   */
  JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_vehicle_VehicleNativeInterface_batch(JNIEnv *env, jobject jobj, jlong handle, jobjectArray syImgParams, jint format, jint batchSize, jobjectArray vehicleAnalysisResultParams)
  {
      int ret = FAILED;
      void *vaHandle = (void *)handle;

      if (nullptr ==  vaHandle || nullptr == dvpp || nullptr == stream || nullptr == ctx)
      {
          return ret;
      }
  
      std::lock_guard<std::mutex> l(m_single_mtx);

  	jclass cls_syImgParam = env->FindClass("com/objecteye/pojo/common/SyImgParam");
  	jfieldID fid_image_str = env->GetFieldID(cls_syImgParam, "image_string", "Ljava/lang/String;");//base64�����ⲿͳһ��url��fileת��base64����
  	
  	sy_img batch_img[batchSize];

      ImageData dvpp_data[batchSize];
  

  	ACL_CALL(aclrtSetCurrentContext(ctx), ACL_ERROR_NONE, FAILED);

  	if (format != 1)

  	{

  		LOG_ERROR("ERROR FORMAT TYPE: {}", format);
  		return FAILED;

  	}
  
  	double t1,t2,t3;
  	t1 = msecond();
  			
  	for (size_t i = 0; i < batchSize; i++)
  	{
  		jobject syImgParam = env->GetObjectArrayElement(syImgParams, i);
  		jstring imageString1 = (jstring)env->GetObjectField(syImgParam, fid_image_str);
  		const char *image_str = env->GetStringUTFChars(imageString1, JNI_FALSE);
  		string imageString  = image_str;

          string decode_str;
          //decode_str = decoder->Decode(encode_str[b].data(), encode_str[b].size());
          decode_str = Decode(imageString.data(), imageString.size());
          env->ReleaseStringUTFChars(imageString1, image_str);
          
          //debug========================================================
          ImageData src;
          uint32_t binFileBufferLen = decode_str.size() + 8;//�ֽ���
          uint8_t* binFileBufferData = new(std::nothrow) uint8_t[binFileBufferLen];
          
          if (binFileBufferData == nullptr) {
              LOG_ERROR("malloc binFileBufferData failed");
              return FAILED;
          }
          
          src.data.reset(binFileBufferData, [](uint8_t* p) { delete[](p); });
  
          memcpy((char *)binFileBufferData, decode_str.data(), binFileBufferLen);
          int32_t ch = 0;
          ret = acldvppJpegGetImageInfo(binFileBufferData, binFileBufferLen, &(src.width), &(src.height), &ch);
          if (SUCCESS != ret) {
              LOG_ERROR("acldvppJpegGetImageInfo failed");
              return FAILED;
          }
  
          src.size = binFileBufferLen;
  
          ret = dvpp->CvtJpegToYuv420sp(dvpp_data[i], src);
          if (SUCCESS != ret) {
              LOG_ERROR("CvtJpegToYuv420sp failed");
              return FAILED;
          }
  
          batch_img[i].w_ = dvpp_data[i].width;//dvpp_data[b].alignWidth;
          batch_img[i].h_ = dvpp_data[i].height;//dvpp_data[b].alignHeight;
          //batch_img[i].data_ = (uint8_t*)Utils::CopyDataDeviceToLocal(dvpp_data[i].data.get(), dvpp_data[i].size);//dvpp_data[b].data.get();
          batch_img[i].data_ = dvpp_data[i].data.get();          

  	}
  	t2 = msecond();
      //printf("va jni info:decode time: %.2f\n", (t2 - t1));	
  	

      std::cout << "village_pic_analysis " << std::endl;

  
      std::vector<AnalysisResult> vec_result = village_pic_analysis(vaHandle, batch_img, batchSize);

  	if (vec_result.size() <= 0 || vec_result.size() != batchSize)

  	{

          LOG_ERROR("village_pic_analysis failed.");
  		return FAILED;

  	}

      cout << "result size:" << vec_result.size() << endl;

  	
  	t3 = msecond();

      std::cout << "struct " << std::endl;
      // getClass
      jclass cls_vehicleAnalysisResult = env->FindClass("com/objecteye/pojo/vehicle/VehicleAnalysisResultParam");
      jclass cls_VehicleInfo = env->FindClass("com/objecteye/pojo/vehicle/VehicleInfoParam");
      jclass cls_LineInfo = env->FindClass("com/objecteye/pojo/vehicle/LineInfoParam");
      jclass cls_SegInfo = env->FindClass("com/objecteye/pojo/vehicle/SegInfoParam");
  
      jclass cls_VehicleDetectResult = env->FindClass("com/objecteye/pojo/vehicle/VehicleDetectResultParam");
      jclass cls_VehicleColorResult = env->FindClass("com/objecteye/pojo/vehicle/VehicleColorResultParam");
      jclass cls_VehicleRecgResult = env->FindClass("com/objecteye/pojo/vehicle/VehicleRecognizeResultParam");
      //jclass cls_VehicleRecgTopnResult = env->FindClass("com/objecteye/pojo/vehicle/VehicleRecognizeResultTopnParam");//wh20210527������topn�ӿ�
      jclass cls_VplateResult = env->FindClass("com/objecteye/pojo/vehicle/VehiclePlateResultParam");
      jclass cls_VehiclePendantDetResult = env->FindClass("com/objecteye/pojo/vehicle/VehiclePendantDetectResultParam");
      jclass cls_VehicleIllegalDetResult = env->FindClass("com/objecteye/pojo/vehicle/VehicleIllegalDetectResultParam");
      jclass cls_VehicleFeaResult = env->FindClass("com/objecteye/pojo/vehicle/VehicleFeatureResultParam");
      jclass cls_SyRect = env->FindClass("com/objecteye/pojo/common/SyRectParam");
      jclass cls_VplateNum = env->FindClass("com/objecteye/pojo/vehicle/VehiclePlateNumParam");
      jclass cls_VehiclePendantDetInfo = env->FindClass("com/objecteye/pojo/vehicle/VehiclePendantDetectInfoParam");
      jclass cls_VehicleIllegalDetInfo = env->FindClass("com/objecteye/pojo/vehicle/VehicleIllegalDetectInfoParam");
      jclass cls_VehicleIllegalDetDetails = env->FindClass("com/objecteye/pojo/vehicle/VehicleIllegalDetectDetailsParam");
      //jclass cls_VehicleSpecialInformationParam = env->FindClass("com/objecteye/pojo/vehicle/VehicleSpecialInformationParam");
      //jclass cls_VehicleSpecialResult = env->FindClass("com/objecteye/pojo/vehicle/VehicleSpecialResultParam");
      //jclass cls_MucktruckcoverResult = env->FindClass("com/objecteye/pojo/vehicle/MucktruckcoverResultParam");
      jclass cls_MtaResult = env->FindClass("com/objecteye/pojo/vehicle/MtaResultParam");
      jclass cls_MtaDetailsParam = env->FindClass("com/objecteye/pojo/vehicle/MtaDetailsParam");

      jclass cls_StainVplateResultParam = env->FindClass("com/objecteye/pojo/vehicle/StainVplateResultParam");
      if (nullptr == cls_StainVplateResultParam)
      {

          LOG_ERROR("cls_StainVplateResultParam find class error!");

      }
      

      jclass cls_MannedResultParam = env->FindClass("com/objecteye/pojo/vehicle/MannedResultParam");
  
      //jclass cls_VehiclePoseResultParam = env->FindClass("com/objecteye/pojo/vehicle/VehiclePoseResultParam");//wh20210601������pose���
  
      jclass cls_SyPoint = env->FindClass("com/objecteye/pojo/common/SyPointParam");
      
      
      //getmethodId
      jmethodID mid_vehicleAnalysisResult = env->GetMethodID(cls_vehicleAnalysisResult, "<init>", "([Lcom/objecteye/pojo/vehicle/VehicleInfoParam;[Lcom/objecteye/pojo/vehicle/LineInfoParam;[Lcom/objecteye/pojo/vehicle/SegInfoParam;I)V");
  
      jmethodID mid_VehicleInfo = env->GetMethodID(cls_VehicleInfo, "<init>", "(Lcom/objecteye/pojo/vehicle/VehicleDetectResultParam;Lcom/objecteye/pojo/vehicle/VehicleDetectResultParam;Lcom/objecteye/pojo/vehicle/VehicleDetectResultParam;Lcom/objecteye/pojo/vehicle/VehicleColorResultParam;Lcom/objecteye/pojo/vehicle/VehicleRecognizeResultParam;Lcom/objecteye/pojo/vehicle/VehiclePlateResultParam;Lcom/objecteye/pojo/vehicle/VehiclePendantDetectResultParam;Lcom/objecteye/pojo/vehicle/VehicleIllegalDetectResultParam;Lcom/objecteye/pojo/vehicle/VehicleFeatureResultParam;Lcom/objecteye/pojo/vehicle/MtaResultParam;Lcom/objecteye/pojo/vehicle/MannedResultParam;IIIFIIIIIIFII)V");	
  
      jmethodID mid_VehicleDetectResult = env->GetMethodID(cls_VehicleDetectResult, "<init>", "(Lcom/objecteye/pojo/common/SyRectParam;F)V");
      jmethodID mid_VehicleColorResult = env->GetMethodID(cls_VehicleColorResult, "<init>", "(FI)V");
      //jmethodID mid_VehicleRecgTopnResult = env->GetMethodID(cls_VehicleRecgTopnResult, "<init>", "([Lcom/objecteye/pojo/vehicle/VehicleRecognizeResultParam;I)V");//wh20210527������topn�ӿ�
      jmethodID mid_VehicleRecgResult = env->GetMethodID(cls_VehicleRecgResult, "<init>", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;F)V");

      jmethodID mid_VplateResult = env->GetMethodID(cls_VplateResult, "<init>", "(Lcom/objecteye/pojo/common/SyRectParam;F[Lcom/objecteye/pojo/vehicle/VehiclePlateNumParam;FIILcom/objecteye/pojo/vehicle/StainVplateResultParam;)V");
      if (nullptr == mid_VplateResult)
      {

          LOG_ERROR("mid_VplateResult GetMethodID error!");

      }

      jmethodID mid_VehiclePendantDetResult = env->GetMethodID(cls_VehiclePendantDetResult, "<init>", "([Lcom/objecteye/pojo/vehicle/VehiclePendantDetectInfoParam;I)V");
      jmethodID mid_VehicleIllegalDetResult = env->GetMethodID(cls_VehicleIllegalDetResult, "<init>", "(Lcom/objecteye/pojo/vehicle/VehicleIllegalDetectInfoParam;Lcom/objecteye/pojo/vehicle/VehicleIllegalDetectInfoParam;)V");

      if (nullptr == mid_VehicleIllegalDetResult)
      {

          LOG_ERROR("mid_VehicleIllegalDetResult GetMethodID error!");

      }

      jmethodID mid_VehicleFeaResult = env->GetMethodID(cls_VehicleFeaResult, "<init>", "([F)V");
      jmethodID mid_SyRect = env->GetMethodID(cls_SyRect, "<init>", "(IIII)V");
      jmethodID mid_VplateNum = env->GetMethodID(cls_VplateNum, "<init>", "(Ljava/lang/String;F)V");
  
  
      jmethodID mid_VehiclePendantDetInfo = env->GetMethodID(cls_VehiclePendantDetInfo, "<init>", "(Lcom/objecteye/pojo/common/SyRectParam;IFII)V");
      jmethodID mid_VehicleIllegalDetInfo = env->GetMethodID(cls_VehicleIllegalDetInfo, "<init>", "(Lcom/objecteye/pojo/vehicle/VehicleIllegalDetectDetailsParam;Lcom/objecteye/pojo/vehicle/VehicleIllegalDetectDetailsParam;Lcom/objecteye/pojo/vehicle/VehicleIllegalDetectDetailsParam;Lcom/objecteye/pojo/vehicle/VehicleIllegalDetectDetailsParam;Lcom/objecteye/pojo/vehicle/VehicleIllegalDetectDetailsParam;)V");
      jmethodID mid_VehicleIllegalDetDetails = env->GetMethodID(cls_VehicleIllegalDetDetails, "<init>", "(IF)V");
      //jmethodID mid_VehicleSpecialInformationParam = env->GetMethodID(cls_VehicleSpecialInformationParam, "<init>", "(FI)V");
      //jmethodID mid_VehicleSpecialResult = env->GetMethodID(cls_VehicleSpecialResult, "<init>", "([Lcom/objecteye/pojo/vehicle/VehicleSpecialInformationParam;I)V");
      jmethodID mid_MtaResult = env->GetMethodID(cls_MtaResult, "<init>", "(Lcom/objecteye/pojo/vehicle/MtaDetailsParam;Lcom/objecteye/pojo/vehicle/MtaDetailsParam;Lcom/objecteye/pojo/vehicle/MtaDetailsParam;Lcom/objecteye/pojo/vehicle/VehicleDetectResultParam;)V");
      jmethodID mid_MtaDetailsParam = env->GetMethodID(cls_MtaDetailsParam, "<init>", "(IF)V");

      jmethodID mid_StainVplateResultParam = env->GetMethodID(cls_StainVplateResultParam, "<init>", "(FI)V");

      //jmethodID mid_MucktruckcoverResult = env->GetMethodID(cls_MucktruckcoverResult, "<init>", "(IF)V");
      jmethodID mid_MannedResult = env->GetMethodID(cls_MannedResultParam, "<init>", "([Lcom/objecteye/pojo/vehicle/VehicleDetectResultParam;I)V");//wh20220222
      jmethodID mid_SyPoint = env->GetMethodID(cls_SyPoint, "<init>", "(II)V");//wh20210601������pose���
      //jmethodID mid_VehiclePoseResult = env->GetMethodID(cls_VehiclePoseResultParam, "<init>", "([Lcom/objecteye/pojo/common/SyPointParam;[F[FDDD)V");
  

      jmethodID mid_LineInfo = env->GetMethodID(cls_LineInfo, "<init>", "([Lcom/objecteye/pojo/common/SyPointParam;I)V");		       
      jmethodID mid_SegInfo = env->GetMethodID(cls_SegInfo, "<init>", "([Lcom/objecteye/pojo/common/SyPointParam;I)V");		

  
      //set value to param
      std::cout << "vehicleInfoArray " << std::endl;
      
      for (size_t i = 0; i < batchSize; i++)

      {

          jobjectArray vehicleInfoArray = env->NewObjectArray(vec_result[i].info.size(), cls_VehicleInfo, NULL);
          for (int j = 0; j < vec_result[i].info.size(); j++)
          { //vehicleDetectRes
              std::cout << "vehicleDetectRes" << std::endl;
              auto vehicle_info = vec_result[i].info[j];
              jobject vehicle_detect_res_syRect_rect = env->NewObject(cls_SyRect, mid_SyRect, vehicle_info.vehicle_detect_res.rect.left_, vehicle_info.vehicle_detect_res.rect.top_, vehicle_info.vehicle_detect_res.rect.width_, vehicle_info.vehicle_detect_res.rect.height_);
              jobject vehicleDetectResult = env->NewObject(cls_VehicleDetectResult, mid_VehicleDetectResult, vehicle_detect_res_syRect_rect, vehicle_info.vehicle_detect_res.score);
              //vehicleWinDetectRes
              jobject vehicle_win_detect_res_syRect_rect = env->NewObject(cls_SyRect, mid_SyRect, vehicle_info.vehicle_win_detect_res.rect.left_, vehicle_info.vehicle_win_detect_res.rect.top_, vehicle_info.vehicle_win_detect_res.rect.width_, vehicle_info.vehicle_win_detect_res.rect.height_);
              jobject vehicleWinDetectResult = env->NewObject(cls_VehicleDetectResult, mid_VehicleDetectResult, vehicle_win_detect_res_syRect_rect, vehicle_info.vehicle_win_detect_res.score);
              //vehicleBodyDetectRes
              jobject vehicle_body_detect_res_syRect_rect = env->NewObject(cls_SyRect, mid_SyRect, vehicle_info.vehicle_body_detect_res.rect.left_, vehicle_info.vehicle_body_detect_res.rect.top_, vehicle_info.vehicle_body_detect_res.rect.width_, vehicle_info.vehicle_body_detect_res.rect.height_);
              jobject vehicleBodyDetectResult = env->NewObject(cls_VehicleDetectResult, mid_VehicleDetectResult, vehicle_body_detect_res_syRect_rect, vehicle_info.vehicle_body_detect_res.score);
              //vehicleColorRes
              jobject vehicleColorResult = NULL;
              if (global_vehicle_color_config == SY_CONFIG_OPEN)
              {
                  std::cout << "vehicleColorResult" << std::endl;
                  vehicleColorResult = env->NewObject(cls_VehicleColorResult, mid_VehicleColorResult, vehicle_info.vehicle_color_res.score, vehicle_info.vehicle_color_res.index);
              }

              //vehicleRecgRes   //0618 atlas�Ļ�top1�Ľӿ�
              jobject vehicleRecgResult = NULL;
              if (global_vehicle_recg_config == SY_CONFIG_OPEN)
              {
                  std::cout << "vehicleRecgResult" << std::endl;
                  jstring vehicleBrand = env->NewStringUTF(vehicle_info.vehicle_recg_res.vehicle_brand);
                  jstring vehicleSubbrand = env->NewStringUTF(vehicle_info.vehicle_recg_res.vehicle_subbrand);
                  jstring vehicleIssueYear = env->NewStringUTF(vehicle_info.vehicle_recg_res.vehicle_issue_year);
                  jstring vehicleType = env->NewStringUTF(vehicle_info.vehicle_recg_res.vehicle_type);
                  jstring freightTon = env->NewStringUTF(vehicle_info.vehicle_recg_res.freight_ton);
                  vehicleRecgResult = env->NewObject(cls_VehicleRecgResult, mid_VehicleRecgResult, vehicleBrand, vehicleSubbrand, vehicleIssueYear, vehicleType, freightTon, vehicle_info.vehicle_recg_res.name_score);
              }

              //vehiclePlateDetRecgRes
              jobject vplateResult = NULL;
              jobject vehicle_plate_det_recg_res_syRect_rect = NULL;
              jobjectArray vplateNumArray = NULL;

              auto vehicle_plate_res = vehicle_info.vehicle_plate_det_recg_res;

              if (global_vehicle_plate_det_recg_config == SY_CONFIG_OPEN)
              {
                  std::cout << "vehicle_plate_det_recg_res_syRect_rect" << std::endl;

                  vehicle_plate_det_recg_res_syRect_rect = env->NewObject(cls_SyRect, mid_SyRect, vehicle_plate_res.rect.left_, vehicle_plate_res.rect.top_, vehicle_plate_res.rect.width_, vehicle_plate_res.rect.height_);

                  vplateNumArray = env->NewObjectArray(PLATENUM, cls_VplateNum, NULL);
                  for (size_t k = 0; k < PLATENUM; k++)

                  {

                      jstring character = env->NewStringUTF(vehicle_plate_res.recg[k].character);
                      jobject vplateNum = env->NewObject(cls_VplateNum, mid_VplateNum, character, vehicle_plate_res.recg[k].maxprob);

                      env->SetObjectArrayElement(vplateNumArray, k, vplateNum);

                  }

              }

              jobject stain_v_plate = env->NewObject(cls_StainVplateResultParam, mid_StainVplateResultParam, vehicle_plate_res.stain_vp_result.score, vehicle_plate_res.stain_vp_result.type);
              std::cout << "vplateResult" << std::endl;

              vplateResult = env->NewObject(cls_VplateResult, mid_VplateResult, vehicle_plate_det_recg_res_syRect_rect, vehicle_plate_res.detect_score, vplateNumArray, vehicle_plate_res.num_score, vehicle_plate_res.type, vehicle_plate_res.special_type, stain_v_plate);                

              std::cout << "vplateResult end" << std::endl;

              //vehiclePendantDetRes
              jobject vehiclePendantDetResult = NULL;
              if (global_vehicle_pendant_det_config == SY_CONFIG_OPEN)
              {
                  jobjectArray vehiclePendantDetInfoArray = env->NewObjectArray(vehicle_info.vehicle_pendant_det_res.size(), cls_VehiclePendantDetInfo, NULL);
                  for (size_t m = 0; m < vehicle_info.vehicle_pendant_det_res.size(); m++)

                  {

                      auto one_pendant_res = vehicle_info.vehicle_pendant_det_res[m];
                      jobject vehicle_pendant_det_res_vpd_res_syRect_rect = env->NewObject(cls_SyRect, mid_SyRect, one_pendant_res.rect.left_,
                                                                                          one_pendant_res.rect.top_, one_pendant_res.rect.width_, one_pendant_res.rect.height_);
                      
                      jobject vehiclePendantDetInfo = env->NewObject(cls_VehiclePendantDetInfo, mid_VehiclePendantDetInfo, vehicle_pendant_det_res_vpd_res_syRect_rect, one_pendant_res.index, one_pendant_res.confidence, one_pendant_res.driver_copilot_info, one_pendant_res.iColor);
                      
                      env->SetObjectArrayElement(vehiclePendantDetInfoArray, m, vehiclePendantDetInfo);

                  }

                  vehiclePendantDetResult = env->NewObject(cls_VehiclePendantDetResult, mid_VehiclePendantDetResult, vehiclePendantDetInfoArray, vehicle_info.vehicle_pendant_det_res.size());
              }

              std::cout << "vehiclePendantDetResult" << std::endl;
  
              //vehicleIllegalDetRes
              jobject vehicleIllegalDetResult = NULL;
              if (global_vehicle_illegal_config == SY_CONFIG_OPEN)
              {
                  jobject vehicleIllegalDetDetails_driver_belt = env->NewObject(cls_VehicleIllegalDetDetails, mid_VehicleIllegalDetDetails, vehicle_info.vehicle_illegal_det_res.driver.belt.status, vehicle_info.vehicle_illegal_det_res.driver.belt.confidence);
                  jobject vehicleIllegalDetDetails_driver_smoke = env->NewObject(cls_VehicleIllegalDetDetails, mid_VehicleIllegalDetDetails, vehicle_info.vehicle_illegal_det_res.driver.smoke.status, vehicle_info.vehicle_illegal_det_res.driver.smoke.confidence);
                  jobject vehicleIllegalDetDetails_driver_call = env->NewObject(cls_VehicleIllegalDetDetails, mid_VehicleIllegalDetDetails, vehicle_info.vehicle_illegal_det_res.driver.call.status, vehicle_info.vehicle_illegal_det_res.driver.call.confidence);
                  jobject vehicleIllegalDetDetails_driver_phone = env->NewObject(cls_VehicleIllegalDetDetails, mid_VehicleIllegalDetDetails, vehicle_info.vehicle_illegal_det_res.driver.phone.status, vehicle_info.vehicle_illegal_det_res.driver.phone.confidence);
                  jobject vehicleIllegalDetDetails_driver_person = env->NewObject(cls_VehicleIllegalDetDetails, mid_VehicleIllegalDetDetails, vehicle_info.vehicle_illegal_det_res.driver.person.status, vehicle_info.vehicle_illegal_det_res.driver.person.confidence);
                  jobject vehicleIllegalDetDetails_copilot_belt = env->NewObject(cls_VehicleIllegalDetDetails, mid_VehicleIllegalDetDetails, vehicle_info.vehicle_illegal_det_res.copilot.belt.status, vehicle_info.vehicle_illegal_det_res.copilot.belt.confidence);
                  jobject vehicleIllegalDetDetails_copilot_smoke = env->NewObject(cls_VehicleIllegalDetDetails, mid_VehicleIllegalDetDetails, vehicle_info.vehicle_illegal_det_res.copilot.smoke.status, vehicle_info.vehicle_illegal_det_res.copilot.smoke.confidence);
                  jobject vehicleIllegalDetDetails_copilot_call = env->NewObject(cls_VehicleIllegalDetDetails, mid_VehicleIllegalDetDetails, vehicle_info.vehicle_illegal_det_res.copilot.call.status, vehicle_info.vehicle_illegal_det_res.copilot.call.confidence);
                  jobject vehicleIllegalDetDetails_copilot_phone = env->NewObject(cls_VehicleIllegalDetDetails, mid_VehicleIllegalDetDetails, vehicle_info.vehicle_illegal_det_res.copilot.phone.status, vehicle_info.vehicle_illegal_det_res.copilot.phone.confidence);
                  jobject vehicleIllegalDetDetails_copilot_person = env->NewObject(cls_VehicleIllegalDetDetails, mid_VehicleIllegalDetDetails, vehicle_info.vehicle_illegal_det_res.copilot.person.status, vehicle_info.vehicle_illegal_det_res.copilot.person.confidence);
  
                  jobject vehicleIllegalDetInfo_driver = env->NewObject(cls_VehicleIllegalDetInfo, mid_VehicleIllegalDetInfo, vehicleIllegalDetDetails_driver_belt, vehicleIllegalDetDetails_driver_smoke, vehicleIllegalDetDetails_driver_phone, vehicleIllegalDetDetails_driver_call,  vehicleIllegalDetDetails_driver_person);
                  jobject vehicleIllegalDetInfo_copilot = env->NewObject(cls_VehicleIllegalDetInfo, mid_VehicleIllegalDetInfo, vehicleIllegalDetDetails_copilot_belt, vehicleIllegalDetDetails_copilot_smoke, vehicleIllegalDetDetails_copilot_phone, vehicleIllegalDetDetails_copilot_call, vehicleIllegalDetDetails_copilot_person);
                  vehicleIllegalDetResult = env->NewObject(cls_VehicleIllegalDetResult, mid_VehicleIllegalDetResult, vehicleIllegalDetInfo_driver, vehicleIllegalDetInfo_copilot);
              }
  
              //vehicleFeaRes
              jobject vehicleFeaResult = NULL;
              if (global_vehicle_feature_config == SY_CONFIG_OPEN)
              {
                  jfloatArray feature = env->NewFloatArray(VA_FEATURESIZE);
                  env->SetFloatArrayRegion(feature, 0, VA_FEATURESIZE, vehicle_info.vehicle_fea_res.feature);
                  vehicleFeaResult = env->NewObject(cls_VehicleFeaResult, mid_VehicleFeaResult, feature);
              }

              //MtaResultParam
              jobject mtaResult = NULL;
              if (global_vehicle_motor_tricycle_analysis_config == SY_CONFIG_OPEN)
              {
                  jobject mtaDetailsParam_motor_driver_helmeted = env->NewObject(cls_MtaDetailsParam, mid_MtaDetailsParam, vehicle_info.mta_res.motor_driver_helmeted.status, vehicle_info.mta_res.motor_driver_helmeted.confidence);
                  jobject mtaDetailsParam_motor_manned = env->NewObject(cls_MtaDetailsParam, mid_MtaDetailsParam, vehicle_info.mta_res.motor_manned.status, vehicle_info.mta_res.motor_manned.confidence);
                  jobject mtaDetailsParam_tricycle_manned = env->NewObject(cls_MtaDetailsParam, mid_MtaDetailsParam, vehicle_info.mta_res.tricycle_manned.status, vehicle_info.mta_res.tricycle_manned.confidence);
                  jobject mtaDetailsParam_motor_driver_hs_rect = NULL;
                  //if (global_vehicle_motor_hs_output_config == SY_CONFIG_OPEN)

                  {

                      jobject mtaDetailsParam_motor_driver_hs_rect_syRect_rect = env->NewObject(cls_SyRect, mid_SyRect, vehicle_info.mta_res.motor_driver_hs_rect.rect.left_, vehicle_info.mta_res.motor_driver_hs_rect.rect.top_, vehicle_info.mta_res.motor_driver_hs_rect.rect.width_, vehicle_info.mta_res.motor_driver_hs_rect.rect.height_);
                      mtaDetailsParam_motor_driver_hs_rect = env->NewObject(cls_VehicleDetectResult, mid_VehicleDetectResult, mtaDetailsParam_motor_driver_hs_rect_syRect_rect, vehicle_info.mta_res.motor_driver_hs_rect.score);

                  }

                  mtaResult = env->NewObject(cls_MtaResult, mid_MtaResult, mtaDetailsParam_motor_driver_helmeted, mtaDetailsParam_motor_manned, mtaDetailsParam_tricycle_manned, mtaDetailsParam_motor_driver_hs_rect);
              }

              //LorryMannedResultParam
              jobject MannedResult = NULL;
              if (global_vehicle_manned_config == SY_CONFIG_OPEN)
              {
                  int MannedResHsCount = vehicle_info.manned_res.hs_count;

                  jobjectArray hsDetectResultArray = env->NewObjectArray(MannedResHsCount, cls_VehicleDetectResult, NULL);

                  for (size_t m = 0; m < MannedResHsCount; m++)

                  {
                      jobject Manned_hsDetect_syRect = env->NewObject(cls_SyRect, mid_SyRect,
                                                                          vehicle_info.manned_res.hs_rect[m].rect.left_,
                                                                          vehicle_info.manned_res.hs_rect[m].rect.top_,
                                                                          vehicle_info.manned_res.hs_rect[m].rect.width_,
                                                                          vehicle_info.manned_res.hs_rect[m].rect.height_);

                      jobject Manned_hsDetect = env->NewObject(cls_VehicleDetectResult, mid_VehicleDetectResult, Manned_hsDetect_syRect, vehicle_info.manned_res.hs_rect[m].score);

                      env->SetObjectArrayElement(hsDetectResultArray, m, Manned_hsDetect);

                  }
  

                  MannedResult = env->NewObject(cls_MannedResultParam, mid_MannedResult,
                              hsDetectResultArray,
                              MannedResHsCount);

              }
  

              std::cout << "type" << std::endl;
              jint type = vehicle_info.type;
              jint vpt_type = vehicle_info.vpt_type;
              jint rainshed = vehicle_info.rainshed;		//是否安装雨棚， 0 有雨棚   1 无雨棚
              jfloat rainshed_prob = vehicle_info.rainshed_prob;
              jint truck_manned = vehicle_info.truck_manned;
              jint motor_manned = vehicle_info.motor_manned;
              jint human_upper_color = vehicle_info.human_upper_color;
              jint human_lower_color = vehicle_info.human_lower_color;
              jint reverse_driving = vehicle_info.reverse_driving;    // 0 正常行驶   1 逆行   -1 未知
              jint phoning = vehicle_info.phoning;        // 骑车打电话
              jfloat phoning_prob = vehicle_info.phoning_prob;
              jint cross_line = vehicle_info.cross_line;         // 压实线， 1 黄实线 2 白实线  -1 其他
              jint cross_diversion_line = vehicle_info.cross_diversion_line;   // 压导流线   1 压了  -1 未压

              jobject vehicleInfo = env->NewObject(cls_VehicleInfo, mid_VehicleInfo, vehicleDetectResult, vehicleWinDetectResult, vehicleBodyDetectResult, vehicleColorResult, vehicleRecgResult, vplateResult, vehiclePendantDetResult, vehicleIllegalDetResult, vehicleFeaResult,mtaResult, MannedResult, type, vpt_type, rainshed, rainshed_prob, truck_manned, motor_manned, human_upper_color, human_lower_color, reverse_driving, phoning, phoning_prob, cross_line, cross_diversion_line);

              std::cout << "vehicleInfo end" << std::endl;

              env->SetObjectArrayElement(vehicleInfoArray, j, vehicleInfo);
  
              std::cout << "SetObjectArrayElement" << std::endl;
          }

          std::cout << "line info " << std::endl;

          // 道路标志线
          jobjectArray LineInfoArray = env->NewObjectArray(vec_result[i].vec_line.size(), cls_LineInfo, NULL);
          for (int j = 0; j < vec_result[i].vec_line.size(); j++)
          {
              auto line_info = vec_result[i].vec_line[j];
              jobjectArray ptArray = env->NewObjectArray(line_info.vec_pt.size(), cls_SyPoint, NULL);
              for (int k = 0; k < line_info.vec_pt.size(); k++)

              {

                  auto pt = line_info.vec_pt[k];
                  jobject line_info_point = env->NewObject(cls_SyPoint, mid_SyPoint, pt.x, pt.y);
                  env->SetObjectArrayElement(ptArray, k, line_info_point);
              }

              jobject one_line_info = env->NewObject(cls_LineInfo, mid_LineInfo, ptArray, line_info.line_type);

              env->SetObjectArrayElement(LineInfoArray, j, one_line_info);
          }
  
          std::cout << "road info " << std::endl;
  
          // 道路
          jobjectArray RoadInfoArray = env->NewObjectArray(vec_result[i].vec_road.size(), cls_SegInfo, NULL);
          for (int j = 0; j < vec_result[i].vec_road.size(); j++)
          {
              auto road_info = vec_result[i].vec_road[j];
              jobjectArray ptArray = env->NewObjectArray(road_info.vec_pt.size(), cls_SyPoint, NULL);
              for (int k = 0; k < road_info.vec_pt.size(); k++)
              {
                  auto pt = road_info.vec_pt[k];
                  jobject road_info_point = env->NewObject(cls_SyPoint, mid_SyPoint, pt.x, pt.y);
                  env->SetObjectArrayElement(ptArray, k, road_info_point);

              }
  

              jobject one_road_info = env->NewObject(cls_SegInfo, mid_SegInfo, ptArray, road_info.seg_type);
  
              env->SetObjectArrayElement(RoadInfoArray, j, one_road_info);

          }

  
          std::cout << "add new " << std::endl;
  
          jobject vehicleAnalysisResult = env->NewObject(cls_vehicleAnalysisResult, mid_vehicleAnalysisResult, vehicleInfoArray, LineInfoArray, RoadInfoArray, vec_result[i].info.size());			
          env->SetObjectArrayElement(vehicleAnalysisResultParams, i, vehicleAnalysisResult);

      }
  

      return SUCCESS;

  }
  
  /*
   * Class:     com_objecteye_nativeinterface_vehicle_VehicleNativeInterface
   * Method:    va_release
   * Signature: (J)V
   */
  JNIEXPORT void JNICALL Java_com_objecteye_nativeinterface_vehicle_VehicleNativeInterface_release(JNIEnv *env, jobject obj, jlong handle)
  {
      void *vaHandle = (void *)handle;
      if (vaHandle != NULL)
      {

          village_pic_release(&vaHandle);

      }

  
      if (ctx) {
          aclrtSetCurrentContext(ctx);
      }
      
      if (dvpp) {
          delete dvpp;
          dvpp = nullptr;
      }
  
      if (stream) {
          (void) aclrtDestroyStream(stream);
      }
      
  	if (ctx) {
          aclrtDestroyContext(ctx);
      }

  }
  
  /*
   * Class:     com_objecteye_nativeinterface_vehicle_VehicleNativeInterface

   * Method:    get_village_pic_version

   * Signature: ()Ljava/lang/String;
   */
  JNIEXPORT jstring JNICALL Java_com_objecteye_nativeinterface_vehicle_VehicleNativeInterface_getVersion(JNIEnv *env, jobject obj)
  {

      const char *version = get_village_pic_version();

      return env->NewStringUTF(version);
  }
  
  /**
   *  ����ͼƬ�ı����ʽ
   * */
  sy_format getImgByteType(int type)
  {
      sy_format syFormat;
      switch (type)
      {
      case 0:
          syFormat = SY_FORMAT_BGR888;
          break;
      case 1:
          syFormat = SY_FORMAT_BGRA888;
          break;
      case 2:
          syFormat = SY_FORMAT_GRAY8;
          break;
      case 3:
          syFormat = SY_FORMAT_YUV4420P;
          break;
      case 4:
          syFormat = SY_FORMAT_NV12;
          break;
      case 5:
          syFormat = SY_FORMAT_NV21;
          break;
      default:
          syFormat = SY_FORMAT_BGR888;
          break;
      }
      return syFormat;

  }