"${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/oak/*.hpp"

# OAK Backend (optional)

src/backends/oak/goak.cpp

src/backends/oak/goakbackend.cpp

src/backends/oak/goak_media_adapter.cpp

if(HAVE_OAK)

ocv_target_compile_definitions(${the_module} PRIVATE -DHAVE_OAK)

if(TARGET opencv_test_gapi)

ocv_target_compile_definitions(opencv_test_gapi PRIVATE -DHAVE_OAK)

endif()

ocv_target_link_libraries(${the_module} PRIVATE depthai::core)

endif()

if(HAVE_OAK)

# FIXME: consider better solution

if(TARGET example_gapi_oak_rgb_camera_encoding)

ocv_target_compile_definitions(example_gapi_oak_rgb_camera_encoding PRIVATE -DHAVE_OAK)

endif()

if(TARGET example_gapi_oak_small_hetero_pipeline)

ocv_target_compile_definitions(example_gapi_oak_small_hetero_pipeline PRIVATE -DHAVE_OAK)

endif()

endif()

OCV_OPTION(WITH_FREETYPE "Enable FreeType framework" OFF)

OCV_OPTION(WITH_PLAIDML "Include PlaidML2 support" OFF)

OCV_OPTION(WITH_OAK "Include OpenCV AI Kit support" OFF)

if(WITH_OAK)

find_package(depthai QUIET)

if(depthai_FOUND)

set(HAVE_OAK TRUE)

endif()

endif()

#ifndef OPENCV_GAPI_OAK_HPP

#define OPENCV_GAPI_OAK_HPP

#include <opencv2/gapi/garg.hpp> // IStreamSource

#include <opencv2/gapi/gkernel.hpp> // GKernelPackage

#include <opencv2/gapi/gstreaming.hpp> // GOptRunArgsP

namespace cv {

namespace gapi {

namespace oak {

struct EncoderConfig {

/**

enum class RateControlMode: int { CBR, VBR };

/**

enum class Profile: int { H264_BASELINE, H264_HIGH, H264_MAIN, H265_MAIN, MJPEG };

/**

std::int32_t bitrate = 8000;

/**

std::int32_t keyframeFrequency = 30;

/**

std::int32_t maxBitrate = 8000;

/**

std::int32_t numBFrames = 0;

/**

std::uint32_t numFramesPool = 4;

/**

Profile profile = Profile::H265_MAIN;

/**

std::int32_t quality = 80;

/**

bool lossless = false;

/**

RateControlMode rateCtrlMode = RateControlMode::CBR;

/**

std::int32_t width = 1920;

/**

std::int32_t height = 1080;

/**

float frameRate = 30.0f;

};

G_API_OP(GEncFrame, <GArray<uint8_t>(GFrame, EncoderConfig)>, "org.opencv.oak.enc_frame") {

static GArrayDesc outMeta(const GFrameDesc&, const EncoderConfig&) {

return cv::empty_array_desc();

}

};

G_API_OP(GSobelXY, <GFrame(GFrame, const cv::Mat&, const cv::Mat&)>, "org.opencv.oak.sobelxy") {

static GFrameDesc outMeta(const GFrameDesc& in, const cv::Mat&, const cv::Mat&) {

return in;

}

};

GAPI_EXPORTS GArray<uint8_t> encode(const GFrame& in, const EncoderConfig&);

GAPI_EXPORTS GFrame sobelXY(const GFrame& in,

const cv::Mat& hk,

const cv::Mat& vk);

GAPI_EXPORTS cv::gapi::GBackend backend();

GAPI_EXPORTS cv::gapi::GKernelPackage kernels();

struct GAPI_EXPORTS ColorCameraParams {};

class GAPI_EXPORTS ColorCamera: public cv::gapi::wip::IStreamSource {

cv::MediaFrame m_dummy;

virtual bool pull(cv::gapi::wip::Data &data) override;

virtual GMetaArg descr_of() const override;

ColorCamera();

};

} // namespace oak

} // namespace gapi

namespace detail {

template<> struct CompileArgTag<gapi::oak::ColorCameraParams> {

static const char* tag() { return "gapi.oak.colorCameraParams"; }

};

template<> struct CompileArgTag<gapi::oak::EncoderConfig> {

static const char* tag() { return "gapi.oak.encoderConfig"; }

};

} // namespace detail

} // namespace cv

#endif // OPENCV_GAPI_OAK_HPP

#include <fstream>

#include <opencv2/gapi.hpp>

#include <opencv2/gapi/core.hpp>

#include <opencv2/gapi/gframe.hpp>

#include <opencv2/gapi/oak/oak.hpp>

#include <opencv2/gapi/streaming/format.hpp> // BGR accessor

#include <opencv2/highgui.hpp> // CommandLineParser

const std::string keys =

"{ h help | | Print this help message }"

"{ output | output.h265 | Path to the output .h265 video file }";

#ifdef HAVE_OAK

int main(int argc, char *argv[]) {

cv::CommandLineParser cmd(argc, argv, keys);

if (cmd.has("help")) {

cmd.printMessage();

return 0;

}

const std::string output_name = cmd.get<std::string>("output");

cv::gapi::oak::EncoderConfig cfg;

cfg.profile = cv::gapi::oak::EncoderConfig::Profile::H265_MAIN;

cv::GFrame in;

cv::GArray<uint8_t> encoded = cv::gapi::oak::encode(in, cfg);

auto args = cv::compile_args(cv::gapi::oak::ColorCameraParams{}, cv::gapi::oak::kernels());

auto pipeline = cv::GComputation(cv::GIn(in), cv::GOut(encoded)).compileStreaming(std::move(args));

// Graph execution /////////////////////////////////////////////////////////

pipeline.setSource(cv::gapi::wip::make_src<cv::gapi::oak::ColorCamera>());

pipeline.start();

std::vector<uint8_t> out_h265_data;

std::ofstream out_h265_file;

out_h265_file.open(output_name, std::ofstream::out | std::ofstream::binary | std::ofstream::trunc);

// Pull 300 frames from the camera

uint32_t frames = 300;

uint32_t pulled = 0;

while (pipeline.pull(cv::gout(out_h265_data))) {

if (out_h265_file.is_open()) {

out_h265_file.write(reinterpret_cast<const char*>(out_h265_data.data()),

out_h265_data.size());

}

if (pulled++ == frames) {

pipeline.stop();

break;

}

}

std::cout << "Pipeline finished: " << output_name << " file has been written." << std::endl;

}

#else // HAVE_OAK

int main() {

GAPI_Assert(false && "Built without OAK support");

return -1;

}

#endif // HAVE_OAK

#include <opencv2/gapi.hpp>

#include <opencv2/gapi/core.hpp>

#include <opencv2/gapi/cpu/core.hpp>

#include <opencv2/gapi/gframe.hpp>

#include <opencv2/gapi/media.hpp>

#include <opencv2/gapi/oak/oak.hpp>

#include <opencv2/gapi/streaming/format.hpp> // BGR accessor

#include <opencv2/highgui.hpp> // CommandLineParser

const std::string keys =

"{ h help | | Print this help message }"

"{ output | output.png | Path to the output file }";

#ifdef HAVE_OAK

int main(int argc, char *argv[]) {

cv::CommandLineParser cmd(argc, argv, keys);

if (cmd.has("help")) {

cmd.printMessage();

return 0;

}

const std::string output_name = cmd.get<std::string>("output");

std::vector<int> h = {1, 0, -1,

2, 0, -2,

1, 0, -1};

std::vector<int> v = { 1, 2, 1,

0, 0, 0,

-1, -2, -1};

cv::Mat hk(3, 3, CV_32SC1, h.data());

cv::Mat vk(3, 3, CV_32SC1, v.data());

// Heterogeneous pipeline:

// OAK camera -> Sobel -> streaming accessor (CPU)

cv::GFrame in;

cv::GFrame sobel = cv::gapi::oak::sobelXY(in, hk, vk);

// Default camera and then sobel work only with nv12 format

cv::GMat out = cv::gapi::streaming::Y(sobel);

auto args = cv::compile_args(cv::gapi::oak::ColorCameraParams{},

cv::gapi::oak::kernels());

auto pipeline = cv::GComputation(cv::GIn(in), cv::GOut(out)).compileStreaming(std::move(args));

// Graph execution /////////////////////////////////////////////////////////

cv::Mat out_mat(1920, 1080, CV_8UC1);

pipeline.setSource(cv::gapi::wip::make_src<cv::gapi::oak::ColorCamera>());

pipeline.start();

// pull 1 frame

pipeline.pull(cv::gout(out_mat));

cv::imwrite(output_name, out_mat);

std::cout << "Pipeline finished: " << output_name << " file has been written." << std::endl;

}

#else // HAVE_OAK

int main() {

GAPI_Assert(false && "Built without OAK support");

return -1;

}

#endif // HAVE_OAK

#include <opencv2/gapi/oak/oak.hpp>

#include <opencv2/gapi/cpu/gcpukernel.hpp>

#include "oak_media_adapter.hpp"

#include <thread>

#include <chrono>

namespace cv {

namespace gapi {

namespace oak {

GArray<uint8_t> encode(const GFrame& in, const EncoderConfig& cfg) {

return GEncFrame::on(in, cfg);

}

GFrame sobelXY(const GFrame& in, const cv::Mat& hk, const cv::Mat& vk) {

return GSobelXY::on(in, hk, vk);

}

ColorCamera::ColorCamera()

: m_dummy(cv::MediaFrame::Create<cv::gapi::oak::OAKMediaAdapter>()) {

}

bool ColorCamera::pull(cv::gapi::wip::Data &data) {

// FIXME: Avoid passing this formal frame to the pipeline

std::this_thread::sleep_for(std::chrono::milliseconds(10));

data = m_dummy;

return true;

}

cv::GMetaArg ColorCamera::descr_of() const {

return cv::GMetaArg{cv::descr_of(m_dummy)};

}

} // namespace oak

} // namespace gapi

} // namespace cv