Image concepts (details)¶

Table of Contents

Image
ConcreteImage
WritableImage
BidirectionalImage
WritableBidirectionalImage
AccessibleImage
WritableAccessibleImage
RandomAccessImage
WritableRandomAccessImage

Image ¶

template<typename Ima> concept Image¶

Ima::pixel_type models the template <typename Pix> Pixel concept.
Ima::domain_type models the template <typename Dom> Domain concept.
Ima::index_type models the template <typename Idx> Index concept.
Ima::const_pixel_range models the template <typename FwdRng> ForwardRange concept.
Ima::const_value_range models the template <typename FwdRng> ForwardRange concept.
Ima::value_type models the template <typename Val> Value concept, is non-const and is not a reference.
Ima::difference_type models the template <typename T> SignedIntegral concept.
Ima is consistant with point_type, value_type and reference from pixel_type.
Ima provide methods is_concrete, to_concrete, values, pixels, domain operator[], index_of_point, point_at_index and delta_index.

Notation

using domain_type = Ima::domain_type¶

using pixel_type = Ima::pixel_type¶

using const_pixel_type = const Ima::pixel_type¶

using index_type = Ima::index_type¶

using difference_type = decltype(index_type() - index_type())¶

using point_type = pixel_type::point_type¶

using value_type = pixel_type::value_type¶

using const_reference = const_pixel_type::reference¶

using const_pixel_range = Ima::const_pixel_range¶

using const_value_range = Ima::const_value_range¶

Ima ima¶

const Ima cima¶

index_type k¶

point_type p¶

Valid Expressions

is_const_v<value_type> returns false
is_reference<value_type> returns false
cima.is_concrete(p) returns-type models template <typename B> Boolean
cima.to_concrete(p) returns-type models template <typename ConcIma> ConcreteImage
cima.pixels() returns const_pixel_range
cima.values() returns const_value_range
cima.domain() returns domain_type
cima[k] returns const_reference
cima.index_of_point(p) returns index_type
cima.point_of_index(k) returns point_type
cima.delta_index(p) returns difference_type

Possible implementation

template <typename Im, Ima = remove_cvref<Im>>
concept Image =
    requires {
        typename Ima::pixel_type;
        typename Ima::const_pixel_type
        typename Ima::point_type;
        typename Ima::value_type;
        typename Ima::domain_type;
        typename Ima::difference_type;
        typename Ima::index_type;
        typename Ima::const_reference;
        typename Ima::const_pixel_range;
        typename Ima::const_value_range;
    } &&

    Pixel<Ima::pixel_type> &&
    Point<Ima::point_type> &&
    Value<Ima::value_type> &&
    Domain<Ima::domain_type> &&
    Index<Ima::index_type> &&
    SignedIntegral<Ima::difference_type> &&
    ForwardRange<Ima::const_pixel_range> &&
    ForwardRange<Ima::const_value_range> &&

    Same<Ima::difference_type, decltype(Ima::index_type() - Ima::index_type())> &&
    Same<Ima::point_type, Ima::pixel_type::point_type> &&
    Same<Ima::value_type, Ima::pixel_type::value_type> &&
    Same<Ima::const_reference, const Ima::pixel_type::reference> &&
    Same<Ima::const_pixel_type, const Ima::pixel_type> &&
    Same<Ima::const_pixel_type, Ima::const_pixel_range::value_type> &&
    Same<Ima::const_reference, Ima::const_value_range::value_type> &&

    !is_const_v<Ima::value_type> &&
    !is_reference_v<Ima::value_type> &&

    requires(   Ima ima, const Ima cima, Ima::domain_type d,
                Ima::index_type k, Ima::point_type p) {
        { cima[k] }                 -> Ima::const_reference,
        { cima.pixels() }           -> Ima::const_pixel_range;
        { cima.values() }           -> Ima::const_value_range;
        { cima.domain() }           -> Ima::domain_type;
        { cima.point_of_index(k) }  -> Ima::point_type
        { cima.index_at_point(p) }  -> Ima::index_type;
        { cima.delta_index(p) }     -> Ima::difference_Type;
        { cima.is_concrete() }      -> Boolean;
        { cima.to_toncrete() }      -> ConcreteImage;
    };

ConcreteImage ¶

template<typename ConcIma> concept ConcreteImage¶

Refines the template <typename T> Semiregular concept.
Refines the template <typename Ima> Image concept.
ConcIma provide methods resize and reindex.

Notation

using domain_type = ConcIma::domain_type¶

using index_type = ConcIma::index_type¶

using pixel_type = ConcIma::pixel_type¶

using value_type = pixel_type::value_type¶

ConcIma concima¶

ConcIma concima_cpy¶

const ConcIma cconcima¶

index_type k¶

domain_type d¶

value_type v¶

Valid Expressions

concima() returns an instance of ConcIma.
cconcima() returns an instance of const ConcIma.
concima_cpy(concima) returns an instance of ConcIma.
concima_cpy(cconcima) returns an instance of ConcIma.
concima_cpy(move(concima)) returns an instance of ConcIma.
concima_cpy = concima returns an instance of ConcIma&.
concima_cpy = cconcima returns an instance of ConcIma&.
concima_cpy = move(concima) returns an instance of ConcIma&.
concima.resize(d) is valid.
concima.resize(d, v) is valid.
concima.reindex(k) is valid.

Possible implementation

template <typename ConcIm, ConcIma = remove_cvref<ConcIm>>
concept ConcreteImage = Semiregular<ConcIma> &&
                        Image<ConcIma> &&

                        requires(   ConcIma ima, ConcIma::domain_type d,
                                    ConcIma::index_type k, ConcIma::value_type v) {
                            { ima.resize(d) };
                            { ima.resize(d, v) };
                            { ima.reindex(k) };
                        };

WritableImage ¶

template<typename WIma> concept WritableImage¶

Refines the concept template <typename Ima> Image.
Defines the non-const version of reference, value_range and pixel_range.
Access methods now return mutable references.

Notation

using pixel_type = WIma::pixel_type¶

using index_type = WIma::index_type¶

using reference = pixel_type::reference¶

using pixel_range = WIma::pixel_range¶

using value_range = WIma::value_range¶

WIma wima¶

index_type k¶

domain_type d¶

Valid Expressions

wima.pixels() returns pixel_range
wima.values() returns value_range
wima[k] returns reference

Possible implementation

template <typename WIm, WIma = remove_cvref<WIm>>
concept WritableImage =
    Image<WIma> &&

    requires {
        typename WIma::pixel_range;
        typename WIma::value_range;
    } &&

    ForwardRange<WIma::pixel_range> &&
    ForwardRange<WIma::value_range> &&
    OutputRange<WIma::pixel_range, WIma::pixel_type> &&
    OutputRange<WIma::value_range, WIma::value_type> &&

    Same<WIma::reference, WIma::pixel_type::reference> &&
    Same<WIma::pixel_type, WIma::pixel_range::value_type> &&
    Same<WIma::reference, WIma::value_range::value_type> &&

    requires(WIma wima, WIma::index_type k, WIma::domain_type d, WIma::value_type v) {
        { wima[k] }             -> WIma::reference;
        { wima.pixels() }       -> WIma::pixel_range;
        { wima.values() }       -> WIma::value_range;
    };

BidirectionalImage ¶

template<typename BidirIma> concept BidirectionalImage¶

Refines the concept template <typename Ima> Image
BidirIma::const_pixel_range models the template <typename BidirRng> BidirectionalRange concept.
BidirIma::const_value_range models the template <typename BidirRng> BidirectionalRange concept.

Notation

using const_pixel_range = BidirIma::const_pixel_range¶

using const_value_range = BidirIma::const_value_range¶

Possible implementation

template <typename BidirIm, BidirIma = remove_cvref<BidirIm>>
concept BidirectionalImage =
    Image<BidirIma> &&

    BidirectionalRange<BidirIma::const_pixel_range> &&
    BidirectionalRange<BidirIma::const_value_range> &&

    Same<BidirIma::const_pixel_type, BidirIma::const_pixel_range::value_type> &&
    Same<BidirIma::const_reference, BidirIma::const_value_range::value_type>;

WritableBidirectionalImage ¶

template<typename WBidirIma> concept WritableBidirectionalImage¶

Refines the concept template <typename WIma> WritableImage.
Refines the concept template <typename BidirIma> BidirectionnalImage.
WBidirIma::pixel_range models the template <typename BidirRng> BidirectionalRange concept.
WBidirIma::value_range models the template <typename BidirRng> BidirectionalRange concept.

Notation

using pixel_range = WBidirIma::pixel_range¶

using value_range = WBidirIma::value_range¶

Possible implementation

template <typename WBidirIm, WBidirIma = remove_cvref<WBidirIm>>
concept WritableBidirectionalImage =
    WritableImage<WBidirIma> &&
    BidirectionnalImage<WBidirIma> &&

    BidirectionalRange<WBidirIma::pixel_range> &&
    BidirectionalRange<WBidirIma::value_range> &&

    Same<WBidirIma::pixel_type, WBidirIma::pixel_range::value_type> &&
    Same<WBidirIma::reference, WBidirIma::value_range::value_type>;

AccessibleImage ¶

template<typename AccIma> concept AccessibleImage¶

Refines the concept template <typename Ima> Image.
Add new access methods based on point_type : operator(), pixel, at and pixel_at

Notation

using const_pixel_type = const AccIma::pixel_type¶

using point_type = pixel_type::point_type¶

using value_type = pixel_type::value_type¶

using const_reference = const pixel_type::reference¶

const AccIma caccima¶

point_type p¶

Valid Expressions

caccima(p) returns const_reference with bound checking.
caccima.pixel(p) returns const_pixel_type with bound checking.
caccima.at(p) returns const_reference without bound checking.
caccima.pixel_at(p) returns const_pixel_type without bound checking.

Possible implementation

template <typename AccIm, AccIma = remove_cvref<AccIm>>
concept AccessibleImage =
    Image<AccIma> &&

    requires(const AccIma caccima, AccIma::point_type p)
        { accima(p) }           -> AccIma::const_reference;
        { accima.pixel(p) }     -> AccIma::const_pixel_type;
        { accima.at(p) }        -> AccIma::const_reference;
        { accima.pixel_at(p) }  -> AccIma::const_pixel_type;
    };

WritableAccessibleImage ¶

template<typename WAccIma> concept WritableAccessibleImage¶

Refines the concept template <typename WIma> WritableImage.
Refines the concept template <typename AccIma> AccessibleImage.
Add new access methods based on point_type : operator(), pixel, at and pixel_at

Notation

using pixel_type = WAccIma::pixel_type¶

using point_type = pixel_type::point_type¶

using value_type = pixel_type::value_type¶

using reference = pixel_type::reference¶

WAccIma waccima¶

point_type p¶

Valid Expressions

waccima(p) returns reference with bound checking.
waccima.pixel(p) returns pixel_type with bound checking.
waccima.at(p) returns reference without bound checking.
waccima.pixel_at(p) returns pixel_type without bound checking.

Possible implementation

template <typename WAccIm, WAccIma = remove_cvref<WAccIm>>
concept WritableAccessibleImage =
    WritableImage<WAccIma> &&
    AccessibleImage<WAccIma> &&

    requires(WAccIma waccima, WAccIma::point_type p)
        { waccima(p) }          -> WAccIma::reference;
        { waccima.pixel(p) }    -> WAccIma::pixel_type;
        { waccima.at(p) }       -> WAccIma::reference;
        { waccima.pixel_at(p) } -> WAccIma::pixel_type;
    };

RandomAccessImage ¶

template<typename RndAccIma> concept RandomAccessImage¶

Refines the concept template <typename BidirIma> BidirectionalImage.
Refines the concept template <typename AccIma> AccessibleImage.
RndAccIm::const_pixel_range models both the template <typename RndAccRng> RandomAccessRange and the template <typename SRng> SizedRange concept.
RndAccIm::const_value_range models both the template <typename RndAccRng> RandomAccessRange and the template <typename SRng> SizedRange concept.

Notation

type RndAccIm¶

using const_pixel_range = RndAccIm::const_pixel_range¶

using const_value_range = RndAccIm::const_value_range¶

Possible implementation

template <typename RndAccIm, RndAccIma = remove_cvref<RndAccIm>>
concept RandomAccessImage =
    BidirectionalImage<RndAccIma> &&
    AccessibleImage<RndAccIma> &&

    RandomAccessRange<RndAccIma::const_pixel_range> &&
    RandomAccessRange<RndAccIma::const_value_range> &&
    SizedRange<WRndAccIma::const_pixel_range> &&
    SizedRange<WRndAccIma::const_value_range> &&

    Same<RndAccIma::const_pixel_type, RndAccIma::const_pixel_range::value_type> &&
    Same<RndAccIma::const_reference, RndAccIma::const_value_range::value_type>;

WritableRandomAccessImage ¶

template<typename WRndAccIma> concept WritableRandomAccessImage¶

Refines the concept template <typename WBidirIma> WritableBidirectionalImage.
Refines the concept template <typename WAccIma> WritableAccessibleImage.
WRndAccIm::pixel_range models both the template <typename RndAccRng> RandomAccessRange and the template <typename SRng> SizedRange concept.
WRndAccIm::value_range models both the template <typename RndAccRng> RandomAccessRange and the template <typename SRng> SizedRange concept.

Notation

..cpp:type:: WRndAccIm .. cpp:type:: pixel_range = WRndAccIm::pixel_range .. cpp:type:: value_range = WRndAccIm::value_range

Possible implementation

template <typename WRndAccIm, WRndAccIma = remove_cvref<WRndAccIm>>
concept WritableRandomAccessImage =
    WritableBidirectionalImage<WRndAccIma> &&
    WritableAccessibleImage<WRndAccIma> &&
    RandomAccessImage<WRndAccIma> &&

    RandomAccessRange<WRndAccIma::pixel_range> &&
    RandomAccessRange<WRndAccIma::value_range> &&
    SizedRange<WRndAccIma::pixel_range> &&
     SizedRange<WRndAccIma::value_range> &&

    Same<WRndAccIma::pixel_type, WRndAccIma::pixel_range::value_type> &&
    Same<WRndAccIma::reference, WRndAccIma::value_range::value_type>;