commit 42c5434dc8be9e9c7ec8c1e20ffe334288958ad3 Author: xinyang Date: Sun Apr 14 17:12:43 2019 +0800 auto-aim diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..9ae13e4 --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +cmake-build-debug/* +.idea/* diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..fadacbf --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,27 @@ +cmake_minimum_required(VERSION 3.5) + +project(auto-aim) +set(CMAKE_CXX_STANDARD 11) +SET(CMAKE_BUILD_TYPE DEBUG) + +FIND_PROGRAM(CCACHE_FOUND ccache) +IF(CCACHE_FOUND) + set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache) + set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ccache) + message("< Use ccache for compiler >") +ENDIF() + +FIND_PACKAGE(OpenCV 3 REQUIRED) +FIND_PACKAGE(Threads) + +include_directories( ${PROJECT_SOURCE_DIR}/energy/include ) +include_directories( ${PROJECT_SOURCE_DIR}/armor/include ) +include_directories( ${PROJECT_SOURCE_DIR}/include ) +include_directories( ${PROJECT_SOURCE_DIR}/src ) +FILE(GLOB_RECURSE sourcefiles "src/*.cpp" "energy/src/*cpp" "armor/src/*.cpp") + +add_executable(run main.cpp ${sourcefiles} ) + +TARGET_LINK_LIBRARIES (run ${CMAKE_THREAD_LIBS_INIT}) +TARGET_LINK_LIBRARIES(run ${OpenCV_LIBS}) +TARGET_LINK_LIBRARIES(run ${PROJECT_SOURCE_DIR}/libMVSDK.so) diff --git a/armor/include/armor_finder/armor_finder.h b/armor/include/armor_finder/armor_finder.h new file mode 100644 index 0000000..1525af5 --- /dev/null +++ b/armor/include/armor_finder/armor_finder.h @@ -0,0 +1,57 @@ +// +// Created by xinyang on 19-3-27. +// + +#ifndef _ARMOR_FINDER_H_ +#define _ARMOR_FINDER_H_ + +#include +#include +#include + +typedef enum{ + ENEMY_BLUE, ENEMY_RED +} EnemyColor; + +class ArmorFinder{ +public: + ArmorFinder(EnemyColor color, Uart &u); + ~ArmorFinder() = default; + +private: + typedef cv::TrackerKCF TrackerToUse; + + typedef enum{ + SEARCHING_STATE, TRACKING_STATE, STANDBY_STATE + } State; + + EnemyColor enemy_color; + State state; + cv::Rect2d armor_box; + cv::Ptr tracker; + + int contour_area; + Uart &uart; + + bool stateSearchingTarget(cv::Mat &src); + bool stateTrackingTarget(cv::Mat &src); + bool stateStandBy(); +public: + void run(cv::Mat &src); + bool sendBoxPosition(); +}; + +struct LightBlob { + cv::RotatedRect rect; + double length; + + explicit LightBlob(cv::RotatedRect &r) : rect(r) { + length = std::max(rect.size.height, rect.size.width); + }; + bool operator<(LightBlob &l2) { return this->rect.center.x < l2.rect.center.x; } + bool operator<=(LightBlob &l2) { return this->rect.center.x <= l2.rect.center.x; } + bool operator>(LightBlob &l2) { return this->rect.center.x > l2.rect.center.x; } + bool operator>=(LightBlob &l2) { return this->rect.center.x >= l2.rect.center.x; } +}; + +#endif /* _ARMOR_FINDER_H_ */ diff --git a/armor/include/show_images/show_images.h b/armor/include/show_images/show_images.h new file mode 100644 index 0000000..14c8c66 --- /dev/null +++ b/armor/include/show_images/show_images.h @@ -0,0 +1,17 @@ +// +// Created by xinyang on 19-3-27. +// + +#ifndef _SHOW_IMAGES_H_ +#define _SHOW_IMAGES_H_ + +#include +#include +#include +#include + +void showArmorBoxVector(std::string windows_name, const cv::Mat &src, const std::vector &armor_box); +void showArmorBox(std::string windows_name, const cv::Mat &src, cv::Rect2d armor_box); +void showContours(std::string windows_name, const cv::Mat &src, const std::vector &light_blobs); + +#endif /* _SHOW_IMAGES_H_ */ diff --git a/armor/src/armor_finder/armor_finder.cpp b/armor/src/armor_finder/armor_finder.cpp new file mode 100644 index 0000000..6fd2cd2 --- /dev/null +++ b/armor/src/armor_finder/armor_finder.cpp @@ -0,0 +1,66 @@ +// +// Created by xinyang on 19-3-27. +// +#include +#include + +ArmorFinder::ArmorFinder(EnemyColor color, Uart &u) : + uart(u), + enemy_color(color), + state(STANDBY_STATE) + { + auto para = TrackerToUse::Params(); + para.desc_npca = 1; + para.desc_pca = 0; + tracker = TrackerToUse::create(para); + if(!tracker){ + LOGW("Tracker Not init"); + } +} + +void ArmorFinder::run(cv::Mat &src) { + cv::Mat src_use; + if (src.type() == CV_8UC3) { + cv::cvtColor(src, src_use, CV_RGB2GRAY); + }else{ + src_use = src.clone(); + } + +// return stateSearchingTarget(src_use); + + switch (state){ + case SEARCHING_STATE: + if(stateSearchingTarget(src_use)){ + if((armor_box & cv::Rect2d(0, 0, 640, 480)) == armor_box) { + cv::Mat roi = src_use.clone()(armor_box); + cv::threshold(roi, roi, 200, 255, cv::THRESH_BINARY); + contour_area = cv::countNonZero(roi); + tracker->init(src_use, armor_box); + state = TRACKING_STATE; + LOGW("into track"); + } + } + break; + case TRACKING_STATE: + if(!stateTrackingTarget(src_use)){ + state = SEARCHING_STATE; + //std::cout << "into search!" << std::endl; + } + break; + case STANDBY_STATE: + default: + stateStandBy(); + } +} + +#define FOCUS_PIXAL (0.36/0.48*640) + +bool ArmorFinder::sendBoxPosition() { + auto rect = armor_box; + double dx = rect.x + rect.width/2 - 320; + double dy = rect.y + rect.height/2 - 240; + double yaw = atan(dx / FOCUS_PIXAL) * 180 / 3.14159265459; + double pitch = atan(dy / FOCUS_PIXAL) * 180 / 3.14159265459; + uart.sendTarget(yaw, pitch, 0); + return true; +} \ No newline at end of file diff --git a/armor/src/armor_finder/state_machine/searching_state/image_process/image_process.cpp b/armor/src/armor_finder/state_machine/searching_state/image_process/image_process.cpp new file mode 100644 index 0000000..140cdc5 --- /dev/null +++ b/armor/src/armor_finder/state_machine/searching_state/image_process/image_process.cpp @@ -0,0 +1,63 @@ +// +// Created by xinyang on 19-3-27. +// + +#include "image_process.h" + +static void splitBayerBG(cv::Mat &src, cv::Mat &blue, cv::Mat &red) { + uchar* data; + uchar* bayer_data[2]; + for (int i = 0; i < src.rows; ++i) { + data = src.ptr(i); + bayer_data[0] = blue.ptr(i / 2); + for (int j = 0; j < blue.cols; ++j, data += 2) { + bayer_data[0][j] = *data; + } + data = src.ptr(++i) + 1; + bayer_data[1] = red.ptr(i / 2); + for (int j = 0; j < red.cols; ++j, data += 2) { + bayer_data[1][j] = *data; + } + } +} + +void imageColorSplit(cv::Mat &src_input, cv::Mat &split, EnemyColor color) { + cv::Mat blue(240, 320, CV_8UC1), red(240, 320, CV_8UC1); + if(src_input.type() == CV_8UC1){ + splitBayerBG(src_input, blue, red); + if(color == ENEMY_RED){ + split = red - blue; + }else if(color == ENEMY_BLUE){ + split = blue - red; + } + }else if(src_input.type() == CV_8UC3){ + std::vector channels; + cv::split(src_input, channels); + resize(channels.at(0), blue, cv::Size(640, 480)); + resize(channels.at(2), red, cv::Size(640, 480)); + if(color == ENEMY_RED){ + split = red; + }else if(color == ENEMY_BLUE){ + split = blue; + } + } + +} + +void imagePreProcess(cv::Mat &src) { + static cv::Mat kernel_erode = getStructuringElement(cv::MORPH_RECT, cv::Size(1, 4)); + erode(src, src, kernel_erode); + + static cv::Mat kernel_dilate = getStructuringElement(cv::MORPH_RECT, cv::Size(2, 4)); + dilate(src, src, kernel_dilate); + + static cv::Mat kernel_erode2 = getStructuringElement(cv::MORPH_RECT, cv::Size(2, 4)); + erode(src, src, kernel_erode2); + + static cv::Mat kernel_dilate2 = getStructuringElement(cv::MORPH_RECT, cv::Size(3, 6)); + dilate(src, src, kernel_dilate2); + + float alpha = 1.5; + int beta = 0; + src.convertTo(src, -1, alpha, beta); +} diff --git a/armor/src/armor_finder/state_machine/searching_state/image_process/image_process.h b/armor/src/armor_finder/state_machine/searching_state/image_process/image_process.h new file mode 100644 index 0000000..69fcecc --- /dev/null +++ b/armor/src/armor_finder/state_machine/searching_state/image_process/image_process.h @@ -0,0 +1,14 @@ +// +// Created by xinyang on 19-3-27. +// + +#ifndef _IMAGE_PROCESS_H_ +#define _IMAGE_PROCESS_H_ + +#include +#include + +void imageColorSplit(cv::Mat &src_input, cv::Mat &split, EnemyColor color); +void imagePreProcess(cv::Mat &src); + +#endif /* _IMAGE_PROCESS_H_ */ diff --git a/armor/src/armor_finder/state_machine/searching_state/searching_state.cpp b/armor/src/armor_finder/state_machine/searching_state/searching_state.cpp new file mode 100644 index 0000000..f36ebc4 --- /dev/null +++ b/armor/src/armor_finder/state_machine/searching_state/searching_state.cpp @@ -0,0 +1,192 @@ +// +// Created by xinyang on 19-3-27. +// + +#include +#include +#include "image_process/image_process.h" +#include +#include + +#include + +typedef std::vector LightBlobs; + +static double lw_rate(const cv::RotatedRect &rect){ + return (rect.size.height > rect.size.width)? + (rect.size.height / rect.size.width): + (rect.size.width / rect.size.height); +} + +static bool isValidLightBlob(const cv::RotatedRect &rect){ + return (lw_rate(rect) > 1.2) && + ((rect.size.width * rect.size.height) < 3000) && + ((rect.size.width * rect.size.height) > 1); +} + +static void pipelineLightBlobPreprocess(cv::Mat &src) { + src -= 150; + src *= 3.5; + src -= 150; + src *= 3.5; +} + +static bool findLightBlobs(const cv::Mat &src, LightBlobs &light_blobs) { + static cv::Mat src_bin; + + cv::threshold(src, src_bin, 80, 255, CV_THRESH_BINARY); + std::vector > light_contours; + cv::findContours(src_bin, light_contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_NONE); + for (auto &light_contour : light_contours) { + cv::RotatedRect rect = cv::minAreaRect(light_contour); + if(isValidLightBlob(rect)){ + light_blobs.emplace_back(rect); + } + } + return light_blobs.size() >= 2; +} + +bool angelJudge(const LightBlob &light_blob_i, const LightBlob &light_blob_j) { + + float angle_i = light_blob_i.rect.size.width > light_blob_i.rect.size.height ? light_blob_i.rect.angle : + light_blob_i.rect.angle - 90; + float angle_j = light_blob_j.rect.size.width > light_blob_j.rect.size.height ? light_blob_j.rect.angle : + light_blob_j.rect.angle - 90; + return abs(angle_i-angle_j)<10; +} +bool heightJudge(const LightBlob &light_blob_i, const LightBlob &light_blob_j) { + cv::Point2f centers = light_blob_i.rect.center - light_blob_j.rect.center; + + return abs(centers.y)<30; +} + +bool lengthJudge(const LightBlob &light_blob_i, const LightBlob &light_blob_j) { + double side_length; + cv::Point2f centers = light_blob_i.rect.center - light_blob_j.rect.center; + side_length = sqrt(centers.ddot(centers)); +// std::cout << "side:" << side_length << " length:" << light_blob_i.length << std::endl; + return (side_length / light_blob_i.length < 6 && side_length / light_blob_i.length > 0.5); +} + +bool lengthRatioJudge(const LightBlob &light_blob_i, const LightBlob &light_blob_j) { +// std::cout << "i:" << light_blob_i.length << " j:" << light_blob_j.length << std::endl; + return (light_blob_i.length / light_blob_j.length < 2 + && light_blob_i.length / light_blob_j.length > 0.5); +} + +bool isCoupleLight(const LightBlob &light_blob_i, const LightBlob &light_blob_j) { + if(!lengthRatioJudge(light_blob_i, light_blob_j)){ +// std::cout << "lengthRatioJudge" << std::endl; + return false; + } + if(!lengthJudge(light_blob_i, light_blob_j)){ +// std::cout << "lengthJudge" << std::endl; + return false; + } + if(!heightJudge(light_blob_i, light_blob_j)){ +// std::cout << "heightJudge" << std::endl; + return false; + } + if(!angelJudge(light_blob_i, light_blob_j)){ +// std::cout << "angelJudge" << std::endl; + return false; + } + return true; + return lengthRatioJudge(light_blob_i, light_blob_j) && + lengthJudge(light_blob_i, light_blob_j) && + heightJudge(light_blob_i, light_blob_j) && + angelJudge(light_blob_i, light_blob_j); + +} + +double centerDistance(cv::Rect2d box){ + double dx = box.x-box.width/2 - 320; + double dy = box.y-box.height/2 - 240; + return dx*dx + dy*dy; +} + +static bool findArmorBoxes(LightBlobs &light_blobs, std::vector &armor_boxes) { + for (int i = 0; i < light_blobs.size() - 1; ++i) { + for (int j = i + 1; j < light_blobs.size(); ++j) { + if (!isCoupleLight(light_blobs.at(i), light_blobs.at(j))) { + continue; + } + cv::Rect2d rect_left = light_blobs.at(static_cast(i)).rect.boundingRect(); + cv::Rect2d rect_right = light_blobs.at(static_cast(j)).rect.boundingRect(); + double min_x, min_y, max_x, max_y; + min_x = fmin(rect_left.x, rect_right.x) - 5; + max_x = fmax(rect_left.x + rect_left.width, rect_right.x + rect_right.width) + 5; + min_y = fmin(rect_left.y, rect_right.y) - 5; + max_y = fmax(rect_left.y + rect_left.height, rect_right.y + rect_right.height) + 5; + if (min_x < 0 || max_x > 640 || min_y < 0 || max_y > 480) { + continue; + } + armor_boxes.emplace_back(cv::Rect2d(min_x, min_y, max_x - min_x, max_y - min_y)); + } + } + if(armor_boxes.empty()){ + return false; + } + sort(armor_boxes.begin(), armor_boxes.end(), [](cv::Rect2d box1, cv::Rect2d box2)->bool{ + return centerDistance(box1) < centerDistance(box2); + }); + return true; +} + +bool judge_light_color(std::vector &light, std::vector &color, std::vector &result) { + for (auto &i:color) { + for (auto &j:light) { + cv::Rect2d a = i.rect.boundingRect2f(); + cv::Rect2d b = j.rect.boundingRect2f(); + cv::Rect2d ab = a & b; + if (ab.area() / fmin(a.area(), b.area()) >= 0.2) { + result.emplace_back(j); + break; + } + } + } + return !result.empty(); +} + +bool ArmorFinder::stateSearchingTarget(cv::Mat &src) { + cv::Mat split, pmsrc=src.clone(); + LightBlobs light_blobs, pm_light_blobs, light_blobs_real; + std::vector armor_boxes; + +// cv::resize(src, pmsrc, cv::Size(320, 240)); + imageColorSplit(src, split, enemy_color); + imagePreProcess(split); + cv::resize(split, split, cv::Size(640, 480)); +// pipelineLightBlobPreprocess(pmsrc); +// if(!findLightBlobs(pmsrc, pm_light_blobs)){ +// return false; +// } + if(!findLightBlobs(split, light_blobs)){ + return false; + } +// if(!judge_light_color(light_blobs, pm_light_blobs, light_blobs_real)){ +// return false; +// } + if(show_light_blobs){ + showContours("blobs", split, light_blobs); +// showContours("pm blobs", pmsrc, pm_light_blobs); +// showContours("blobs real", src, light_blobs_real); + cv::waitKey(1); + } + if(!findArmorBoxes(light_blobs, armor_boxes)){ + return false; + } + armor_box = armor_boxes[0]; + if(show_armor_boxes){ + showArmorBoxVector("boxes", split, armor_boxes); + cv::waitKey(1); + } + if(split.size() == cv::Size(320, 240)){ + armor_box.x *= 2; + armor_box.y *= 2; + armor_box.width *= 2; + armor_box.height *= 2; + } + + return sendBoxPosition(); +} diff --git a/armor/src/armor_finder/state_machine/standby_state/standby_state.cpp b/armor/src/armor_finder/state_machine/standby_state/standby_state.cpp new file mode 100644 index 0000000..dd0a4e8 --- /dev/null +++ b/armor/src/armor_finder/state_machine/standby_state/standby_state.cpp @@ -0,0 +1,11 @@ +// +// Created by xinyang on 19-3-27. +// + +#include + +bool ArmorFinder::stateStandBy() { + state = SEARCHING_STATE; + return true; +} + diff --git a/armor/src/armor_finder/state_machine/tracking_state/tracking_state.cpp b/armor/src/armor_finder/state_machine/tracking_state/tracking_state.cpp new file mode 100644 index 0000000..be3c67a --- /dev/null +++ b/armor/src/armor_finder/state_machine/tracking_state/tracking_state.cpp @@ -0,0 +1,21 @@ +// +// Created by xinyang on 19-3-27. +// +#include +#include + +bool ArmorFinder::stateTrackingTarget(cv::Mat &src) { + auto last = armor_box; + tracker->update(src, armor_box); + + if((armor_box & cv::Rect2d(0, 0, 640, 480)) != armor_box){ + return false; + } + cv::Mat roi = src(armor_box); + threshold(roi, roi, 200, 255, cv::THRESH_BINARY); + + if(abs(cv::countNonZero(roi) - contour_area) > contour_area * 0.3){ + return false; + } + return sendBoxPosition(); +} diff --git a/armor/src/show_images/show_images.cpp b/armor/src/show_images/show_images.cpp new file mode 100644 index 0000000..7ba2c41 --- /dev/null +++ b/armor/src/show_images/show_images.cpp @@ -0,0 +1,52 @@ +#include + +using namespace cv; + +void showArmorBoxVector(std::string windows_name, const cv::Mat &src, const std::vector &armor_box) { + static Mat image2show; + if (src.type() == CV_8UC1) // 黑白图像 + { + cvtColor(src, image2show, COLOR_GRAY2RGB); + } else if(src.type() == CV_8UC3) //RGB 彩色 + { + image2show = src.clone(); + } + + for (auto &box:armor_box) { + rectangle(image2show, box, Scalar(0, 255, 0), 1); + } + imshow(windows_name, image2show); +} + +void showArmorBox(std::string windows_name, const cv::Mat &src, cv::Rect2d armor_box) { + static Mat image2show; + if (src.type() == CV_8UC1) // 黑白图像 + { + cvtColor(src, image2show, COLOR_GRAY2RGB); + } else if(src.type() == CV_8UC3) //RGB 彩色 + { + image2show = src.clone(); + } + rectangle(image2show, armor_box, Scalar(0, 255, 0), 1); + imshow(windows_name, image2show); +} + +void showContours(std::string windows_name, const cv::Mat &src, const std::vector &light_blobs) { + static Mat image2show; + + if(src.type() == CV_8UC1) // 黑白图像 + { + cvtColor(src, image2show, COLOR_GRAY2RGB); + } + else if(src.type() == CV_8UC3) //RGB 彩色 + { + image2show = src.clone(); + } + + for(const auto &light_blob:light_blobs) + { + rectangle(image2show, light_blob.rect.boundingRect(), Scalar(255,0,0), 3); + } + imshow(windows_name, image2show); +} + diff --git a/energy/include/energy/constant.h b/energy/include/energy/constant.h new file mode 100644 index 0000000..de0ef7a --- /dev/null +++ b/energy/include/energy/constant.h @@ -0,0 +1,43 @@ +// +// Created by xixiliadorabarry on 1/24/19. +// +#ifndef CONSTANT_H +#define CONSTANT_H + +#define d2r (CV_PI / 180.0) + +const int ALLY_BLUE = 123; +const int ALLY_RED = 456; +const int SRC_WIDTH_CAMERA = 640; +const int SRC_HEIGHT_CAMERA = 480; +const int SRC_WIDTH = 320; +const int SRC_HEIGHT = 240; +const double PI = 3.1415926; +const int CLOCKWISE = 1; +const int ANTICLOCKWISE = -1; +const float ATTACK_DISTANCE = 770;//cm +const double WHOLE_FAN = 80;//cm +//const double ARMOR_CENTER_TO_CYCLE_CENTER = 75;//cm +const double ARMOR_CENTER_TO_CYCLE_CENTER = 71;//cm +const int EXTRACT_POINT_X = 200; +const int EXTRACT_POINT_Y = 20; +const int EXTRACT_WIDTH = 240; +const int EXTRACT_HEIGHT = 180; + +//以摄像头正方向位y轴 +const int GM_L = 14;//云台摄像头z方向 +const int GM_X = 15;//云台摄像头x方向 +const int GM_H = 16;//云台摄像头y方向 + +//const double STRETCH = 231.0/640.0;//实际距离与图像伸缩比 +const double STRETCH = 231.0/640.0; + +const int ZERO_POINT_X = 281; +const int ZERO_POINT_Y = 188; +const double YAW_ORIGIN_RAD = PI/180*2.25; +const double PITCH_ORIGIN_RAD = PI/180*14.85; + +const double LIFT_HEIGHT = 20;//云台抬升高度 + +#endif //CONSTANT_H + diff --git a/energy/include/energy/energy.h b/energy/include/energy/energy.h new file mode 100644 index 0000000..08850c6 --- /dev/null +++ b/energy/include/energy/energy.h @@ -0,0 +1,129 @@ +// +// Created by xixiliadorabarry on 1/24/19. +// +#ifndef ENERGY_H +#define ENERGY_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include "energy/constant.h" +#include "energy/param_struct_define.h" +#include "uart/uart.h" + +using std::vector; + +class Energy { +public: + Energy(Uart &u); + ~Energy(); + int run(cv::Mat &src); + + cv::Point2f uart_hit_point; + clock_t start; + Uart &uart; + + void setAllyColor(int color); + void setRotation(int rotation); + + void extract(cv::Mat &src); + + void sendTargetByUart(float x, float y, float z); + + +private: + + EnergyPartParam energy_part_param_; + int fans_cnt; + int armors_cnt; + int count; + int last_fans_cnt; + int last_armors_cnt; + double radius; + double target_position; + double last_target_position; + float target_armor; + int ally_color_; + int energy_part_rotation; + float attack_distance; + int send_cnt; + double rectified_focal_length; + double theta;//电机pitch轴应旋转的角度 + double phi;//电机yaw轴应旋转的角度 + float yaw_rotation; + float pitch_rotation; + int isLeftVertexFound, isTopVertexFound, isRightVertexFound, isBottomVertexFound; + + std::vector fans; + std::vector armors; + std::vector gimble_zero_points; + + cv::Point cycle_center; + cv::Point target_center; + cv::Point last_target_center; + cv::Point hit_point; + std::vectorfanPosition; + std::vectorarmorPosition; + std::vector Armor_center; + std::vector first_armor_centers; + std::vector all_armor_centers; + cv::Point left, right, top, bottom; + cv::Mat src_blue, src_red, src_green; + + + + void initEnergyPartParam(); + + int findFan(const cv::Mat &src, vector &fans, int &last_fans_cnt); + int findArmor(const cv::Mat &src, vector &armors, int &last_armors_cnt); + int findGimbleZeroPoint(const cv::Mat &src, vector &gimble_zero_point); + + void showFanContours(std::string windows_name, const cv::Mat &src, const std::vector &fans); + void showArmorContours(std::string windows_name, const cv::Mat &src, const std::vector &armors); + void showBothContours(std::string windows_name, const cv::Mat &src, const std::vector &fans, + const std::vector &armors); + + bool isValidFanContour(const vector &fan_contour); + bool isValidArmorContour(const vector &armor_contour); + + void getFanPosition(std::vector &fanPosition, const std::vector &fans, cv::Point cycle_center, double radius); + void getArmorPosition(std::vector &armorPosition, const std::vector &armors, cv::Point cycle_center, double radius); + void getFirstArmorCenters(vector &armors, std::vector &first_armor_centers); + void getAllArmorCenters(); + void getPosition(cv::Point point, double &angle); + + void cycleQuickCalculate(std::vector &first_armor_centers, cv::Point &cycle_center, double &radius); + void cycleDefaultCalculateConst(cv::Point &cycle_center, double &radius); + void cycleCalculate(); + void cycleLeastFit(); + + void findTarget(const std::vectorfanPosition, const std::vectorarmorPosition, float &target_armor); + + void findWholeCycle(const std::vector&first_armor_centers); + + void saveFourPoints(std::vector &FourPoints, cv::Point point_1, cv::Point point_2, cv::Point point_3, cv::Point point_4); + void savePoint2f(std::vector &point_save, cv::Point point); + double pointDistance(cv::Point point_1, cv::Point point_2); + void rotate(double rad, double radius, cv::Point center, cv::Point point_old, cv::Point &point_new); + void stretch(cv::Point point_1, cv::Point2f &point_2); + void cycle(cv::Point p1, cv::Point p2, cv::Point p3, cv::Point ¢er, double &radius); + + void getHitPoint(); + bool changeTarget(); + void gimbleRotation(); + + void splitBayerBG(cv::Mat &src, cv::Mat &blue, cv::Mat &red); + void imagePreprocess(cv::Mat &src); + + void StructingElementClose(cv::Mat &src); + void StructingElementErodeDilate(cv::Mat &src); + +}; + +#endif //ENERGY_H + diff --git a/energy/include/energy/param_struct_define.h b/energy/include/energy/param_struct_define.h new file mode 100644 index 0000000..5c8209f --- /dev/null +++ b/energy/include/energy/param_struct_define.h @@ -0,0 +1,60 @@ +// +// Created by xixiliadorabarry on 1/24/19. +// +#ifndef PARAM_STRUCT_DEFINE_H +#define PARAM_STRUCT_DEFINE_H +#include +#include +#include +#include + +using std::vector; + +struct EnergyPart { + cv::RotatedRect rect; + float angle; + vector contour; + + explicit EnergyPart(vector &c) : contour(c) { + rect = cv::minAreaRect(c); + angle = cv::minAreaRect(c).angle; + }; +}; + +struct EnergyPartParam { + double RPM; + double HIT_TIME; + + int GRAY_THRESH; + int SPLIT_GRAY_THRESH; + int FAN_GRAY_THRESH; + int ARMOR_GRAY_THRESH; + + long FAN_CONTOUR_AREA_MAX; + long FAN_CONTOUR_AREA_MIN; + long FAN_CONTOUR_LENGTH_MIN; + long FAN_CONTOUR_WIDTH_MIN; + float FAN_CONTOUR_HW_RATIO_MAX; + float FAN_CONTOUR_HW_RATIO_MIN; + + long ARMOR_CONTOUR_AREA_MAX; + long ARMOR_CONTOUR_AREA_MIN; + long ARMOR_CONTOUR_LENGTH_MIN; + long ARMOR_CONTOUR_WIDTH_MIN; + long ARMOR_CONTOUR_LENGTH_MAX; + long ARMOR_CONTOUR_WIDTH_MAX; + float ARMOR_CONTOUR_HW_RATIO_MAX; + float ARMOR_CONTOUR_HW_RATIO_MIN; + + float TWIN_ANGEL_MAX; +}; + +typedef struct GMAngle_t{ + float yaw; + float pitch; +}GMAngle_t; + +extern GMAngle_t aim; + +#endif //PARAM_STRUCT_DEFINE_H + diff --git a/energy/src/energy/calculate/cycle_calculate.cpp b/energy/src/energy/calculate/cycle_calculate.cpp new file mode 100644 index 0000000..56d32d6 --- /dev/null +++ b/energy/src/energy/calculate/cycle_calculate.cpp @@ -0,0 +1,106 @@ +// +// Created by xixiliadorabarry on 1/24/19. +// +#include "energy/energy.h" + +using namespace cv; +using std::cout; +using std::endl; +using std::vector; + +void Energy::cycleQuickCalculate(std::vector &first_armor_centers, cv::Point &cycle_center, double &radius) { + //if (isCalibrated()) return; + + int cur_size = static_cast(first_armor_centers.size()); + if (cur_size < 3)return; + cv::Point point_1, point_2, point_3; + point_1 = first_armor_centers.at(0); + point_2 = first_armor_centers.at(static_cast(cur_size - 1)); + point_3 = first_armor_centers.at(static_cast(cur_size / 2)); + //cout << point_1 << '\t' << point_2 << endl; + //cout << first_armor_centers.at(point_1) << '\t' << first_armor_centers.at(point_2) << endl; + cycle(point_1, point_2, point_3, cycle_center, radius); + cout << "The cycle center is: " << cycle_center << endl; + cout << "The radius is: " << radius << endl; +} + +void Energy::cycleDefaultCalculateConst(cv::Point &cycle_center, double &radius) { + if (count >= 5) + return; + clock_t end; + double time_duration = 1.0, dt; + if (Armor_center.size() < 3) { + end = clock(); + dt = (end - start) / 1000000.00; + if (dt >= time_duration * count) { + getFirstArmorCenters(armors, Armor_center); + count++; + } + } + else { + cycleQuickCalculate(Armor_center, cycle_center, radius); + count++; + } +} + +void Energy::cycleCalculate(){ + cycle_center.x = (top.x + bottom.x)/2; + cycle_center.y = (left.y + right.y)/2; + radius = (right.x - left.x)/2; + cout << "The cycle center is: " << cycle_center << endl; + cout << "The radius is: " << radius << endl; +} + +void Energy::cycleLeastFit() +{ + cycle_center.x = 0; + cycle_center.y = 0; + radius = 0.0f; + if (all_armor_centers.size() < 3) + { + cout<<"Cannot calculate a circle"<(all_armor_centers.size()); + for (int i = 0; i < N; i++) + { + double x = all_armor_centers.at(i).x; + double y = all_armor_centers.at(i).y; + double x2 = x * x; + double y2 = y * y; + sum_x += x; + sum_y += y; + sum_x2 += x2; + sum_y2 += y2; + sum_x3 += x2 * x; + sum_y3 += y2 * y; + sum_xy += x * y; + sum_x1y2 += x * y2; + sum_x2y1 += x2 * y; + } + + double C, D, E, G, H; + double a, b, c; + + C = N * sum_x2 - sum_x * sum_x; + D = N * sum_xy - sum_x * sum_y; + E = N * sum_x3 + N * sum_x1y2 - (sum_x2 + sum_y2) * sum_x; + G = N * sum_y2 - sum_y * sum_y; + H = N * sum_x2y1 + N * sum_y3 - (sum_x2 + sum_y2) * sum_y; + a = (H * D - E * G) / (C * G - D * D); + b = (H * C - E * D) / (D * D - G * C); + c = -(a * sum_x + b * sum_y + sum_x2 + sum_y2) / N; + + cycle_center.x = static_cast(a / (-2)); + cycle_center.y = static_cast(b / (-2)); + radius = sqrt(a * a + b * b - 4 * c) / 2; + + cout << "The cycle center is: " << cycle_center << endl; + cout << "The radius is: " << radius << endl; +} diff --git a/energy/src/energy/calibrate/split.cpp b/energy/src/energy/calibrate/split.cpp new file mode 100644 index 0000000..f0b8049 --- /dev/null +++ b/energy/src/energy/calibrate/split.cpp @@ -0,0 +1,59 @@ +// +// Created by xixiliadorabarry on 1/24/19. +// +#include "energy/energy.h" + +using namespace cv; +using std::cout; +using std::endl; +using std::vector; + +void Energy::splitBayerBG(cv::Mat &src, cv::Mat &blue, cv::Mat &red) { + uchar* data; + uchar* bayer_data[2]; + for (int i = 0; i < src.rows; ++i) { + data = src.ptr(i); + bayer_data[0] = blue.ptr(i / 2); + for (int j = 0; j < blue.cols; ++j, data += 2) { + bayer_data[0][j] = *data; + } + data = src.ptr(++i) + 1; + bayer_data[1] = red.ptr(i / 2); + for (int j = 0; j < red.cols; ++j, data += 2) { + bayer_data[1][j] = *data; + } + } +} +void Energy::imagePreprocess(cv::Mat &src) { + if(src.type() == CV_8UC1) + { + splitBayerBG(src, src_blue, src_red); + if(ally_color_ == ALLY_RED) + { + src = src_red - src_blue; + }else if(ally_color_ == ALLY_BLUE){ + src = src_blue - src_red; + } + } + + + else if(src.type() == CV_8UC3) + { + std::vector channels; + split(src, channels); + resize(channels.at(0), src_blue, Size(SRC_WIDTH, SRC_HEIGHT)); + resize(channels.at(1), src_green, Size(SRC_WIDTH, SRC_HEIGHT)); + resize(channels.at(2), src_red, Size(SRC_WIDTH, SRC_HEIGHT)); + if(ally_color_ == ALLY_RED) + { + src = src_red-src_blue; + //src=src_red; + }else if(ally_color_ == ALLY_BLUE){ + src = src_blue-src_red; + //src=src_blue; + } + } + cv::resize(src, src, cv::Size(640, 480), 2); + threshold(src, src, energy_part_param_.SPLIT_GRAY_THRESH, 255, THRESH_BINARY); + +} diff --git a/energy/src/energy/calibrate/structing.cpp b/energy/src/energy/calibrate/structing.cpp new file mode 100644 index 0000000..4916b45 --- /dev/null +++ b/energy/src/energy/calibrate/structing.cpp @@ -0,0 +1,26 @@ +// +// Created by xixiliadorabarry on 1/24/19. +// +#include "energy/energy.h" + +using namespace cv; +using std::cout; +using std::endl; +using std::vector; + +void Energy::StructingElementClose(cv::Mat &src){ + if (src.empty())return; + //threshold(src, src, energy_part_param_.CAMERA_GRAY_THRESH, 255, THRESH_BINARY); + Mat element = getStructuringElement(MORPH_RECT, Size(4, 4)); + morphologyEx(src, src, MORPH_CLOSE, element); +} + +void Energy::StructingElementErodeDilate(cv::Mat &src) { + cv::Mat src_out, src_out_out; + Mat element_erode = getStructuringElement(MORPH_RECT, Size(4, 4)); + Mat element_dilate = getStructuringElement(MORPH_RECT, Size(20, 20)); + erode(src,src_out, element_erode); + imshow("erode", src_out); + dilate(src_out, src_out_out, element_dilate); + imshow("dilate", src_out_out); +} diff --git a/energy/src/energy/energy.cpp b/energy/src/energy/energy.cpp new file mode 100644 index 0000000..360c83a --- /dev/null +++ b/energy/src/energy/energy.cpp @@ -0,0 +1,64 @@ +// +// Created by xixiliadorabarry on 1/24/19. +// +#include "energy/energy.h" + +using namespace cv; +using std::cout; +using std::endl; +using std::vector; + +Energy::Energy(Uart &u):uart(u), + src_blue(SRC_HEIGHT, SRC_WIDTH, CV_8UC1), + src_red(SRC_HEIGHT, SRC_WIDTH, CV_8UC1) +{ + fans_cnt = 0; + armors_cnt = 0; + cycle_center = Point(0, 0); + target_center = Point(0, 0); + last_target_center = Point(0, 0); + hit_point = Point(0,0); + target_position = -1; + last_target_position = -1; + target_armor = -1; + radius = 0; + + ally_color_ = ALLY_RED; + energy_part_rotation = CLOCKWISE; + attack_distance = ATTACK_DISTANCE; + count = 1; + last_fans_cnt = 0; + last_armors_cnt = 0; + send_cnt = 0; + + rectified_focal_length = 1000; + theta = 0; + phi = 0; + yaw_rotation = 0; + pitch_rotation = 0; + + isLeftVertexFound = -1; + isTopVertexFound = -1; + isRightVertexFound = -1; + isBottomVertexFound = -1; + + left = Point(640, 480); + right = Point(0, 0); + top = Point(640, 480); + bottom = Point(0, 0); + + initEnergyPartParam(); +} + +Energy::~Energy() = default; + + +void Energy::setAllyColor(int color) +{ + ally_color_ = color; +} + +void Energy::setRotation(int rotation){ + energy_part_rotation = rotation; +} + diff --git a/energy/src/energy/find/cycle_finder.cpp b/energy/src/energy/find/cycle_finder.cpp new file mode 100644 index 0000000..bff7ee9 --- /dev/null +++ b/energy/src/energy/find/cycle_finder.cpp @@ -0,0 +1,89 @@ +// +// Created by xixiliadorabarry on 19-3-23. +// + +#include "energy/energy.h" +#include + +using namespace cv; +using std::cout; +using std::endl; +using std::vector; + +void Energy::findWholeCycle(const std::vector&first_armor_centers) { + int cur_size = static_cast(first_armor_centers.size()); + //cout << "first armor centers' size: " << first_armor_centers.size() << endl; + if (cur_size == 0)return; + int vertex = 0; + for (int i = 1; i < cur_size - 1; ++i) + { + if (vertex == 4)break; + if (first_armor_centers.at(i).x >= first_armor_centers.at(i - 1).x && first_armor_centers.at(i).x >= first_armor_centers.at(i + 1).x) + { + if (isRightVertexFound == -1) { + vertex += 1; + isRightVertexFound = 1; + right = first_armor_centers.at(i); + cout << "right vertex: " << right << endl; + continue; + } + else if (right.x > first_armor_centers.at(i).x)continue; + else { + right = first_armor_centers.at(i); + continue; + } + } + if (first_armor_centers.at(i).x <= first_armor_centers.at(i - 1).x && first_armor_centers.at(i).x <= first_armor_centers.at(i + 1).x) + { + if (isLeftVertexFound == -1) { + vertex += 1; + isLeftVertexFound = 1; + left = first_armor_centers.at(i); + cout << "left vertex: " << left << endl; + continue; + } + else if (left.x < first_armor_centers.at(i).x)continue; + else { + left = first_armor_centers.at(i); + continue; + } + } + if (first_armor_centers.at(i).y <= first_armor_centers.at(i - 1).y && first_armor_centers.at(i).y <= first_armor_centers.at(i + 1).y) + { + if (isTopVertexFound == -1) { + vertex += 1; + isTopVertexFound = 1; + top = first_armor_centers.at(i); + cout << "top vertex: " << top << endl; + continue; + } + else if (top.y < first_armor_centers.at(i).y)continue; + else { + top = first_armor_centers.at(i); + continue; + } + + } + if (first_armor_centers.at(i).y >= first_armor_centers.at(i - 1).y && first_armor_centers.at(i).y >= first_armor_centers.at(i + 1).y) + { + if (isBottomVertexFound == -1) { + vertex += 1; + isBottomVertexFound = 1; + bottom = first_armor_centers.at(i); + cout << "bottom vertex: " << bottom << endl; + continue; + } + else if (bottom.y > first_armor_centers.at(i).y)continue; + else { + bottom = first_armor_centers.at(i); + continue; + } + } + } + + /*for (int k = 0; k < first_armor_centers.size(); ++k) { + cout << k << " : " << first_armor_centers.at(k) << '\t'; + float angle = static_cast(180 / PI * atan2(-1 * (first_armor_centers.at(k).y - 298), (first_armor_centers.at(k).x - 298))); + cout << angle << endl; + }*/ +} diff --git a/energy/src/energy/find/energy_finder.cpp b/energy/src/energy/find/energy_finder.cpp new file mode 100644 index 0000000..a547c84 --- /dev/null +++ b/energy/src/energy/find/energy_finder.cpp @@ -0,0 +1,222 @@ +// +// Created by xixiliadorabarry on 1/24/19. +// +#include "energy/energy.h" + +using namespace cv; +using std::cout; +using std::endl; +using std::vector; + +int Energy::findFan(const cv::Mat &src, vector &fans, int &last_fans_cnt) { + if (src.empty())return 0; + static Mat src_bin; + src_bin = src.clone(); +// threshold(src, src_bin, energy_part_param_.FAN_GRAY_THRESH, 255, THRESH_BINARY); + if(src.type() == CV_8UC3){ + cvtColor(src_bin, src_bin, CV_BGR2GRAY); + } + std::vector > fan_contours; + + StructingElementClose(src_bin); +// imshow("fan struct",src_bin); + + findContours(src_bin, fan_contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_NONE); + + for (auto &fan_contour : fan_contours) { + if (!isValidFanContour(fan_contour)) { + continue; + } + +// double cur_contour_area = contourArea(fan_contour); +// RotatedRect cur_rect = minAreaRect(fan_contour); +// Size2f cur_size = cur_rect.size; +// +// cout<<"cur_contour_area: "< cur_size.width ? cur_size.height : cur_size.width; +// float width = cur_size.height < cur_size.width ? cur_size.height : cur_size.width; + +// if(length>5&&width>5){ +// cout<(fans.size()); + return -1; + } + last_fans_cnt = static_cast(fans.size()); + return static_cast(fans.size()); +} + + + +int Energy::findArmor(const cv::Mat &src, vector &armors, int &last_armors_cnt) { + if (src.empty())return 0; + static Mat src_bin; + src_bin = src.clone(); +// threshold(src, src_bin, energy_part_param_.ARMOR_GRAY_THRESH, 255, THRESH_BINARY); + if(src.type() == CV_8UC3){ + cvtColor(src_bin, src_bin, CV_BGR2GRAY); + } + std::vector > armor_contours; + std::vector > armor_contours_external;//用总轮廓减去外轮廓，只保留内轮廓，除去流动条的影响。 + + StructingElementClose(src_bin); +// imshow("armor struct",src_bin); + + findContours(src_bin, armor_contours, CV_RETR_LIST, CV_CHAIN_APPROX_NONE); + findContours(src_bin, armor_contours_external, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_NONE); + + for (int i = 0; i < armor_contours_external.size(); i++)//去除外轮廓 + { + unsigned long external_contour_size = armor_contours_external[i].size(); + for (int j = 0; j < armor_contours.size(); j++) + { + unsigned long all_size = armor_contours[j].size(); + if (external_contour_size == all_size) + { + swap(armor_contours[j], armor_contours[armor_contours.size() - 1]); + armor_contours.pop_back(); + break; + } + } + } + + for (auto &armor_contour : armor_contours) { + if (!isValidArmorContour(armor_contour)) + { + continue; + } + + RotatedRect cur_rect = minAreaRect(armor_contour); + Size2f cur_size = cur_rect.size; + float length = cur_size.height > cur_size.width ? cur_size.height : cur_size.width; + float width = cur_size.height < cur_size.width ? cur_size.height : cur_size.width; + +// if(length>10&&width>10){ +// armors.emplace_back(armor_contour); +// cout<<"armor area: "<(armors.size()); + return -1; + } + last_armors_cnt = static_cast(armors.size()); + return static_cast(armors.size()); +} + +int Energy::findGimbleZeroPoint(const cv::Mat &src, vector &gimble_zero_points) { + if (src.empty())return 0; + static Mat src_bin; + src_bin = src.clone(); +// threshold(src, src_bin, energy_part_param_.FAN_GRAY_THRESH, 255, THRESH_BINARY); + if(src.type() == CV_8UC3){ + cvtColor(src_bin, src_bin, CV_BGR2GRAY); + } + std::vector > zero_point_contours; + + findContours(src_bin, zero_point_contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_NONE); + + for (auto &zero_point_contour : zero_point_contours) { + + double cur_contour_area = contourArea(zero_point_contour); + RotatedRect cur_rect = minAreaRect(zero_point_contour); + Size2f cur_size = cur_rect.size; + +// cout<<"cur_contour_area: "< cur_size.width ? cur_size.height : cur_size.width; + float width = cur_size.height < cur_size.width ? cur_size.height : cur_size.width; + + if(length<10&&width<10&&length>1&&width>1){ + cout<<"zero point center: "<(fans.size()); +} + +bool Energy::isValidFanContour(const vector &fan_contour) { + double cur_contour_area = contourArea(fan_contour); + if (cur_contour_area > energy_part_param_.FAN_CONTOUR_AREA_MAX || + cur_contour_area < energy_part_param_.FAN_CONTOUR_AREA_MIN) + { + //cout< cur_size.width ? cur_size.height : cur_size.width; + float width = cur_size.height < cur_size.width ? cur_size.height : cur_size.width; + if (length < energy_part_param_.FAN_CONTOUR_LENGTH_MIN || width < energy_part_param_.FAN_CONTOUR_WIDTH_MIN) + { + //cout<<"length width min fail."< energy_part_param_.FAN_CONTOUR_HW_RATIO_MAX || +// length_width_ratio < energy_part_param_.FAN_CONTOUR_HW_RATIO_MIN) +// { +// //cout<<"length width ratio fail."< &armor_contour) { + double cur_contour_area = contourArea(armor_contour); +// if (cur_contour_area > energy_part_param_.ARMOR_CONTOUR_AREA_MAX || +// cur_contour_area < energy_part_param_.ARMOR_CONTOUR_AREA_MIN) +// { +// //cout< cur_size.width ? cur_size.height : cur_size.width; + float width = cur_size.height < cur_size.width ? cur_size.height : cur_size.width; + if (length < energy_part_param_.ARMOR_CONTOUR_LENGTH_MIN || width < energy_part_param_.ARMOR_CONTOUR_WIDTH_MIN) + { + //cout<<"length width min fail."< energy_part_param_.ARMOR_CONTOUR_LENGTH_MAX||width>energy_part_param_.ARMOR_CONTOUR_WIDTH_MAX) + { + //cout<<"length width max fail."< energy_part_param_.ARMOR_CONTOUR_HW_RATIO_MAX || + length_width_ratio < energy_part_param_.ARMOR_CONTOUR_HW_RATIO_MIN) + { + //cout<<"length width ratio fail."<fanPosition, std::vectorarmorPosition, float &target_armor) { + if (fanPosition.size() >= armorPosition.size()) return; + if (armorPosition.size()==0)return; + if (fanPosition.size() == 0) { + target_armor = armorPosition.at(0); + for (const auto &armor : armors) + { + target_center = armor.rect.center; +// cout<<"target center: "<::iterator it = fanPosition.begin(); it != fanPosition.end(); it++) { + cout << *it << endl; + }*/ + sort(armorPosition.begin(), armorPosition.end()); + /*for (vector::iterator it = armorPosition.begin(); it != armorPosition.end(); it++) { + cout << *it << endl; + }*/ + int i, j = 0; + for (i = 0; i < fanPosition.size(); ++i) { + if (armorPosition.at(i) - fanPosition.at(j) < energy_part_param_.TWIN_ANGEL_MAX && armorPosition.at(i) - fanPosition.at(j) > -1 * energy_part_param_.TWIN_ANGEL_MAX) { + j++; + continue; + } + else { + target_armor = armorPosition.at(j); + for (const auto &armor : armors) + { + float angle = static_cast(180 / PI * atan2(-1 * (armor.rect.center.y - cycle_center.y), (armor.rect.center.x - cycle_center.x))); + if(target_armor==angle){ + target_center = armor.rect.center; +// cout<<"target center: "<(180 / PI * atan2(-1 * (armor.rect.center.y - cycle_center.y), (armor.rect.center.x - cycle_center.x))); + if(target_armor == angle){ + target_center = armor.rect.center; +// cout<<"target center: "< + +using namespace cv; +using std::cout; +using std::endl; +using std::vector; + + +void Energy::gimbleRotation(){ +//该方法用于标定激光零点的情况，对操作手友好，但建立在云台稳定情况下 +// yaw_rotation = static_cast(180 / PI * atan2(-1*STRETCH*(hit_point.x-ZERO_POINT_X), ATTACK_DISTANCE)); +// pitch_rotation = static_cast(180 / PI * atan2((ATTACK_DISTANCE*tan(PITCH_ORIGIN_RAD)-STRETCH*(hit_point.y-ZERO_POINT_Y)), ATTACK_DISTANCE)); + +//该方法用于操作手自己完成对心工作的情况，对操作手要求高 + cv::Point2f real_hit_point; + stretch(hit_point, real_hit_point); +// yaw_rotation = static_cast(180 / PI * atan2((ATTACK_DISTANCE*tan(YAW_ORIGIN_RAD)-real_hit_point.x), ATTACK_DISTANCE)); +// pitch_rotation = static_cast(180 / PI * atan2((ATTACK_DISTANCE*tan(PITCH_ORIGIN_RAD)-real_hit_point.y), ATTACK_DISTANCE)); + + yaw_rotation = static_cast(180 / PI * atan2((ATTACK_DISTANCE*tan(aim.yaw)-real_hit_point.x), ATTACK_DISTANCE)); + pitch_rotation = static_cast(180 / PI * atan2((ATTACK_DISTANCE*tan(aim.pitch)-real_hit_point.y), ATTACK_DISTANCE)); +} \ No newline at end of file diff --git a/energy/src/energy/get/hit_point_get.cpp b/energy/src/energy/get/hit_point_get.cpp new file mode 100644 index 0000000..08886ac --- /dev/null +++ b/energy/src/energy/get/hit_point_get.cpp @@ -0,0 +1,31 @@ +// +// Created by xixiliadorabarry on 1/24/19. +// + +#include "energy/energy.h" +#include "energy/constant.h" + +using namespace cv; +using std::cout; +using std::endl; +using std::vector; + +void Energy::getHitPoint(){ +// if(!changeTarget()){ +// //last_target_center = target_center; +// //last_target_position = target_position; +// return; +// } +// else { + double rad = static_cast(energy_part_rotation * energy_part_param_.RPM + * energy_part_param_.HIT_TIME * 360 / 60); + rotate(rad, radius, cycle_center, target_center, hit_point); + //last_target_center = target_center; + //last_target_position = target_position; +// } +} + +bool Energy::changeTarget(){ + return !(pointDistance(target_center, last_target_center) < 25 || fabs(target_position - last_target_position) < 30 + ||fabs(target_position - last_target_position) > 330); +} \ No newline at end of file diff --git a/energy/src/energy/get/position_get.cpp b/energy/src/energy/get/position_get.cpp new file mode 100644 index 0000000..fc3d51a --- /dev/null +++ b/energy/src/energy/get/position_get.cpp @@ -0,0 +1,49 @@ +// +// Created by xixiliadorabarry on 1/24/19. +// +#include "energy/energy.h" + +using namespace cv; +using std::cout; +using std::endl; +using std::vector; + +void Energy::getFanPosition(std::vector &fanPosition, const std::vector &fans, cv::Point cycle_center, double radius) { + if (radius == 0)return; + for (const auto &fan : fans) + { + float angle = static_cast(180 / PI * atan2(-1 * (fan.rect.center.y - cycle_center.y), (fan.rect.center.x - cycle_center.x))); + fanPosition.push_back(angle); + } + cout << "fanPosition.size() = " << fanPosition.size() << '\t' << endl; +} + +void Energy::getArmorPosition(std::vector &armorPosition, const std::vector &armors, cv::Point cycle_center, double radius) { + if (radius == 0)return; + for (const auto &armor : armors) + { + float angle = static_cast(180 / PI * atan2(-1 * (armor.rect.center.y - cycle_center.y), (armor.rect.center.x - cycle_center.x))); + armorPosition.push_back(angle); + + } + cout << "armorPosition.size() = " << armorPosition.size() << '\t' << endl; +} + +void Energy::getFirstArmorCenters(vector &armors, std::vector &first_armor_centers) +{ + for (const auto &armor : armors) { + if (armors.size() < 2)first_armor_centers.push_back(armor.rect.center); + } +} + +void Energy::getAllArmorCenters() +{ + for (const auto &armor : armors) { + all_armor_centers.push_back(armor.rect.center); + } +} + +void Energy::getPosition(cv::Point point, double &angle){ + if (radius == 0)return; + angle = (180 / PI * atan2(-1 * (point.y - cycle_center.y), (point.x - cycle_center.x))); +} diff --git a/energy/src/energy/param_init.cpp b/energy/src/energy/param_init.cpp new file mode 100644 index 0000000..a81ca0e --- /dev/null +++ b/energy/src/energy/param_init.cpp @@ -0,0 +1,42 @@ +// +// Created by xixiliadorabarry on 1/24/19. +// +#include "energy/energy.h" + +using namespace cv; +using std::cout; +using std::endl; +using std::vector; + +void Energy::initEnergyPartParam() { + + energy_part_param_.RPM = 10; + energy_part_param_.HIT_TIME = 1.0; + + energy_part_param_.GRAY_THRESH = 240; + energy_part_param_.SPLIT_GRAY_THRESH = 80; + energy_part_param_.FAN_GRAY_THRESH = 75; + energy_part_param_.ARMOR_GRAY_THRESH = 80; + + energy_part_param_.FAN_CONTOUR_AREA_MAX = 17000; + energy_part_param_.FAN_CONTOUR_AREA_MIN = 7000; + energy_part_param_.FAN_CONTOUR_LENGTH_MIN = 150; + energy_part_param_.FAN_CONTOUR_WIDTH_MIN = 50; + energy_part_param_.FAN_CONTOUR_HW_RATIO_MAX = 4; + energy_part_param_.FAN_CONTOUR_HW_RATIO_MIN = 1; + + energy_part_param_.ARMOR_CONTOUR_AREA_MAX = 100000; + energy_part_param_.ARMOR_CONTOUR_AREA_MIN = 0; + energy_part_param_.ARMOR_CONTOUR_LENGTH_MIN = 50; + energy_part_param_.ARMOR_CONTOUR_WIDTH_MIN = 25; + energy_part_param_.ARMOR_CONTOUR_LENGTH_MAX = 80; + energy_part_param_.ARMOR_CONTOUR_WIDTH_MAX = 50; + energy_part_param_.ARMOR_CONTOUR_HW_RATIO_MAX = 3; + energy_part_param_.ARMOR_CONTOUR_HW_RATIO_MIN = 1; + + energy_part_param_.TWIN_ANGEL_MAX = 10; + + +} + + diff --git a/energy/src/energy/run.cpp b/energy/src/energy/run.cpp new file mode 100644 index 0000000..df8b4c5 --- /dev/null +++ b/energy/src/energy/run.cpp @@ -0,0 +1,76 @@ +// +// Created by xixiliadorabarry on 3/5/19. +// +#include "energy/energy.h" + +using namespace cv; +using std::cout; +using std::endl; +using std::vector; + +int Energy::run(cv::Mat &src){ + fans.clear(); + armors.clear(); + fanPosition.clear(); + armorPosition.clear(); + gimble_zero_points.clear(); +// if(all_armor_centers.size()>200)all_armor_centers.clear(); +// if(first_armor_centers.size()>200)first_armor_centers.clear(); +// cout<<"first_armor_centers.size(): "<0)showFanContours("fan",src,fans); +// fans_cnt=0; + + armors_cnt = findArmor(src, armors, last_armors_cnt); +// cout<<"armors_cnt: "<0) showArmorContours("armor",src,armors); + + if(armors_cnt>0||fans_cnt>0) showBothContours("Both",src, fans, armors); + + if(armors_cnt != fans_cnt+1) return 0; + + +//此处用于标定云台在摄像头视频中的零点 +// findGimbleZeroPoint(src,gimble_zero_points); +// cout<<"gimble zero points: :"< &fans) { + if (src.empty())return; + static Mat image2show; + + if(src.type() == CV_8UC1) // 黑白图像 + { + cvtColor(src, image2show, COLOR_GRAY2RGB); + + } else if (src.type() == CV_8UC3) //RGB 彩色 + { + image2show = src.clone(); + } + //cvtColor(image2show, image2show, COLOR_GRAY2RGB); + for (const auto &fan : fans) + { + Point2f vertices[4]; //定义矩形的4个顶点 + fan.rect.points(vertices); //计算矩形的4个顶点 + for (int i = 0; i < 4; i++) + line(image2show, vertices[i], vertices[(i + 1) % 4], Scalar(255, 0, 0), 2); + //cout << fan.rect.center << '\t' << fan.rect.angle << '\t'; + //cout << endl; + } + imshow(windows_name, image2show); +} + +void Energy::showArmorContours(std::string windows_name, const cv::Mat &src, const std::vector &armors) { + if (src.empty())return; + static Mat image2show; + + if(src.type() == CV_8UC1) // 黑白图像 + { + cvtColor(src, image2show, COLOR_GRAY2RGB); + + } else if (src.type() == CV_8UC3) //RGB 彩色 + { + image2show = src.clone(); + } + //cvtColor(image2show, image2show, COLOR_GRAY2RGB); + for (const auto &armor : armors) + { + Point2f vertices[4]; //定义矩形的4个顶点 + armor.rect.points(vertices); //计算矩形的4个顶点 + for (int i = 0; i < 4; i++) + line(image2show, vertices[i], vertices[(i + 1) % 4], Scalar(0, 0, 255), 2); + //cout << armor.rect.center << '\t' << armor.rect.angle << '\t'; + //cout << endl; + } + imshow(windows_name, image2show); +} + +void Energy::showBothContours(std::string windows_name, const cv::Mat &src, const std::vector &fans, + const std::vector &armors) { + if (src.empty())return; + static Mat image2show; + if(src.type() == CV_8UC1) // 黑白图像 + { + cvtColor(src, image2show, COLOR_GRAY2RGB); + + } else if (src.type() == CV_8UC3) //RGB 彩色 + { + image2show = src.clone(); + } + //cvtColor(image2show, image2show, COLOR_GRAY2RGB); + for (const auto &fan : fans) + { + Point2f vertices[4]; //定义矩形的4个顶点 + fan.rect.points(vertices); //计算矩形的4个顶点 + for (int i = 0; i < 4; i++) + line(image2show, vertices[i], vertices[(i + 1) % 4], Scalar(255, 0, 0), 4); +// cout << "fan" << fan.rect.size.height <<'\t'<< fan.rect.size.width << '\t' << '\t'; +// cout << endl; + } + for (const auto &armor : armors) + { + Point2f vertices[4]; //定义矩形的4个顶点 + armor.rect.points(vertices); //计算矩形的4个顶点 + for (int i = 0; i < 4; i++) + line(image2show, vertices[i], vertices[(i + 1) % 4], Scalar(0, 0, 255), 4); +// cout << "armor center: "<< armor.rect.center << '\t'<< "armor angle: "<< armor.rect.angle; +// cout << endl; + } + + imshow(windows_name, image2show); +} + + diff --git a/energy/src/energy/tool/tool.cpp b/energy/src/energy/tool/tool.cpp new file mode 100644 index 0000000..24ba1e2 --- /dev/null +++ b/energy/src/energy/tool/tool.cpp @@ -0,0 +1,88 @@ +// +// Created by xixiliadorabarry on 1/24/19. +// +#include "energy/energy.h" +#include +#include +#include +#include +#include +#include +using namespace cv; +using std::cout; +using std::endl; +using std::vector; + +void Energy::extract(cv::Mat &src){ + cv::Rect rect(EXTRACT_POINT_X, EXTRACT_POINT_Y, EXTRACT_WIDTH, EXTRACT_HEIGHT); + src = src(rect).clone(); + cv::resize(src, src, cv::Size(640, 480), 2); + imshow("extract", src); +} + +void Energy::saveFourPoints(std::vector &FourPoints, cv::Point point_1, cv::Point point_2, cv::Point point_3, cv::Point point_4) { + FourPoints.push_back(point_1); + FourPoints.push_back(point_2); + FourPoints.push_back(point_3); + FourPoints.push_back(point_4); +} + +void Energy::savePoint2f(std::vector &point_save, cv::Point point) { + point_save.push_back(static_cast(point)); +} + +double Energy::pointDistance(cv::Point point_1, cv::Point point_2){ + double distance = 0; + distance = sqrt(pow(static_cast(point_1.x - point_2.x),2) + + pow(static_cast(point_1.y - point_2.y),2)); + return distance; +} + +void Energy::rotate(double rad, double radius, cv::Point center, cv::Point point_old, cv::Point &point_new) { + int x1, x2, y1, y2; + // 为了减小强制转换的误差 + x1 = center.x * 100; + x2 = point_old.x * 100; + y1 = center.y * 100; + y2 = point_old.y * 100; + + point_new.x = static_cast((x1 + (x2 - x1)*cos(-rad * d2r) - (y1 - y2)*sin(-rad * d2r))/100); + point_new.y = static_cast((y1 - (x2 - x1)*sin(-rad * d2r) - (y1 - y2)*cos(-rad * d2r))/100); +} + +void Energy::stretch(cv::Point point_1, cv::Point2f &point_2){ + if(point_1==cycle_center){ + cout<<"stretch wrong!"<( ARMOR_CENTER_TO_CYCLE_CENTER * x_0 / r_0); + point_2.y = static_cast( ARMOR_CENTER_TO_CYCLE_CENTER * y_0 / r_0); +} + +void Energy::cycle(cv::Point p1, cv::Point p2, cv::Point p3, cv::Point ¢er, double &radius){ + double x1, y1, x2, y2, x3, y3; + double a, b, c, g, e, f; + x1 = p1.x; + y1 = p1.y; + x2 = p2.x; + y2 = p2.y; + x3 = p3.x; + y3 = p3.y; + + //三点确定圆的方程：(2x2-2x1)X+(2y2-2y1)Y=x2²-x1²+y2²-y1²；(2x3-2x2)X+(2y3-2y2)Y=x3²-x2²+y3²-y2² + e = 2 * (x2 - x1); + f = 2 * (y2 - y1); + g = x2 * x2 - x1 * x1 + y2 * y2 - y1 * y1; + a = 2 * (x3 - x2); + b = 2 * (y3 - y2); + c = x3 * x3 - x2 * x2 + y3 * y3 - y2 * y2; + cycle_center.x = static_cast((g*b - c * f) / (e*b - a * f)); + cycle_center.y = static_cast((a*g - c * e) / (a*f - b * e)); + radius = sqrt((cycle_center.x - x1)*(cycle_center.x - x1) + (cycle_center.y - y1)*(cycle_center.y - y1)); + +} + diff --git a/include/camera/camera_api.h b/include/camera/camera_api.h new file mode 100644 index 0000000..625b5c5 --- /dev/null +++ b/include/camera/camera_api.h @@ -0,0 +1,2823 @@ +#ifndef _MVCAMAPI_H_ +#define _MVCAMAPI_H_ + +#define MVSDK_API + +#ifdef __cplusplus +extern "C" { +#endif + + +#include "camera_status.h" +#include "camera_define.h" + + + +/******************************************************/ +// 函数名 : CameraSdkInit +// 功能描述 : 相机SDK初始化，在调用任何SDK其他接口前，必须 +// 先调用该接口进行初始化。该函数在整个进程运行 +// 期间只需要调用一次。 +// 参数 : iLanguageSel 用于选择SDK内部提示信息和界面的语种, +// 0:表示英文,1:表示中文。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSdkInit( + int iLanguageSel +); + +/******************************************************/ +// 函数名 : CameraEnumerateDevice +// 功能描述 : 枚举设备，并建立设备列表。在调用CameraInit +// 之前，必须调用该函数来获得设备的信息。 +// 参数 : pCameraList 设备列表数组指针。 +// piNums 设备的个数指针，调用时传入pCameraList +// 数组的元素个数，函数返回时，保存实际找到的设备个数。 +// 注意，piNums指向的值必须初始化，且不超过pCameraList数组元素个数， +// 否则有可能造成内存溢出。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraEnumerateDevice( + tSdkCameraDevInfo* pCameraList, + INT* piNums +); + +/******************************************************/ +// 函数名 : CameraIdleStateDevice +// 功能描述 : 当前系统有未使用的相机信息。 +// 参数 : pCameraList 设备列表数组指针。 +// piNums 设备的个数指针，调用时传入pCameraList +// 数组的元素个数，函数返回时，保存实际找到的设备个数。 +// 注意，piNums指向的值必须初始化，且不超过pCameraList数组元素个数， +// 否则有可能造成内存溢出。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraIdleStateDevice( + tSdkCameraDevInfo* pCameraList, + INT* piNums +); + + +/******************************************************/ +// 函数名 : CameraEnumerateDeviceEx +// 功能描述 : 枚举设备，并建立设备列表。在调用CameraInitEx +// 之前，必须调用该函数枚举设备。 +// 参数 : +// 返回值 : 返回设备个数，0表示无。 +/******************************************************/ +MVSDK_API INT CameraEnumerateDeviceEx( +); + + +/******************************************************/ +// 函数名 : CameraIsOpened +// 功能描述 : 检测设备是否已经被其他应用程序打开。在调用CameraInit +// 之前，可以使用该函数进行检测，如果已经被打开，调用 +// CameraInit会返回设备已经被打开的错误码。 +// 参数 : pCameraList 设备的枚举信息结构体指针，由CameraEnumerateDevice获得。 +// pOpened 设备的状态指针，返回设备是否被打开的状态，TRUE为打开，FALSE为空闲。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraIsOpened( + tSdkCameraDevInfo* pCameraList, + BOOL* pOpened +); + + +/******************************************************/ +// 函数名 : CameraInit +// 功能描述 : 相机初始化。初始化成功后，才能调用任何其他 +// 相机相关的操作接口。 +// 参数 : pCameraInfo 该相机的设备描述信息，由CameraEnumerateDevice +// 函数获得。 +// iParamLoadMode 相机初始化时使用的参数加载方式。-1表示使用上次退出时的参数加载方式。 +// emTeam 初始化时使用的参数组。-1表示加载上次退出时的参数组。 +// pCameraHandle 相机的句柄指针，初始化成功后，该指针 +// 返回该相机的有效句柄，在调用其他相机 +// 相关的操作接口时，都需要传入该句柄，主要 +// 用于多相机之间的区分。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraInit( + tSdkCameraDevInfo* pCameraInfo, + int emParamLoadMode, + int emTeam, + CameraHandle* pCameraHandle +); + +/******************************************************/ +// 函数名 : CameraInitEx +// 功能描述 : 相机初始化。初始化成功后，才能调用任何其他 +// 相机相关的操作接口。 +// 参数 : iDeviceIndex 相机的索引号，CameraEnumerateDeviceEx返回相机个数。 +// iParamLoadMode 相机初始化时使用的参数加载方式。-1表示使用上次退出时的参数加载方式。 +// emTeam 初始化时使用的参数组。-1表示加载上次退出时的参数组。 +// pCameraHandle 相机的句柄指针，初始化成功后，该指针 +// 返回该相机的有效句柄，在调用其他相机 +// 相关的操作接口时，都需要传入该句柄，主要 +// 用于多相机之间的区分。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraInitEx( + int iDeviceIndex, + int iParamLoadMode, + int emTeam, + CameraHandle* pCameraHandle +); + + +/******************************************************/ +// 函数名 : CameraSetCallbackFunction +// 功能描述 : 设置图像捕获的回调函数。当捕获到新的图像数据帧时， +// pCallBack所指向的回调函数就会被调用。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// pCallBack 回调函数指针。 +// pContext 回调函数的附加参数，在回调函数被调用时 +// 该附加参数会被传入，可以为NULL。多用于 +// 多个相机时携带附加信息。 +// pCallbackOld 用于保存当前的回调函数。可以为NULL。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetCallbackFunction( + CameraHandle hCamera, + CAMERA_SNAP_PROC pCallBack, + PVOID pContext, + CAMERA_SNAP_PROC* pCallbackOld +); + +/******************************************************/ +// 函数名 : CameraUnInit +// 功能描述 : 相机反初始化。释放资源。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraUnInit( + CameraHandle hCamera +); + +/******************************************************/ +// 函数名 : CameraGetInformation +// 功能描述 : 获得相机的描述信息 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// pbuffer 指向相机描述信息指针的指针。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetInformation( + CameraHandle hCamera, + char** pbuffer +); + +/******************************************************/ +// 函数名 : CameraImageProcess +// 功能描述 : 将获得的相机原始输出图像数据进行处理，叠加饱和度、 +// 颜色增益和校正、降噪等处理效果，最后得到RGB888 +// 格式的图像数据。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// pbyIn 输入图像数据的缓冲区地址，不能为NULL。 +// pbyOut 处理后图像输出的缓冲区地址，不能为NULL。 +// pFrInfo 输入图像的帧头信息，处理完成后，帧头信息 +// 中的图像格式uiMediaType会随之改变。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraImageProcess( + CameraHandle hCamera, + BYTE* pbyIn, + BYTE* pbyOut, + tSdkFrameHead* pFrInfo +); + +/******************************************************/ +// 函数名 : CameraDisplayInit +// 功能描述 : 初始化SDK内部的显示模块。在调用CameraDisplayRGB24 +// 前必须先调用该函数初始化。如果您在二次开发中， +// 使用自己的方式进行图像显示(不调用CameraDisplayRGB24)， +// 则不需要调用本函数。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// hWndDisplay 显示窗口的句柄，一般为窗口的m_hWnd成员。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraDisplayInit( + CameraHandle hCamera, + HWND hWndDisplay +); + +/******************************************************/ +// 函数名 : CameraDisplayRGB24 +// 功能描述 : 显示图像。必须调用过CameraDisplayInit进行 +// 初始化才能调用本函数。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// pbyRGB24 图像的数据缓冲区，RGB888格式。 +// pFrInfo 图像的帧头信息。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraDisplayRGB24( + CameraHandle hCamera, + BYTE* pbyRGB24, + tSdkFrameHead* pFrInfo +); + +/******************************************************/ +// 函数名 : CameraSetDisplayMode +// 功能描述 : 设置显示的模式。必须调用过CameraDisplayInit +// 进行初始化才能调用本函数。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iMode 显示模式，DISPLAYMODE_SCALE或者 +// DISPLAYMODE_REAL,具体参见CameraDefine.h +// 中emSdkDisplayMode的定义。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetDisplayMode( + CameraHandle hCamera, + INT iMode +); + +/******************************************************/ +// 函数名 : CameraSetDisplayOffset +// 功能描述 : 设置显示的起始偏移值。仅当显示模式为DISPLAYMODE_REAL +// 时有效。例如显示控件的大小为320X240，而图像的 +// 的尺寸为640X480，那么当iOffsetX = 160,iOffsetY = 120时 +// 显示的区域就是图像的居中320X240的位置。必须调用过 +// CameraDisplayInit进行初始化才能调用本函数。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iOffsetX 偏移的X坐标。 +// iOffsetY 偏移的Y坐标。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetDisplayOffset( + CameraHandle hCamera, + int iOffsetX, + int iOffsetY +); + +/******************************************************/ +// 函数名 : CameraSetDisplaySize +// 功能描述 : 设置显示控件的尺寸。必须调用过 +// CameraDisplayInit进行初始化才能调用本函数。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iWidth 宽度 +// iHeight 高度 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetDisplaySize( + CameraHandle hCamera, + INT iWidth, + INT iHeight +); + +/******************************************************/ +// 函数名 : CameraGetImageBuffer +// 功能描述 : 获得一帧图像数据。为了提高效率，SDK在图像抓取时采用了零拷贝机制， +// CameraGetImageBuffer实际获得是内核中的一个缓冲区地址， +// 该函数成功调用后，必须调用CameraReleaseImageBuffer释放由 +// CameraGetImageBuffer得到的缓冲区,以便让内核继续使用 +// 该缓冲区。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// pFrameInfo 图像的帧头信息指针。 +// pbyBuffer 指向图像的数据的缓冲区指针。由于 +// 采用了零拷贝机制来提高效率，因此 +// 这里使用了一个指向指针的指针。 +// UINT wTimes 抓取图像的超时时间。单位毫秒。在 +// wTimes时间内还未获得图像，则该函数 +// 会返回超时信息。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetImageBuffer( + CameraHandle hCamera, + tSdkFrameHead* pFrameInfo, + BYTE** pbyBuffer, + UINT wTimes +); + +/******************************************************/ +// 函数名 : CameraGetImageBufferEx +// 功能描述 : 获得一帧图像数据。该接口获得的图像是经过处理后的RGB格式。该函数调用后， +// 不需要调用 CameraReleaseImageBuffer 释放，也不要调用free之类的函数释放 +// 来释放该函数返回的图像数据缓冲区。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// piWidth 整形指针，返回图像的宽度 +// piHeight 整形指针，返回图像的高度 +// UINT wTimes 抓取图像的超时时间。单位毫秒。在 +// wTimes时间内还未获得图像，则该函数 +// 会返回超时信息。 +// 返回值 : 成功时，返回RGB数据缓冲区的首地址; +// 否则返回0。 +/******************************************************/ +MVSDK_API unsigned char* CameraGetImageBufferEx( + CameraHandle hCamera, + INT* piWidth, + INT* piHeight, + UINT wTimes +); + + +/******************************************************/ +// 函数名 : CameraSnapToBuffer +// 功能描述 : 抓拍一张图像到缓冲区中。相机会进入抓拍模式，并且 +// 自动切换到抓拍模式的分辨率进行图像捕获。然后将 +// 捕获到的数据保存到缓冲区中。 +// 该函数成功调用后，必须调用CameraReleaseImageBuffer +// 释放由CameraSnapToBuffer得到的缓冲区。具体请参考 +// CameraGetImageBuffer函数的功能描述部分。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// pFrameInfo 指针，返回图像的帧头信息。 +// pbyBuffer 指向指针的指针，用来返回图像缓冲区的地址。 +// uWaitTimeMs 超时时间，单位毫秒。在该时间内，如果仍然没有 +// 成功捕获的数据，则返回超时信息。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSnapToBuffer( + CameraHandle hCamera, + tSdkFrameHead* pFrameInfo, + BYTE** pbyBuffer, + UINT uWaitTimeMs +); + +/******************************************************/ +// 函数名 : CameraReleaseImageBuffer +// 功能描述 : 释放由CameraGetImageBuffer获得的缓冲区。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// pbyBuffer 由CameraGetImageBuffer获得的缓冲区地址。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraReleaseImageBuffer( + CameraHandle hCamera, + BYTE* pbyBuffer +); + +/******************************************************/ +// 函数名 : CameraPlay +// 功能描述 : 让SDK进入工作模式，开始接收来自相机发送的图像 +// 数据。如果当前相机是触发模式，则需要接收到 +// 触发帧以后才会更新图像。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraPlay( + CameraHandle hCamera +); + +/******************************************************/ +// 函数名 : CameraPause +// 功能描述 : 让SDK进入暂停模式，不接收来自相机的图像数据， +// 同时也会发送命令让相机暂停输出，释放传输带宽。 +// 暂停模式下，可以对相机的参数进行配置，并立即生效。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraPause( + CameraHandle hCamera +); + +/******************************************************/ +// 函数名 : CameraStop +// 功能描述 : 让SDK进入停止状态，一般是反初始化时调用该函数， +// 该函数被调用，不能再对相机的参数进行配置。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraStop( + CameraHandle hCamera +); + +/******************************************************/ +// 函数名 : CameraInitRecord +// 功能描述 : 初始化一次录像。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iFormat 录像的格式，当前只支持不压缩和MSCV两种方式。 +// 0:不压缩；1:MSCV方式压缩。 +// pcSavePath 录像文件保存的路径。 +// b2GLimit 如果为TRUE,则文件大于2G时自动分割。 +// dwQuality 录像的质量因子，越大，则质量越好。范围1到100. +// iFrameRate 录像的帧率。建议设定的比实际采集帧率大， +// 这样就不会漏帧。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraInitRecord( + CameraHandle hCamera, + int iFormat, + char* pcSavePath, + BOOL b2GLimit, + DWORD dwQuality, + int iFrameRate +); + +/******************************************************/ +// 函数名 : CameraStopRecord +// 功能描述 : 结束本次录像。当CameraInitRecord后，可以通过该函数 +// 来结束一次录像，并完成文件保存操作。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraStopRecord( + CameraHandle hCamera +); + +/******************************************************/ +// 函数名 : CameraPushFrame +// 功能描述 : 将一帧数据存入录像流中。必须调用CameraInitRecord +// 才能调用该函数。CameraStopRecord调用后，不能再调用 +// 该函数。由于我们的帧头信息中携带了图像采集的时间戳 +// 信息，因此录像可以精准的时间同步，而不受帧率不稳定 +// 的影响。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// pbyImageBuffer 图像的数据缓冲区，必须是RGB格式。 +// pFrInfo 图像的帧头信息。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraPushFrame( + CameraHandle hCamera, + BYTE* pbyImageBuffer, + tSdkFrameHead* pFrInfo +); + +/******************************************************/ +// 函数名 : CameraSaveImage +// 功能描述 : 将图像缓冲区的数据保存成图片文件。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// lpszFileName 图片保存文件完整路径。 +// pbyImageBuffer 图像的数据缓冲区。 +// pFrInfo 图像的帧头信息。 +// byFileType 图像保存的格式。取值范围参见CameraDefine.h +// 中emSdkFileType的类型定义。目前支持 +// BMP、JPG、PNG、RAW四种格式。其中RAW表示 +// 相机输出的原始数据，保存RAW格式文件要求 +// pbyImageBuffer和pFrInfo是由CameraGetImageBuffer +// 获得的数据，而且未经CameraImageProcess转换 +// 成BMP格式；反之，如果要保存成BMP、JPG或者 +// PNG格式，则pbyImageBuffer和pFrInfo是由 +// CameraImageProcess处理后的RGB格式数据。 +// 具体用法可以参考Advanced的例程。 +// byQuality 图像保存的质量因子，仅当保存为JPG格式 +// 时该参数有效，范围1到100。其余格式 +// 可以写成0。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSaveImage( + CameraHandle hCamera, + char* lpszFileName, + BYTE* pbyImageBuffer, + tSdkFrameHead* pFrInfo, + BYTE byFileType, + BYTE byQuality +); + +/******************************************************/ +// 函数名 : CameraGetImageResolution +// 功能描述 : 获得当前预览的分辨率。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// psCurVideoSize 结构体指针，用于返回当前的分辨率。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetImageResolution( + CameraHandle hCamera, + tSdkImageResolution* psCurVideoSize +); + +/******************************************************/ +// 函数名 : CameraSetImageResolution +// 功能描述 : 设置预览的分辨率。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// pImageResolution 结构体指针，用于返回当前的分辨率。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetImageResolution( + CameraHandle hCamera, + tSdkImageResolution* pImageResolution +); + +/******************************************************/ +// 函数名 : CameraGetMediaType +// 功能描述 : 获得相机当前输出原始数据的格式索引号。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// piMediaType 指针，用于返回当前格式类型的索引号。 +// 由CameraGetCapability获得相机的属性， +// 在tSdkCameraCapbility结构体中的pMediaTypeDesc +// 成员中，以数组的形式保存了相机支持的格式， +// piMediaType所指向的索引号，就是该数组的索引号。 +// pMediaTypeDesc[*piMediaType].iMediaType则表示当前格式的 +// 编码。该编码请参见CameraDefine.h中[图像格式定义]部分。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetMediaType( + CameraHandle hCamera, + INT* piMediaType +); + +/******************************************************/ +// 函数名 : CameraSetMediaType +// 功能描述 : 设置相机的输出原始数据格式。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iMediaType 由CameraGetCapability获得相机的属性， +// 在tSdkCameraCapbility结构体中的pMediaTypeDesc +// 成员中，以数组的形式保存了相机支持的格式， +// iMediaType就是该数组的索引号。 +// pMediaTypeDesc[iMediaType].iMediaType则表示当前格式的 +// 编码。该编码请参见CameraDefine.h中[图像格式定义]部分。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetMediaType( + CameraHandle hCamera, + INT iMediaType +); + +/******************************************************/ +// 函数名 : CameraSetAeState +// 功能描述 : 设置相机曝光的模式。自动或者手动。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// bAeState TRUE，使能自动曝光；FALSE，停止自动曝光。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetAeState( + CameraHandle hCamera, + BOOL bAeState +); + +/******************************************************/ +// 函数名 : CameraGetAeState +// 功能描述 : 获得相机当前的曝光模式。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// pAeState 指针，用于返回自动曝光的使能状态。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetAeState( + CameraHandle hCamera, + BOOL* pAeState +); + +/******************************************************/ +// 函数名 : CameraSetSharpness +// 功能描述 : 设置图像的处理的锐化参数。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iSharpness 锐化参数。范围由CameraGetCapability +// 获得，一般是[0,100]，0表示关闭锐化处理。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetSharpness( + CameraHandle hCamera, + int iSharpness +); + +/******************************************************/ +// 函数名 : CameraGetSharpness +// 功能描述 : 获取当前锐化设定值。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// piSharpness 指针，返回当前设定的锐化的设定值。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetSharpness( + CameraHandle hCamera, + int* piSharpness +); + +/******************************************************/ +// 函数名 : CameraSetLutMode +// 功能描述 : 设置相机的查表变换模式LUT模式。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// emLutMode LUTMODE_PARAM_GEN 表示由伽马和对比度参数动态生成LUT表。 +// LUTMODE_PRESET 表示使用预设的LUT表。 +// LUTMODE_USER_DEF 表示使用用户自定的LUT表。 +// LUTMODE_PARAM_GEN的定义参考CameraDefine.h中emSdkLutMode类型。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetLutMode( + CameraHandle hCamera, + int emLutMode +); + +/******************************************************/ +// 函数名 : CameraGetLutMode +// 功能描述 : 获得相机的查表变换模式LUT模式。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// pemLutMode 指针，返回当前LUT模式。意义与CameraSetLutMode +// 中emLutMode参数相同。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetLutMode( + CameraHandle hCamera, + int* pemLutMode +); + +/******************************************************/ +// 函数名 : CameraSelectLutPreset +// 功能描述 : 选择预设LUT模式下的LUT表。必须先使用CameraSetLutMode +// 将LUT模式设置为预设模式。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iSel 表的索引号。表的个数由CameraGetCapability +// 获得。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSelectLutPreset( + CameraHandle hCamera, + int iSel +); + +/******************************************************/ +// 函数名 : CameraGetLutPresetSel +// 功能描述 : 获得预设LUT模式下的LUT表索引号。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// piSel 指针，返回表的索引号。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetLutPresetSel( + CameraHandle hCamera, + int* piSel +); + +/******************************************************/ +// 函数名 : CameraSetCustomLut +// 功能描述 : 设置自定义的LUT表。必须先使用CameraSetLutMode +// 将LUT模式设置为自定义模式。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iChannel 指定要设定的LUT颜色通道，当为LUT_CHANNEL_ALL时， +// 三个通道的LUT将被同时替换。 +// 参考CameraDefine.h中emSdkLutChannel定义。 +// pLut 指针，指向LUT表的地址。LUT表为无符号短整形数组，数组大小为 +// 4096，分别代码颜色通道从0到4096(12bit颜色精度)对应的映射值。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetCustomLut( + CameraHandle hCamera, + int iChannel, + USHORT* pLut +); + +/******************************************************/ +// 函数名 : CameraGetCustomLut +// 功能描述 : 获得当前使用的自定义LUT表。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iChannel 指定要获得的LUT颜色通道。当为LUT_CHANNEL_ALL时， +// 返回红色通道的LUT表。 +// 参考CameraDefine.h中emSdkLutChannel定义。 +// pLut 指针，指向LUT表的地址。LUT表为无符号短整形数组，数组大小为 +// 4096，分别代码颜色通道从0到4096(12bit颜色精度)对应的映射值。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetCustomLut( + CameraHandle hCamera, + int iChannel, + USHORT* pLut +); + +/******************************************************/ +// 函数名 : CameraGetCurrentLut +// 功能描述 : 获得相机当前的LUT表，在任何LUT模式下都可以调用, +// 用来直观的观察LUT曲线的变化。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iChannel 指定要获得的LUT颜色通道。当为LUT_CHANNEL_ALL时， +// 返回红色通道的LUT表。 +// 参考CameraDefine.h中emSdkLutChannel定义。 +// pLut 指针，指向LUT表的地址。LUT表为无符号短整形数组，数组大小为 +// 4096，分别代码颜色通道从0到4096(12bit颜色精度)对应的映射值。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetCurrentLut( + CameraHandle hCamera, + int iChannel, + USHORT* pLut +); + +/******************************************************/ +// 函数名 : CameraSetWbMode +// 功能描述 : 设置相机白平衡模式。分为手动和自动两种方式。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// bAuto TRUE，则表示使能自动模式。 +// FALSE，则表示使用手动模式，通过调用 +// CameraSetOnceWB来进行一次白平衡。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetWbMode( + CameraHandle hCamera, + BOOL bAuto +); + +/******************************************************/ +// 函数名 : CameraGetWbMode +// 功能描述 : 获得当前的白平衡模式。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// pbAuto 指针，返回TRUE表示自动模式，FALSE +// 为手动模式。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetWbMode( + CameraHandle hCamera, + BOOL* pbAuto +); + +/******************************************************/ +// 函数名 : CameraSetPresetClrTemp +// 功能描述 : 选择指定预设色温模式 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iSel 预设色温的模式索引号，从0开始 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetPresetClrTemp( + CameraHandle hCamera, + int iSel +); + +/******************************************************/ +// 函数名 : CameraGetPresetClrTemp +// 功能描述 : 获得当前选择的预设色温模式。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// piSel 指针，返回选择的预设色温索引号 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetPresetClrTemp( + CameraHandle hCamera, + int* piSel +); + +/******************************************************/ +// 函数名 : CameraSetUserClrTempGain +// 功能描述 : 设置自定义色温模式下的数字增益 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iRgain 红色增益，范围0到400，表示0到4倍 +// iGgain 绿色增益，范围0到400，表示0到4倍 +// iBgain 蓝色增益，范围0到400，表示0到4倍 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetUserClrTempGain( + CameraHandle hCamera, + int iRgain, + int iGgain, + int iBgain +); + + +/******************************************************/ +// 函数名 : CameraGetUserClrTempGain +// 功能描述 : 获得自定义色温模式下的数字增益 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// piRgain 指针，返回红色增益，范围0到400，表示0到4倍 +// piGgain 指针，返回绿色增益，范围0到400，表示0到4倍 +// piBgain 指针，返回蓝色增益，范围0到400，表示0到4倍 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetUserClrTempGain( + CameraHandle hCamera, + int* piRgain, + int* piGgain, + int* piBgain +); + +/******************************************************/ +// 函数名 : CameraSetUserClrTempMatrix +// 功能描述 : 设置自定义色温模式下的颜色矩阵 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// pMatrix 指向一个float[3][3]数组的首地址 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetUserClrTempMatrix( + CameraHandle hCamera, + float* pMatrix +); + + +/******************************************************/ +// 函数名 : CameraGetUserClrTempMatrix +// 功能描述 : 获得自定义色温模式下的颜色矩阵 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// pMatrix 指向一个float[3][3]数组的首地址 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetUserClrTempMatrix( + CameraHandle hCamera, + float* pMatrix +); + +/******************************************************/ +// 函数名 : CameraSetClrTempMode +// 功能描述 : 设置白平衡时使用的色温模式， +// 支持的模式有三种，分别是自动，预设和自定义。 +// 自动模式下，会自动选择合适的色温模式 +// 预设模式下，会使用用户指定的色温模式 +// 自定义模式下，使用用户自定义的色温数字增益和矩阵 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iMode 模式，只能是emSdkClrTmpMode中定义的一种 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetClrTempMode( + CameraHandle hCamera, + int iMode +); + +/******************************************************/ +// 函数名 : CameraGetClrTempMode +// 功能描述 : 获得白平衡时使用的色温模式。参考CameraSetClrTempMode +// 中功能描述部分。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// pimode 指针，返回模式选择，参考emSdkClrTmpMode类型定义 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetClrTempMode( + CameraHandle hCamera, + int* pimode +); + + + +/******************************************************/ +// 函数名 : CameraSetOnceWB +// 功能描述 : 在手动白平衡模式下，调用该函数会进行一次白平衡。 +// 生效的时间为接收到下一帧图像数据时。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetOnceWB( + CameraHandle hCamera +); + +/******************************************************/ +// 函数名 : CameraSetOnceBB +// 功能描述 : 执行一次黑平衡操作。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetOnceBB( + CameraHandle hCamera +); + + +/******************************************************/ +// 函数名 : CameraSetAeTarget +// 功能描述 : 设定自动曝光的亮度目标值。设定范围由CameraGetCapability +// 函数获得。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iAeTarget 亮度目标值。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetAeTarget( + CameraHandle hCamera, + int iAeTarget +); + +/******************************************************/ +// 函数名 : CameraGetAeTarget +// 功能描述 : 获得自动曝光的亮度目标值。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// *piAeTarget 指针，返回目标值。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetAeTarget( + CameraHandle hCamera, + int* piAeTarget +); + +/******************************************************/ +// 函数名 : CameraSetExposureTime +// 功能描述 : 设置曝光时间。单位为微秒。对于CMOS传感器，其曝光 +// 的单位是按照行来计算的，因此，曝光时间并不能在微秒 +// 级别连续可调。而是会按照整行来取舍。在调用 +// 本函数设定曝光时间后，建议再调用CameraGetExposureTime +// 来获得实际设定的值。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// fExposureTime 曝光时间，单位微秒。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ + +MVSDK_API CameraSdkStatus CameraSetExposureTime( + CameraHandle hCamera, + double fExposureTime +); + +/******************************************************/ +// 函数名 : CameraGetExposureLineTime +// 功能描述 : 获得一行的曝光时间。对于CMOS传感器，其曝光 +// 的单位是按照行来计算的，因此，曝光时间并不能在微秒 +// 级别连续可调。而是会按照整行来取舍。这个函数的 +// 作用就是返回CMOS相机曝光一行对应的时间。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// pfLineTime 指针，返回一行的曝光时间，单位为微秒。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ + +MVSDK_API CameraSdkStatus CameraGetExposureLineTime( + CameraHandle hCamera, + double* pfLineTime +); + +/******************************************************/ +// 函数名 : CameraGetExposureTime +// 功能描述 : 获得相机的曝光时间。请参见CameraSetExposureTime +// 的功能描述。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// pfExposureTime 指针，返回当前的曝光时间，单位微秒。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetExposureTime( + CameraHandle hCamera, + double* pfExposureTime +); + +/******************************************************/ +// 函数名 : CameraSetAnalogGain +// 功能描述 : 设置相机的图像模拟增益值。该值乘以CameraGetCapability获得 +// 的相机属性结构体中sExposeDesc.fAnalogGainStep，就 +// 得到实际的图像信号放大倍数。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iAnalogGain 设定的模拟增益值。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetAnalogGain( + CameraHandle hCamera, + INT iAnalogGain +); + +/******************************************************/ +// 函数名 : CameraGetAnalogGain +// 功能描述 : 获得图像信号的模拟增益值。参见CameraSetAnalogGain +// 详细说明。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// piAnalogGain 指针，返回当前的模拟增益值。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetAnalogGain( + CameraHandle hCamera, + INT* piAnalogGain +); + +/******************************************************/ +// 函数名 : CameraSetGain +// 功能描述 : 设置图像的数字增益。设定范围由CameraGetCapability +// 获得的相机属性结构体中sRgbGainRange成员表述。 +// 实际的放大倍数是设定值/100。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iRGain 红色通道的增益值。 +// iGGain 绿色通道的增益值。 +// iBGain 蓝色通道的增益值。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetGain( + CameraHandle hCamera, + int iRGain, + int iGGain, + int iBGain +); + + +/******************************************************/ +// 函数名 : CameraGetGain +// 功能描述 : 获得图像处理的数字增益。具体请参见CameraSetGain +// 的功能描述部分。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// piRGain 指针，返回红色通道的数字增益值。 +// piGGain 指针，返回绿色通道的数字增益值。 +// piBGain 指针，返回蓝色通道的数字增益值。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetGain( + CameraHandle hCamera, + int* piRGain, + int* piGGain, + int* piBGain +); + + +/******************************************************/ +// 函数名 : CameraSetGamma +// 功能描述 : 设定LUT动态生成模式下的Gamma值。设定的值会 +// 马上保存在SDK内部，但是只有当相机处于动态 +// 参数生成的LUT模式时，才会生效。请参考CameraSetLutMode +// 的函数说明部分。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iGamma 要设定的Gamma值。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetGamma( + CameraHandle hCamera, + int iGamma +); + +/******************************************************/ +// 函数名 : CameraGetGamma +// 功能描述 : 获得LUT动态生成模式下的Gamma值。请参考CameraSetGamma +// 函数的功能描述。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// piGamma 指针，返回当前的Gamma值。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetGamma( + CameraHandle hCamera, + int* piGamma +); + +/******************************************************/ +// 函数名 : CameraSetContrast +// 功能描述 : 设定LUT动态生成模式下的对比度值。设定的值会 +// 马上保存在SDK内部，但是只有当相机处于动态 +// 参数生成的LUT模式时，才会生效。请参考CameraSetLutMode +// 的函数说明部分。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iContrast 设定的对比度值。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetContrast( + CameraHandle hCamera, + int iContrast +); + +/******************************************************/ +// 函数名 : CameraGetContrast +// 功能描述 : 获得LUT动态生成模式下的对比度值。请参考 +// CameraSetContrast函数的功能描述。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// piContrast 指针，返回当前的对比度值。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetContrast( + CameraHandle hCamera, + int* piContrast +); + +/******************************************************/ +// 函数名 : CameraSetSaturation +// 功能描述 : 设定图像处理的饱和度。对黑白相机无效。 +// 设定范围由CameraGetCapability获得。100表示 +// 表示原始色度，不增强。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iSaturation 设定的饱和度值。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetSaturation( + CameraHandle hCamera, + int iSaturation +); + +/******************************************************/ +// 函数名 : CameraGetSaturation +// 功能描述 : 获得图像处理的饱和度。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// piSaturation 指针，返回当前图像处理的饱和度值。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetSaturation( + CameraHandle hCamera, + int* piSaturation +); + +/******************************************************/ +// 函数名 : CameraSetMonochrome +// 功能描述 : 设置彩色转为黑白功能的使能。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// bEnable TRUE，表示将彩色图像转为黑白。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetMonochrome( + CameraHandle hCamera, + BOOL bEnable +); + +/******************************************************/ +// 函数名 : CameraGetMonochrome +// 功能描述 : 获得彩色转换黑白功能的使能状况。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// pbEnable 指针。返回TRUE表示开启了彩色图像 +// 转换为黑白图像的功能。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetMonochrome( + CameraHandle hCamera, + BOOL* pbEnable +); + +/******************************************************/ +// 函数名 : CameraSetInverse +// 功能描述 : 设置彩图像颜色翻转功能的使能。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// bEnable TRUE，表示开启图像颜色翻转功能， +// 可以获得类似胶卷底片的效果。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetInverse( + CameraHandle hCamera, + BOOL bEnable +); + +/******************************************************/ +// 函数名 : CameraGetInverse +// 功能描述 : 获得图像颜色反转功能的使能状态。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// pbEnable 指针，返回该功能使能状态。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetInverse( + CameraHandle hCamera, + BOOL* pbEnable +); + +/******************************************************/ +// 函数名 : CameraSetAntiFlick +// 功能描述 : 设置自动曝光时抗频闪功能的使能状态。对于手动 +// 曝光模式下无效。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// bEnable TRUE，开启抗频闪功能;FALSE，关闭该功能。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetAntiFlick( + CameraHandle hCamera, + BOOL bEnable +); + +/******************************************************/ +// 函数名 : CameraGetAntiFlick +// 功能描述 : 获得自动曝光时抗频闪功能的使能状态。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// pbEnable 指针，返回该功能的使能状态。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetAntiFlick( + CameraHandle hCamera, + BOOL* pbEnable +); + +/******************************************************/ +// 函数名 : CameraGetLightFrequency +// 功能描述 : 获得自动曝光时，消频闪的频率选择。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// piFrequencySel 指针，返回选择的索引号。0:50HZ 1:60HZ +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetLightFrequency( + CameraHandle hCamera, + int* piFrequencySel +); + +/******************************************************/ +// 函数名 : CameraSetLightFrequency +// 功能描述 : 设置自动曝光时消频闪的频率。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iFrequencySel 0:50HZ , 1:60HZ +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetLightFrequency( + CameraHandle hCamera, + int iFrequencySel +); + +/******************************************************/ +// 函数名 : CameraSetFrameSpeed +// 功能描述 : 设定相机输出图像的帧率。相机可供选择的帧率模式由 +// CameraGetCapability获得的信息结构体中iFrameSpeedDesc +// 表示最大帧率选择模式个数。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iFrameSpeed 选择的帧率模式索引号，范围从0到 +// CameraGetCapability获得的信息结构体中iFrameSpeedDesc - 1 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetFrameSpeed( + CameraHandle hCamera, + int iFrameSpeed +); + +/******************************************************/ +// 函数名 : CameraGetFrameSpeed +// 功能描述 : 获得相机输出图像的帧率选择索引号。具体用法参考 +// CameraSetFrameSpeed函数的功能描述部分。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// piFrameSpeed 指针，返回选择的帧率模式索引号。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetFrameSpeed( + CameraHandle hCamera, + int* piFrameSpeed +); + + +/******************************************************/ +// 函数名 : CameraSetParameterMode +// 功能描述 : 设定参数存取的目标对象。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iMode 参数存取的对象。参考CameraDefine.h +// 中emSdkParameterMode的类型定义。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetParameterMode( + CameraHandle hCamera, + int iMode +); + +/******************************************************/ +// 函数名 : CameraGetParameterMode +// 功能描述 : +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// int* piTarget +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetParameterMode( + CameraHandle hCamera, + int* piTarget +); + +/******************************************************/ +// 函数名 : CameraSetParameterMask +// 功能描述 : 设置参数存取的掩码。参数加载和保存时会根据该 +// 掩码来决定各个模块参数的是否加载或者保存。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// uMask 掩码。参考CameraDefine.h中PROP_SHEET_INDEX +// 类型定义。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetParameterMask( + CameraHandle hCamera, + UINT uMask +); + +/******************************************************/ +// 函数名 : CameraSaveParameter +// 功能描述 : 保存当前相机参数到指定的参数组中。相机提供了A,B,C,D +// A,B,C,D四组空间来进行参数的保存。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iTeam PARAMETER_TEAM_A 保存到A组中, +// PARAMETER_TEAM_B 保存到B组中, +// PARAMETER_TEAM_C 保存到C组中, +// PARAMETER_TEAM_D 保存到D组中 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSaveParameter( + CameraHandle hCamera, + int iTeam +); + + +/******************************************************/ +// 函数名 : CameraSaveParameterToFile +// 功能描述 : 保存当前相机参数到指定的文件中。该文件可以复制到 +// 别的电脑上供其他相机加载，也可以做参数备份用。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// sFileName 参数文件的完整路径。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSaveParameterToFile( + CameraHandle hCamera, + char* sFileName +); + + +/******************************************************/ +// 函数名 : CameraReadParameterFromFile +// 功能描述 : 从PC上指定的参数文件中加载参数。我公司相机参数 +// 保存在PC上为.config后缀的文件，位于安装下的 +// Camera\Configs文件夹中。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// *sFileName 参数文件的完整路径。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraReadParameterFromFile( + CameraHandle hCamera, + char* sFileName +); + +/******************************************************/ +// 函数名 : CameraLoadParameter +// 功能描述 : 加载指定组的参数到相机中。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iTeam PARAMETER_TEAM_A 加载A组参数, +// PARAMETER_TEAM_B 加载B组参数, +// PARAMETER_TEAM_C 加载C组参数, +// PARAMETER_TEAM_D 加载D组参数, +// PARAMETER_TEAM_DEFAULT 加载默认参数。 +// 类型定义参考CameraDefine.h中emSdkParameterTeam类型 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraLoadParameter( + CameraHandle hCamera, + int iTeam +); + +/******************************************************/ +// 函数名 : CameraGetCurrentParameterGroup +// 功能描述 : 获得当前选择的参数组。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// piTeam 指针，返回当前选择的参数组。返回值 +// 参考CameraLoadParameter中iTeam参数。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetCurrentParameterGroup( + CameraHandle hCamera, + int* piTeam +); + +/******************************************************/ +// 函数名 : CameraSetTransPackLen +// 功能描述 : 设置相机传输图像数据的分包大小。 +// 目前的SDK版本中，该接口仅对GIGE接口相机有效， +// 用来控制网络传输的分包大小。对于支持巨帧的网卡， +// 我们建议选择8K的分包大小，可以有效的降低传输 +// 所占用的CPU处理时间。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iPackSel 分包长度选择的索引号。分包长度可由 +// 获得相机属性结构体中pPackLenDesc成员表述， +// iPackLenDesc成员则表示最大可选的分包模式个数。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetTransPackLen( + CameraHandle hCamera, + INT iPackSel +); + +/******************************************************/ +// 函数名 : CameraGetTransPackLen +// 功能描述 : 获得相机当前传输分包大小的选择索引号。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// piPackSel 指针，返回当前选择的分包大小索引号。 +// 参见CameraSetTransPackLen中iPackSel的 +// 说明。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetTransPackLen( + CameraHandle hCamera, + INT* piPackSel +); + +/******************************************************/ +// 函数名 : CameraIsAeWinVisible +// 功能描述 : 获得自动曝光参考窗口的显示状态。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// pbIsVisible 指针，返回TRUE，则表示当前窗口会 +// 被叠加在图像内容上。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraIsAeWinVisible( + CameraHandle hCamera, + BOOL* pbIsVisible +); + +/******************************************************/ +// 函数名 : CameraSetAeWinVisible +// 功能描述 : 设置自动曝光参考窗口的显示状态。当设置窗口状态 +// 为显示，调用CameraImageOverlay后，能够将窗口位置 +// 以矩形的方式叠加在图像上。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// bIsVisible TRUE，设置为显示；FALSE，不显示。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetAeWinVisible( + CameraHandle hCamera, + BOOL bIsVisible +); + +/******************************************************/ +// 函数名 : CameraGetAeWindow +// 功能描述 : 获得自动曝光参考窗口的位置。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// piHOff 指针，返回窗口位置左上角横坐标值。 +// piVOff 指针，返回窗口位置左上角纵坐标值。 +// piWidth 指针，返回窗口的宽度。 +// piHeight 指针，返回窗口的高度。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetAeWindow( + CameraHandle hCamera, + INT* piHOff, + INT* piVOff, + INT* piWidth, + INT* piHeight +); + +/******************************************************/ +// 函数名 : CameraSetAeWindow +// 功能描述 : 设置自动曝光的参考窗口。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iHOff 窗口左上角的横坐标 +// iVOff 窗口左上角的纵坐标 +// iWidth 窗口的宽度 +// iHeight 窗口的高度 +// 如果iHOff、iVOff、iWidth、iHeight全部为0，则 +// 窗口设置为每个分辨率下的居中1/2大小。可以随着 +// 分辨率的变化而跟随变化；如果iHOff、iVOff、iWidth、iHeight +// 所决定的窗口位置范围超出了当前分辨率范围内， +// 则自动使用居中1/2大小窗口。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetAeWindow( + CameraHandle hCamera, + int iHOff, + int iVOff, + int iWidth, + int iHeight +); + +/******************************************************/ +// 函数名 : CameraSetMirror +// 功能描述 : 设置图像镜像操作。镜像操作分为水平和垂直两个方向。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iDir 表示镜像的方向。0，表示水平方向；1，表示垂直方向。 +// bEnable TRUE，使能镜像;FALSE，禁止镜像 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetMirror( + CameraHandle hCamera, + int iDir, + BOOL bEnable +); + +/******************************************************/ +// 函数名 : CameraGetMirror +// 功能描述 : 获得图像的镜像状态。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iDir 表示要获得的镜像方向。 +// 0，表示水平方向；1，表示垂直方向。 +// pbEnable 指针，返回TRUE，则表示iDir所指的方向 +// 镜像被使能。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetMirror( + CameraHandle hCamera, + int iDir, + BOOL* pbEnable +); + +/******************************************************/ +// 函数名 : CameraGetWbWindow +// 功能描述 : 获得白平衡参考窗口的位置。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// PiHOff 指针，返回参考窗口的左上角横坐标 。 +// PiVOff 指针，返回参考窗口的左上角纵坐标 。 +// PiWidth 指针，返回参考窗口的宽度。 +// PiHeight 指针，返回参考窗口的高度。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetWbWindow( + CameraHandle hCamera, + INT* PiHOff, + INT* PiVOff, + INT* PiWidth, + INT* PiHeight +); + +/******************************************************/ +// 函数名 : CameraSetWbWindow +// 功能描述 : 设置白平衡参考窗口的位置。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iHOff 参考窗口的左上角横坐标。 +// iVOff 参考窗口的左上角纵坐标。 +// iWidth 参考窗口的宽度。 +// iHeight 参考窗口的高度。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetWbWindow( + CameraHandle hCamera, + INT iHOff, + INT iVOff, + INT iWidth, + INT iHeight +); + +/******************************************************/ +// 函数名 : CameraIsWbWinVisible +// 功能描述 : 获得白平衡窗口的显示状态。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// pbShow 指针，返回TRUE，则表示窗口是可见的。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraIsWbWinVisible( + CameraHandle hCamera, + BOOL* pbShow +); + +/******************************************************/ +// 函数名 : CameraSetWbWinVisible +// 功能描述 : 设置白平衡窗口的显示状态。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// bShow TRUE，则表示设置为可见。在调用 +// CameraImageOverlay后，图像内容上将以矩形 +// 的方式叠加白平衡参考窗口的位置。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetWbWinVisible( + CameraHandle hCamera, + BOOL bShow +); + +/******************************************************/ +// 函数名 : CameraImageOverlay +// 功能描述 : 将输入的图像数据上叠加十字线、白平衡参考窗口、 +// 自动曝光参考窗口等图形。只有设置为可见状态的 +// 十字线和参考窗口才能被叠加上。 +// 注意，该函数的输入图像必须是RGB格式。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// pRgbBuffer 图像数据缓冲区。 +// pFrInfo 图像的帧头信息。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraImageOverlay( + CameraHandle hCamera, + BYTE* pRgbBuffer, + tSdkFrameHead* pFrInfo +); + +/******************************************************/ +// 函数名 : CameraSetCrossLine +// 功能描述 : 设置指定十字线的参数。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iLine 表示要设置第几条十字线的状态。范围为[0,8]，共9条。 +// x 十字线中心位置的横坐标值。 +// y 十字线中心位置的纵坐标值。 +// uColor 十字线的颜色，格式为(R|(G<<8)|(B<<16)) +// bVisible 十字线的显示状态。TRUE，表示显示。 +// 只有设置为显示状态的十字线，在调用 +// CameraImageOverlay后才会被叠加到图像上。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetCrossLine( + CameraHandle hCamera, + int iLine, + INT x, + INT y, + UINT uColor, + BOOL bVisible +); + +/******************************************************/ +// 函数名 : CameraGetCrossLine +// 功能描述 : 获得指定十字线的状态。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iLine 表示要获取的第几条十字线的状态。范围为[0,8]，共9条。 +// px 指针，返回该十字线中心位置的横坐标。 +// py 指针，返回该十字线中心位置的横坐标。 +// pcolor 指针，返回该十字线的颜色，格式为(R|(G<<8)|(B<<16))。 +// pbVisible 指针，返回TRUE，则表示该十字线可见。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetCrossLine( + CameraHandle hCamera, + INT iLine, + INT* px, + INT* py, + UINT* pcolor, + BOOL* pbVisible +); + +/******************************************************/ +// 函数名 : CameraGetCapability +// 功能描述 : 获得相机的特性描述结构体。该结构体中包含了相机 +// 可设置的各种参数的范围信息。决定了相关函数的参数 +// 返回，也可用于动态创建相机的配置界面。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// pCameraInfo 指针，返回该相机特性描述的结构体。 +// tSdkCameraCapbility在CameraDefine.h中定义。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetCapability( + CameraHandle hCamera, + tSdkCameraCapbility* pCameraInfo +); + +/******************************************************/ +// 函数名 : CameraGetCapabilityEx +// 功能描述 : 获得相机的特性描述结构体。该结构体中包含了相机 +// 可设置的各种参数的范围信息。决定了相关函数的参数 +// 返回，也可用于动态创建相机的配置界面。 +// 参数 : sDeviceModel 相机的型号，由扫描列表中获取 +// pCameraInfo 指针，返回该相机特性描述的结构体。 +// tSdkCameraCapbility在CameraDefine.h中定义。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetCapabilityEx( + char* sDeviceModel, + tSdkCameraCapbility* pCameraInfo, + PVOID hCameraHandle +); + + +/******************************************************/ +// 函数名 : CameraWriteSN +// 功能描述 : 设置相机的序列号。我公司相机序列号分为3级。 +// 0级的是我公司自定义的相机序列号，出厂时已经 +// 设定好，1级和2级留给二次开发使用。每级序列 +// 号长度都是32个字节。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// pbySN 序列号的缓冲区。 +// iLevel 要设定的序列号级别，只能是1或者2。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraWriteSN( + CameraHandle hCamera, + BYTE* pbySN, + INT iLevel +); + +/******************************************************/ +// 函数名 : CameraReadSN +// 功能描述 : 读取相机指定级别的序列号。序列号的定义请参考 +// CameraWriteSN函数的功能描述部分。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// pbySN 序列号的缓冲区。 +// iLevel 要读取的序列号级别。只能是1和2。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraReadSN( + CameraHandle hCamera, + BYTE* pbySN, + INT iLevel +); +/******************************************************/ +// 函数名 : CameraSetTriggerDelayTime +// 功能描述 : 设置硬件触发模式下的触发延时时间，单位微秒。 +// 当硬触发信号来临后，经过指定的延时，再开始采集 +// 图像。仅部分型号的相机支持该功能。具体请查看 +// 产品说明书。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// uDelayTimeUs 硬触发延时。单位微秒。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetTriggerDelayTime( + CameraHandle hCamera, + UINT uDelayTimeUs +); + +/******************************************************/ +// 函数名 : CameraGetTriggerDelayTime +// 功能描述 : 获得当前设定的硬触发延时时间。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// puDelayTimeUs 指针，返回延时时间，单位微秒。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetTriggerDelayTime( + CameraHandle hCamera, + UINT* puDelayTimeUs +); + +/******************************************************/ +// 函数名 : CameraSetTriggerCount +// 功能描述 : 设置触发模式下的触发帧数。对软件触发和硬件触发 +// 模式都有效。默认为1帧，即一次触发信号采集一帧图像。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iCount 一次触发采集的帧数。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetTriggerCount( + CameraHandle hCamera, + INT iCount +); + +/******************************************************/ +// 函数名 : CameraGetTriggerCount +// 功能描述 : 获得一次触发的帧数。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// INT* piCount +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetTriggerCount( + CameraHandle hCamera, + INT* piCount +); + +/******************************************************/ +// 函数名 : CameraSoftTrigger +// 功能描述 : 执行一次软触发。执行后，会触发由CameraSetTriggerCount +// 指定的帧数。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSoftTrigger( + CameraHandle hCamera +); + +/******************************************************/ +// 函数名 : CameraSetTriggerMode +// 功能描述 : 设置相机的触发模式。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iModeSel 模式选择索引号。可设定的模式由 +// CameraGetCapability函数获取。请参考 +// CameraDefine.h中tSdkCameraCapbility的定义。 +// 一般情况，0表示连续采集模式；1表示 +// 软件触发模式；2表示硬件触发模式。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetTriggerMode( + CameraHandle hCamera, + int iModeSel +); + +/******************************************************/ +// 函数名 : CameraGetTriggerMode +// 功能描述 : 获得相机的触发模式。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// piModeSel 指针，返回当前选择的相机触发模式的索引号。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetTriggerMode( + CameraHandle hCamera, + INT* piModeSel +); + +/******************************************************/ +// 函数名 : CameraSetStrobeMode +// 功能描述 : 设置IO引脚端子上的STROBE信号。该信号可以做闪光灯控制，也可以做外部机械快门控制。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iMode 当为STROBE_SYNC_WITH_TRIG_AUTO 和触发信号同步，触发后，相机进行曝光时，自动生成STROBE信号。 +// 此时，有效极性可设置(CameraSetStrobePolarity)。 +// 当为STROBE_SYNC_WITH_TRIG_MANUAL时，和触发信号同步，触发后，STROBE延时指定的时间后(CameraSetStrobeDelayTime)， +// 再持续指定时间的脉冲(CameraSetStrobePulseWidth)， +// 有效极性可设置(CameraSetStrobePolarity)。 +// 当为STROBE_ALWAYS_HIGH时，STROBE信号恒为高,忽略其他设置 +// 当为STROBE_ALWAYS_LOW时，STROBE信号恒为低,忽略其他设置 +// +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetStrobeMode( + CameraHandle hCamera, + INT iMode +); + +/******************************************************/ +// 函数名 : CameraGetStrobeMode +// 功能描述 : 或者当前STROBE信号设置的模式。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// piMode 指针，返回STROBE_SYNC_WITH_TRIG_AUTO,STROBE_SYNC_WITH_TRIG_MANUAL、STROBE_ALWAYS_HIGH或者STROBE_ALWAYS_LOW。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetStrobeMode( + CameraHandle hCamera, + INT* piMode +); + +/******************************************************/ +// 函数名 : CameraSetStrobeDelayTime +// 功能描述 : 当STROBE信号处于STROBE_SYNC_WITH_TRIG时，通过该函数设置其相对触发信号延时时间。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// uDelayTimeUs 相对触发信号的延时时间，单位为us。可以为0，但不能为负数。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetStrobeDelayTime( + CameraHandle hCamera, + UINT uDelayTimeUs +); + +/******************************************************/ +// 函数名 : CameraGetStrobeDelayTime +// 功能描述 : 当STROBE信号处于STROBE_SYNC_WITH_TRIG时，通过该函数获得其相对触发信号延时时间。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// upDelayTimeUs 指针，返回延时时间，单位us。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetStrobeDelayTime( + CameraHandle hCamera, + UINT* upDelayTimeUs +); + +/******************************************************/ +// 函数名 : CameraSetStrobePulseWidth +// 功能描述 : 当STROBE信号处于STROBE_SYNC_WITH_TRIG时，通过该函数设置其脉冲宽度。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// uTimeUs 脉冲的宽度，单位为时间us。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetStrobePulseWidth( + CameraHandle hCamera, + UINT uTimeUs +); + +/******************************************************/ +// 函数名 : CameraGetStrobePulseWidth +// 功能描述 : 当STROBE信号处于STROBE_SYNC_WITH_TRIG时，通过该函数获得其脉冲宽度。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// upTimeUs 指针，返回脉冲宽度。单位为时间us。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetStrobePulseWidth( + CameraHandle hCamera, + UINT* upTimeUs +); + +/******************************************************/ +// 函数名 : CameraSetStrobePolarity +// 功能描述 : 当STROBE信号处于STROBE_SYNC_WITH_TRIG时，通过该函数设置其有效电平的极性。默认为高有效，当触发信号到来时，STROBE信号被拉高。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iPolarity STROBE信号的极性，0为低电平有效，1为高电平有效。默认为高电平有效。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetStrobePolarity( + CameraHandle hCamera, + INT uPolarity +); + +/******************************************************/ +// 函数名 : CameraGetStrobePolarity +// 功能描述 : 获得相机当前STROBE信号的有效极性。默认为高电平有效。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// ipPolarity 指针，返回STROBE信号当前的有效极性。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetStrobePolarity( + CameraHandle hCamera, + INT* upPolarity +); + +/******************************************************/ +// 函数名 : CameraSetExtTrigSignalType +// 功能描述 : 设置相机外触发信号的种类。上边沿、下边沿、或者高、低电平方式。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iType 外触发信号种类，返回值参考CameraDefine.h中 +// emExtTrigSignal类型定义。 + +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetExtTrigSignalType( + CameraHandle hCamera, + INT iType +); + +/******************************************************/ +// 函数名 : CameraGetExtTrigSignalType +// 功能描述 : 获得相机当前外触发信号的种类。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// ipType 指针，返回外触发信号种类，返回值参考CameraDefine.h中 +// emExtTrigSignal类型定义。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetExtTrigSignalType( + CameraHandle hCamera, + INT* ipType +); + +/******************************************************/ +// 函数名 : CameraSetExtTrigShutterType +// 功能描述 : 设置外触发模式下，相机快门的方式，默认为标准快门方式。 +// 部分滚动快门的CMOS相机支持GRR方式。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iType 外触发快门方式。参考CameraDefine.h中emExtTrigShutterMode类型。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetExtTrigShutterType( + CameraHandle hCamera, + INT iType +); + +/******************************************************/ +// 函数名 : CameraSetExtTrigShutterType +// 功能描述 : 获得外触发模式下，相机快门的方式，默认为标准快门方式。 +// 部分滚动快门的CMOS相机支持GRR方式。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// ipType 指针，返回当前设定的外触发快门方式。返回值参考 +// CameraDefine.h中emExtTrigShutterMode类型。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetExtTrigShutterType( + CameraHandle hCamera, + INT* ipType +); + +/******************************************************/ +// 函数名 : CameraSetExtTrigDelayTime +// 功能描述 : 设置外触发信号延时时间，默认为0，单位为微秒。 +// 当设置的值uDelayTimeUs不为0时，相机接收到外触发信号后，将延时uDelayTimeUs个微秒后再进行图像捕获。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// uDelayTimeUs 延时时间，单位为微秒，默认为0. +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetExtTrigDelayTime( + CameraHandle hCamera, + UINT uDelayTimeUs +); + +/******************************************************/ +// 函数名 : CameraGetExtTrigDelayTime +// 功能描述 : 获得设置的外触发信号延时时间，默认为0，单位为微秒。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// UINT* upDelayTimeUs +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetExtTrigDelayTime( + CameraHandle hCamera, + UINT* upDelayTimeUs +); + +/******************************************************/ +// 函数名 : CameraSetExtTrigJitterTime +// 功能描述 : 设置相机外触发信号的消抖时间。默认为0，单位为微秒。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// UINT uTimeUs +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetExtTrigJitterTime( + CameraHandle hCamera, + UINT uTimeUs +); + +/******************************************************/ +// 函数名 : CameraGetExtTrigJitterTime +// 功能描述 : 获得设置的相机外触发消抖时间，默认为0.单位为微妙 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// UINT* upTimeUs +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetExtTrigJitterTime( + CameraHandle hCamera, + UINT* upTimeUs +); + +/******************************************************/ +// 函数名 : CameraGetExtTrigCapability +// 功能描述 : 获得相机外触发的属性掩码 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// puCapabilityMask 指针，返回该相机外触发特性掩码，掩码参考CameraDefine.h中 +// EXT_TRIG_MASK_ 开头的宏定义。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetExtTrigCapability( + CameraHandle hCamera, + UINT* puCapabilityMask +); + + +/******************************************************/ +// 函数名 : CameraGetResolutionForSnap +// 功能描述 : 获得抓拍模式下的分辨率选择索引号。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// pImageResolution 指针，返回抓拍模式的分辨率。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetResolutionForSnap( + CameraHandle hCamera, + tSdkImageResolution* pImageResolution +); + +/******************************************************/ +// 函数名 : CameraSetResolutionForSnap +// 功能描述 : 设置抓拍模式下相机输出图像的分辨率。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// pImageResolution 如果pImageResolution->iWidth +// 和 pImageResolution->iHeight都为0， +// 则表示设定为跟随当前预览分辨率。抓 +// 怕到的图像的分辨率会和当前设定的 +// 预览分辨率一样。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetResolutionForSnap( + CameraHandle hCamera, + tSdkImageResolution* pImageResolution +); + +/******************************************************/ +// 函数名 : CameraCustomizeResolution +// 功能描述 : 打开分辨率自定义面板，并通过可视化的方式 +// 来配置一个自定义分辨率。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// pImageCustom 指针，返回自定义的分辨率。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraCustomizeResolution( + CameraHandle hCamera, + tSdkImageResolution* pImageCustom +); + +/******************************************************/ +// 函数名 : CameraCustomizeReferWin +// 功能描述 : 打开参考窗口自定义面板。并通过可视化的方式来 +// 获得一个自定义窗口的位置。一般是用自定义白平衡 +// 和自动曝光的参考窗口。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iWinType 要生成的参考窗口的用途。0,自动曝光参考窗口； +// 1,白平衡参考窗口。 +// hParent 调用该函数的窗口的句柄。可以为NULL。 +// piHOff 指针，返回自定义窗口的左上角横坐标。 +// piVOff 指针，返回自定义窗口的左上角纵坐标。 +// piWidth 指针，返回自定义窗口的宽度。 +// piHeight 指针，返回自定义窗口的高度。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraCustomizeReferWin( + CameraHandle hCamera, + INT iWinType, + HWND hParent, + INT* piHOff, + INT* piVOff, + INT* piWidth, + INT* piHeight +); + +/******************************************************/ +// 函数名 : CameraShowSettingPage +// 功能描述 : 设置相机属性配置窗口显示状态。必须先调用CameraCreateSettingPage +// 成功创建相机属性配置窗口后，才能调用本函数进行 +// 显示。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// bShow TRUE，显示;FALSE，隐藏。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraShowSettingPage( + CameraHandle hCamera, + BOOL bShow +); + +/******************************************************/ +// 函数名 : CameraCreateSettingPage +// 功能描述 : 创建该相机的属性配置窗口。调用该函数，SDK内部会 +// 帮您创建好相机的配置窗口，省去了您重新开发相机 +// 配置界面的时间。强烈建议使用您使用该函数让 +// SDK为您创建好配置窗口。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// hParent 应用程序主窗口的句柄。可以为NULL。 +// pWinText 字符串指针，窗口显示的标题栏。 +// pCallbackFunc 窗口消息的回调函数，当相应的事件发生时， +// pCallbackFunc所指向的函数会被调用， +// 例如切换了参数之类的操作时，pCallbackFunc +// 被回调时，在入口参数处指明了消息类型。 +// 这样可以方便您自己开发的界面和我们生成的UI +// 之间进行同步。该参数可以为NULL。 +// pCallbackCtx 回调函数的附加参数。可以为NULL。pCallbackCtx +// 会在pCallbackFunc被回调时，做为参数之一传入。 +// 您可以使用该参数来做一些灵活的判断。 +// uReserved 预留。必须设置为0。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraCreateSettingPage( + CameraHandle hCamera, + HWND hParent, + char* pWinText, + CAMERA_PAGE_MSG_PROC pCallbackFunc, + PVOID pCallbackCtx, + UINT uReserved +); + +/******************************************************/ +// 函数名 : CameraCreateSettingPageEx +// 功能描述 : 创建该相机的属性配置窗口。调用该函数，SDK内部会 +// 帮您创建好相机的配置窗口，省去了您重新开发相机 +// 配置界面的时间。强烈建议使用您使用该函数让 +// SDK为您创建好配置窗口。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraCreateSettingPageEx( + CameraHandle hCamera +); + + +/******************************************************/ +// 函数名 : CameraSetActiveSettingSubPage +// 功能描述 : 设置相机配置窗口的激活页面。相机配置窗口有多个 +// 子页面构成，该函数可以设定当前哪一个子页面 +// 为激活状态，显示在最前端。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// index 子页面的索引号。参考CameraDefine.h中 +// PROP_SHEET_INDEX的定义。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetActiveSettingSubPage( + CameraHandle hCamera, + INT index +); + +/******************************************************/ +// 函数名 : CameraSpecialControl +// 功能描述 : 相机一些特殊配置所调用的接口，二次开发时一般不需要 +// 调用。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// dwCtrlCode 控制码。 +// dwParam 控制子码，不同的dwCtrlCode时，意义不同。 +// lpData 附加参数。不同的dwCtrlCode时，意义不同。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSpecialControl( + CameraHandle hCamera, + DWORD dwCtrlCode, + DWORD dwParam, + LPVOID lpData +); + +/******************************************************/ +// 函数名 : CameraGetFrameStatistic +// 功能描述 : 获得相机接收帧率的统计信息，包括错误帧和丢帧的情况。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// psFrameStatistic 指针，返回统计信息。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetFrameStatistic( + CameraHandle hCamera, + tSdkFrameStatistic* psFrameStatistic +); + +/******************************************************/ +// 函数名 : CameraSetNoiseFilter +// 功能描述 : 设置图像降噪模块的使能状态。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// bEnable TRUE，使能；FALSE，禁止。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetNoiseFilter( + CameraHandle hCamera, + BOOL bEnable +); + +/******************************************************/ +// 函数名 : CameraGetNoiseFilterState +// 功能描述 : 获得图像降噪模块的使能状态。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// *pEnable 指针，返回状态。TRUE，为使能。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetNoiseFilterState( + CameraHandle hCamera, + BOOL* pEnable +); + +/******************************************************/ +// 函数名 : CameraRstTimeStamp +// 功能描述 : 复位图像采集的时间戳，从0开始。 +// 参数 : CameraHandle hCamera +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraRstTimeStamp( + CameraHandle hCamera +); + +/******************************************************/ +// 函数名 : CameraSaveUserData +// 功能描述 : 将用户自定义的数据保存到相机的非易性存储器中。 +// 每个型号的相机可能支持的用户数据区最大长度不一样。 +// 可以从设备的特性描述中获取该长度信息。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// uStartAddr 起始地址，从0开始。 +// pbData 数据缓冲区指针 +// ilen 写入数据的长度，ilen + uStartAddr必须 +// 小于用户区最大长度 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSaveUserData( + CameraHandle hCamera, + UINT uStartAddr, + BYTE *pbData, + int ilen +); + +/******************************************************/ +// 函数名 : CameraLoadUserData +// 功能描述 : 从相机的非易性存储器中读取用户自定义的数据。 +// 每个型号的相机可能支持的用户数据区最大长度不一样。 +// 可以从设备的特性描述中获取该长度信息。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// uStartAddr 起始地址，从0开始。 +// pbData 数据缓冲区指针，返回读到的数据。 +// ilen 读取数据的长度，ilen + uStartAddr必须 +// 小于用户区最大长度 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraLoadUserData( + CameraHandle hCamera, + UINT uStartAddr, + BYTE *pbData, + int ilen +); + +/******************************************************/ +// 函数名 : CameraGetFriendlyName +// 功能描述 : 读取用户自定义的设备昵称。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// pName 指针，返回指向0结尾的字符串， +// 设备昵称不超过32个字节，因此该指针 +// 指向的缓冲区必须大于等于32个字节空间。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetFriendlyName( + CameraHandle hCamera, + char* pName +); + +/******************************************************/ +// 函数名 : CameraSetFriendlyName +// 功能描述 : 设置用户自定义的设备昵称。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// pName 指针，指向0结尾的字符串， +// 设备昵称不超过32个字节，因此该指针 +// 指向字符串必须小于等于32个字节空间。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetFriendlyName( + CameraHandle hCamera, + char* pName +); + +/******************************************************/ +// 函数名 : CameraSdkGetVersionString +// 功能描述 : +// 参数 : pVersionString 指针，返回SDK版本字符串。 +// 该指针指向的缓冲区大小必须大于 +// 32个字节 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSdkGetVersionString( + char* pVersionString +); + +/******************************************************/ +// 函数名 : CameraCheckFwUpdate +// 功能描述 : 检测固件版本，是否需要升级。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// pNeedUpdate 指针，返回固件检测状态，TRUE表示需要更新 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraCheckFwUpdate( + CameraHandle hCamera, + BOOL* pNeedUpdate +); + +/******************************************************/ +// 函数名 : CameraGetFirmwareVision +// 功能描述 : 获得固件版本的字符串 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// pVersion 必须指向一个大于32字节的缓冲区， +// 返回固件的版本字符串。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetFirmwareVision( + CameraHandle hCamera, + char* pVersion +); + +/******************************************************/ +// 函数名 : CameraGetEnumInfo +// 功能描述 : 获得指定设备的枚举信息 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// pCameraInfo 指针，返回设备的枚举信息。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetEnumInfo( + CameraHandle hCamera, + tSdkCameraDevInfo* pCameraInfo +); + +/******************************************************/ +// 函数名 : CameraGetInerfaceVersion +// 功能描述 : 获得指定设备接口的版本 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// pVersion 指向一个大于32字节的缓冲区，返回接口版本字符串。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetInerfaceVersion( + CameraHandle hCamera, + char* pVersion +); + +/******************************************************/ +// 函数名 : CameraSetIOState +// 功能描述 : 设置指定IO的电平状态，IO为输出型IO，相机 +// 预留可编程输出IO的个数由tSdkCameraCapbility中 +// iOutputIoCounts决定。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iOutputIOIndex IO的索引号，从0开始。 +// uState 要设定的状态，1为高，0为低 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetIOState( + CameraHandle hCamera, + INT iOutputIOIndex, + UINT uState +); + +/******************************************************/ +// 函数名 : CameraGetIOState +// 功能描述 : 设置指定IO的电平状态，IO为输入型IO，相机 +// 预留可编程输出IO的个数由tSdkCameraCapbility中 +// iInputIoCounts决定。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iInputIOIndex IO的索引号，从0开始。 +// puState 指针，返回IO状态,1为高，0为低 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetIOState( + CameraHandle hCamera, + INT iInputIOIndex, + UINT* puState +); + +/******************************************************/ +// 函数名 : CameraSetAeAlgorithm +// 功能描述 : 设置自动曝光时选择的算法，不同的算法适用于 +// 不同的场景。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iIspProcessor 选择执行该算法的对象，参考CameraDefine.h +// emSdkIspProcessor的定义 +// iAeAlgorithmSel 要选择的算法编号。从0开始，最大值由tSdkCameraCapbility +// 中iAeAlmSwDesc和iAeAlmHdDesc决定。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetAeAlgorithm( + CameraHandle hCamera, + INT iIspProcessor, + INT iAeAlgorithmSel +); + +/******************************************************/ +// 函数名 : CameraGetAeAlgorithm +// 功能描述 : 获得当前自动曝光所选择的算法 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iIspProcessor 选择执行该算法的对象，参考CameraDefine.h +// emSdkIspProcessor的定义 +// piAeAlgorithmSel 返回当前选择的算法编号。从0开始，最大值由tSdkCameraCapbility +// 中iAeAlmSwDesc和iAeAlmHdDesc决定。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetAeAlgorithm( + CameraHandle hCamera, + INT iIspProcessor, + INT* piAlgorithmSel +); + +/******************************************************/ +// 函数名 : CameraSetBayerDecAlgorithm +// 功能描述 : 设置Bayer数据转彩色的算法。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iIspProcessor 选择执行该算法的对象，参考CameraDefine.h +// emSdkIspProcessor的定义 +// iAlgorithmSel 要选择的算法编号。从0开始，最大值由tSdkCameraCapbility +// 中iBayerDecAlmSwDesc和iBayerDecAlmHdDesc决定。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetBayerDecAlgorithm( + CameraHandle hCamera, + INT iIspProcessor, + INT iAlgorithmSel +); + +/******************************************************/ +// 函数名 : CameraGetBayerDecAlgorithm +// 功能描述 : 获得Bayer数据转彩色所选择的算法。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iIspProcessor 选择执行该算法的对象，参考CameraDefine.h +// emSdkIspProcessor的定义 +// piAlgorithmSel 返回当前选择的算法编号。从0开始，最大值由tSdkCameraCapbility +// 中iBayerDecAlmSwDesc和iBayerDecAlmHdDesc决定。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetBayerDecAlgorithm( + CameraHandle hCamera, + INT iIspProcessor, + INT* piAlgorithmSel +); + +/******************************************************/ +// 函数名 : CameraSetIspProcessor +// 功能描述 : 设置图像处理单元的算法执行对象，由PC端或者相机端 +// 来执行算法，当由相机端执行时，会降低PC端的CPU占用率。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iIspProcessor 参考CameraDefine.h中 +// emSdkIspProcessor的定义。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetIspProcessor( + CameraHandle hCamera, + INT iIspProcessor +); + +/******************************************************/ +// 函数名 : CameraGetIspProcessor +// 功能描述 : 获得图像处理单元的算法执行对象。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// piIspProcessor 返回选择的对象，返回值参考CameraDefine.h中 +// emSdkIspProcessor的定义。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetIspProcessor( + CameraHandle hCamera, + INT* piIspProcessor +); + +/******************************************************/ +// 函数名 : CameraSetBlackLevel +// 功能描述 : 设置图像的黑电平基准，默认值为0 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iBlackLevel 要设定的电平值。范围为0到255。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetBlackLevel( + CameraHandle hCamera, + INT iBlackLevel +); + +/******************************************************/ +// 函数名 : CameraGetBlackLevel +// 功能描述 : 获得图像的黑电平基准，默认值为0 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// piBlackLevel 返回当前的黑电平值。范围为0到255。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetBlackLevel( + CameraHandle hCamera, + INT* piBlackLevel +); + +/******************************************************/ +// 函数名 : CameraSetWhiteLevel +// 功能描述 : 设置图像的白电平基准，默认值为255 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// iWhiteLevel 要设定的电平值。范围为0到255。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetWhiteLevel( + CameraHandle hCamera, + INT iWhiteLevel +); + +/******************************************************/ +// 函数名 : CameraGetWhiteLevel +// 功能描述 : 获得图像的白电平基准，默认值为255 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// piWhiteLevel 返回当前的白电平值。范围为0到255。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetWhiteLevel( + CameraHandle hCamera, + INT* piWhiteLevel +); + +/******************************************************/ +// 函数名 : CameraSetIspOutFormat +// 功能描述 : 设置CameraGetImageBuffer函数的图像处理的输出格式，支持 +// CAMERA_MEDIA_TYPE_MONO8和CAMERA_MEDIA_TYPE_RGB8 +// (在CameraDefine.h中定义)三种，分别对应8位灰度图像和24位彩色图像。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// uFormat 要设定格式。CAMERA_MEDIA_TYPE_MONO8或者CAMERA_MEDIA_TYPE_RGB8 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraSetIspOutFormat( + CameraHandle hCamera, + UINT uFormat +); + +/******************************************************/ +// 函数名 : CameraGetIspOutFormat +// 功能描述 : 获得图像处理的输出格式，目前只支持 +// CAMERA_MEDIA_TYPE_MONO8和CAMERA_MEDIA_TYPE_RGB8 +// (在CameraDefine.h中定义)两种，其他的参数会返回错误。 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// puFormat 返回当前设定的格式。CAMERA_MEDIA_TYPE_MONO8或者CAMERA_MEDIA_TYPE_RGB8 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraGetIspOutFormat( + CameraHandle hCamera, + UINT* puFormat +); + +/******************************************************/ +// 函数名 : CameraGetErrorString +// 功能描述 : 获得错误码对应的描述字符串 +// 参数 : iStatusCode 错误码。(定义于CameraStatus.h中) +// 返回值 : 成功时，返回错误码对应的字符串首地址; +// 否则返回NULL。 +/******************************************************/ +MVSDK_API char* CameraGetErrorString( + CameraSdkStatus iStatusCode +); + + +/******************************************************/ +// 函数名 : CameraReConnect +// 功能描述 : 重新连接设备，用于USB设备意外掉线后重连 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0); +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraReConnect( + CameraHandle hCamera +); + + +/******************************************************/ +// 函数名 : CameraConnectTest +// 功能描述 : 测试相机的连接状态，用于检测相机是否掉线 +// 参数 : hCamera 相机的句柄，由CameraInit函数获得。 +// 返回值 : 成功时，返回CAMERA_STATUS_SUCCESS (0)，表示相机连接状态正常; +// 否则返回非0值的错误码,请参考CameraStatus.h +// 中错误码的定义。 +/******************************************************/ +MVSDK_API CameraSdkStatus CameraConnectTest( + CameraHandle hCamera +); + +#ifdef __cplusplus +} +#endif +#endif + diff --git a/include/camera/camera_define.h b/include/camera/camera_define.h new file mode 100644 index 0000000..ba7d937 --- /dev/null +++ b/include/camera/camera_define.h @@ -0,0 +1,663 @@ +#pragma once +#ifndef _CAMERA_DEFINE_H_ +#define _CAMERA_DEFINE_H_ + +#include "camera_status.h" + +#define MAX_CROSS_LINE 9 + +//相机的句柄类型定义 +typedef int CameraHandle; +typedef int INT; +typedef long LONG; +typedef unsigned int UINT; +typedef unsigned long long UINT64; +typedef int BOOL; +typedef unsigned char BYTE; +typedef unsigned int DWORD; +typedef void* PVOID; +typedef void* HWND; +typedef char* LPCTSTR; +typedef unsigned short USHORT; +typedef short SHORT; +typedef unsigned char* LPBYTE; +typedef char CHAR; +typedef short WORD; +typedef INT HANDLE; +typedef void VOID; +typedef unsigned long ULONG; +typedef void** LPVOID; +typedef unsigned char UCHAR; +typedef void* HMODULE; + +#define TRUE 1 +#define FALSE 0 +//图像查表变换的方式 +typedef enum +{ + LUTMODE_PARAM_GEN=0,//通过调节参数动态生成LUT表 + LUTMODE_PRESET, //使用预设的LUT表 + LUTMODE_USER_DEF //使用用户自定义的LUT表 +}emSdkLutMode; + +//相机的视频流控制 +typedef enum +{ + RUNMODE_PLAY=0, //正常预览，捕获到图像就显示。（如果相机处于触发模式，则会等待触发帧的到来） + RUNMODE_PAUSE, //暂停，会暂停相机的图像输出，同时也不会去捕获图像 + RUNMODE_STOP //停止相机工作。反初始化后，相机就处于停止模式 +}emSdkRunMode; + +//SDK内部显示接口的显示方式 +typedef enum +{ + DISPLAYMODE_SCALE=0, //缩放显示模式，缩放到显示控件的尺寸 + DISPLAYMODE_REAL //1:1显示模式，当图像尺寸大于显示控件的尺寸时，只显示局部 +}emSdkDisplayMode; + +//录像状态 +typedef enum +{ + RECORD_STOP = 0, //停止 + RECORD_START, //录像中 + RECORD_PAUSE //暂停 +}emSdkRecordMode; + +//图像的镜像操作 +typedef enum +{ + MIRROR_DIRECTION_HORIZONTAL = 0,//水平镜像 + MIRROR_DIRECTION_VERTICAL //垂直镜像 +}emSdkMirrorDirection; + +//相机视频的帧率 +typedef enum +{ + FRAME_SPEED_LOW = 0, //低速模式 + FRAME_SPEED_NORMAL, //普通模式 + FRAME_SPEED_HIGH, //高速模式(需要较高的传输带宽,多设备共享传输带宽时会对帧率的稳定性有影响) + FRAME_SPEED_SUPER //超高速模式(需要较高的传输带宽,多设备共享传输带宽时会对帧率的稳定性有影响) +}emSdkFrameSpeed; + +//保存文件的格式类型 +typedef enum +{ + FILE_JPG = 1,//JPG + FILE_BMP = 2,//BMP + FILE_RAW = 4,//相机输出的bayer格式文件,对于不支持bayer格式输出相机，无法保存为该格式 + FILE_PNG = 8 //PNG +}emSdkFileType; + +//相机中的图像传感器的工作模式 +typedef enum +{ + CONTINUATION = 0,//连续采集模式 + SOFT_TRIGGER, //软件触发模式，由软件发送指令后，传感器开始采集指定帧数的图像，采集完成后，停止输出 + EXTERNAL_TRIGGER //硬件触发模式，当接收到外部信号，传感器开始采集指定帧数的图像，采集完成后，停止输出 +} emSdkSnapMode; + +//自动曝光时抗频闪的频闪 +typedef enum +{ + LIGHT_FREQUENCY_50HZ = 0,//50HZ,一般的灯光都是50HZ + LIGHT_FREQUENCY_60HZ //60HZ,主要是指显示器的 +}emSdkLightFrequency; + +//相机的配置参数，分为A,B,C,D 4组进行保存。 +typedef enum +{ + PARAMETER_TEAM_DEFAULT = 0xff, + PARAMETER_TEAM_A = 0, + PARAMETER_TEAM_B = 1, + PARAMETER_TEAM_C = 2, + PARAMETER_TEAM_D = 3 +}emSdkParameterTeam; + + +/*emSdkParameterMode 相机参数加载模式，参数加载分为从文件和从设备加载两种方式 + +PARAM_MODE_BY_MODEL:所有同型号的相机共用ABCD四组参数文件。修改 + 一台相机的参数文件，会影响到整个同型号的 + 相机参数加载。 + +PARAM_MODE_BY_NAME:所有设备名相同的相机，共用ABCD四组参数文件。 + 默认情况下，当电脑上只接了某型号一台相机时， + 设备名都是一样的，而您希望某一台相机能够加载 + 不同的参数文件，则可以通过修改其设备名的方式 + 来让其加载指定的参数文件。 + +PARAM_MODE_BY_SN:相机按照自己的唯一序列号来加载ABCD四组参数文件， + 序列号在出厂时已经固化在相机内，每台相机的序列号 + 都不相同，通过这种方式，每台相机的参数文件都是独立的。 + +您可以根据自己的使用环境，灵活使用以上几种方式加载参数。例如，以 +MV-U300为例，您希望多台该型号的相机在您的 电脑上都共用4组参数，那么就 +使用PARAM_MODE_BY_MODEL方式;如果您希望其中某一台或者某几台MV-U300能 +使用自己参数文件而其余的MV-U300又要使用相同的参数文件，那么使用 +PARAM_MODE_BY_NAME方式;如果您希望每台MV-U300都使用不同的参数文件，那么 +使用PARAM_MODE_BY_SN方式。 +参数文件存在安装目录的 \Camera\Configs 目录下，以config为后缀名的文件。 +*/ +typedef enum +{ + PARAM_MODE_BY_MODEL = 0, //根据相机型号名从文件中加载参数，例如MV-U300 + PARAM_MODE_BY_NAME, //根据设备昵称(tSdkCameraDevInfo.acFriendlyName)从文件中加载参数，例如MV-U300,该昵称可自定义 + PARAM_MODE_BY_SN, //根据设备的唯一序列号从文件中加载参数，序列号在出厂时已经写入设备，每台相机拥有不同的序列号。 + PARAM_MODE_IN_DEVICE //从设备的固态存储器中加载参数。不是所有的型号都支持从相机中读写参数组，由tSdkCameraCapbility.bParamInDevice决定 +}emSdkParameterMode; + + +//SDK生成的相机配置页面掩码值 +typedef enum +{ + PROP_SHEET_INDEX_EXPOSURE = 0, + PROP_SHEET_INDEX_ISP_COLOR, + PROP_SHEET_INDEX_ISP_LUT, + PROP_SHEET_INDEX_ISP_SHAPE, + PROP_SHEET_INDEX_VIDEO_FORMAT, + PROP_SHEET_INDEX_RESOLUTION, + PROP_SHEET_INDEX_IO_CTRL, + PROP_SHEET_INDEX_TRIGGER_SET, + PROP_SHEET_INDEX_OVERLAY, + PROP_SHEET_INDEX_DEVICE_INFO +}emSdkPropSheetMask; + +//SDK生成的相机配置页面的回调消息类型 +typedef enum +{ + SHEET_MSG_LOAD_PARAM_DEFAULT = 0, //参数被恢复成默认后，触发该消息 + SHEET_MSG_LOAD_PARAM_GROUP, //加载指定参数组，触发该消息 + SHEET_MSG_LOAD_PARAM_FROMFILE, //从指定文件加载参数后，触发该消息 + SHEET_MSG_SAVE_PARAM_GROUP //当前参数组被保存时，触发该消息 +}emSdkPropSheetMsg; + +//可视化选择参考窗口的类型 +typedef enum +{ + REF_WIN_AUTO_EXPOSURE = 0, + REF_WIN_WHITE_BALANCE, +}emSdkRefWinType; + +//可视化选择参考窗口的类型 +typedef enum +{ + RES_MODE_PREVIEW = 0, + RES_MODE_SNAPSHOT, +}emSdkResolutionMode; + +//白平衡时色温模式 +typedef enum +{ + CT_MODE_AUTO = 0, //自动识别色温 + CT_MODE_PRESET, //使用指定的预设色温 + CT_MODE_USER_DEF //自定义色温(增益和矩阵) +}emSdkClrTmpMode; + +//LUT的颜色通道 +typedef enum +{ + LUT_CHANNEL_ALL = 0,//R,B,G三通道同时调节 + LUT_CHANNEL_RED, //红色通道 + LUT_CHANNEL_GREEN, //绿色通道 + LUT_CHANNEL_BLUE, //蓝色通道 +}emSdkLutChannel; + +//ISP处理单元 +typedef enum +{ + ISP_PROCESSSOR_PC = 0,//使用PC的软件ISP模块 + ISP_PROCESSSOR_DEVICE //使用相机自带的硬件ISP模块 +}emSdkIspProcessor; + +//闪光灯信号控制方式 +typedef enum +{ + STROBE_SYNC_WITH_TRIG_AUTO = 0, //和触发信号同步，触发后，相机进行曝光时，自动生成STROBE信号。此时，有效极性可设置(CameraSetStrobePolarity)。 + STROBE_SYNC_WITH_TRIG_MANUAL, //和触发信号同步，触发后，STROBE延时指定的时间后(CameraSetStrobeDelayTime)，再持续指定时间的脉冲(CameraSetStrobePulseWidth)，有效极性可设置(CameraSetStrobePolarity)。 + STROBE_ALWAYS_HIGH, //始终为高，忽略STROBE信号的其他设置 + STROBE_ALWAYS_LOW //始终为低，忽略STROBE信号的其他设置 +}emStrobeControl; + +//硬件外触发的信号种类 +typedef enum +{ + EXT_TRIG_LEADING_EDGE = 0, //上升沿触发，默认为该方式 + EXT_TRIG_TRAILING_EDGE, //下降沿触发 + EXT_TRIG_HIGH_LEVEL, //高电平触发,电平宽度决定曝光时间，仅部分型号的相机支持电平触发方式。 + EXT_TRIG_LOW_LEVEL //低电平触发, +}emExtTrigSignal; + +//硬件外触发时的快门方式 +typedef enum +{ + EXT_TRIG_EXP_STANDARD = 0, //标准方式，默认为该方式。 + EXT_TRIG_EXP_GRR, //全局复位方式，部分滚动快门的CMOS型号的相机支持该方式，配合外部机械快门，可以达到全局快门的效果，适合拍高速运动的物体 +}emExtTrigShutterMode; + + +//相机的设备信息 +typedef struct +{ + char acProductSeries[32]; // 产品系列 + char acProductName[32]; // 产品名称 + char acFriendlyName[32]; // 产品昵称，用户可自定义改昵称，保存在相机内，用于区分多个相机同时使用,可以用CameraSetFriendlyName接口改变该昵称，设备重启后生效。 + char acLinkName[32]; // 内核符号连接名，内部使用 + char acDriverVersion[32]; // 驱动版本 + char acSensorType[32]; // sensor类型 + char acPortType[32]; // 接口类型 + char acSn[32]; // 产品唯一序列号 + UINT uInstance; // 该型号相机在该电脑上的实例索引号，用于区分同型号多相机 +} tSdkCameraDevInfo; + +//tSdkResolutionRange结构体中SKIP、 BIN、RESAMPLE模式的掩码值 +#define MASK_2X2_HD (1<<0) //硬件SKIP、BIN、重采样 2X2 +#define MASK_3X3_HD (1<<1) +#define MASK_4X4_HD (1<<2) +#define MASK_5X5_HD (1<<3) +#define MASK_6X6_HD (1<<4) +#define MASK_7X7_HD (1<<5) +#define MASK_8X8_HD (1<<6) +#define MASK_9X9_HD (1<<7) +#define MASK_10X10_HD (1<<8) +#define MASK_11X11_HD (1<<9) +#define MASK_12X12_HD (1<<10) +#define MASK_13X13_HD (1<<11) +#define MASK_14X14_HD (1<<12) +#define MASK_15X15_HD (1<<13) +#define MASK_16X16_HD (1<<14) +#define MASK_17X17_HD (1<<15) +#define MASK_2X2_SW (1<<16) //硬件SKIP、BIN、重采样 2X2 +#define MASK_3X3_SW (1<<17) +#define MASK_4X4_SW (1<<18) +#define MASK_5X5_SW (1<<19) +#define MASK_6X6_SW (1<<20) +#define MASK_7X7_SW (1<<21) +#define MASK_8X8_SW (1<<22) +#define MASK_9X9_SW (1<<23) +#define MASK_10X10_SW (1<<24) +#define MASK_11X11_SW (1<<25) +#define MASK_12X12_SW (1<<26) +#define MASK_13X13_SW (1<<27) +#define MASK_14X14_SW (1<<28) +#define MASK_15X15_SW (1<<29) +#define MASK_16X16_SW (1<<30) +#define MASK_17X17_SW (1<<31) + +//相机的分辨率设定范围，用于构件UI +typedef struct +{ + INT iHeightMax; //图像最大高度 + INT iHeightMin; //图像最小高度 + INT iWidthMax; //图像最大宽度 + INT iWidthMin; //图像最小宽度 + UINT uSkipModeMask; //SKIP模式掩码，为0，表示不支持SKIP 。bit0为1,表示支持SKIP 2x2 ;bit1为1，表示支持SKIP 3x3.... + UINT uBinSumModeMask; //BIN(求和)模式掩码，为0，表示不支持BIN 。bit0为1,表示支持BIN 2x2 ;bit1为1，表示支持BIN 3x3.... + UINT uBinAverageModeMask; //BIN(求均值)模式掩码，为0，表示不支持BIN 。bit0为1,表示支持BIN 2x2 ;bit1为1，表示支持BIN 3x3.... + UINT uResampleMask; //硬件重采样的掩码 +} tSdkResolutionRange; + + +//相机的分辨率描述 +typedef struct +{ + INT iIndex; // 索引号，[0,N]表示预设的分辨率(N 为预设分辨率的最大个数，一般不超过20),OXFF 表示自定义分辨率(ROI) + char acDescription[32]; // 该分辨率的描述信息。仅预设分辨率时该信息有效。自定义分辨率可忽略该信息 + UINT uBinSumMode; // BIN(求和)的模式,范围不能超过tSdkResolutionRange中uBinSumModeMask + UINT uBinAverageMode; // BIN(求均值)的模式,范围不能超过tSdkResolutionRange中uBinAverageModeMask + UINT uSkipMode; // 是否SKIP的尺寸，为0表示禁止SKIP模式，范围不能超过tSdkResolutionRange中uSkipModeMask + UINT uResampleMask; // 硬件重采样的掩码 + INT iHOffsetFOV; // 采集视场相对于Sensor最大视场左上角的垂直偏移 + INT iVOffsetFOV; // 采集视场相对于Sensor最大视场左上角的水平偏移 + INT iWidthFOV; // 采集视场的宽度 + INT iHeightFOV; // 采集视场的高度 + INT iWidth; // 相机最终输出的图像的宽度 + INT iHeight; // 相机最终输出的图像的高度 + INT iWidthZoomHd; // 硬件缩放的宽度,不需要进行此操作的分辨率，此变量设置为0. + INT iHeightZoomHd; // 硬件缩放的高度,不需要进行此操作的分辨率，此变量设置为0. + INT iWidthZoomSw; // 软件缩放的宽度,不需要进行此操作的分辨率，此变量设置为0. + INT iHeightZoomSw; // 软件缩放的高度,不需要进行此操作的分辨率，此变量设置为0. +} tSdkImageResolution; + +//相机白平衡色温模式描述信息 +typedef struct +{ + INT iIndex; // 模式索引号 + char acDescription[32]; // 描述信息 +} tSdkColorTemperatureDes; + +//相机帧率描述信息 +typedef struct +{ + INT iIndex; // 帧率索引号，一般0对应于低速模式，1对应于普通模式，2对应于高速模式 + char acDescription[32]; // 描述信息 +} tSdkFrameSpeed; + +//相机曝光功能范围定义 +typedef struct +{ + UINT uiTargetMin; //自动曝光亮度目标最小值 + UINT uiTargetMax; //自动曝光亮度目标最大值 + UINT uiAnalogGainMin; //模拟增益的最小值，单位为fAnalogGainStep中定义 + UINT uiAnalogGainMax; //模拟增益的最大值，单位为fAnalogGainStep中定义 + float fAnalogGainStep; //模拟增益每增加1，对应的增加的放大倍数。例如，uiAnalogGainMin一般为16，fAnalogGainStep一般为0.125，那么最小放大倍数就是16*0.125 = 2倍 + UINT uiExposeTimeMin; //手动模式下，曝光时间的最小值，单位:行。根据CameraGetExposureLineTime可以获得一行对应的时间(微秒),从而得到整帧的曝光时间 + UINT uiExposeTimeMax; //手动模式下，曝光时间的最大值，单位:行 +} tSdkExpose; + +//触发模式描述 +typedef struct +{ + INT iIndex; //模式索引号 + char acDescription[32]; //该模式的描述信息 +} tSdkTrigger; + +//传输分包大小描述(主要是针对网络相机有效) +typedef struct +{ + INT iIndex; //分包大小索引号 + char acDescription[32]; //对应的描述信息 + UINT iPackSize; +} tSdkPackLength; + +//预设的LUT表描述 +typedef struct +{ + INT iIndex; //编号 + char acDescription[32]; //描述信息 +} tSdkPresetLut; + +//AE算法描述 +typedef struct +{ + INT iIndex; //编号 + char acDescription[32]; //描述信息 +} tSdkAeAlgorithm; + +//RAW转RGB算法描述 +typedef struct +{ + INT iIndex; //编号 + char acDescription[32]; //描述信息 +} tSdkBayerDecodeAlgorithm; + + +//帧率统计信息 +typedef struct +{ + INT iTotal; //当前采集的总帧数（包括错误帧） + INT iCapture; //当前采集的有效帧的数量 + INT iLost; //当前丢帧的数量 +} tSdkFrameStatistic; + +//相机输出的图像数据格式 +typedef struct +{ + INT iIndex; //格式种类编号 + char acDescription[32]; //描述信息 + UINT iMediaType; //对应的图像格式编码，如CAMERA_MEDIA_TYPE_BAYGR8，在本文件中有定义。 +} tSdkMediaType; + +//伽马的设定范围 +typedef struct +{ + INT iMin; //最小值 + INT iMax; //最大值 +} tGammaRange; + +//对比度的设定范围 +typedef struct +{ + INT iMin; //最小值 + INT iMax; //最大值 +} tContrastRange; + +//RGB三通道数字增益的设定范围 +typedef struct +{ + INT iRGainMin; //红色增益的最小值 + INT iRGainMax; //红色增益的最大值 + INT iGGainMin; //绿色增益的最小值 + INT iGGainMax; //绿色增益的最大值 + INT iBGainMin; //蓝色增益的最小值 + INT iBGainMax; //蓝色增益的最大值 +} tRgbGainRange; + +//饱和度设定的范围 +typedef struct +{ + INT iMin; //最小值 + INT iMax; //最大值 +} tSaturationRange; + +//锐化的设定范围 +typedef struct +{ + INT iMin; //最小值 + INT iMax; //最大值 +} tSharpnessRange; + +//ISP模块的使能信息 +typedef struct +{ + BOOL bMonoSensor; //表示该型号相机是否为黑白相机,如果是黑白相机，则颜色相关的功能都无法调节 + BOOL bWbOnce; //表示该型号相机是否支持手动白平衡功能 + BOOL bAutoWb; //表示该型号相机是否支持自动白平衡功能 + BOOL bAutoExposure; //表示该型号相机是否支持自动曝光功能 + BOOL bManualExposure; //表示该型号相机是否支持手动曝光功能 + BOOL bAntiFlick; //表示该型号相机是否支持抗频闪功能 + BOOL bDeviceIsp; //表示该型号相机是否支持硬件ISP功能 + BOOL bForceUseDeviceIsp;//bDeviceIsp和bForceUseDeviceIsp同时为TRUE时，表示强制只用硬件ISP，不可取消。 + BOOL bZoomHD; //相机硬件是否支持图像缩放输出(只能是缩小)。 +} tSdkIspCapacity; + +/* 定义整合的设备描述信息，这些信息可以用于动态构建UI */ +typedef struct +{ + + tSdkTrigger *pTriggerDesc; // 触发模式 + INT iTriggerDesc; // 触发模式的个数，即pTriggerDesc数组的大小 + + tSdkImageResolution *pImageSizeDesc;// 预设分辨率选择 + INT iImageSizeDesc; // 预设分辨率的个数，即pImageSizeDesc数组的大小 + + tSdkColorTemperatureDes *pClrTempDesc;// 预设色温模式，用于白平衡 + INT iClrTempDesc; + + tSdkMediaType *pMediaTypeDesc; // 相机输出图像格式 + INT iMediaTypdeDesc; // 相机输出图像格式的种类个数，即pMediaTypeDesc数组的大小。 + + tSdkFrameSpeed *pFrameSpeedDesc; // 可调节帧速类型，对应界面上普通 高速 和超级三种速度设置 + INT iFrameSpeedDesc; // 可调节帧速类型的个数，即pFrameSpeedDesc数组的大小。 + + tSdkPackLength *pPackLenDesc; // 传输包长度，一般用于网络设备 + INT iPackLenDesc; // 可供选择的传输分包长度的个数，即pPackLenDesc数组的大小。 + + INT iOutputIoCounts; // 可编程输出IO的个数 + INT iInputIoCounts; // 可编程输入IO的个数 + + tSdkPresetLut *pPresetLutDesc; // 相机预设的LUT表 + INT iPresetLut; // 相机预设的LUT表的个数，即pPresetLutDesc数组的大小 + + INT iUserDataMaxLen; // 指示该相机中用于保存用户数据区的最大长度。为0表示无。 + BOOL bParamInDevice; // 指示该设备是否支持从设备中读写参数组。1为支持，0不支持。 + + tSdkAeAlgorithm *pAeAlmSwDesc; // 软件自动曝光算法描述 + int iAeAlmSwDesc; // 软件自动曝光算法个数 + + tSdkAeAlgorithm *pAeAlmHdDesc; // 硬件自动曝光算法描述，为NULL表示不支持硬件自动曝光 + int iAeAlmHdDesc; // 硬件自动曝光算法个数，为0表示不支持硬件自动曝光 + + tSdkBayerDecodeAlgorithm *pBayerDecAlmSwDesc; // 软件Bayer转换为RGB数据的算法描述 + int iBayerDecAlmSwDesc; // 软件Bayer转换为RGB数据的算法个数 + + tSdkBayerDecodeAlgorithm *pBayerDecAlmHdDesc; // 硬件Bayer转换为RGB数据的算法描述，为NULL表示不支持 + int iBayerDecAlmHdDesc; // 硬件Bayer转换为RGB数据的算法个数，为0表示不支持 + + /* 图像参数的调节范围定义,用于动态构建UI*/ + tSdkExpose sExposeDesc; // 曝光的范围值 + tSdkResolutionRange sResolutionRange; // 分辨率范围描述 + tRgbGainRange sRgbGainRange; // 图像数字增益范围描述 + tSaturationRange sSaturationRange; // 饱和度范围描述 + tGammaRange sGammaRange; // 伽马范围描述 + tContrastRange sContrastRange; // 对比度范围描述 + tSharpnessRange sSharpnessRange; // 锐化范围描述 + tSdkIspCapacity sIspCapacity; // ISP能力描述 + + +} tSdkCameraCapbility; + + +//图像帧头信息 +typedef struct +{ + UINT uiMediaType; // 图像格式,Image Format + UINT uBytes; // 图像数据字节数,Total bytes + INT iWidth; // 图像的宽度，调用图像处理函数后，该变量可能被动态修改，来指示处理后的图像尺寸 + INT iHeight; // 图像的高度，调用图像处理函数后，该变量可能被动态修改，来指示处理后的图像尺寸 + INT iWidthZoomSw; // 软件缩放的宽度,不需要进行软件裁剪的图像，此变量设置为0. + INT iHeightZoomSw; // 软件缩放的高度,不需要进行软件裁剪的图像，此变量设置为0. + BOOL bIsTrigger; // 指示是否为触发帧 is trigger + UINT uiTimeStamp; // 该帧的采集时间，单位0.1毫秒 + UINT uiExpTime; // 当前图像的曝光值，单位为微秒us + float fAnalogGain; // 当前图像的模拟增益倍数 + INT iGamma; // 该帧图像的伽马设定值，仅当LUT模式为动态参数生成时有效，其余模式下为-1 + INT iContrast; // 该帧图像的对比度设定值，仅当LUT模式为动态参数生成时有效，其余模式下为-1 + INT iSaturation; // 该帧图像的饱和度设定值，对于黑白相机无意义，为0 + float fRgain; // 该帧图像处理的红色数字增益倍数，对于黑白相机无意义，为1 + float fGgain; // 该帧图像处理的绿色数字增益倍数，对于黑白相机无意义，为1 + float fBgain; // 该帧图像处理的蓝色数字增益倍数，对于黑白相机无意义，为1 +}tSdkFrameHead; + +//图像帧描述 +typedef struct sCameraFrame +{ + tSdkFrameHead head; //帧头 + BYTE * pBuffer; //数据区 +}tSdkFrame; + +//图像捕获的回调函数定义 +typedef void (*CAMERA_SNAP_PROC)(CameraHandle hCamera, BYTE *pFrameBuffer, tSdkFrameHead* pFrameHead,PVOID pContext); + +//SDK生成的相机配置页面的消息回调函数定义 +typedef void (*CAMERA_PAGE_MSG_PROC)(CameraHandle hCamera,UINT MSG,UINT uParam,PVOID pContext); + + +//----------------------------IMAGE FORMAT DEFINE------------------------------------ +//----------------------------图像格式定义------------------------------------------- +#define CAMERA_MEDIA_TYPE_MONO 0x01000000 +#define CAMERA_MEDIA_TYPE_RGB 0x02000000 +#define CAMERA_MEDIA_TYPE_COLOR 0x02000000 +#define CAMERA_MEDIA_TYPE_CUSTOM 0x80000000 +#define CAMERA_MEDIA_TYPE_COLOR_MASK 0xFF000000 +#define CAMERA_MEDIA_TYPE_OCCUPY1BIT 0x00010000 +#define CAMERA_MEDIA_TYPE_OCCUPY2BIT 0x00020000 +#define CAMERA_MEDIA_TYPE_OCCUPY4BIT 0x00040000 +#define CAMERA_MEDIA_TYPE_OCCUPY8BIT 0x00080000 +#define CAMERA_MEDIA_TYPE_OCCUPY10BIT 0x000A0000 +#define CAMERA_MEDIA_TYPE_OCCUPY12BIT 0x000C0000 +#define CAMERA_MEDIA_TYPE_OCCUPY16BIT 0x00100000 +#define CAMERA_MEDIA_TYPE_OCCUPY24BIT 0x00180000 +#define CAMERA_MEDIA_TYPE_OCCUPY32BIT 0x00200000 +#define CAMERA_MEDIA_TYPE_OCCUPY36BIT 0x00240000 +#define CAMERA_MEDIA_TYPE_OCCUPY48BIT 0x00300000 +#define CAMERA_MEDIA_TYPE_EFFECTIVE_PIXEL_SIZE_MASK 0x00FF0000 +#define CAMERA_MEDIA_TYPE_EFFECTIVE_PIXEL_SIZE_SHIFT 16 + + +#define CAMERA_MEDIA_TYPE_ID_MASK 0x0000FFFF +#define CAMERA_MEDIA_TYPE_COUNT 0x46 + +/*mono*/ +#define CAMERA_MEDIA_TYPE_MONO1P (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY1BIT | 0x0037) +#define CAMERA_MEDIA_TYPE_MONO2P (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY2BIT | 0x0038) +#define CAMERA_MEDIA_TYPE_MONO4P (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY4BIT | 0x0039) +#define CAMERA_MEDIA_TYPE_MONO8 (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY8BIT | 0x0001) +#define CAMERA_MEDIA_TYPE_MONO8S (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY8BIT | 0x0002) +#define CAMERA_MEDIA_TYPE_MONO10 (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x0003) +#define CAMERA_MEDIA_TYPE_MONO10_PACKED (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY12BIT | 0x0004) +#define CAMERA_MEDIA_TYPE_MONO12 (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x0005) +#define CAMERA_MEDIA_TYPE_MONO12_PACKED (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY12BIT | 0x0006) +#define CAMERA_MEDIA_TYPE_MONO14 (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x0025) +#define CAMERA_MEDIA_TYPE_MONO16 (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x0007) + +/*Bayer */ +#define CAMERA_MEDIA_TYPE_BAYGR8 (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY8BIT | 0x0008) +#define CAMERA_MEDIA_TYPE_BAYRG8 (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY8BIT | 0x0009) +#define CAMERA_MEDIA_TYPE_BAYGB8 (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY8BIT | 0x000A) +#define CAMERA_MEDIA_TYPE_BAYBG8 (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY8BIT | 0x000B) + +#define CAMERA_MEDIA_TYPE_BAYGR10_MIPI (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY10BIT | 0x0026) +#define CAMERA_MEDIA_TYPE_BAYRG10_MIPI (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY10BIT | 0x0027) +#define CAMERA_MEDIA_TYPE_BAYGB10_MIPI (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY10BIT | 0x0028) +#define CAMERA_MEDIA_TYPE_BAYBG10_MIPI (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY10BIT | 0x0029) + + +#define CAMERA_MEDIA_TYPE_BAYGR10 (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x000C) +#define CAMERA_MEDIA_TYPE_BAYRG10 (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x000D) +#define CAMERA_MEDIA_TYPE_BAYGB10 (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x000E) +#define CAMERA_MEDIA_TYPE_BAYBG10 (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x000F) + +#define CAMERA_MEDIA_TYPE_BAYGR12 (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x0010) +#define CAMERA_MEDIA_TYPE_BAYRG12 (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x0011) +#define CAMERA_MEDIA_TYPE_BAYGB12 (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x0012) +#define CAMERA_MEDIA_TYPE_BAYBG12 (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x0013) + + +#define CAMERA_MEDIA_TYPE_BAYGR10_PACKED (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY12BIT | 0x0026) +#define CAMERA_MEDIA_TYPE_BAYRG10_PACKED (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY12BIT | 0x0027) +#define CAMERA_MEDIA_TYPE_BAYGB10_PACKED (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY12BIT | 0x0028) +#define CAMERA_MEDIA_TYPE_BAYBG10_PACKED (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY12BIT | 0x0029) + +#define CAMERA_MEDIA_TYPE_BAYGR12_PACKED (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY12BIT | 0x002A) +#define CAMERA_MEDIA_TYPE_BAYRG12_PACKED (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY12BIT | 0x002B) +#define CAMERA_MEDIA_TYPE_BAYGB12_PACKED (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY12BIT | 0x002C) +#define CAMERA_MEDIA_TYPE_BAYBG12_PACKED (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY12BIT | 0x002D) + +#define CAMERA_MEDIA_TYPE_BAYGR16 (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x002E) +#define CAMERA_MEDIA_TYPE_BAYRG16 (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x002F) +#define CAMERA_MEDIA_TYPE_BAYGB16 (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x0030) +#define CAMERA_MEDIA_TYPE_BAYBG16 (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x0031) + +/*RGB */ +#define CAMERA_MEDIA_TYPE_RGB8 (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY24BIT | 0x0014) +#define CAMERA_MEDIA_TYPE_BGR8 (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY24BIT | 0x0015) +#define CAMERA_MEDIA_TYPE_RGBA8 (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY32BIT | 0x0016) +#define CAMERA_MEDIA_TYPE_BGRA8 (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY32BIT | 0x0017) +#define CAMERA_MEDIA_TYPE_RGB10 (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY48BIT | 0x0018) +#define CAMERA_MEDIA_TYPE_BGR10 (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY48BIT | 0x0019) +#define CAMERA_MEDIA_TYPE_RGB12 (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY48BIT | 0x001A) +#define CAMERA_MEDIA_TYPE_BGR12 (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY48BIT | 0x001B) +#define CAMERA_MEDIA_TYPE_RGB16 (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY48BIT | 0x0033) +#define CAMERA_MEDIA_TYPE_RGB10V1_PACKED (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY32BIT | 0x001C) +#define CAMERA_MEDIA_TYPE_RGB10P32 (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY32BIT | 0x001D) +#define CAMERA_MEDIA_TYPE_RGB12V1_PACKED (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY36BIT | 0X0034) +#define CAMERA_MEDIA_TYPE_RGB565P (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x0035) +#define CAMERA_MEDIA_TYPE_BGR565P (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0X0036) + +/*YUV and YCbCr*/ +#define CAMERA_MEDIA_TYPE_YUV411_8_UYYVYY (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY12BIT | 0x001E) +#define CAMERA_MEDIA_TYPE_YUV422_8_UYVY (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x001F) +#define CAMERA_MEDIA_TYPE_YUV422_8 (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x0032) +#define CAMERA_MEDIA_TYPE_YUV8_UYV (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY24BIT | 0x0020) +#define CAMERA_MEDIA_TYPE_YCBCR8_CBYCR (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY24BIT | 0x003A) +//CAMERA_MEDIA_TYPE_YCBCR422_8 : YYYYCbCrCbCr +#define CAMERA_MEDIA_TYPE_YCBCR422_8 (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x003B) +#define CAMERA_MEDIA_TYPE_YCBCR422_8_CBYCRY (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x0043) +#define CAMERA_MEDIA_TYPE_YCBCR411_8_CBYYCRYY (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY12BIT | 0x003C) +#define CAMERA_MEDIA_TYPE_YCBCR601_8_CBYCR (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY24BIT | 0x003D) +#define CAMERA_MEDIA_TYPE_YCBCR601_422_8 (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x003E) +#define CAMERA_MEDIA_TYPE_YCBCR601_422_8_CBYCRY (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x0044) +#define CAMERA_MEDIA_TYPE_YCBCR601_411_8_CBYYCRYY (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY12BIT | 0x003F) +#define CAMERA_MEDIA_TYPE_YCBCR709_8_CBYCR (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY24BIT | 0x0040) +#define CAMERA_MEDIA_TYPE_YCBCR709_422_8 (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x0041) +#define CAMERA_MEDIA_TYPE_YCBCR709_422_8_CBYCRY (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x0045) +#define CAMERA_MEDIA_TYPE_YCBCR709_411_8_CBYYCRYY (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY12BIT | 0x0042) + +/*RGB Planar */ +#define CAMERA_MEDIA_TYPE_RGB8_PLANAR (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY24BIT | 0x0021) +#define CAMERA_MEDIA_TYPE_RGB10_PLANAR (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY48BIT | 0x0022) +#define CAMERA_MEDIA_TYPE_RGB12_PLANAR (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY48BIT | 0x0023) +#define CAMERA_MEDIA_TYPE_RGB16_PLANAR (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY48BIT | 0x0024) + + +#endif \ No newline at end of file diff --git a/include/camera/camera_status.h b/include/camera/camera_status.h new file mode 100644 index 0000000..402d546 --- /dev/null +++ b/include/camera/camera_status.h @@ -0,0 +1,102 @@ +#ifndef __CAMERA_STATUS_DEF__ +#define __CAMERA_STATUS_DEF__ + +typedef int CameraSdkStatus; + + +/*常用的宏*/ +#define SDK_SUCCESS(_FUC_) (_FUC_ == CAMERA_STATUS_SUCCESS) + +#define SDK_UNSUCCESS(_FUC_) (_FUC_ != CAMERA_STATUS_SUCCESS) + +#define SDK_UNSUCCESS_RETURN(_FUC_,RET) if((RET = _FUC_) != CAMERA_STATUS_SUCCESS)\ + {\ + return RET;\ + } + +#define SDK_UNSUCCESS_BREAK(_FUC_) if(_FUC_ != CAMERA_STATUS_SUCCESS)\ + {\ + break;\ + } + + +/* 常用错误 */ + +#define CAMERA_STATUS_SUCCESS 0 // 操作成功 +#define CAMERA_STATUS_FAILED -1 // 操作失败 +#define CAMERA_STATUS_INTERNAL_ERROR -2 // 内部错误 +#define CAMERA_STATUS_UNKNOW -3 // 未知错误 +#define CAMERA_STATUS_NOT_SUPPORTED -4 // 不支持该功能 +#define CAMERA_STATUS_NOT_INITIALIZED -5 // 初始化未完成 +#define CAMERA_STATUS_PARAMETER_INVALID -6 // 参数无效 +#define CAMERA_STATUS_PARAMETER_OUT_OF_BOUND -7 // 参数越界 +#define CAMERA_STATUS_UNENABLED -8 // 未使能 +#define CAMERA_STATUS_USER_CANCEL -9 // 用户手动取消了，比如roi面板点击取消，返回 +#define CAMERA_STATUS_PATH_NOT_FOUND -10 // 注册表中没有找到对应的路径 +#define CAMERA_STATUS_SIZE_DISMATCH -11 // 获得图像数据长度和定义的尺寸不匹配 +#define CAMERA_STATUS_TIME_OUT -12 // 超时错误 +#define CAMERA_STATUS_IO_ERROR -13 // 硬件IO错误 +#define CAMERA_STATUS_COMM_ERROR -14 // 通讯错误 +#define CAMERA_STATUS_BUS_ERROR -15 // 总线错误 +#define CAMERA_STATUS_NO_DEVICE_FOUND -16 // 没有发现设备 +#define CAMERA_STATUS_NO_LOGIC_DEVICE_FOUND -17 // 未找到逻辑设备 +#define CAMERA_STATUS_DEVICE_IS_OPENED -18 // 设备已经打开 +#define CAMERA_STATUS_DEVICE_IS_CLOSED -19 // 设备已经关闭 +#define CAMERA_STATUS_DEVICE_VEDIO_CLOSED -20 // 没有打开设备视频，调用录像相关的函数时，如果相机视频没有打开，则回返回该错误。 +#define CAMERA_STATUS_NO_MEMORY -21 // 没有足够系统内存 +#define CAMERA_STATUS_FILE_CREATE_FAILED -22 // 创建文件失败 +#define CAMERA_STATUS_FILE_INVALID -23 // 文件格式无效 +#define CAMERA_STATUS_WRITE_PROTECTED -24 // 写保护，不可写 +#define CAMERA_STATUS_GRAB_FAILED -25 // 数据采集失败 +#define CAMERA_STATUS_LOST_DATA -26 // 数据丢失，不完整 +#define CAMERA_STATUS_EOF_ERROR -27 // 未接收到帧结束符 +#define CAMERA_STATUS_BUSY -28 // 正忙(上一次操作还在进行中)，此次操作不能进行 +#define CAMERA_STATUS_WAIT -29 // 需要等待(进行操作的条件不成立)，可以再次尝试 +#define CAMERA_STATUS_IN_PROCESS -30 // 正在进行，已经被操作过 +#define CAMERA_STATUS_IIC_ERROR -31 // IIC传输错误 +#define CAMERA_STATUS_SPI_ERROR -32 // SPI传输错误 +#define CAMERA_STATUS_USB_CONTROL_ERROR -33 // USB控制传输错误 +#define CAMERA_STATUS_USB_BULK_ERROR -34 // USB BULK传输错误 +#define CAMERA_STATUS_SOCKET_INIT_ERROR -35 // 网络传输套件初始化失败 +#define CAMERA_STATUS_GIGE_FILTER_INIT_ERROR -36 // 网络相机内核过滤驱动初始化失败，请检查是否正确安装了驱动，或者重新安装。 +#define CAMERA_STATUS_NET_SEND_ERROR -37 // 网络数据发送错误 +#define CAMERA_STATUS_DEVICE_LOST -38 // 与网络相机失去连接，心跳检测超时 +#define CAMERA_STATUS_DATA_RECV_LESS -39 // 接收到的字节数比请求的少 +#define CAMERA_STATUS_FUNCTION_LOAD_FAILED -40 // 从文件中加载程序失败 +#define CAMERA_STATUS_CRITICAL_FILE_LOST -41 // 程序运行所必须的文件丢失。 +#define CAMERA_STATUS_SENSOR_ID_DISMATCH -42 // 固件和程序不匹配，原因是下载了错误的固件。 +#define CAMERA_STATUS_OUT_OF_RANGE -43 // 参数超出有效范围。 +#define CAMERA_STATUS_REGISTRY_ERROR -44 // 安装程序注册错误。请重新安装程序，或者运行安装目录Setup/Installer.exe +#define CAMERA_STATUS_ACCESS_DENY -45 // 禁止访问。指定相机已经被其他程序占用时，再申请访问该相机，会返回该状态。(一个相机不能被多个程序同时访问) +#define CAMERA_STATUS_CAMERA_NEED_RESET -46 // 表示相机需要复位后才能正常使用，此时请让相机断电重启，或者重启操作系统后，便可正常使用。 + + + +//和AIA制定的标准相同 +/*#define CAMERA_AIA_SUCCESS 0x0000 */ +#define CAMERA_AIA_PACKET_RESEND 0x0100 //该帧需要重传 +#define CAMERA_AIA_NOT_IMPLEMENTED 0x8001 //设备不支持的命令 +#define CAMERA_AIA_INVALID_PARAMETER 0x8002 //命令参数非法 +#define CAMERA_AIA_INVALID_ADDRESS 0x8003 //不可访问的地址 +#define CAMERA_AIA_WRITE_PROTECT 0x8004 //访问的对象不可写 +#define CAMERA_AIA_BAD_ALIGNMENT 0x8005 //访问的地址没有按照要求对齐 +#define CAMERA_AIA_ACCESS_DENIED 0x8006 //没有访问权限 +#define CAMERA_AIA_BUSY 0x8007 //命令正在处理中 +#define CAMERA_AIA_DEPRECATED 0x8008 //0x8008-0x0800B 0x800F 该指令已经废弃 +#define CAMERA_AIA_PACKET_UNAVAILABLE 0x800C //包无效 +#define CAMERA_AIA_DATA_OVERRUN 0x800D //数据溢出，通常是收到的数据比需要的多 +#define CAMERA_AIA_INVALID_HEADER 0x800E //数据包头部中某些区域与协议不匹配 +#define CAMERA_AIA_PACKET_NOT_YET_AVAILABLE 0x8010 //图像分包数据还未准备好，多用于触发模式，应用程序访问超时 +#define CAMERA_AIA_PACKET_AND_PREV_REMOVED_FROM_MEMORY 0x8011 //需要访问的分包已经不存在。多用于重传时数据已经不在缓冲区中 +#define CAMERA_AIA_PACKET_REMOVED_FROM_MEMORY 0x8012 //CAMERA_AIA_PACKET_AND_PREV_REMOVED_FROM_MEMORY +#define CAMERA_AIA_NO_REF_TIME 0x0813 //没有参考时钟源。多用于时间同步的命令执行时 +#define CAMERA_AIA_PACKET_TEMPORARILY_UNAVAILABLE 0x0814 //由于信道带宽问题，当前分包暂时不可用，需稍后进行访问 +#define CAMERA_AIA_OVERFLOW 0x0815 //设备端数据溢出，通常是队列已满 +#define CAMERA_AIA_ACTION_LATE 0x0816 //命令执行已经超过有效的指定时间 +#define CAMERA_AIA_ERROR 0x8FFF //错误 + + + + + +#endif \ No newline at end of file diff --git a/include/camera/camera_wrapper.h b/include/camera/camera_wrapper.h new file mode 100644 index 0000000..283e3b2 --- /dev/null +++ b/include/camera/camera_wrapper.h @@ -0,0 +1,60 @@ +// +// Created by zhikun on 18-11-7. +// used for testing double cameras +// camera0 is left camera, camera1 is right camera. +// + +#ifndef VIDEO_TEST1_CAMERA_WRAPPER_H +#define VIDEO_TEST1_CAMERA_WRAPPER_H + +#include +#include +#include "opencv2/core/core.hpp" +#include "opencv2/highgui/highgui.hpp" +#include + +#include "camera/wrapper_head.h" +#include "camera/camera_api.h" + +class CameraWrapper: public WrapperHead { +private: + unsigned char* rgb_buffer0; + unsigned char* rgb_buffer1; + int camera_cnts; + int camera_status0, camera_status1; + tSdkCameraDevInfo camera_enum_list[2]; + int h_camera0; + int h_camera1; + char camera_name0[32]; + char camera_name1[32]; + + tSdkCameraCapbility tCapability0; + tSdkCameraCapbility tCapability1; + tSdkFrameHead frame_info0; + tSdkFrameHead frame_info1; + BYTE *pby_buffer0; + BYTE *pby_buffer1; + IplImage* iplImage0; + IplImage* iplImage1; + int channel0; + int channel1; + + + + + void swapCameraHandle(); + +public: + CameraWrapper(); + ~CameraWrapper() final; + + bool init() final; + bool read(cv::Mat& src0, cv::Mat& src1) final; + bool readRaw(cv::Mat& src0, cv::Mat& src1); + bool readProcessed(cv::Mat& src0, cv::Mat& src1); + + +}; + + +#endif //VIDEO_TEST1_CAMERA_WRAPPER_H diff --git a/include/camera/video_wrapper.h b/include/camera/video_wrapper.h new file mode 100644 index 0000000..1ef2d1b --- /dev/null +++ b/include/camera/video_wrapper.h @@ -0,0 +1,43 @@ +// +// Created by zhikun on 18-11-16. +// wrapper for video read from file +// + +#ifndef STEREOVISION_FROM_VIDEO_FILE_VIDEO_WRAPPER_H +#define STEREOVISION_FROM_VIDEO_FILE_VIDEO_WRAPPER_H + + +#include +#include +#include + +#include "wrapper_head.h" + + +class VideoWrapper:public WrapperHead { +public: + VideoWrapper(const std::string& filename0, const std::string& filename1); + ~VideoWrapper(); + + + /** + * @brief initialize cameras + * @return bool value: whether it success + */ + bool init() final; + + + /** + * @brief read images from camera + * @param src_left : output source video of left camera + * @param src_right : output source video of right camera + * @return bool value: whether the reading is successful + */ + bool read(cv::Mat &src_left, cv::Mat &src_right) final; +private: + cv::VideoCapture video0, video1; + +}; + + +#endif //STEREOVISION_FROM_VIDEO_FILE_VIDEO_WRAPPER_H diff --git a/include/camera/wrapper_head.h b/include/camera/wrapper_head.h new file mode 100644 index 0000000..7df8c47 --- /dev/null +++ b/include/camera/wrapper_head.h @@ -0,0 +1,24 @@ +// +// Created by zhikun on 18-11-18. +// + +#ifndef STEREOVISION_FROM_VIDEO_FILE_WRAPPER_HEAD_H +#define STEREOVISION_FROM_VIDEO_FILE_WRAPPER_HEAD_H + +#include + +/** + * @brief A virtual class for wrapper of camera and video files + */ +class WrapperHead { + +public: + virtual ~WrapperHead() = default;; + virtual bool init() = 0; + virtual bool read(cv::Mat &src_left, cv::Mat &src_right) = 0; + +}; + + + +#endif //STEREOVISION_FROM_VIDEO_FILE_WRAPPER_HEAD_H diff --git a/include/log.h b/include/log.h new file mode 100644 index 0000000..313c873 --- /dev/null +++ b/include/log.h @@ -0,0 +1,138 @@ +// +// Created by xinyang on 19-2-19. +// + +#ifndef _LOG_H_ +#define _LOG_H_ + +#include +#include +#include + +/************** Define the control code *************/ +#define START_CTR "\033[0" +#define END_CTR "m" +#define CLEAR_CODE ";0" +#define LIGHT_CODE ";1" +#define LINE_CODE ";4" +#define BLINK_CODE ";5" +#define REVERSE_CODE ";7" +#define VANISH_CODE ";8" +#define WORD_WHITE_CODE ";30" +#define WORD_RED_CODE ";31" +#define WORD_GREEN_CODE ";32" +#define WORD_YELLOW_CODE ";33" +#define WORD_BLUE_CODE ";34" +#define WORD_PURPLE_CODE ";35" +#define WORD_CYAN_CODE ";36" +#define WORD_GRAY_CODE ";37" +#define BACK_WHITE_CODE ";40" +#define BACK_RED_CODE ";41" +#define BACK_GREEN_CODE ";42" +#define BACK_YELLOW_CODE ";43" +#define BACK_BLUE_CODE ";44" +#define BACK_PURPLE_CODE ";45" +#define BACK_CYAN_CODE ";46" +#define BACK_GRAY_CODE ";47" + +#define CTRS(ctrs) START_CTR ctrs END_CTR + +#define WORD_WHITE WORD_WHITE_CODE +#define WORD_RED WORD_RED_CODE +#define WORD_GREEN WORD_GREEN_CODE +#define WORD_YELLOW WORD_YELLOW_CODE +#define WORD_BLUE WORD_BLUE_CODE +#define WORD_PURPLE WORD_PURPLE_CODE +#define WORD_CYAN WORD_CYAN_CODE +#define WORD_GRAY WORD_GRAY_CODE +#define WORD_LIGHT_WHITE LIGHT_CODE WORD_WHITE +#define WORD_LIGHT_RED LIGHT_CODE WORD_RED +#define WORD_LIGHT_GREEN LIGHT_CODE WORD_GREEN +#define WORD_LIGHT_YELLOW LIGHT_CODE WORD_YELLOW +#define WORD_LIGHT_BLUE LIGHT_CODE WORD_BLUE +#define WORD_LIGHT_PURPLE LIGHT_CODE WORD_PURPLE +#define WORD_LIGHT_CYAN LIGHT_CODE WORD_CYAN +#define WORD_LIGHT_GRAY LIGHT_CODE WORD_GRAY +#define CLEAR_ALL CTRS(CLEAR_CODE) +/*************** Define the log level value ***************/ +#define LOG_NONE 0 +#define LOG_ERROR 1 +#define LOG_WARRING 2 +#define LOG_MSG 3 +/************** Ensure the current log level **************/ +#ifndef LOG_LEVEL + #define LOG_LEVEL LOG_MSG +#endif +#if LOG_LEVEL < LOG_NONE + #define LOG_LEVEL LOG_NONE +#elif LOG_LEVEL > LOG_MSG + #define LOG_LEVEL LOG_MSG +#endif +/******* Ensure the color corresponding to the level ******/ +#ifndef LOG_ERROR_COLOR + #define LOG_ERROR_COLOR WORD_RED +#endif +#ifndef LOG_WARRING_COLOR + #define LOG_WARRING_COLOR WORD_YELLOW +#endif +#ifndef LOG_MSG_COLOR + #define LOG_MSG_COLOR WORD_GRAY +#endif +#ifndef LOG_LINK_COLOR + #define LOG_LINK_COLOR LINE_CODE WORD_BLUE +#endif +/******************** The log API *************************/ +#define LOG_0(format, ...) printf(format, ##__VA_ARGS__) +#if LOG_LEVEL >= LOG_ERROR + #define LOG_1(format, ...) printf(format, ##__VA_ARGS__) +#else + #define LOG_1(format, ...) ((void)0) +#endif +#if LOG_LEVEL >= LOG_WARRING + #define LOG_2(format, ...) printf(format, ##__VA_ARGS__) +#else + #define LOG_2(format, ...) ((void)0) +#endif +#if LOG_LEVEL >= LOG_MSG + #define LOG_3(format, ...) printf(format, ##__VA_ARGS__) +#else + #define LOG_3(format, ...) ((void)0) +#endif +#define LOG_(level, format, ...) LOG_##level (format, ##__VA_ARGS__) +#define LOG(level, format, ...) LOG_(level, format"\n", ##__VA_ARGS__) +#define STR_CTR(ctrs, str) START_CTR ctrs END_CTR str CLEAR_ALL + +#define LOGA(format, ...) LOG(LOG_NONE, format, ##__VA_ARGS__) +#define LOGA_INFO(format, ...) LOG(LOG_NONE, "<%s:%d>: " format, ##__VA_ARGS__) +#define LOGE(format, ...) LOG(LOG_ERROR, STR_CTR(LOG_ERROR_COLOR, ": " format), ## __VA_ARGS__) +#define LOGW(format, ...) LOG(LOG_WARRING, STR_CTR(LOG_WARRING_COLOR,": " format), ## __VA_ARGS__) +#define LOGM(format, ...) LOG(LOG_MSG, STR_CTR(LOG_MSG_COLOR, ": " format), ## __VA_ARGS__) +#define LOGE_INFO(format, ...) LOG(LOG_ERROR, \ + STR_CTR(LOG_ERROR_COLOR, "<") \ + STR_CTR(LOG_LINK_COLOR, "%s:%d") \ + STR_CTR(LOG_ERROR_COLOR, " ERROR>: " format), \ + __FILE__, __LINE__, ##__VA_ARGS__) +#define LOGW_INFO(format, ...) LOG(LOG_WARRING, \ + STR_CTR(LOG_WARRING_COLOR,"<") \ + STR_CTR(LOG_LINK_COLOR,"%s:%d") \ + STR_CTR(LOG_WARRING_COLOR, " WARRING>: " format), \ + __FILE__, __LINE__, ##__VA_ARGS__) +#define LOGM_INFO(format, ...) LOG(LOG_MSG, \ + STR_CTR(LOG_MSG_COLOR, "<") \ + STR_CTR(LOG_LINK_COLOR, "%s:%d") \ + STR_CTR(LOG_MSG_COLOR, " MSG>: " format), \ + __FILE__, __LINE__, ##__VA_ARGS__) + +/******************** the time counter API ************************/ +#if LOG_LEVEL > LOG_NONE && (!defined(DO_NOT_CNT_TIME)) + #define CNT_TIME(str_ctrs, tag, codes, ...) do{\ + timeval ts, te; \ + gettimeofday(&ts, NULL); \ + codes; \ + gettimeofday(&te, NULL); \ + LOGM(STR_CTR(str_ctrs, tag": %fms"), ## __VA_ARGS__, (te.tv_sec-ts.tv_sec)*1000.0 + (te.tv_usec-ts.tv_usec)/1000.0); \ + }while(0) +#else + #define CNT_TIME(str_ctrs, tag, codes, ...) codes +#endif +#endif /* _LOG_H_ */ diff --git a/include/options/additions.h b/include/options/additions.h new file mode 100644 index 0000000..03b67c3 --- /dev/null +++ b/include/options/additions.h @@ -0,0 +1,17 @@ +// +// Created by xinyang on 19-4-7. +// + +#ifndef _ADDITIONS_H_ +#define _ADDITIONS_H_ + +#include +#include +#include + +std::thread* create_data_recv_thread(Uart *uart); +void save_video_file(cv::Mat &src); +void save_labelled_image(cv::Mat &src, cv::Rect2d box); + + +#endif /* _ADDITIONS_H_ */ diff --git a/include/options/options.h b/include/options/options.h new file mode 100644 index 0000000..73b8a7d --- /dev/null +++ b/include/options/options.h @@ -0,0 +1,19 @@ +// +// Created by xinyang on 19-3-27. +// + +#ifndef _OPTIONS_H_ +#define _OPTIONS_H_ + +extern bool show_armor_box; +extern bool show_armor_boxes; +extern bool show_light_blobs; +extern bool show_origin; +extern bool save_labelled; +extern bool run_with_camera; +extern bool save_video; +extern bool collect_data; + +void process_options(int argc, char *argv[]); + +#endif /* _OPTIONS_H_ */ diff --git a/include/uart/uart.h b/include/uart/uart.h new file mode 100644 index 0000000..05f856d --- /dev/null +++ b/include/uart/uart.h @@ -0,0 +1,42 @@ +// +// Created by xixiliadorabarry on 1/24/19. +// + +#ifndef STEREOVISION_UART_H +#define STEREOVISION_UART_H + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +//#include + + + +class Uart { +private: + int fd; + char buff[8]; + int fps; + time_t cur_time; + + int set_opt(int fd, int nSpeed, int nBits, char nEvent, int nStop); + +public: + Uart(); + void sendTarget(float x, float y ,float z); + + char receive(); + void receive_data(); +}; + + +#endif //STEREOVISION_UART_H diff --git a/libMVSDK.so b/libMVSDK.so new file mode 100644 index 0000000..67c4ed0 Binary files /dev/null and b/libMVSDK.so differ diff --git a/main.cpp b/main.cpp new file mode 100644 index 0000000..bcca454 --- /dev/null +++ b/main.cpp @@ -0,0 +1,118 @@ +// +// Created by xixiliadorabarry on 1/24/19. +// +#include +#include +#include +#include +#include + +#include "energy/energy.h" +#include "include/uart/uart.h" +#include "energy/param_struct_define.h" +#include "energy/constant.h" +#include "camera/camera_wrapper.h" +#include "camera/video_wrapper.h" +#include "camera/wrapper_head.h" +#include "armor_finder/armor_finder.h" + +#include +#include + +using namespace cv; +using namespace std; + +#define ENERGY_STATE 1 +#define ARMOR_STATE 0 + +int state = ARMOR_STATE; +float yaw, pitch; + +void uartReceive(Uart* uart); + +int main() +{ + Uart uart; + bool flag = true; + short done = 0;//用于检测是否已经读完初始激光中心时的角度 + + while (flag) + { + int ally_color = ALLY_RED; + int energy_part_rotation = CLOCKWISE; + + int from_camera = 1; + cout<<"Input 1 for camera, 0 for video files"<>from_camera; + + WrapperHead *video; + if(from_camera) + video = new CameraWrapper; + else + video = new VideoWrapper("r_l_640.avi", "fan_640.avi"); + + if (video->init()) { + cout << "Video source initialization successfully." << endl; + } + + Mat src, src_none; + + ArmorFinder armorFinder(ENEMY_BLUE, uart); + + Energy energy(uart); + energy.setAllyColor(ally_color); + energy.setRotation(energy_part_rotation); + + static thread receive(uartReceive, &uart); + + if(state==1 && done == 0){ + energy.uart.receive_data(); + done = 1; + } + +// energy.sendTargetByUart(-8,-8,-8); + + + time_t t1 = time(nullptr), t2 = time(nullptr); + + while (video->read(src, src_none)) + { +// if(!from_camera)energy.extract(src); + if(state == 1){ + imshow("src", src); + energy.run(src); + }else{ + armorFinder.run(src_none); + } + + if (waitKey(10) == 'q') { + flag = false; + break; + } + } + delete video; + cout << "Program fails. Restarting" << endl; + } + + return 0; +} + + +void uartReceive(Uart* uart){ + char buffer[100]; + int cnt=0; + while(true){ + char data; + while((data=uart->receive()) != '\n'){ + buffer[cnt++] = data; + }buffer[cnt] = 0; + if(cnt==1 && buffer[0]=='e'){ + state = ENERGY_STATE; + }else if(cnt==1 && buffer[0]=='a'){ + state = ARMOR_STATE; + }else{ + sscanf(buffer, "%f, %f", &yaw, &pitch); + } + cnt = 0; + } +} diff --git a/monitor.sh b/monitor.sh new file mode 100755 index 0000000..cf657c1 --- /dev/null +++ b/monitor.sh @@ -0,0 +1,11 @@ +#!/bin/sh + +exe=$1 +while true; do + state=`ps aux | grep "$1" | grep -v grep | grep -v $0` + if [ ! "$state" ]; then + exec $exe & + echo "restart $exe" + fi + sleep 2 +done diff --git a/src/camera/camera_wrapper.cpp b/src/camera/camera_wrapper.cpp new file mode 100644 index 0000000..d6adb57 --- /dev/null +++ b/src/camera/camera_wrapper.cpp @@ -0,0 +1,230 @@ +// +// Created by zhikun on 18-11-7. +// + +#include + +using std::cout; +using std::endl; +using namespace cv; + +CameraWrapper::CameraWrapper() +{ + camera_cnts = 2; + camera_status0 = -1; + camera_status1 = -1; + iplImage0 = nullptr; + iplImage1 = nullptr; + channel0 = 3; + channel1 = 3; +} + + +bool CameraWrapper::init() { + CameraSdkInit(1); + + //枚举设备，并建立设备列表 + int camera_enumerate_device_status = CameraEnumerateDevice(camera_enum_list, &camera_cnts); + //cout<<"camera enumerate device status: "< +#include +#include +#include +#include +#include +#include +#include + +using namespace std; + +#define VIDEO_SAVE_DIR "/home/sjturm/Desktop/video/" + +static cv::VideoWriter *create_video_writer(){ + FILE* info = fopen(VIDEO_SAVE_DIR"info.txt", "r"); + int cnt=0; + fscanf(info, "%d", &cnt); + fclose(info); + info = fopen(VIDEO_SAVE_DIR"info.txt", "w"); + fprintf(info, "%d", ++cnt); + + char name[100]; + sprintf(name, VIDEO_SAVE_DIR"%d.avi", cnt); + return new cv::VideoWriter(name, cv::VideoWriter::fourcc('P','I','M','1'), 80, cv::Size(640,480),false); +} + +void save_video_file(cv::Mat &src){ + static cv::VideoWriter *video = create_video_writer(); + video->write(src); +} + +#define SAVE_DIR "/home/sjturm/Desktop/labelled/" + +int get_labelled_cnt(){ + FILE *fp = fopen(SAVE_DIR"info.txt", "r"); + int cnt=0; + fscanf(fp, "%d", &cnt); + fclose(fp); + return cnt+1; +} + +void save_labelled_cnt(int cnt){ + FILE *fp = fopen(SAVE_DIR"info.txt", "w"); + fprintf(fp, "%d", cnt); + fclose(fp); +} + +void save_labelled_image(cv::Mat &src, cv::Rect2d box){ + static int cnt=get_labelled_cnt(); + char name[50]; + sprintf(name, SAVE_DIR"%d.jpg", cnt); + cv::imwrite(name, src); + sprintf(name, SAVE_DIR"%d.txt", cnt); + FILE *fp = fopen(name, "w"); + if(fp == NULL){ + LOGW("Can't create file: %s!\nStop saving!", name); + save_labelled = false; + return; + } + fprintf(fp, "%lf %lf %lf %lf\n", box.x, box.y, box.width, box.height); + fclose(fp); + save_labelled_cnt(cnt); +} diff --git a/src/options/options.cpp b/src/options/options.cpp new file mode 100644 index 0000000..bd92120 --- /dev/null +++ b/src/options/options.cpp @@ -0,0 +1,68 @@ +// +// Created by xinyang on 19-3-27. +// + +#include +#include +#include + +bool show_armor_box = false; +bool show_armor_boxes = false; +bool show_light_blobs = false; +bool show_origin = false; +bool save_labelled = false; +bool run_with_camera = false; +bool save_video = false; +bool collect_data = false; + +void process_options(int argc, char *argv[]){ + if(argc >= 2){ + for(int i=1; i +#include + +using std::cout; +using std::cerr; +using std::clog; +using std::dec; +using std::endl; +using std::hex; + +GMAngle_t aim; + + +Uart::Uart(){ + + fd = open("/dev/ttyUSB0", O_RDWR); + if(fd < 0) + { + cerr<<"open port error"<> 8) & 0xFF; + buff[3] = 0 & 0xFF; + buff[4] = '+'; + buff[5] = (0 >> 8) & 0xFF; + buff[6] = (0 & 0xFF); + buff[7] = 'e'; + + fps = 0; + cur_time = time(nullptr); + +} + +int Uart::set_opt(int fd, int nSpeed, int nBits, char nEvent, int nStop) { + termios newtio{}, oldtio{}; + if (tcgetattr(fd, &oldtio) != 0) { + perror("SetupSerial 1"); + return -1; + } + bzero(&newtio, sizeof(newtio)); + newtio.c_cflag |= CLOCAL | CREAD; + newtio.c_cflag &= ~CSIZE; + + switch (nBits) { + case 7: + newtio.c_cflag |= CS7;break; + case 8: + newtio.c_cflag |= CS8;break; + default:break; + } + + switch (nEvent) { + case 'O': //奇校验 + newtio.c_cflag |= PARENB; + newtio.c_cflag |= PARODD; + newtio.c_iflag |= (INPCK | ISTRIP); + break; + case 'E': //偶校验 + newtio.c_iflag |= (INPCK | ISTRIP); + newtio.c_cflag |= PARENB; + newtio.c_cflag &= ~PARODD; + break; + case 'N': //无校验 + newtio.c_cflag &= ~PARENB; + break; + default:break; + } + + switch (nSpeed) { + case 2400: + cfsetispeed(&newtio, B2400); + cfsetospeed(&newtio, B2400); + break; + case 4800: + cfsetispeed(&newtio, B4800); + cfsetospeed(&newtio, B4800); + break; + case 9600: + cfsetispeed(&newtio, B9600); + cfsetospeed(&newtio, B9600); + break; + case 115200: + cfsetispeed(&newtio, B115200); + cfsetospeed(&newtio, B115200); + break; + default: + cfsetispeed(&newtio, B9600); + cfsetospeed(&newtio, B9600); + break; + } + + if (nStop == 1) { + newtio.c_cflag &= ~CSTOPB; + } else if (nStop == 2) { + newtio.c_cflag |= CSTOPB; + } + + newtio.c_cc[VTIME] = 0; + newtio.c_cc[VMIN] = 0; + tcflush(fd, TCIFLUSH); + if ((tcsetattr(fd, TCSANOW, &newtio)) != 0) { + perror("com set error"); + return -1; + } + printf("set done!\n"); + + return 0; +} + +void Uart::sendTarget(float x, float y, float z) { + static short x_tmp, y_tmp, z_tmp; + + time_t t = time(nullptr); + if(cur_time != t) + { + cur_time = t; + cout<<"fps:"<(x * (32768 - 1) / 100); + y_tmp= static_cast(y * (32768 - 1) / 100); + z_tmp= static_cast(z * (32768 - 1) / 1000); + + buff[0] = 's'; + buff[1] = static_cast((x_tmp >> 8) & 0xFF); + buff[2] = static_cast((x_tmp >> 0) & 0xFF); + buff[3] = static_cast((y_tmp >> 8) & 0xFF); + buff[4] = static_cast((y_tmp >> 0) & 0xFF); + buff[5] = static_cast((z_tmp >> 8) & 0xFF); + buff[6] = static_cast((z_tmp >> 0) & 0xFF); + buff[7] = 'e'; + + write(fd, buff, 8); + +} + +// 's' + (x) ( 8bit + 8bit ) + (y) ( 8bit + 8bit ) + (z) ( 8bit + 8bit ) + 'e' + + +char Uart::receive() { + char data; + while(read(fd, &data, 1) < 1); + return data; +} + + +void Uart::receive_data() { + char Enemy_Info[6] = {0}; + read(fd, &Enemy_Info, 6); + if(Enemy_Info[0]=='s'&&Enemy_Info[5]=='e'){ + aim.yaw = static_cast(((Enemy_Info[1]<<8)|(Enemy_Info[2]))*(100.0 / (32768.0 - 1.0))); + aim.pitch = static_cast(((Enemy_Info[3]<<8)|(Enemy_Info[4]))*(100.0 / (32768.0 - 1.0))); + } + else return; +}