SpireCV/video_io/sv_camera.cpp

#include "sv_camera_privately.h"
#include "sv_camera.h"
#include "driver/sv_camera_G1.cpp"
#include "driver/sv_camera_V4L2s.cpp"
#include "driver/sv_camera_file.cpp"
#include "driver/sv_camera_streaming.cpp"
#include "driver/sv_camera_mipi.cpp"
#include "driver/sv_camera_MC1.cpp"
#include "driver/sv_camera_GX40.cpp"

#include <map>
#include <iterator>

sv_p::CameraBase *cameraCreatEmpty(int timeOut)
{
  throw std::runtime_error("SpireCV (101) Camera not supported");
  return nullptr;
}

typedef sv_p::CameraBase *(*cameraCreat)(int timeOut);
static std::map<sv::CameraType, cameraCreat> svCameraList =
    {
        {sv::CameraType::NONE, sv_camera_NONE::creat},
        {sv::CameraType::WEBCAM, sv_camera_WEBCAM::creat},
        {sv::CameraType::V4L2CAM, sv_camera_V4L2::creat},
        {sv::CameraType::VIDEOFILE, sv_camera_FILE::creat},
        {sv::CameraType::STREAMING, sv_camera_Streaming::creat},
        {sv::CameraType::MIPI, sv_camera_MIPI::creat},
        {sv::CameraType::G1, sv_camera_G1::creat},
        {sv::CameraType::Q10, sv_camera_Q10::creat},
        {sv::CameraType::GX40, sv_camera_GX40::creat},
        {sv::CameraType::MC1, sv_camera_MC1::creat},
        {sv::CameraType::VIRTUAL, cameraCreatEmpty}};

static sv_p::CameraBase *svCreatCamera(sv::CameraType type, int timeOut)
{
  std::map<sv::CameraType, cameraCreat>::iterator temp = svCameraList.find(type);
  if (temp != svCameraList.end())
  {
    return temp->second(timeOut);
  }
  return nullptr;
}

sv::Camera::Camera(CameraType type, int timeOut)
{
  this->dev = svCreatCamera(type, timeOut);
}

sv::Camera::~Camera()
{
  // 休眠50ms 以便能退出线程
  std::this_thread::sleep_for(std::chrono::milliseconds(50));
  delete (sv_p::CameraBase *)dev;
}

sv_p::CameraBase::~CameraBase()
{
  pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
  readThreadHandle = readThreadHandle == 0 ? 0 : pthread_cancel(readThreadHandle);
  release();
}

bool sv::Camera::setStream(const std::string &ip, int port)
{
  return ((sv_p::CameraBase *)dev)->setStream(ip, port);
}

bool sv::Camera::setName(const std::string &name)
{
  return ((sv_p::CameraBase *)dev)->setName(name);
}

bool sv::Camera::setIndex(int index)
{
  return ((sv_p::CameraBase *)dev)->setIndex(index);
}

bool sv::Camera::open(void)
{
  return ((sv_p::CameraBase *)dev)->open();
}

bool sv::Camera::read(cv::Mat &image)
{
  return ((sv_p::CameraBase *)dev)->read(image);
}

bool sv::Camera::readNoBlock(cv::Mat &image)
{
  return ((sv_p::CameraBase *)dev)->readNoBlock(image);
}

void sv::Camera::release(void)
{
  ((sv_p::CameraBase *)dev)->release();
}

void sv::Camera::setWH(int width, int height)
{
  ((sv_p::CameraBase *)dev)->setWH(width, height);
}

void sv::Camera::setFps(int fps)
{
  ((sv_p::CameraBase *)dev)->setFps(fps);
}

void sv::Camera::setBrightness(double brightness)
{
  ((sv_p::CameraBase *)dev)->setBrightness(brightness);
}

void sv::Camera::setContrast(double contrast)
{
  ((sv_p::CameraBase *)dev)->setContrast(contrast);
}

void sv::Camera::setSaturation(double saturation)
{
  ((sv_p::CameraBase *)dev)->setSaturation(saturation);
}

void sv::Camera::setHue(double hue)
{
  ((sv_p::CameraBase *)dev)->setHue(hue);
}

void sv::Camera::setExposure(double exposure)
{
  ((sv_p::CameraBase *)dev)->setExposure(exposure);
}

bool sv::Camera::isActive(void)
{
  return ((sv_p::CameraBase *)dev)->isActive();
}

sv::CameraType sv::Camera::getType(void)
{
  return ((sv_p::CameraBase *)dev)->getType();
}

std::string sv::Camera::getName(void)
{
  return ((sv_p::CameraBase *)dev)->getName();
}

int sv::Camera::getW(void)
{
  return ((sv_p::CameraBase *)dev)->getW();
}

int sv::Camera::getH(void)
{
  return ((sv_p::CameraBase *)dev)->getH();
}

int sv::Camera::getExpectFps(void)
{
  return ((sv_p::CameraBase *)dev)->getExpectFps();
}

double sv::Camera::getFps(void)
{
  return ((sv_p::CameraBase *)dev)->getFps();
}

double sv::Camera::getBrightness(void)
{
  return ((sv_p::CameraBase *)dev)->getBrightness();
}

double sv::Camera::getContrast(void)
{
  return ((sv_p::CameraBase *)dev)->getContrast();
}

double sv::Camera::getSaturation(void)
{
  return ((sv_p::CameraBase *)dev)->getSaturation();
}

double sv::Camera::getHue(void)
{
  return ((sv_p::CameraBase *)dev)->getHue();
}

double sv::Camera::getExposure(void)
{
  return ((sv_p::CameraBase *)dev)->getExposure();
}