template class cv::Scalar_

Overview

Template class for a 4-element vector derived from Vec. Moreā€¦

#include <types.hpp>

template <typename _Tp>
class Scalar_: public cv::Vec
{
public:
    // construction

    Scalar_();

    Scalar_(
        _Tp v0,
        _Tp v1,
        _Tp v2 = 0,
        _Tp v3 = 0
        );

    Scalar_(_Tp v0);

    template <
        typename _Tp2,
        int cn
        >
    Scalar_(const Vec<_Tp2, cn>& v);

    // methods

    Scalar_<_Tp>
    conj() const;

    bool
    isReal() const;

    Scalar_<_Tp>
    mul(
        const Scalar_<_Tp>& a,
        double scale = 1
        ) const;

    template <typename T2>
    operator Scalar_< T2 >() const;

    static
    Scalar_<_Tp>
    all(_Tp v0);
};

// direct descendants

class Color;

Inherited Members

public:
    // typedefs

    typedef Matx<_Tp, shortdim, 1> diag_type;
    typedef Matx<_Tp, m, n> mat_type;
    typedef _Tp value_type;
    typedef _Tp value_type;

    // enums

    enum
    {
        depth    = DataType<_Tp>::depth,
        rows     = m,
        cols     = n,
        channels = rows*cols,
        type     = CV_MAKETYPE(depth, channels),
        shortdim = (m <n ? m : n),
    };

    enum
    {
        depth    = Matx<_Tp, cn, 1>::depth,
        channels = cn,
        type     = CV_MAKETYPE(depth, channels),
    };

    // fields

    _Tp val[m *n];

    // methods

    template <
        typename _Tp1,
        typename _Tp2,
        int m,
        int n
        >
    static
    Matx<_Tp1, m, n>&
    operator+=(
        Matx<_Tp1, m, n>& a,
        const Matx<_Tp2, m, n>& b
        );

    template <
        typename _Tp1,
        typename _Tp2,
        int m,
        int n
        >
    static
    Matx<_Tp1, m, n>&
    operator-=(
        Matx<_Tp1, m, n>& a,
        const Matx<_Tp2, m, n>& b
        );

    template <
        typename _Tp,
        int m,
        int n
        >
    static
    Matx<_Tp, m, n>
    operator+(
        const Matx<_Tp, m, n>& a,
        const Matx<_Tp, m, n>& b
        );

    template <
        typename _Tp,
        int m,
        int n
        >
    static
    Matx<_Tp, m, n>
    operator-(
        const Matx<_Tp, m, n>& a,
        const Matx<_Tp, m, n>& b
        );

    template <
        typename _Tp,
        int m,
        int n
        >
    static
    Matx<_Tp, m, n>&
    operator*=(
        Matx<_Tp, m, n>& a,
        int alpha
        );

    template <
        typename _Tp,
        int m,
        int n
        >
    static
    Matx<_Tp, m, n>&
    operator*=(
        Matx<_Tp, m, n>& a,
        float alpha
        );

    template <
        typename _Tp,
        int m,
        int n
        >
    static
    Matx<_Tp, m, n>&
    operator*=(
        Matx<_Tp, m, n>& a,
        double alpha
        );

    template <
        typename _Tp,
        int m,
        int n
        >
    static
    Matx<_Tp, m, n>
    operator*(
        const Matx<_Tp, m, n>& a,
        int alpha
        );

    template <
        typename _Tp,
        int m,
        int n
        >
    static
    Matx<_Tp, m, n>
    operator*(
        const Matx<_Tp, m, n>& a,
        float alpha
        );

    template <
        typename _Tp,
        int m,
        int n
        >
    static
    Matx<_Tp, m, n>
    operator*(
        const Matx<_Tp, m, n>& a,
        double alpha
        );

    template <
        typename _Tp,
        int m,
        int n
        >
    static
    Matx<_Tp, m, n>
    operator*(
        int alpha,
        const Matx<_Tp, m, n>& a
        );

    template <
        typename _Tp,
        int m,
        int n
        >
    static
    Matx<_Tp, m, n>
    operator*(
        float alpha,
        const Matx<_Tp, m, n>& a
        );

    template <
        typename _Tp,
        int m,
        int n
        >
    static
    Matx<_Tp, m, n>
    operator*(
        double alpha,
        const Matx<_Tp, m, n>& a
        );

    template <
        typename _Tp,
        int m,
        int n
        >
    static
    Matx<_Tp, m, n>
    operator-(const Matx<_Tp, m, n>& a);

    template <
        typename _Tp,
        int m,
        int n,
        int l
        >
    static
    Matx<_Tp, m, n>
    operator*(
        const Matx<_Tp, m, l>& a,
        const Matx<_Tp, l, n>& b
        );

    template <
        typename _Tp,
        int m,
        int n
        >
    static
    Vec<_Tp, m>
    operator*(
        const Matx<_Tp, m, n>& a,
        const Vec<_Tp, n>& b
        );

    template <
        typename _Tp,
        int m,
        int n
        >
    static
    bool
    operator==(
        const Matx<_Tp, m, n>& a,
        const Matx<_Tp, m, n>& b
        );

    template <
        typename _Tp,
        int m,
        int n
        >
    static
    bool
    operator!=(
        const Matx<_Tp, m, n>& a,
        const Matx<_Tp, m, n>& b
        );

    Matx<_Tp, m, 1>
    col(int i) const;

    double
    ddot(const Matx<_Tp, m, n>& v) const;

    diag_type
    diag() const;

    Matx<_Tp, m, n>
    div(const Matx<_Tp, m, n>& a) const;

    _Tp
    dot(const Matx<_Tp, m, n>& v) const;

    template <
        int m1,
        int n1
        >
    Matx<_Tp, m1, n1>
    get_minor(
        int i,
        int j
        ) const;

    Matx<_Tp, n, m>
    inv(
        int method = DECOMP_LU,
        bool* p_is_ok = NULL
        ) const;

    Matx<_Tp, m, n>
    mul(const Matx<_Tp, m, n>& a) const;

    template <typename T2>
    operator Matx< T2, m, n >() const;

    const _Tp&
    operator()(
        int i,
        int j
        ) const;

    _Tp&
    operator()(
        int i,
        int j
        );

    const _Tp&
    operator()(int i) const;

    _Tp&
    operator()(int i);

    template <
        int m1,
        int n1
        >
    Matx<_Tp, m1, n1>
    reshape() const;

    Matx<_Tp, 1, n>
    row(int i) const;

    template <int l>
    Matx<_Tp, n, l>
    solve(
        const Matx<_Tp, m, l>& rhs,
        int flags = DECOMP_LU
        ) const;

    Vec<_Tp, n>
    solve(
        const Vec<_Tp, m>& rhs,
        int method
        ) const;

    Matx<_Tp, n, m>
    t() const;

    static
    Matx
    all(_Tp alpha);

    static
    Matx
    diag(const diag_type& d);

    static
    Matx
    eye();

    static
    Matx
    ones();

    static
    Matx
    randn(
        _Tp a,
        _Tp b
        );

    static
    Matx
    randu(
        _Tp a,
        _Tp b
        );

    static
    Matx
    zeros();

    template <
        typename _Tp1,
        typename _Tp2,
        int cn
        >
    static
    Vec<_Tp1, cn>&
    operator+=(
        Vec<_Tp1, cn>& a,
        const Vec<_Tp2, cn>& b
        );

    template <
        typename _Tp1,
        typename _Tp2,
        int cn
        >
    static
    Vec<_Tp1, cn>&
    operator-=(
        Vec<_Tp1, cn>& a,
        const Vec<_Tp2, cn>& b
        );

    template <
        typename _Tp,
        int cn
        >
    static
    Vec<_Tp, cn>
    operator+(
        const Vec<_Tp, cn>& a,
        const Vec<_Tp, cn>& b
        );

    template <
        typename _Tp,
        int cn
        >
    static
    Vec<_Tp, cn>
    operator-(
        const Vec<_Tp, cn>& a,
        const Vec<_Tp, cn>& b
        );

    template <
        typename _Tp,
        int cn
        >
    static
    Vec<_Tp, cn>&
    operator*=(
        Vec<_Tp, cn>& a,
        int alpha
        );

    template <
        typename _Tp,
        int cn
        >
    static
    Vec<_Tp, cn>&
    operator*=(
        Vec<_Tp, cn>& a,
        float alpha
        );

    template <
        typename _Tp,
        int cn
        >
    static
    Vec<_Tp, cn>&
    operator*=(
        Vec<_Tp, cn>& a,
        double alpha
        );

    template <
        typename _Tp,
        int cn
        >
    static
    Vec<_Tp, cn>&
    operator/=(
        Vec<_Tp, cn>& a,
        int alpha
        );

    template <
        typename _Tp,
        int cn
        >
    static
    Vec<_Tp, cn>&
    operator/=(
        Vec<_Tp, cn>& a,
        float alpha
        );

    template <
        typename _Tp,
        int cn
        >
    static
    Vec<_Tp, cn>&
    operator/=(
        Vec<_Tp, cn>& a,
        double alpha
        );

    template <
        typename _Tp,
        int cn
        >
    static
    Vec<_Tp, cn>
    operator*(
        const Vec<_Tp, cn>& a,
        int alpha
        );

    template <
        typename _Tp,
        int cn
        >
    static
    Vec<_Tp, cn>
    operator*(
        int alpha,
        const Vec<_Tp, cn>& a
        );

    template <
        typename _Tp,
        int cn
        >
    static
    Vec<_Tp, cn>
    operator*(
        const Vec<_Tp, cn>& a,
        float alpha
        );

    template <
        typename _Tp,
        int cn
        >
    static
    Vec<_Tp, cn>
    operator*(
        float alpha,
        const Vec<_Tp, cn>& a
        );

    template <
        typename _Tp,
        int cn
        >
    static
    Vec<_Tp, cn>
    operator*(
        const Vec<_Tp, cn>& a,
        double alpha
        );

    template <
        typename _Tp,
        int cn
        >
    static
    Vec<_Tp, cn>
    operator*(
        double alpha,
        const Vec<_Tp, cn>& a
        );

    template <
        typename _Tp,
        int cn
        >
    static
    Vec<_Tp, cn>
    operator/(
        const Vec<_Tp, cn>& a,
        int alpha
        );

    template <
        typename _Tp,
        int cn
        >
    static
    Vec<_Tp, cn>
    operator/(
        const Vec<_Tp, cn>& a,
        float alpha
        );

    template <
        typename _Tp,
        int cn
        >
    static
    Vec<_Tp, cn>
    operator/(
        const Vec<_Tp, cn>& a,
        double alpha
        );

    template <
        typename _Tp,
        int cn
        >
    static
    Vec<_Tp, cn>
    operator-(const Vec<_Tp, cn>& a);

    template <typename _Tp>
    Vec<_Tp, 4>
    operator*(
        const Vec<_Tp, 4>& v1,
        const Vec<_Tp, 4>& v2
        );

    template <typename _Tp>
    Vec<_Tp, 4>&
    operator*=(
        Vec<_Tp, 4>& v1,
        const Vec<_Tp, 4>& v2
        );

    Vec
    conj() const;

    Vec
    cross(const Vec& v) const;

    Vec
    mul(const Vec<_Tp, cn>& v) const;

    template <typename T2>
    operator Vec< T2, cn >() const;

    const _Tp&
    operator()(int i) const;

    _Tp&
    operator()(int i);

    const _Tp&
    operator[](int i) const;

    _Tp&
    operator[](int i);

    static
    Vec
    all(_Tp alpha);

Detailed Documentation

Template class for a 4-element vector derived from Vec.

Being derived from Vec <_Tp, 4> , Scalar_ and Scalar can be used just as typical 4-element vectors. In addition, they can be converted to/from CvScalar. The type Scalar is widely used in OpenCV to pass pixel values.

Construction

Scalar_()

various constructors

Methods

Scalar_<_Tp>
mul(
    const Scalar_<_Tp>& a,
    double scale = 1
    ) const

per-element product

template <typename T2>
operator Scalar_< T2 >() const

conversion to another data type

static
Scalar_<_Tp>
all(_Tp v0)

returns a scalar with all elements set to v0