In G-API, kernels (or operation implementations) are objects. Kernels are
organized into collections, or _kernel packages_, represented by class
-cv::gapi::GKernelPackage. The main purpose of a kernel package is to
+cv::GKernelPackage. The main purpose of a kernel package is to
capture which kernels we would like to use in our graph, and pass it
as a _graph compilation option_:
namespace core {
namespace cpu {
-GAPI_EXPORTS_W cv::gapi::GKernelPackage kernels();
+GAPI_EXPORTS_W cv::GKernelPackage kernels();
} // namespace cpu
} // namespace core
namespace cv { namespace gapi { namespace core { namespace fluid {
-GAPI_EXPORTS_W cv::gapi::GKernelPackage kernels();
+GAPI_EXPORTS_W cv::GKernelPackage kernels();
}}}}
};
} // namespace std
-
namespace cv {
+ class GAPI_EXPORTS_W_SIMPLE GKernelPackage;
+
namespace gapi {
+ GAPI_EXPORTS cv::GKernelPackage combine(const cv::GKernelPackage &lhs,
+ const cv::GKernelPackage &rhs);
+
/// @private
class GFunctor
{
private:
const char* m_id;
};
+} // namespace gapi
/** \addtogroup gapi_compile_args
* @{
{
/// @private
- using M = std::unordered_map<std::string, std::pair<GBackend, GKernelImpl>>;
+ using M = std::unordered_map<std::string, std::pair<cv::gapi::GBackend, cv::GKernelImpl>>;
/// @private
M m_id_kernels;
}
public:
- void include(const GFunctor& functor)
- {
- m_id_kernels[functor.id()] = std::make_pair(functor.backend(), functor.impl());
- }
+ void include(const cv::gapi::GFunctor& functor);
+
/**
* @brief Returns total number of kernels
* in the package (across all backends included)
*
* @param backend backend which kernels to remove
*/
- void remove(const GBackend& backend);
+ void remove(const cv::gapi::GBackend& backend);
/**
* @brief Remove all kernels implementing the given API from
*
*/
template<typename KAPI>
- GBackend lookup() const
+ cv::gapi::GBackend lookup() const
{
return lookup(KAPI::id()).first;
}
* @param backend backend associated with the kernel
* @param kernel_id a name/id of the kernel
*/
- void include(const cv::gapi::GBackend& backend, const std::string& kernel_id)
- {
- removeAPI(kernel_id);
- m_id_kernels[kernel_id] = std::make_pair(backend, GKernelImpl{{}, {}});
- }
+ void include(const cv::gapi::GBackend& backend, const std::string& kernel_id);
/**
* @brief Lists all backends which are included into package
*
* @return vector of backends
*/
- std::vector<GBackend> backends() const;
+ std::vector<cv::gapi::GBackend> backends() const;
// TODO: Doxygen bug -- it wants me to place this comment
// here, not below.
* @param rhs "Right-hand-side" package in the process
* @return a new kernel package.
*/
- friend GAPI_EXPORTS GKernelPackage combine(const GKernelPackage &lhs,
- const GKernelPackage &rhs);
+ friend GAPI_EXPORTS GKernelPackage cv::gapi::combine(const GKernelPackage &lhs,
+ const GKernelPackage &rhs);
};
+ /** @} */
+
+namespace gapi {
+ using GKernelPackage = cv::GKernelPackage; // Keep backward compatibility
+
+ /** \addtogroup gapi_compile_args
+ * @{
+ */
/**
* @brief Create a kernel package object containing kernels
/** @} */
- // FYI - this function is already commented above
- GAPI_EXPORTS GKernelPackage combine(const GKernelPackage &lhs,
- const GKernelPackage &rhs);
-
/**
* @brief Combines multiple G-API kernel packages into one
*
* @return The resulting kernel package
*/
template<typename... Ps>
- GKernelPackage combine(const GKernelPackage &a, const GKernelPackage &b, Ps&&... rest)
+ cv::GKernelPackage combine(const cv::GKernelPackage &a, const cv::GKernelPackage &b, Ps&&... rest)
{
return combine(a, combine(b, rest...));
}
namespace detail
{
- template<> struct CompileArgTag<cv::gapi::GKernelPackage>
+ template<> struct CompileArgTag<cv::GKernelPackage>
{
static const char* tag() { return "gapi.kernel_package"; }
};
namespace core {
namespace ocl {
- GAPI_EXPORTS_W cv::gapi::GKernelPackage kernels();
+GAPI_EXPORTS_W cv::GKernelPackage kernels();
} // namespace ocl
} // namespace core
namespace cv { namespace gapi { namespace core { namespace plaidml {
-GAPI_EXPORTS cv::gapi::GKernelPackage kernels();
+GAPI_EXPORTS cv::GKernelPackage kernels();
}}}}
{
namespace ocv
{
- GAPI_EXPORTS_W cv::gapi::GKernelPackage kernels();
+ GAPI_EXPORTS_W cv::GKernelPackage kernels();
} // namespace ocv
} // namespace render
namespace gapi {
namespace streaming {
-GAPI_EXPORTS cv::gapi::GKernelPackage kernels();
+GAPI_EXPORTS cv::GKernelPackage kernels();
G_API_OP(GBGR, <GMat(GFrame)>, "org.opencv.streaming.BGR")
{
#include <opencv2/gapi/python/python.hpp>
// NB: Python wrapper replaces :: with _ for classes
-using gapi_GKernelPackage = cv::gapi::GKernelPackage;
+using gapi_GKernelPackage = cv::GKernelPackage;
using gapi_GNetPackage = cv::gapi::GNetPackage;
using gapi_ie_PyParams = cv::gapi::ie::PyParams;
using gapi_wip_IStreamSource_Ptr = cv::Ptr<cv::gapi::wip::IStreamSource>;
static PyObject* pyopencv_cv_gapi_kernels(PyObject* , PyObject* py_args, PyObject*)
{
using namespace cv;
- gapi::GKernelPackage pkg;
+ GKernelPackage pkg;
Py_ssize_t size = PyTuple_Size(py_args);
for (int i = 0; i < size; ++i)
{
struct GAPI_EXPORTS_W_SIMPLE GCompileArg
{
- GAPI_WRAP GCompileArg(gapi::GKernelPackage arg);
+ GAPI_WRAP GCompileArg(GKernelPackage arg);
GAPI_WRAP GCompileArg(gapi::GNetPackage arg);
GAPI_WRAP GCompileArg(gapi::streaming::queue_capacity arg);
};
auto customKernel = gapi::kernels<GCPUMinScalar>();
auto kernels = gapi::combine(customKernel,
- params.compileArgs[0].get<gapi::GKernelPackage>());
+ params.compileArgs[0].get<GKernelPackage>());
params.compileArgs = compile_args(kernels);
OptFlowLKTestOutput outOCV { outPtsOCV, outStatusOCV, outErrOCV };
// which are sensitive to metadata
}
-cv::gapi::GKernelPackage cv::gapi::GBackend::Priv::auxiliaryKernels() const
+cv::GKernelPackage cv::gapi::GBackend::Priv::auxiliaryKernels() const
{
return {};
}
// they are called when meta information becomes available.
virtual void addMetaSensitiveBackendPasses(ade::ExecutionEngineSetupContext &);
- virtual cv::gapi::GKernelPackage auxiliaryKernels() const;
+ virtual cv::GKernelPackage auxiliaryKernels() const;
// Ask backend if it has a custom control over island fusion process
// This method is quite redundant but there's nothing better fits
#include "api/gbackend_priv.hpp"
// GKernelPackage public implementation ////////////////////////////////////////
-void cv::gapi::GKernelPackage::remove(const cv::gapi::GBackend& backend)
+void cv::GKernelPackage::remove(const cv::gapi::GBackend& backend)
{
std::vector<std::string> id_deleted_kernels;
for (const auto& p : m_id_kernels)
}
}
-bool cv::gapi::GKernelPackage::includesAPI(const std::string &id) const
+void cv::GKernelPackage::include(const cv::gapi::GFunctor& functor)
+{
+ m_id_kernels[functor.id()] = std::make_pair(functor.backend(), functor.impl());
+}
+
+void cv::GKernelPackage::include(const cv::gapi::GBackend& backend, const std::string& kernel_id)
+{
+ removeAPI(kernel_id);
+ m_id_kernels[kernel_id] = std::make_pair(backend, GKernelImpl{{}, {}});
+}
+
+bool cv::GKernelPackage::includesAPI(const std::string &id) const
{
return ade::util::contains(m_id_kernels, id);
}
-void cv::gapi::GKernelPackage::removeAPI(const std::string &id)
+void cv::GKernelPackage::removeAPI(const std::string &id)
{
m_id_kernels.erase(id);
}
-std::size_t cv::gapi::GKernelPackage::size() const
+std::size_t cv::GKernelPackage::size() const
{
return m_id_kernels.size();
}
-const std::vector<cv::GTransform> &cv::gapi::GKernelPackage::get_transformations() const
+const std::vector<cv::GTransform> &cv::GKernelPackage::get_transformations() const
{
return m_transformations;
}
-std::vector<std::string> cv::gapi::GKernelPackage::get_kernel_ids() const
+std::vector<std::string> cv::GKernelPackage::get_kernel_ids() const
{
std::vector<std::string> ids;
for (auto &&id : m_id_kernels)
return ids;
}
-cv::gapi::GKernelPackage cv::gapi::combine(const GKernelPackage &lhs,
- const GKernelPackage &rhs)
+cv::GKernelPackage cv::gapi::combine(const cv::GKernelPackage &lhs,
+ const cv::GKernelPackage &rhs)
{
// If there is a collision, prefer RHS to LHS
// since RHS package has a precedense, start with its copy
- GKernelPackage result(rhs);
+ cv::GKernelPackage result(rhs);
// now iterate over LHS package and put kernel if and only
// if there's no such one
for (const auto& kernel : lhs.m_id_kernels)
}
std::pair<cv::gapi::GBackend, cv::GKernelImpl>
-cv::gapi::GKernelPackage::lookup(const std::string &id) const
+cv::GKernelPackage::lookup(const std::string &id) const
{
auto kernel_it = m_id_kernels.find(id);
if (kernel_it != m_id_kernels.end())
util::throw_error(std::logic_error("Kernel " + id + " was not found"));
}
-std::vector<cv::gapi::GBackend> cv::gapi::GKernelPackage::backends() const
+std::vector<cv::gapi::GBackend> cv::GKernelPackage::backends() const
{
using kernel_type = std::pair<std::string, std::pair<cv::gapi::GBackend, cv::GKernelImpl>>;
std::unordered_set<cv::gapi::GBackend> unique_set;
} // anonymous namespace
-cv::gapi::GKernelPackage cv::gimpl::meta::kernels() {
+cv::GKernelPackage cv::gimpl::meta::kernels() {
return cv::gapi::kernels<InGraphMetaKernel>();
}
namespace gimpl {
namespace meta {
-cv::gapi::GKernelPackage kernels();
+cv::GKernelPackage kernels();
} // namespace meta
} // namespace gimpl
}
};
-cv::gapi::GKernelPackage cv::gapi::core::cpu::kernels()
+cv::GKernelPackage cv::gapi::core::cpu::kernels()
{
static auto pkg = cv::gapi::kernels
< GCPUAdd
}
};
-cv::gapi::GKernelPackage cv::gapi::imgproc::cpu::kernels()
+cv::GKernelPackage cv::gapi::imgproc::cpu::kernels()
{
static auto pkg = cv::gapi::kernels
< GCPUFilter2D
}
};
-cv::gapi::GKernelPackage cv::gapi::calib3d::cpu::kernels() {
+cv::GKernelPackage cv::gapi::calib3d::cpu::kernels() {
static auto pkg = cv::gapi::kernels<GCPUStereo>();
return pkg;
}
#else
-cv::gapi::GKernelPackage cv::gapi::calib3d::cpu::kernels()
+cv::GKernelPackage cv::gapi::calib3d::cpu::kernels()
{
return GKernelPackage();
}
}
};
-cv::gapi::GKernelPackage cv::gapi::video::cpu::kernels()
+cv::GKernelPackage cv::gapi::video::cpu::kernels()
{
static auto pkg = cv::gapi::kernels
< GCPUBuildOptFlowPyramid
#else
-cv::gapi::GKernelPackage cv::gapi::video::cpu::kernels()
+cv::GKernelPackage cv::gapi::video::cpu::kernels()
{
return GKernelPackage();
}
} // namespace gapi
} // namespace cv
-cv::gapi::GKernelPackage cv::gapi::core::fluid::kernels()
+cv::GKernelPackage cv::gapi::core::fluid::kernels()
{
using namespace cv::gapi::fluid;
} // namespace gapi
} // namespace cv
-cv::gapi::GKernelPackage cv::gapi::imgproc::fluid::kernels()
+cv::GKernelPackage cv::gapi::imgproc::fluid::kernels()
{
using namespace cv::gapi::fluid;
return EPtr{new cv::gimpl::ie::GIEExecutable(graph, nodes)};
}
- virtual cv::gapi::GKernelPackage auxiliaryKernels() const override {
+ virtual cv::GKernelPackage auxiliaryKernels() const override {
return cv::gapi::kernels< cv::gimpl::ie::Infer
, cv::gimpl::ie::InferROI
, cv::gimpl::ie::InferList
}
};
-cv::gapi::GKernelPackage cv::gapi::core::ocl::kernels()
+cv::GKernelPackage cv::gapi::core::ocl::kernels()
{
static auto pkg = cv::gapi::kernels
< GOCLAdd
};
-cv::gapi::GKernelPackage cv::gapi::imgproc::ocl::kernels()
+cv::GKernelPackage cv::gapi::imgproc::ocl::kernels()
{
static auto pkg = cv::gapi::kernels
< GOCLFilter2D
return EPtr{new cv::gimpl::onnx::GONNXExecutable(graph, nodes)};
}
- virtual cv::gapi::GKernelPackage auxiliaryKernels() const override {
+ virtual cv::GKernelPackage auxiliaryKernels() const override {
return cv::gapi::kernels< cv::gimpl::onnx::Infer
, cv::gimpl::onnx::InferROI
, cv::gimpl::onnx::InferList
GAPI_PLAIDML_ARITHMETIC_OP(GPlaidMLAdd, cv::gapi::core::GAdd, +);
GAPI_PLAIDML_ARITHMETIC_OP(GPlaidMLSub, cv::gapi::core::GSub, -);
-cv::gapi::GKernelPackage cv::gapi::core::plaidml::kernels()
+cv::GKernelPackage cv::gapi::core::plaidml::kernels()
{
static auto pkg = cv::gapi::kernels<GPlaidMLAdd, GPlaidMLSub, GPlaidMLAnd, GPlaidMLXor, GPlaidMLOr>();
return pkg;
#else // HAVE_PLAIDML
-cv::gapi::GKernelPackage cv::gapi::core::plaidml::kernels()
+cv::GKernelPackage cv::gapi::core::plaidml::kernels()
{
// Still provide this symbol to avoid linking issues
util::throw_error(std::runtime_error("G-API has been compiled without PlaidML2 support"));
};
-cv::gapi::GKernelPackage cv::gapi::render::ocv::kernels()
+cv::GKernelPackage cv::gapi::render::ocv::kernels()
{
const static auto pkg = cv::gapi::kernels<RenderBGROCVImpl, RenderNV12OCVImpl, RenderFrameOCVImpl>();
return pkg;
out.post(std::move(out_arg));
}
-cv::gapi::GKernelPackage cv::gimpl::streaming::kernels()
+cv::GKernelPackage cv::gimpl::streaming::kernels()
{
return cv::gapi::kernels<Copy>();
}
}
}
-cv::gapi::GKernelPackage cv::gapi::streaming::kernels()
+cv::GKernelPackage cv::gapi::streaming::kernels()
{
return cv::gapi::kernels<GOCVBGR, GOCVY, GOCVUV>();
}
#else
-cv::gapi::GKernelPackage cv::gapi::streaming::kernels()
+cv::GKernelPackage cv::gapi::streaming::kernels()
{
// Still provide this symbol to avoid linking issues
util::throw_error(std::runtime_error("cv::gapi::streaming::kernels() isn't supported in standalone"));
namespace gimpl {
namespace streaming {
-cv::gapi::GKernelPackage kernels();
+cv::GKernelPackage kernels();
struct GCopy final : public cv::detail::NoTag
{
namespace
{
- cv::gapi::GKernelPackage getKernelPackage(cv::GCompileArgs &args)
+ cv::GKernelPackage getKernelPackage(cv::GCompileArgs &args)
{
- auto withAuxKernels = [](const cv::gapi::GKernelPackage& pkg) {
- cv::gapi::GKernelPackage aux_pkg;
+ auto withAuxKernels = [](const cv::GKernelPackage& pkg) {
+ cv::GKernelPackage aux_pkg;
for (const auto &b : pkg.backends()) {
- aux_pkg = combine(aux_pkg, b.priv().auxiliaryKernels());
+ aux_pkg = cv::gapi::combine(aux_pkg, b.priv().auxiliaryKernels());
}
// Always include built-in meta<> and copy implementation
- return combine(pkg,
- aux_pkg,
- cv::gimpl::meta::kernels(),
- cv::gimpl::streaming::kernels());
+ return cv::gapi::combine(pkg,
+ aux_pkg,
+ cv::gimpl::meta::kernels(),
+ cv::gimpl::streaming::kernels());
};
auto has_use_only = cv::gapi::getCompileArg<cv::gapi::use_only>(args);
static auto ocv_pkg =
#if !defined(GAPI_STANDALONE)
- combine(cv::gapi::core::cpu::kernels(),
- cv::gapi::imgproc::cpu::kernels(),
- cv::gapi::video::cpu::kernels(),
- cv::gapi::render::ocv::kernels(),
- cv::gapi::streaming::kernels());
+ cv::gapi::combine(cv::gapi::core::cpu::kernels(),
+ cv::gapi::imgproc::cpu::kernels(),
+ cv::gapi::video::cpu::kernels(),
+ cv::gapi::render::ocv::kernels(),
+ cv::gapi::streaming::kernels());
#else
- cv::gapi::GKernelPackage();
+ cv::GKernelPackage();
#endif // !defined(GAPI_STANDALONE)
- auto user_pkg = cv::gapi::getCompileArg<cv::gapi::GKernelPackage>(args);
- auto user_pkg_with_aux = withAuxKernels(user_pkg.value_or(cv::gapi::GKernelPackage{}));
- return combine(ocv_pkg, user_pkg_with_aux);
+ auto user_pkg = cv::gapi::getCompileArg<cv::GKernelPackage>(args);
+ auto user_pkg_with_aux = withAuxKernels(user_pkg.value_or(cv::GKernelPackage{}));
+ return cv::gapi::combine(ocv_pkg, user_pkg_with_aux);
}
cv::gapi::GNetPackage getNetworkPackage(cv::GCompileArgs &args)
}
template<typename C>
- cv::gapi::GKernelPackage auxKernelsFrom(const C& c) {
- cv::gapi::GKernelPackage result;
+ cv::GKernelPackage auxKernelsFrom(const C& c) {
+ cv::GKernelPackage result;
for (const auto &b : c) {
result = cv::gapi::combine(result, b.priv().auxiliaryKernels());
}
using adeGraphs = std::vector<std::unique_ptr<ade::Graph>>;
// Creates ADE graphs (patterns and substitutes) from pkg's transformations
- void makeTransformationGraphs(const cv::gapi::GKernelPackage& pkg,
+ void makeTransformationGraphs(const cv::GKernelPackage& pkg,
adeGraphs& patterns,
adeGraphs& substitutes) {
const auto& transforms = pkg.get_transformations();
}
}
- void checkTransformations(const cv::gapi::GKernelPackage& pkg,
+ void checkTransformations(const cv::GKernelPackage& pkg,
const adeGraphs& patterns,
const adeGraphs& substitutes) {
const auto& transforms = pkg.get_transformations();
GCompileArgs m_args;
ade::ExecutionEngine m_e;
- cv::gapi::GKernelPackage m_all_kernels;
+ cv::GKernelPackage m_all_kernels;
cv::gapi::GNetPackage m_all_networks;
// Patterns built from transformations
// kernels, but if not, they are handled by the framework itself in
// its optimization/execution passes.
void cv::gimpl::passes::resolveKernels(ade::passes::PassContext &ctx,
- const gapi::GKernelPackage &kernels)
+ const GKernelPackage &kernels)
{
std::unordered_set<cv::gapi::GBackend> active_backends;
gr.metadata().set(ActiveBackends{active_backends});
}
-void cv::gimpl::passes::expandKernels(ade::passes::PassContext &ctx, const gapi::GKernelPackage &kernels)
+void cv::gimpl::passes::expandKernels(ade::passes::PassContext &ctx, const GKernelPackage &kernels)
{
GModel::Graph gr(ctx.graph);
}
}
+// Forward declarations - internal
namespace cv {
+ class GKernelPackage;
-// Forward declarations - internal
namespace gapi {
- class GKernelPackage;
struct GNetPackage;
} // namespace gapi
void storeResultingMeta(ade::passes::PassContext &ctx);
void expandKernels(ade::passes::PassContext &ctx,
- const gapi::GKernelPackage& kernels);
+ const GKernelPackage& kernels);
void bindNetParams(ade::passes::PassContext &ctx,
const gapi::GNetPackage &networks);
void resolveKernels(ade::passes::PassContext &ctx,
- const gapi::GKernelPackage &kernels);
+ const GKernelPackage &kernels);
void fuseIslands(ade::passes::PassContext &ctx);
void syncIslandTags(ade::passes::PassContext &ctx);
void topoSortIslands(ade::passes::PassContext &ctx);
void applyTransformations(ade::passes::PassContext &ctx,
- const gapi::GKernelPackage &pkg,
+ const GKernelPackage &pkg,
const std::vector<std::unique_ptr<ade::Graph>> &preGeneratedPatterns);
void addStreaming(ade::passes::PassContext &ctx);
} // anonymous namespace
void applyTransformations(ade::passes::PassContext& ctx,
- const gapi::GKernelPackage& pkg,
+ const GKernelPackage& pkg,
const std::vector<std::unique_ptr<ade::Graph>>& patterns)
{
const auto& transforms = pkg.get_transformations();
auto customKernel = gapi::kernels<GCPUMinScalar>();
auto kernels = gapi::combine(customKernel,
- params.compileArgs[0].get<gapi::GKernelPackage>());
+ params.compileArgs[0].get<GKernelPackage>());
params.compileArgs = compile_args(kernels);
OptFlowLKTestOutput outOCV { outPtsOCV, outStatusOCV, outErrOCV };
struct GAPIHeteroTest: public ::testing::Test
{
cv::GComputation m_comp;
- cv::gapi::GKernelPackage m_ocv_kernels;
- cv::gapi::GKernelPackage m_fluid_kernels;
- cv::gapi::GKernelPackage m_hetero_kernels;
+ cv::GKernelPackage m_ocv_kernels;
+ cv::GKernelPackage m_fluid_kernels;
+ cv::GKernelPackage m_hetero_kernels;
cv::Mat m_in_mat;
cv::Mat m_out_mat;
struct GAPIBigHeteroTest : public ::testing::TestWithParam<std::array<int, 9>>
{
cv::GComputation m_comp;
- cv::gapi::GKernelPackage m_kernels;
+ cv::GKernelPackage m_kernels;
cv::Mat m_in_mat;
cv::Mat m_out_mat1;
TEST(GetCompileArgTest, PredefinedArgs)
{
- cv::gapi::GKernelPackage pkg = cv::gapi::kernels<GOCVTestOp>();
+ cv::GKernelPackage pkg = cv::gapi::kernels<GOCVTestOp>();
cv::GCompileArg arg0 { pkg },
arg1 { cv::gapi::use_only { pkg } },
arg2 { cv::graph_dump_path { "fake_path" } };
GCompileArgs compArgs { arg0, arg1, arg2 };
- auto kernelPkgOpt = cv::gapi::getCompileArg<cv::gapi::GKernelPackage>(compArgs);
+ auto kernelPkgOpt = cv::gapi::getCompileArg<cv::GKernelPackage>(compArgs);
GAPI_Assert(kernelPkgOpt.has_value());
EXPECT_NO_THROW(kernelPkgOpt.value().lookup("org.opencv.test.test_op"));
default: CV_Assert(false); \
}
- GKernelPackage pkg;
+ cv::GKernelPackage pkg;
switch (interpolation)
{
case INTER_NEAREST: RESIZE_SWITCH(NN); break;
return TMerge3_4lpi::on(src1, src2, src3);
}
-cv::gapi::GKernelPackage fluidTestPackage = cv::gapi::kernels
+cv::GKernelPackage fluidTestPackage = cv::gapi::kernels
<FAddSimple
,FAddCSimple
,FAddScalar
GMat merge3_4lpi(const GMat& src1, const GMat& src2, const GMat& src3);
std::tuple<GMat, GMat, GMat> split3_4lpi(const GMat& src);
-extern cv::gapi::GKernelPackage fluidTestPackage;
+extern cv::GKernelPackage fluidTestPackage;
} // namespace gapi_test_kernels
} // namespace cv
}
};
- cv::gapi::GKernelPackage gpuTestPackage = cv::gapi::kernels
+ cv::GKernelPackage gpuTestPackage = cv::gapi::kernels
<GGPUSymm7x7_test
>();
TEST(KernelPackageTransform, Include)
{
- cv::gapi::GKernelPackage pkg;
+ cv::GKernelPackage pkg;
pkg.include<gmat_in_gmat_out>();
pkg.include<gmat2_in_gmat_out>();
pkg.include<gmat2_in_gmat3_out>();
GMockExecutable island2;
std::shared_ptr<GMockBackendImpl> backend_impl2;
cv::gapi::GBackend backend2;
- cv::gapi::GKernelPackage pkg;
+ cv::GKernelPackage pkg;
cv::Mat in_mat1, in_mat2, out_mat;;
};
};
struct OcvKernels {
- cv::gapi::GKernelPackage kernels() { return cv::gapi::imgproc::cpu::kernels(); }
+ cv::GKernelPackage kernels() { return cv::gapi::imgproc::cpu::kernels(); }
};
struct FluidKernels {
- cv::gapi::GKernelPackage kernels() { return cv::gapi::imgproc::fluid::kernels(); }
+ cv::GKernelPackage kernels() { return cv::gapi::imgproc::fluid::kernels(); }
};
struct RMatIntTestCpuRef : public
return cap;
}
- cv::gapi::GKernelPackage getKernelPackage(KernelPackage pkg_kind)
+ cv::GKernelPackage getKernelPackage(KernelPackage pkg_kind)
{
using namespace cv::gapi;
switch (pkg_kind)
return args;
}
- cv::gapi::GKernelPackage pkg;
+ cv::GKernelPackage pkg;
cv::optional<size_t> cap;
};
cv::GMat blur;
cv::GArray<int> vec;
cv::GOpaque<int> opq;
- cv::gapi::GKernelPackage pkg;
+ cv::GKernelPackage pkg;
cv::Mat in_mat;
};
//! [graph_decl_apply]
//! [apply_with_param]
- cv::gapi::GKernelPackage kernels = cv::gapi::combine
+ cv::GKernelPackage kernels = cv::gapi::combine
(cv::gapi::core::fluid::kernels(),
cv::gapi::imgproc::fluid::kernels());
sobelEdge.apply(input, output, cv::compile_args(kernels));
cv::imwrite(argv[2], output);
//! [kernels_snippet]
- cv::gapi::GKernelPackage pkg = cv::gapi::kernels
+ cv::GKernelPackage pkg = cv::gapi::kernels
< CustomAdd
, CustomFilter2D
, CustomRGB2YUV
//! [kernel_pkg_proper]
//! [kernel_pkg]
// Prepare the kernel package and run the graph
- cv::gapi::GKernelPackage fluid_kernels = cv::gapi::combine // Define a custom kernel package:
+ cv::GKernelPackage fluid_kernels = cv::gapi::combine // Define a custom kernel package:
(cv::gapi::core::fluid::kernels(), // ...with Fluid Core kernels
cv::gapi::imgproc::fluid::kernels()); // ...and Fluid ImgProc kernels
//! [kernel_pkg]
projects / platform / upstream / opencv.git / commitdiff