Пример #1
0
 public static bool pl_enum_str_length(Int16 hcam, UInt32 param_id, UInt32 index, out UInt32 length)
 {
     if (m_is64bit)
     {
         return(Pvcam64.pl_enum_str_length(hcam, param_id, index, out length));
     }
     else
     {
         return(Pvcam32.pl_enum_str_length(hcam, param_id, index, out length));
     }
 }
Пример #2
0
 public static bool pl_set_param(Int16 hcam, UInt32 param_id, IntPtr param_value)
 {
     if (m_is64bit)
     {
         return(Pvcam64.pl_set_param(hcam, param_id, param_value));
     }
     else
     {
         return(Pvcam32.pl_set_param(hcam, param_id, param_value));
     }
 }
Пример #3
0
 public static bool pl_error_message(Int16 err_code, StringBuilder msg)
 {
     if (m_is64bit)
     {
         return(Pvcam64.pl_error_message(err_code, msg));
     }
     else
     {
         return(Pvcam32.pl_error_message(err_code, msg));
     }
 }
Пример #4
0
 public static Int16 pl_error_code()
 {
     if (m_is64bit)
     {
         return(Pvcam64.pl_error_code());
     }
     else
     {
         return(Pvcam32.pl_error_code());
     }
 }
Пример #5
0
 public static bool pl_pp_reset(Int16 hcam)
 {
     if (m_is64bit)
     {
         return(Pvcam64.pl_pp_reset(hcam));
     }
     else
     {
         return(Pvcam32.pl_pp_reset(hcam));
     }
 }
Пример #6
0
 public static bool pl_exp_start_cont(Int16 hcam, IntPtr pixel_stream, UInt32 size)
 {
     if (m_is64bit)
     {
         return(Pvcam64.pl_exp_start_cont(hcam, pixel_stream, size));
     }
     else
     {
         return(Pvcam32.pl_exp_start_cont(hcam, pixel_stream, size));
     }
 }
Пример #7
0
 public static bool pl_cam_get_total(out Int16 hCam)
 {
     if (m_is64bit)
     {
         return(Pvcam64.pl_cam_get_total(out hCam));
     }
     else
     {
         return(Pvcam32.pl_cam_get_total(out hCam));
     }
 }
Пример #8
0
 public static bool pl_exp_unlock_oldest_frame(Int16 hcam)
 {
     if (m_is64bit)
     {
         return(Pvcam64.pl_exp_unlock_oldest_frame(hcam));
     }
     else
     {
         return(Pvcam32.pl_exp_unlock_oldest_frame(hcam));
     }
 }
Пример #9
0
 public static bool pl_pvcam_get_ver(out UInt16 version)
 {
     if (m_is64bit)
     {
         return(Pvcam64.pl_pvcam_get_ver(out version));
     }
     else
     {
         return(Pvcam32.pl_pvcam_get_ver(out version));
     }
 }
Пример #10
0
 public static bool pl_release_smart_stream_struct(out PvTypes.smart_stream_type smtStreamStruct)
 {
     if (m_is64bit)
     {
         return(Pvcam64.pl_release_smart_stream_struct(out smtStreamStruct));
     }
     else
     {
         return(Pvcam32.pl_release_smart_stream_struct(out smtStreamStruct));
     }
 }
Пример #11
0
 public static bool pl_exp_stop_cont(Int16 hcam, Int16 cam_state)
 {
     if (m_is64bit)
     {
         return(Pvcam64.pl_exp_stop_cont(hcam, cam_state));
     }
     else
     {
         return(Pvcam32.pl_exp_stop_cont(hcam, cam_state));
     }
 }
Пример #12
0
 public static bool pl_pvcam_uninit()
 {
     if (m_is64bit)
     {
         return(Pvcam64.pl_pvcam_uninit());
     }
     else
     {
         return(Pvcam32.pl_pvcam_uninit());
     }
 }
Пример #13
0
 public static bool pl_cam_get_name(Int16 cameraNumber, StringBuilder cameraName)
 {
     if (m_is64bit)
     {
         return(Pvcam64.pl_cam_get_name(cameraNumber, cameraName));
     }
     else
     {
         return(Pvcam32.pl_cam_get_name(cameraNumber, cameraName));
     }
 }
Пример #14
0
 public static bool pl_exp_finish_seq(Int16 hcam, IntPtr pixel_stream_ptr, Int16 hbuf)
 {
     if (m_is64bit)
     {
         return(Pvcam64.pl_exp_finish_seq(hcam, pixel_stream_ptr, hbuf));
     }
     else
     {
         return(Pvcam32.pl_exp_finish_seq(hcam, pixel_stream_ptr, hbuf));
     }
 }
Пример #15
0
 public static bool pl_cam_deregister_callback(Int16 hCam, PvTypes.PL_CALLBACK_EVENT callBackEvent)
 {
     if (m_is64bit)
     {
         return(Pvcam64.pl_cam_deregister_callback(hCam, callBackEvent));
     }
     else
     {
         return(Pvcam32.pl_cam_deregister_callback(hCam, callBackEvent));
     }
 }
Пример #16
0
 public static bool pl_exp_check_status(Int16 hcam, out Int16 status, out UInt32 byte_cnt)
 {
     if (m_is64bit)
     {
         return(Pvcam64.pl_exp_check_status(hcam, out status, out byte_cnt));
     }
     else
     {
         return(Pvcam32.pl_exp_check_status(hcam, out status, out byte_cnt));
     }
 }
Пример #17
0
 public static bool pl_exp_uninit_seq()
 {
     if (m_is64bit)
     {
         return(Pvcam64.pl_exp_uninit_seq());
     }
     else
     {
         return(Pvcam32.pl_exp_uninit_seq());
     }
 }
Пример #18
0
 public static bool pl_exp_start_seq(Int16 hcam, IntPtr pixel_stream_ptr)
 {
     if (m_is64bit)
     {
         return(Pvcam64.pl_exp_start_seq(hcam, pixel_stream_ptr));
     }
     else
     {
         return(Pvcam32.pl_exp_start_seq(hcam, pixel_stream_ptr));
     }
 }
Пример #19
0
 public static bool pl_release_frame_info_struct(PvTypes.FRAME_INFO frame_to_delete)
 {
     if (m_is64bit)
     {
         return(Pvcam64.pl_release_frame_info_struct(frame_to_delete));
     }
     else
     {
         return(Pvcam32.pl_release_frame_info_struct(frame_to_delete));
     }
 }
Пример #20
0
 public static bool pl_create_frame_info_struct(out PvTypes.FRAME_INFO new_frame)
 {
     if (m_is64bit)
     {
         return(Pvcam64.pl_create_frame_info_struct(out new_frame));
     }
     else
     {
         return(Pvcam32.pl_create_frame_info_struct(out new_frame));
     }
 }
Пример #21
0
        /*********************Frame Metadata methods ********************/

        public static bool pl_md_frame_decode(IntPtr pDstFrame, IntPtr pSrcBuf, UInt32 srcBufSize)
        {
            if (m_is64bit)
            {
                return(Pvcam64.pl_md_frame_decode(pDstFrame, pSrcBuf, srcBufSize));
            }
            else
            {
                return(Pvcam32.pl_md_frame_decode(pDstFrame, pSrcBuf, srcBufSize));
            }
        }
Пример #22
0
 public static bool pl_exp_get_oldest_frame(Int16 hcam, out IntPtr frame)
 {
     if (m_is64bit)
     {
         return(Pvcam64.pl_exp_get_oldest_frame(hcam, out frame));
     }
     else
     {
         return(Pvcam32.pl_exp_get_oldest_frame(hcam, out frame));
     }
 }
Пример #23
0
 public static bool pl_cam_close(Int16 hCam)
 {
     if (m_is64bit)
     {
         return(Pvcam64.pl_cam_close(hCam));
     }
     else
     {
         return(Pvcam32.pl_cam_close(hCam));
     }
 }
Пример #24
0
 public static bool pl_cam_open(StringBuilder cameraName, out Int16 hCam, PvTypes.CameraOpenMode o_mode)
 {
     if (m_is64bit)
     {
         return(Pvcam64.pl_cam_open(cameraName, out hCam, o_mode));
     }
     else
     {
         return(Pvcam32.pl_cam_open(cameraName, out hCam, o_mode));
     }
 }
Пример #25
0
 public static bool pl_md_release_frame_struct(IntPtr pFrame)
 {
     if (m_is64bit)
     {
         return(Pvcam64.pl_md_release_frame_struct(pFrame));
     }
     else
     {
         return(Pvcam32.pl_md_release_frame_struct(pFrame));
     }
 }
Пример #26
0
 public static bool pl_md_create_frame_struct_cont(ref IntPtr pFrame, UInt16 roiCount)
 {
     if (m_is64bit)
     {
         return(Pvcam64.pl_md_create_frame_struct_cont(ref pFrame, roiCount));
     }
     else
     {
         return(Pvcam32.pl_md_create_frame_struct_cont(ref pFrame, roiCount));
     }
 }
Пример #27
0
 public static bool pl_md_create_frame_struct(ref IntPtr pFrame, IntPtr pSrcBuf, UInt32 srcBufSize)
 {
     if (m_is64bit)
     {
         return(Pvcam64.pl_md_create_frame_struct(ref pFrame, pSrcBuf, srcBufSize));
     }
     else
     {
         return(Pvcam32.pl_md_create_frame_struct(ref pFrame, pSrcBuf, srcBufSize));
     }
 }
Пример #28
0
 public static bool pl_md_frame_recompose(IntPtr pDstBuf, UInt16 offX, UInt16 offY,
                                          UInt16 dstWidth, UInt16 dstHeight, ref PvTypes.MD_Frame pSrcFrame)
 {
     if (m_is64bit)
     {
         return(Pvcam64.pl_md_frame_recompose(pDstBuf, offX, offY, dstWidth, dstHeight, ref pSrcFrame));
     }
     else
     {
         return(Pvcam32.pl_md_frame_recompose(pDstBuf, offX, offY, dstWidth, dstHeight, ref pSrcFrame));
     }
 }
Пример #29
0
 public static bool pl_exp_get_oldest_frame_ex(Int16 hcam, out IntPtr frame,
                                               out PvTypes.FRAME_INFO pFrameInfo)
 {
     if (m_is64bit)
     {
         return(Pvcam64.pl_exp_get_oldest_frame_ex(hcam, out frame, out pFrameInfo));
     }
     else
     {
         return(Pvcam32.pl_exp_get_oldest_frame_ex(hcam, out frame, out pFrameInfo));
     }
 }
Пример #30
0
 public static bool pl_create_smart_stream_struct(out PvTypes.smart_stream_type smtStreamStruct,
                                                  UInt16 entries)
 {
     if (m_is64bit)
     {
         return(Pvcam64.pl_create_smart_stream_struct(out smtStreamStruct, entries));
     }
     else
     {
         return(Pvcam32.pl_create_smart_stream_struct(out smtStreamStruct, entries));
     }
 }