cv::detail namespace#

Namespaces#

Namespace
namespace contrib_feature
namespace kalman_filters
namespace online_boosting
namespace tbm
namespace tld
namespace tracking

Classes#

Name
`struct` `CameraParams`
`struct` `CompileArgTag`
`struct` `CompileArgTag< GFluidOutputRois >`
`struct` `CompileArgTag< GFluidParallelFor >`
`struct` `CompileArgTag< GFluidParallelOutputRois >`
`struct` `CompileArgTag< cv::GKernelPackage >`
`struct` `CompileArgTag< cv::gapi::GNetPackage >`
`struct` `CompileArgTag< cv::gapi::calib3d::cpu::StereoInitParam >`
`struct` `CompileArgTag< cv::gapi::onnx::WorkloadTypeONNXPtr >`
`struct` `CompileArgTag< cv::gapi::ot::ObjectTrackerParams >`
`struct` `CompileArgTag< cv::gapi::plaidml::config >`
`struct` `CompileArgTag< cv::gapi::streaming::queue_capacity >`
`struct` `CompileArgTag< cv::gapi::use_only >`
`struct` `CompileArgTag< cv::gapi::video::BackgroundSubtractorParams >`
`struct` `CompileArgTag< cv::gapi::wip::draw::freetype_font >`
`struct` `CompileArgTag< cv::gapi::wip::ov::WorkloadTypeOVPtr >`
`struct` `CompileArgTag< cv::gapi::wip::ov::benchmark_mode >`
`struct` `CompileArgTag< cv::graph_dump_path >`
`struct` `CompileArgTag< cv::use_threaded_executor >`
`struct` `CompileArgTag< gapi::oak::ColorCameraParams >`
`struct` `CompileArgTag< gapi::oak::EncoderConfig >`
`struct` `CompileArgTag< gapi::streaming::sync_policy >`
`struct` `CompressedRectilinearPortraitProjector`
`struct` `CompressedRectilinearProjector`
`struct` `CylindricalPortraitProjector`
`struct` `CylindricalProjector`
`struct` `ExtractArgsCallback`
`struct` `ExtractMetaCallback`
`struct` `FisheyeProjector`
`struct` `FluidCallHelper`
`struct` `FluidCallHelper< Impl, std::tuple< Ins... >, std::tuple< Outs... >, UseScratch >`
`struct` `GCompoundCallHelper`
`struct` `GCompoundCallHelper< Impl, std::tuple< Ins... >, std::tuple< Outs... > >`
`struct` `GCompoundContext`
`struct` `GObtainCtor`
`struct` `GOpaqueTraits`
`struct` `GOpaqueTraits< bool >`
`struct` `GOpaqueTraits< cv::GMat >`
`struct` `GOpaqueTraits< cv::Mat >`
`struct` `GOpaqueTraits< cv::Point2f >`
`struct` `GOpaqueTraits< cv::Point3f >`
`struct` `GOpaqueTraits< cv::Point >`
`struct` `GOpaqueTraits< cv::Rect >`
`struct` `GOpaqueTraits< cv::Scalar >`
`struct` `GOpaqueTraits< cv::Size >`
`struct` `GOpaqueTraits< cv::gapi::wip::draw::Prim >`
`struct` `GOpaqueTraits< double >`
`struct` `GOpaqueTraits< float >`
`struct` `GOpaqueTraits< int64_t >`
`struct` `GOpaqueTraits< std::string >`
`struct` `GOpaqueTraits< uint64_t >`
`struct` `GTypeOf`
`struct` `GTypeOf< cv::Mat >`
`struct` `GTypeOf< cv::MediaFrame >`
`struct` `GTypeOf< cv::RMat >`
`struct` `GTypeOf< cv::Scalar >`
`struct` `GTypeOf< cv::UMat >`
`struct` `GTypeOf< cv::gapi::wip::IStreamSource::Ptr >`
`struct` `GTypeOf< std::vector< U > >`
`struct` `GTypeTraits`
`struct` `GTypeTraits< cv::GArray< T > >`
`struct` `GTypeTraits< cv::GFrame >`
`struct` `GTypeTraits< cv::GMatP >`
`struct` `GTypeTraits< cv::GMat >`
`struct` `GTypeTraits< cv::GOpaque< T > >`
`struct` `GTypeTraits< cv::GScalar >`
`struct` `GraphEdge`
`struct` `ImageFeatures`
`struct` `InOutInfo`
`struct` `InferROITraits`
`struct` `InferROITraits< GInferListBase >`
`struct` `InferROITraits< GInferROIBase >`
`struct` `KernelTag`
`struct` `MatchesInfo`
`struct` `MercatorProjector`
`struct` `MetaHelper`
`struct` `MetaHelper< K, std::tuple< Ins... >, Out >`
`struct` `MetaHelper< K, std::tuple< Ins... >, std::tuple< Outs... > >`
`struct` `MetaType`
`struct` `MetaType< cv::GArray< U > >`
`struct` `MetaType< cv::GFrame >`
`struct` `MetaType< cv::GMatP >`
`struct` `MetaType< cv::GMat >`
`struct` `MetaType< cv::GOpaque< U > >`
`struct` `MetaType< cv::GScalar >`
`struct` `NoTag`
`struct` `OCLCallHelper`
`struct` `OCLCallHelper< Impl, std::tuple< Ins... >, std::tuple< Outs... > >::call_and_postprocess`
`struct` `OCLCallHelper< Impl, std::tuple< Ins... >, std::tuple< Outs... > >`
`struct` `OCVCallHelper`
`struct` `OCVCallHelper< Impl, std::tuple< Ins... >, std::tuple< Outs... > >::call_and_postprocess`
`struct` `OCVCallHelper< Impl, std::tuple< Ins... >, std::tuple< Outs... > >`
`struct` `OCVSetupHelper`
`struct` `OCVSetupHelper< Impl, std::tuple< Ins... > >`
`struct` `OCVStCallHelper`
`struct` `OCVStCallHelper< Impl, std::tuple< Ins... >, std::tuple< Outs... > >::call_and_postprocess`
`struct` `OCVStCallHelper< Impl, std::tuple< Ins... >, std::tuple< Outs... > >`
`struct` `OptRef`
`struct` `PaniniPortraitProjector`
`struct` `PaniniProjector`
`struct` `PlaidMLCallHelper`
`struct` `PlaidMLCallHelper< Impl, std::tuple< Ins... >, std::tuple< Outs... > >`
`struct` `PlanePortraitProjector`
`struct` `PlaneProjector`
`struct` `ProjectorBase`
`struct` `ProtoToMeta`
`struct` `ProtoToMeta< cv::GArray< U > >`
`struct` `ProtoToMeta< cv::GMat >`
`struct` `ProtoToMeta< cv::GOpaque< U > >`
`struct` `ProtoToMeta< cv::GScalar >`
`struct` `ProtoToParam`
`struct` `ProtoToParam< cv::GArray< U > >`
`struct` `ProtoToParam< cv::GArray< cv::GMat > >`
`struct` `ProtoToParam< cv::GMat >`
`struct` `ProtoToParam< cv::GOpaque< U > >`
`struct` `ProtoToParam< cv::GScalar >`
`struct` `SphericalPortraitProjector`
`struct` `SphericalProjector`
`struct` `StereographicProjector`
`struct` `TransHelper`
`struct` `TransHelper< K, std::tuple< Ins... >, Out >`
`struct` `TransformTag`
`struct` `TransverseMercatorProjector`
`struct` `TypeHint`
`struct` `TypeHintBase`
`struct` `WrapValue`
`struct` `Yield`
`struct` `Yield< GFrame >`
`struct` `Yield< cv::GArray< U > >`
`struct` `Yield< cv::GMatP >`
`struct` `Yield< cv::GMat >`
`struct` `Yield< cv::GOpaque< U > >`
`struct` `Yield< cv::GScalar >`
`struct` `accepted_infer_types`
`struct` `callCustomGetBorder`
`struct` `callCustomGetBorder< false, Impl >`
`struct` `callCustomGetBorder< true, Impl >`
`struct` `contains_shape_field`
`struct` `contains_shape_field< TaggedTypeCandidate, void_t< decltype(TaggedTypeCandidate::shape)> >`
`struct` `flatten_g`
`struct` `flatten_g< cv::GMat >`
`struct` `flatten_g< cv::GScalar >`
`struct` `fluid_get_in`
`struct` `fluid_get_in< cv::GArray< U > >`
`struct` `fluid_get_in< cv::GMat >`
`struct` `fluid_get_in< cv::GOpaque< U > >`
`struct` `fluid_get_in< cv::GScalar >`
`struct` `get_border_helper`
`struct` `get_border_helper< false, Impl, Ins... >`
`struct` `get_border_helper< true, Impl, Ins... >`
`struct` `get_compound_in`
`struct` `get_compound_in< cv::GArray< U > >`
`struct` `get_compound_in< cv::GMatP >`
`struct` `get_compound_in< cv::GOpaque< U > >`
`struct` `get_in`
`struct` `get_in< cv::GArray< U > >`
`struct` `get_in< cv::GArray< cv::GArray< U > > >`
`struct` `get_in< cv::GArray< cv::GMat > >`
`struct` `get_in< cv::GArray< cv::GScalar > >`
`struct` `get_in< cv::GFrame >`
`struct` `get_in< cv::GMatP >`
`struct` `get_in< cv::GMat >`
`struct` `get_in< cv::GOpaque< U > >`
`struct` `get_in< cv::GOpaque< cv::GMat > >`
`struct` `get_in< cv::GOpaque< cv::GScalar > >`
`struct` `get_in< cv::GScalar >`
`struct` `get_out`
`struct` `get_out< cv::GArray< U > >`
`struct` `get_out< cv::GArray< cv::GArray< U > > >`
`struct` `get_out< cv::GArray< cv::GMat > >`
`struct` `get_out< cv::GFrame >`
`struct` `get_out< cv::GMatP >`
`struct` `get_out< cv::GMat >`
`struct` `get_out< cv::GOpaque< U > >`
`struct` `get_out< cv::GScalar >`
`struct` `get_window_helper`
`struct` `get_window_helper< false, Impl, Ins... >`
`struct` `get_window_helper< true, Impl, Ins... >`
`struct` `has_Window`
`struct` `has_custom_wrap`
`struct` `has_gshape`
`struct` `in_variant`
`struct` `is_gmat_type`
`struct` `is_meta_descr`
`struct` `is_meta_descr< GArrayDesc >`
`struct` `is_meta_descr< GMatDesc >`
`struct` `is_meta_descr< GOpaqueDesc >`
`struct` `is_meta_descr< GScalarDesc >`
`struct` `last_type`
`struct` `ocl_get_in`
`struct` `ocl_get_in< cv::GArray< U > >`
`struct` `ocl_get_in< cv::GFrame >`
`struct` `ocl_get_in< cv::GMat >`
`struct` `ocl_get_in< cv::GOpaque< U > >`
`struct` `ocl_get_in< cv::GScalar >`
`struct` `ocl_get_out`
`struct` `ocl_get_out< cv::GArray< U > >`
`struct` `ocl_get_out< cv::GMat >`
`struct` `ocl_get_out< cv::GOpaque< U > >`
`struct` `ocl_get_out< cv::GScalar >`
`struct` `plaidml_get_in`
`struct` `plaidml_get_in< cv::GMat >`
`struct` `plaidml_get_out`
`struct` `plaidml_get_out< cv::GMat >`
`struct` `scratch_helper`
`struct` `scratch_helper< false, Impl, Ins... >`
`struct` `scratch_helper< true, Impl, Ins... >`
`struct` `tracked_cv_mat`
`struct` `tracked_cv_umat`
`struct` `valid_infer2_types`
`struct` `valid_infer2_types< std::tuple< Ns... >, std::tuple<> >`
`struct` `valid_infer2_types< std::tuple<>, std::tuple< Ts... > >`
`struct` `wref_spec`
`class` `AffineBasedEstimator`
`class` `AffineBestOf2NearestMatcher`
`class` `AffineWarper`
`class` `BasicOpaqueRef`
`class` `BasicVectorRef`
`class` `BestOf2NearestMatcher`
`class` `BestOf2NearestRangeMatcher`
`class` `Blender`
`class` `BlocksChannelsCompensator`
`class` `BlocksCompensator`
`class` `BlocksGainCompensator`
`class` `BundleAdjusterAffine`
`class` `BundleAdjusterAffinePartial`
`class` `BundleAdjusterBase`
`class` `BundleAdjusterRay`
`class` `BundleAdjusterReproj`
`class` `ChannelsCompensator`
`class` `CompressedRectilinearPortraitWarper`
`class` `CompressedRectilinearWarper`
`class` `CylindricalPortraitWarper`
`class` `CylindricalWarper`
`class` `CylindricalWarperGpu`
`class` `DisjointSets`
`class` `DpSeamFinder`
`class` `Estimator`
`class` `ExposureCompensator`
`class` `FeatherBlender`
`class` `FeaturesMatcher`
`class` `FisheyeWarper`
`class` `GArrayU`
`class` `GCompoundKernel`
`class` `GCompoundKernelImpl`
`class` `GInferInputsTyped`
`class` `GInferOutputsTyped`
`class` `GOpaqueU`
`class` `GainCompensator`
`class` `Graph`
`class` `GraphCutSeamFinder`
`class` `GraphCutSeamFinderBase`
`class` `HomographyBasedEstimator`
`class` `KernelTypeMedium`
`class` `KernelTypeMedium< K, std::function< R(Args...)> >`
`class` `KernelTypeMedium< K, std::function< std::tuple< R... >(Args...)> >`
`class` `LevMarqBackend`
`class` `LevMarqBase`
`class` `LightGlueFeaturesMatcher`
`class` `MercatorWarper`
`class` `MultiBandBlender`
`class` `NoBundleAdjuster`
`class` `NoExposureCompensator`
`class` `NoSeamFinder`
`class` `OpaqueRef`
`class` `OpaqueRefT`
`class` `PairwiseSeamFinder`
`class` `PaniniPortraitWarper`
`class` `PaniniWarper`
`class` `PlanePortraitWarper`
`class` `PlaneWarper`
`class` `PlaneWarperGpu`
`class` `PoseGraph`
`class` `RotationWarper`
`class` `RotationWarperBase`
`class` `SeamFinder`
`class` `SphericalPortraitWarper`
`class` `SphericalWarper`
`class` `SphericalWarperGpu`
`class` `StereographicWarper`
`class` `Submap`
`class` `SubmapManager`
`class` `Timelapser`
`class` `TimelapserCrop`
`class` `TransverseMercatorWarper`
`class` `VectorRef`
`class` `VectorRefT`
`class` `VoronoiSeamFinder`
`class` `UkfSystemModel`
`class` `UnscentedKalmanFilter`
`class` `UnscentedKalmanFilterParams`
`class` `WeakClassifierHaarFeature`

Enumerations#

enum class cv::detail::ArgKind {
    cv::detail::ArgKind::OPAQUE_VAL,
    cv::detail::ArgKind::GOBJREF,
    cv::detail::ArgKind::GMAT,
    cv::detail::ArgKind::GMATP,
    cv::detail::ArgKind::GFRAME,
    cv::detail::ArgKind::GSCALAR,
    cv::detail::ArgKind::GARRAY,
    cv::detail::ArgKind::GOPAQUE
}

enum class cv::detail::OpaqueKind {
    cv::detail::OpaqueKind::CV_UNKNOWN,
    cv::detail::OpaqueKind::CV_BOOL,
    cv::detail::OpaqueKind::CV_INT,
    cv::detail::OpaqueKind::CV_INT64,
    cv::detail::OpaqueKind::CV_DOUBLE,
    cv::detail::OpaqueKind::CV_FLOAT,
    cv::detail::OpaqueKind::CV_UINT64,
    cv::detail::OpaqueKind::CV_STRING,
    cv::detail::OpaqueKind::CV_POINT,
    cv::detail::OpaqueKind::CV_POINT2F,
    cv::detail::OpaqueKind::CV_POINT3F,
    cv::detail::OpaqueKind::CV_SIZE,
    cv::detail::OpaqueKind::CV_RECT,
    cv::detail::OpaqueKind::CV_SCALAR,
    cv::detail::OpaqueKind::CV_MAT,
    cv::detail::OpaqueKind::CV_DRAW_PRIM
}

enum cv::detail::WaveCorrectKind {
    cv::detail::WAVE_CORRECT_HORIZ,
    cv::detail::WAVE_CORRECT_VERT,
    cv::detail::WAVE_CORRECT_AUTO
}

Typedef Documentation#

are_meta_descrs#

template<typename ...Ts> using cv::detail::are_meta_descrs = all_satisfy<is_meta_descr, Ts...>#

are_meta_descrs_but_last#

template<typename ...Ts> using cv::detail::are_meta_descrs_but_last = all_satisfy<is_meta_descr, typename all_but_last<Ts...>::type>#

ConstructOpaque#

using cv::detail::ConstructOpaque = std::function<void(OpaqueRef&)>#

ConstructVec#

using cv::detail::ConstructVec = std::function<void(VectorRef&)>#

g_type_of_t#

template<class T> using cv::detail::g_type_of_t = typename GTypeOf<T>::type#

GOpaqueTraitsArrayTypes#

using cv::detail::GOpaqueTraitsArrayTypes = std::tuple<int, double, float, uint64_t, bool, std::string, cv::Size, cv::Scalar, cv::Point, cv::Point2f, cv::Point3f, cv::Mat, cv::Rect, cv::gapi::wip::draw::Prim>#

GOpaqueTraitsOpaqueTypes#

using cv::detail::GOpaqueTraitsOpaqueTypes = std::tuple<int, double, float, uint64_t, bool, std::string, cv::Size, cv::Point, cv::Point2f, cv::Point3f, cv::Rect, cv::gapi::wip::draw::Prim>#

HostCtor#

using cv::detail::HostCtor = util::variant<util::monostate, detail::ConstructVec, detail::ConstructOpaque>#

is_compile_arg#

template<typename T> using cv::detail::is_compile_arg = std::is_same<GCompileArg, typename std::decay<T>::type>#

is_garg#

template<typename T> using cv::detail::is_garg = std::is_same<GArg, typename std::decay<T>::type>#

is_nongapi_type#

template<typename T> using cv::detail::is_nongapi_type = std::is_same<T, typename MetaType<T>::type>#

last_type_t#

template<typename ...Ts> using cv::detail::last_type_t = typename last_type<Ts...>::type#

OptionalOpaqueRef#

using cv::detail::OptionalOpaqueRef = OptRef<cv::detail::OpaqueRef>#

OptionalVectorRef#

using cv::detail::OptionalVectorRef = OptRef<cv::detail::VectorRef>#

ProtoToMetaT#

template<typename T> using cv::detail::ProtoToMetaT = typename ProtoToMeta<T>::type#

ProtoToParamT#

template<typename T> using cv::detail::ProtoToParamT = typename ProtoToParam<T>::type#

valid_infer_types#

template<typename ...Ts> using cv::detail::valid_infer_types = all_satisfy<accepted_infer_types, Ts...>#

wrap_gapi_helper#

template<typename T> using cv::detail::wrap_gapi_helper = WrapValue<typename std::decay<T>::type>#

wrap_host_helper#

template<typename T> using cv::detail::wrap_host_helper = WrapValue<typename std::decay<g_type_of_t<T>>::type>#

Enumeration Type Documentation#

ArgKind#

enum class cv::detail::ArgKind

OPAQUE_VAL
Python: cv.detail.ArgKind_OPAQUE_VAL

GOBJREF
Python: cv.detail.ArgKind_GOBJREF

GMAT
Python: cv.detail.ArgKind_GMAT

GMATP
Python: cv.detail.ArgKind_GMATP

GFRAME
Python: cv.detail.ArgKind_GFRAME

GSCALAR
Python: cv.detail.ArgKind_GSCALAR

GARRAY
Python: cv.detail.ArgKind_GARRAY

GOPAQUE
Python: cv.detail.ArgKind_GOPAQUE

OpaqueKind#

enum class cv::detail::OpaqueKind

CV_UNKNOWN
Python: cv.detail.OpaqueKind_CV_UNKNOWN

CV_BOOL
Python: cv.detail.OpaqueKind_CV_BOOL

CV_INT
Python: cv.detail.OpaqueKind_CV_INT

CV_INT64
Python: cv.detail.OpaqueKind_CV_INT64

CV_DOUBLE
Python: cv.detail.OpaqueKind_CV_DOUBLE

CV_FLOAT
Python: cv.detail.OpaqueKind_CV_FLOAT

CV_UINT64
Python: cv.detail.OpaqueKind_CV_UINT64

CV_STRING
Python: cv.detail.OpaqueKind_CV_STRING

CV_POINT
Python: cv.detail.OpaqueKind_CV_POINT

CV_POINT2F
Python: cv.detail.OpaqueKind_CV_POINT2F

CV_POINT3F
Python: cv.detail.OpaqueKind_CV_POINT3F

CV_SIZE
Python: cv.detail.OpaqueKind_CV_SIZE

CV_RECT
Python: cv.detail.OpaqueKind_CV_RECT

CV_SCALAR
Python: cv.detail.OpaqueKind_CV_SCALAR

CV_MAT
Python: cv.detail.OpaqueKind_CV_MAT

CV_DRAW_PRIM
Python: cv.detail.OpaqueKind_CV_DRAW_PRIM

WaveCorrectKind#

enum cv::detail::WaveCorrectKind

WAVE_CORRECT_HORIZ
Python: cv.detail.WAVE_CORRECT_HORIZ

WAVE_CORRECT_VERT
Python: cv.detail.WAVE_CORRECT_VERT

WAVE_CORRECT_AUTO
Python: cv.detail.WAVE_CORRECT_AUTO

Function Documentation#

constructGraphOutputs()#

void cv::detail::constructGraphOutputs(const cv::GTypesInfo &out_info, cv::GRunArgs &args, cv::GRunArgsP &outs)#

get_in_meta()#

Warning

doxygenfunction: Unable to resolve function “cv::detail::get_in_meta” with arguments (const GMetaArgs&, const GArgs&, int) in doxygen xml output for project “opencv” from directory: /media/abhishek/hugedrive21/opencv_abhishek/build/doc/doxygen/xml_for_sphinx. Potential matches:

- template<typename T> std::enable_if<!is_nongapi_type<T>::value, typenameMetaType<T>::type>::type get_in_meta(const GMetaArgs &in_meta, const GArgs&, int idx)
- template<typename T> std::enable_if<is_nongapi_type<T>::value, T>::type get_in_meta(const GMetaArgs&, const GArgs &in_args, int idx)

get_in_meta()#

Warning

doxygenfunction: Unable to resolve function “cv::detail::get_in_meta” with arguments (const GMetaArgs&, const GArgs&, int) in doxygen xml output for project “opencv” from directory: /media/abhishek/hugedrive21/opencv_abhishek/build/doc/doxygen/xml_for_sphinx. Potential matches:

- template<typename T> std::enable_if<!is_nongapi_type<T>::value, typenameMetaType<T>::type>::type get_in_meta(const GMetaArgs &in_meta, const GArgs&, int idx)
- template<typename T> std::enable_if<is_nongapi_type<T>::value, T>::type get_in_meta(const GMetaArgs&, const GArgs &in_args, int idx)

getGOut_impl()#

template<typename ...Ts, int... Indexes> static GProtoOutputArgs cv::detail::getGOut_impl(const std::tuple<Ts...> &ts, detail::Seq<Indexes...>)#

inferGenericROI()#

template<typename InferType> InferROITraits<InferType>::outType cv::detail::inferGenericROI(const std::string &tag, const typename InferROITraits<InferType>::inType &in, const cv::GInferInputs &inputs)#

make_default()#

Warning

doxygenfunction: Unable to resolve function “cv::detail::make_default” with arguments “()”. Candidate function could not be parsed. Parsing error is Invalid C++ declaration: Expecting “,” or “)” in parameters-and-qualifiers, got “{”. [error at 2] (T{}) make_default() –^

makeCall()#

template<typename InferT> std::shared_ptr<cv::GCall> cv::detail::makeCall(const std::string &tag, std::vector<cv::GArg> &&args, std::vector<std::string> &&names, cv::GKinds &&kinds)#

packArgs()#

template<typename ...Ts> inline GProtoArgs cv::detail::packArgs(Ts... args)#

postprocess()#

template<typename ...Outputs> void cv::detail::postprocess(Outputs&... outs)#

postprocess_ocl()#

template<typename ...Outputs> void cv::detail::postprocess_ocl(Outputs&... outs)#

renderPointsNormals()#

void cv::detail::renderPointsNormals(InputArray _points, InputArray _normals, OutputArray image, cv::Vec3f lightLoc)#

renderPointsNormalsColors()#

void cv::detail::renderPointsNormalsColors(InputArray _points, InputArray _normals, InputArray _colors, OutputArray image)#

strip()#

template<typename T> gapi::GNetParam cv::detail::strip(T &&t)#

unpackBlobs()#

inline void cv::detail::unpackBlobs(const cv::GInferInputs::Map &blobs, std::vector<cv::GArg> &args, std::vector<std::string> &names, cv::GKinds &kinds)#

wrap_opt_arg()#

template<> inline GOptRunArgP cv::detail::wrap_opt_arg(optional<cv::Mat> &m)#

wrap_opt_arg()#

template<> inline GOptRunArgP cv::detail::wrap_opt_arg(optional<cv::MediaFrame> &f)#

wrap_opt_arg()#

template<> inline GOptRunArgP cv::detail::wrap_opt_arg(optional<cv::RMat> &m)#

wrap_opt_arg()#

template<> inline GOptRunArgP cv::detail::wrap_opt_arg(optional<cv::Scalar> &s)#

wrap_opt_arg()#

template<typename T> inline GOptRunArgP cv::detail::wrap_opt_arg(optional<std::vector<T>> &arg)#

wrap_opt_arg()#

template<typename T> inline GOptRunArgP cv::detail::wrap_opt_arg(optional<T> &arg)#

autoDetectWaveCorrectKind()#

WaveCorrectKind cv::detail::autoDetectWaveCorrectKind(const std::vector<Mat> &rmats)#

Tries to detect the wave correction kind depending on whether a panorama spans horizontally or vertically.

Parameters:: rmats – Camera rotation matrices.
Returns:: The correction kind to use for this panorama

calibrateRotatingCamera()#

bool cv::detail::calibrateRotatingCamera(const std::vector<Mat> &Hs, Mat &K)#

computeImageFeatures()#

void cv::detail::computeImageFeatures(const Ptr<Feature2D> &featuresFinder, InputArray image, ImageFeatures &features, InputArray mask = noArray())#

Parameters:

featuresFinder –
image –
features –
mask –

computeImageFeatures()#

void cv::detail::computeImageFeatures(const Ptr<Feature2D> &featuresFinder, InputArrayOfArrays images, std::vector<ImageFeatures> &features, InputArrayOfArrays masks = noArray())#

Parameters:

featuresFinder –
images –
features –
masks –

createLaplacePyr()#

void cv::detail::createLaplacePyr(InputArray img, int num_levels, std::vector<UMat> &pyr)#

createLaplacePyrGpu()#

void cv::detail::createLaplacePyrGpu(InputArray img, int num_levels, std::vector<UMat> &pyr)#

createWeightMap()#

void cv::detail::createWeightMap(InputArray mask, float sharpness, InputOutputArray weight)#

estimateFocal()#

void cv::detail::estimateFocal(const std::vector<ImageFeatures> &features, const std::vector<MatchesInfo> &pairwise_matches, std::vector<double> &focals)#

Estimates focal lengths for each given camera.

Parameters:

features – Features of images.
pairwise_matches – Matches between all image pairs.
focals – Estimated focal lengths for each camera.

findMaxSpanningTree()#

void cv::detail::findMaxSpanningTree(int num_images, const std::vector<MatchesInfo> &pairwise_matches, Graph &span_tree, std::vector<int> &centers)#

focalsFromHomography()#

void cv::detail::focalsFromHomography(const Mat &H, double &f0, double &f1, bool &f0_ok, bool &f1_ok)#

Tries to estimate focal lengths from the given homography under the assumption that the camera undergoes rotations around its centre only.

See “Construction of Panoramic Image Mosaics with Global and Local Alignment” by Heung-Yeung Shum and Richard Szeliski.

Parameters:

H – Homography.
f0 – Estimated focal length along X axis.
f1 – Estimated focal length along Y axis.
f0_ok – True, if f0 was estimated successfully, false otherwise.
f1_ok – True, if f1 was estimated successfully, false otherwise.

leaveBiggestComponent()#

std::vector<int> cv::detail::leaveBiggestComponent(std::vector<ImageFeatures> &features, std::vector<MatchesInfo> &pairwise_matches, float conf_threshold)#

matchesGraphAsString()#

String cv::detail::matchesGraphAsString(std::vector<String> &paths, std::vector<MatchesInfo> &pairwise_matches, float conf_threshold)#

normalizeUsingWeightMap()#

void cv::detail::normalizeUsingWeightMap(InputArray weight, InputOutputArray src)#

overlapRoi()#

bool cv::detail::overlapRoi(Point tl1, Point tl2, Size sz1, Size sz2, Rect &roi)#

restoreImageFromLaplacePyr()#

void cv::detail::restoreImageFromLaplacePyr(std::vector<UMat> &pyr)#

restoreImageFromLaplacePyrGpu()#

void cv::detail::restoreImageFromLaplacePyrGpu(std::vector<UMat> &pyr)#

resultRoi()#

Rect cv::detail::resultRoi(const std::vector<Point> &corners, const std::vector<Size> &sizes)#

resultRoi()#

Rect cv::detail::resultRoi(const std::vector<Point> &corners, const std::vector<UMat> &images)#

resultRoiIntersection()#

Rect cv::detail::resultRoiIntersection(const std::vector<Point> &corners, const std::vector<Size> &sizes)#

resultTl()#

Point cv::detail::resultTl(const std::vector<Point> &corners)#

selectRandomSubset()#

void cv::detail::selectRandomSubset(int count, int size, std::vector<int> &subset)#

stitchingLogLevel()#

int &cv::detail::stitchingLogLevel()#

waveCorrect()#

void cv::detail::waveCorrect(std::vector<Mat> &rmats, WaveCorrectKind kind)#

Tries to make panorama more horizontal (or vertical).

Parameters:

rmats – Camera rotation matrices.
kind – Correction kind, see detail::WaveCorrectKind.