BppImage.hpp

Go to the documentation of this file.

/*
 * This file is part of the DUDS project. It is subject to the BSD-style
 * license terms in the LICENSE file found in the top-level directory of this
 * distribution and at https://github.com/jjackowski/duds/blob/master/LICENSE.
 * No part of DUDS, including this file, may be copied, modified, propagated,
 * or distributed except according to the terms contained in the LICENSE file.
 *
 * Copyright (C) 2018  Jeff Jackowski
 */
#ifndef BPPIMAGE_HPP
#define BPPIMAGE_HPP

#include <vector>
#include <cstdint>
#include <type_traits>
#include <boost/exception/info.hpp>

namespace duds { namespace ui {

namespace graphics {

struct ImageDimensions;

struct ImageLocation {
    std::int16_t x;
    std::int16_t y;
    ImageLocation() = default;
    template <
        typename Int0,
        typename Int1,
        std::enable_if_t<std::is_integral<Int0>::value, bool> = true,
        std::enable_if_t<std::is_integral<Int1>::value, bool> = true
    >
    constexpr ImageLocation(Int0 px, Int1 py) :
    x((std::int16_t)px), y((std::int16_t)py) { }
    constexpr bool operator == (const ImageLocation &il) const {
        return (x == il.x) && (y == il.y);
    }
    constexpr bool operator != (const ImageLocation &il) const {
        return (x != il.x) || (y != il.y);
    }
    constexpr ImageLocation operator + (const ImageLocation &il) const {
        return ImageLocation(x + il.x, y + il.y);
    }
    constexpr ImageLocation operator - (const ImageLocation &il) const {
        return ImageLocation(x - il.x, y - il.y);
    }
    constexpr ImageLocation operator + (const ImageDimensions &id) const;
    constexpr ImageLocation operator - (const ImageDimensions &id) const;
    void swapAxes() {
        std::swap(x, y);
    }
    constexpr ImageLocation swappedAxes() const {
        return ImageLocation(y, x);
    }
};

std::ostream &operator << (std::ostream &os, const ImageLocation &il);

inline void swap(ImageLocation &l0, ImageLocation &l1) {
    std::swap(l0.x, l1.x);
    std::swap(l0.y, l1.y);
}

struct ImageDimensions {
    std::int16_t w;
    std::int16_t h;
    ImageDimensions() = default;
    template <
        typename Int0,
        typename Int1,
        std::enable_if_t<std::is_integral<Int0>::value, bool> = true,
        std::enable_if_t<std::is_integral<Int1>::value, bool> = true
    >
    constexpr ImageDimensions(Int0 dw, Int1 dh) :
    w((std::int16_t)dw), h((std::int16_t)dh) { }
    constexpr bool operator == (const ImageDimensions &id) const {
        return (w == id.w) && (h == id.h);
    }
    constexpr bool operator != (const ImageDimensions &id) const {
        return (w != id.w) || (h != id.h);
    }
    constexpr bool empty() const {
        return !w || !h;
    }
    void clear() {
        w = h = 0;
    }
    constexpr bool withinBounds(const ImageLocation &loc) const {
        return (loc.x >= 0) && (loc.x < w) && (loc.y >= 0) && (loc.y < h);
    }
    constexpr bool fits(const ImageDimensions &id) const {
        return (id.w <= w) && (id.h <= h);
    }
    constexpr bool fits(const ImageLocation &loc, const ImageDimensions &id) const {
        return ((loc.x + id.w) <= w) && ((loc.y + id.h) <= h);
    }
    void swapAxes() {
        std::swap(w, h);
    }
    constexpr ImageDimensions swappedAxes() const {
        return ImageDimensions(h, w);
    }
    constexpr ImageDimensions minExtent(const ImageDimensions &dim) const {
        return ImageDimensions(std::min(w, dim.w), std::min(h, dim.h));
    }
    constexpr ImageDimensions maxExtent(const ImageDimensions &dim) const {
        return ImageDimensions(std::max(w, dim.w), std::max(h, dim.h));
    }
    constexpr ImageDimensions clip(
        const ImageDimensions &dim,
        const ImageLocation &loc = ImageLocation(0, 0)
    ) const {
        return ImageDimensions(
            std::max(
                std::min(dim.w - ((loc.x < 0) ? loc.x : 0), w - std::abs(loc.x)),
                0  // don't be negative
            ),
            std::max(
                std::min(dim.h - ((loc.y < 0) ? loc.y : 0), h - std::abs(loc.y)),
                0
            )
        );
    }
};

std::ostream &operator << (std::ostream &os, const ImageDimensions &id);

inline void swap(ImageDimensions &d0, ImageDimensions &d1) {
    std::swap(d0.w, d1.w);
    std::swap(d0.h, d1.h);
}

constexpr ImageLocation ImageLocation::operator + (
    const ImageDimensions &id
) const {
    return ImageLocation(x + id.w, y + id.h);
}

constexpr ImageLocation ImageLocation::operator - (
    const ImageDimensions &id
) const {
    return ImageLocation(x - id.w, y - id.h);
}

typedef boost::error_info<struct Info_ImageLocation, ImageLocation>
    ImageErrorLocation;
typedef boost::error_info<struct Info_ImageDimensions, ImageDimensions>
    ImageErrorDimensions;
typedef boost::error_info<struct Info_ImageDimensions, ImageDimensions>
    ImageErrorSourceDimensions;
typedef boost::error_info<struct Info_FrameDimensions, ImageDimensions>
    ImageErrorTargetDimensions;


class BppImage {
public:
    typedef std::uintptr_t  PixelBlock;
private:
    std::vector<PixelBlock> img;
    ImageDimensions dim;
    int blkPerLine;
public:
    static constexpr std::size_t bufferBlockSize(int w, int h) {
        return (w / (sizeof(PixelBlock) * 8) +
        ((w % (sizeof(PixelBlock) * 8)) ? 1 : 0)) * h;
    }
    static constexpr std::size_t bufferByteSize(int w, int h) {
        return bufferBlockSize(w, h) * sizeof(PixelBlock);
    }
    static constexpr int bufferBlocksPerLine(int width) {
        return width / (sizeof(PixelBlock) * 8) +
        ((width % (sizeof(PixelBlock) * 8)) ? 1 : 0);
    }
    static constexpr int bufferBlocksPerLine(ImageDimensions dim) {
        return dim.w / (sizeof(PixelBlock) * 8) +
        ((dim.w % (sizeof(PixelBlock) * 8)) ? 1 : 0);
    }
    enum Direction {
        HorizInc,
        VertInc,
        HorizDec,
        VertDec,
        Rotate0DCCW = HorizInc,
        Rotate90DCCW = VertInc,
        Rotate180DCCW = HorizDec,
        Rotate270DCCW = VertDec,
    };
    struct EndPixel { };
    class Pixel;
    class ConstPixel {
    public:
        struct End { };
    protected:
        BppImage *src;
        // allow for quick referencing of data; recalc of img array index and
        // bit position is not always required
        PixelBlock *blk;
        PixelBlock mask;
        ImageLocation pos;
        ImageLocation orig;
        ImageDimensions dim;
        Direction dir;
    public:
        constexpr ConstPixel() :
            src(nullptr),
            blk(nullptr),
            mask(0),
            pos(-1, -1),
            orig(0, 0),
            dim(0, 0),
            dir(HorizInc)
            { }
        constexpr ConstPixel(const EndPixel) : ConstPixel() { }
        ConstPixel(const ConstPixel &) = default;
        ConstPixel(const BppImage *img, const End e);
        ConstPixel(
            const BppImage *img,
            const ImageLocation &il = ImageLocation(0, 0),
            Direction d = HorizInc
        );
        ConstPixel(
            const BppImage *img,
            int x,
            int y,
            Direction d = HorizInc
        ) : ConstPixel(img, ImageLocation(x, y), d) { }
        ConstPixel(
            const BppImage *img,
            const ImageLocation &o,
            const ImageDimensions &s,
            const ImageLocation &p = ImageLocation(0, 0),
            Direction d = HorizInc
        );
        ConstPixel &operator = (const ConstPixel &) = default;
        ConstPixel &operator = (const Pixel &p);
        ConstPixel &operator = (const EndPixel) {
            pos.x = pos.y = -1;
            blk = nullptr;
            return *this;
        }
        Direction direction() const {
            return dir;
        }
        void direction(Direction d) {
            dir = d;
        }
        bool state() const;
        /* *
         * Works like adding a number to increment the ConstPixel and calling
         * state() on the result, but without making a new ConstPixel object.
         * @todo  This requires an implementation similar to operator+(int).
         */
        //bool stateAtOffset(int inc) const;
        bool operator == (const ConstPixel &cp) const;
        bool operator == (const EndPixel) const {
            return (pos.x == -1) && (pos.y == -1);
        }
        bool operator != (const ConstPixel &cp) const {
            return (src != cp.src) || (pos != cp.pos);
        }
        bool operator != (const EndPixel) const {
            return (pos.x != -1) || (pos.y != -1);
        }
        ConstPixel &operator ++();
        ConstPixel operator ++(int) {
            ConstPixel cp(*this);
            operator++();
            return cp;
        }
        //operator +(int);
        //operator +=(int);  ?
        int x() const {
            return pos.x;
        }
        int y() const {
            return pos.y;
        }
        const ImageLocation &location() const {
            return pos;
        }
        void location(const ImageLocation &il);
        void location(int x, int y) {
            location(ImageLocation(x, y));
        }
        int absX() const {
            return orig.x + pos.x;
        }
        int absY() const {
            return orig.y + pos.y;
        }
        ImageLocation absLocation() const {
            return orig + pos;
        }
        int originX() const {
            return orig.x;
        }
        int originY() const {
            return orig.y;
        }
        const ImageLocation &origin() const {
            return orig;
        }
        void origin(const ImageLocation &il);
        int width() const {
            return dim.w;
        }
        int height() const {
            return dim.h;
        }
        const ImageDimensions &dimensions() const {
            return dim;
        }
        void dimensions(const ImageDimensions &d);
        void origdimloc(
            const ImageLocation &o,
            const ImageDimensions &d,
            const ImageLocation &p
        );
        /* *
         * Changes the coordinate perpendicular to the set direction as if by
         * incrementing this pixel by an amount equal to @a l multiplied by
         * the width, for HorizInc and HorizDec, or the height, for VertInc
         * and VertDec. This means that with direction HorizInc starting at
         * position (x,y), line(l) will change the position to (x,y+l) if y+l
         * is within the height bound.
         */
        //void line(int l);

        class ConstBoolProxy {
            const ConstPixel *cp;
        public:
            ConstBoolProxy(const ConstPixel *p) : cp(p) { }
            operator bool () const {
                return cp->state();
            }
        };
        ConstBoolProxy operator*() const {
            return ConstBoolProxy(this);
        }

        // incomplete attempt at fulfilling all standard iterator requirements
        //typedef std::forward_iterator_tag iterator_category;
        typedef bool value_type;
        //typedef ? difference_type;
        //typedef ConstBoolProxy pointer; // doesn't seem quite right
        //typedef ? reference;
    };
    class Pixel : public ConstPixel {
    public:
        Pixel(
            BppImage *img,
            const ImageLocation &il = { 0, 0 },
            Direction d = HorizInc
        ) : ConstPixel(img, il, d) { }
        Pixel(
            BppImage *img,
            int x,
            int y,
            Direction d = HorizInc
        ) : ConstPixel(img, ImageLocation(x, y), d) { }
        Pixel(
            BppImage *img,
            const ImageLocation &o,
            const ImageDimensions &s,
            const ImageLocation &p = { 0, 0 },
            Direction d = HorizInc
        ) : ConstPixel(img, o, s, p, d) { }
        Pixel &operator = (const Pixel &p) = default;
        Pixel &operator = (const EndPixel) {
            pos.x = pos.y = -1;
            blk = nullptr;
            return *this;
        }
        void state(bool s);
        bool state() const {
            return ConstPixel::state();
        }
        Pixel &operator = (bool s) {
            state(s);
            return *this;
        }
        void clear() {
            state(false);
        }
        void set() {
            state(true);
        }
        bool toggle();

        class BoolProxy {
            Pixel *pix;
        public:
            BoolProxy(Pixel *p) : pix(p) { }
            operator bool () {
                return pix->state();
            }
            bool operator = (bool b) {
                pix->state(b);
                return b;
            }
        };
        BoolProxy operator*() {
            return BoolProxy(this);
        }
    };
    BppImage() : dim(0, 0), blkPerLine(0) { };
    BppImage(const ImageDimensions &id);
    BppImage(int width, int height) : BppImage(ImageDimensions(width, height)) { }
    BppImage(BppImage &&mv);
    BppImage(const BppImage &src);
    BppImage(const char *data);
    BppImage(const std::vector<char> &data);
    static std::shared_ptr<BppImage> make(const ImageDimensions &id) {
        return std::make_shared<BppImage>(id);
    }
    static std::shared_ptr<BppImage> make(int width, int height) {
        return std::make_shared<BppImage>(width, height);
    }
    static std::shared_ptr<BppImage> make(const char *data) {
        return std::make_shared<BppImage>(data);
    }
    static std::shared_ptr<BppImage> make(const std::vector<char> &data) {
        return std::make_shared<BppImage>(data);
    }
    BppImage &operator = (BppImage &&mv);
    BppImage &operator = (const BppImage &src);
    void swap(BppImage &other);
    void clear();
    void resize(const duds::ui::graphics::ImageDimensions &newdim);
    void resize(int width, int height) {
        resize(duds::ui::graphics::ImageDimensions(width, height));
    }
    bool empty() const {
        return img.empty();
    }
    std::size_t bufferSize() const {
        return img.size();
    }
    int size() const {
        return dim.w * dim.h;
    }
    std::int16_t width() const {
        return dim.w;
    }
    std::int16_t height() const {
        return dim.h;
    }
    const ImageDimensions &dimensions() const {
        return dim;
    }
    const PixelBlock *buffer() const;
    PixelBlock *buffer() {
        // re-use the const implementation
        return const_cast<BppImage::PixelBlock*>
        (((const BppImage*)this)->buffer());
    }
    // C++ containers are going with data() for underlying container
    const std::vector<PixelBlock> &data() const {
        return img;
    }
    bool operator == (const BppImage &other) const;
    const PixelBlock *bufferLine(int py) const;
    PixelBlock *bufferLine(int py) {
        // re-use the const implementation
        return const_cast<BppImage::PixelBlock*>
        (((const BppImage*)this)->bufferLine(py));
    }
    int blocksPerLine() const {
        return blkPerLine;
    }
    void bufferSpot(
        PixelBlock *(&addr),
        PixelBlock &mask,
        const ImageLocation &il
    );
    void bufferSpot(PixelBlock *(&addr), PixelBlock &mask, int x, int y) {
        bufferSpot(addr, mask, ImageLocation(x, y));
    }
    void bufferSpot(
        const PixelBlock *(&addr),
        PixelBlock &mask,
        const ImageLocation &il
    ) const {
        // the implementation is the same, save for a couple of const
        const_cast<BppImage*>(this)->bufferSpot(
            const_cast<PixelBlock*&>(addr),
            mask,
            il
        );
    }
    ImageLocation startPosition(Direction dir = HorizInc) const;
    static ImageLocation startPosition(
        const ImageLocation &origin,
        const ImageDimensions &size,
        Direction dir = HorizInc
    );
    Pixel pixel(const ImageLocation &il, Direction dir = HorizInc);
    Pixel pixel(int x, int y, Direction dir = HorizInc) {
        return pixel(ImageLocation(x, y), dir);
    }
    ConstPixel cpixel(const ImageLocation &il, Direction dir = HorizInc) const;
    ConstPixel cpixel(int x, int y, Direction dir = HorizInc) const {
        return cpixel(ImageLocation(x, y), dir);
    }
    ConstPixel operator () (int x, int y) const {
        return cpixel(x, y);
    }
    Pixel begin();
    Pixel begin(Direction dir);
    Pixel begin(
        const ImageLocation &origin,
        const ImageDimensions &size,
        Direction dir = HorizInc
    );
    ConstPixel cbegin() const;
    ConstPixel cbegin(Direction dir) const;
    ConstPixel cbegin(
        const ImageLocation &origin,
        const ImageDimensions &size,
        Direction dir = HorizInc
    ) const;
    ConstPixel begin() const {
        return cbegin();
    }
    static EndPixel endPixel() {
        return EndPixel();
    }
    Pixel end();
    static constexpr ConstPixel cend() {
        return ConstPixel();
    }
    ConstPixel end() const {
        return cend();
    }
    bool state(const ImageLocation &il) const;
    bool state(int x, int y) const {
        return state(ImageLocation(x, y));
    }
    void state(const ImageLocation &il, bool s);
    void state(int x, int y, bool s) {
        state(ImageLocation(x, y), s);
    }
    void clearPixel(const ImageLocation &il) {
        state(il, false);
    }
    void clearPixel(int x, int y) {
        state(x, y, false);
    }
    void setPixel(const ImageLocation &il) {
        state(il, true);
    }
    void setPixel(int x, int y) {
        state(x, y, true);
    }
    bool invertPixel(const ImageLocation &il);
    bool invertPixel(int x, int y) {
        return invertPixel(ImageLocation(x, y));
    }
    void invert();
    void invertLines(int start, int height);
    void patternLines(int start, int height, PixelBlock val);
    void setLines(int start, int height) {
        patternLines(start, height, -1);
    }
    void clearLines(int start, int height) {
        patternLines(start, height, 0);
    }
    void blankImage(bool state);
    void clearImage() {
        blankImage(false);
    }
    void setImage() {
        blankImage(true);
    }
    enum Operation {
        OpSet,
        OpNot,
        OpAnd,
        OpOr,
        OpXor,
        OpTotal
    };
private:
    typedef bool (*OpBitFunction)(bool dest, bool src);
    static const OpBitFunction OpBitFunctions[OpTotal];
    typedef void (*OpFunction)(PixelBlock *dest, const PixelBlock &src, const PixelBlock &mask);
    static const OpFunction OpFunctions[OpTotal];
public:
    void write(
        const BppImage * const src,
        const ImageLocation &destLoc,
        const ImageLocation &srcLoc,
        const ImageDimensions &srcSize,
        Direction srcDir = HorizInc,
        Operation op = OpSet
    );
    void write(
        const BppImage * const src,
        const ImageLocation &destLoc,
        const ImageDimensions &srcSize,
        Direction srcDir = HorizInc,
        Operation op = OpSet
    ) {
        write(src, destLoc, ImageLocation(0, 0), srcSize, srcDir, op);
    }
    void write(
        const std::shared_ptr<const BppImage> &src,
        const ImageLocation &destLoc,
        const ImageLocation &srcLoc,
        const ImageDimensions &srcSize,
        Direction srcDir = HorizInc,
        Operation op = OpSet
    ) {
        write(src.get(), destLoc, srcLoc, srcSize, srcDir, op);
    }
    void write(
        const std::shared_ptr<const BppImage> src,
        const ImageLocation &destLoc,
        const ImageDimensions &srcSize,
        Direction srcDir = HorizInc,
        Operation op = OpSet
    ) {
        write(src.get(), destLoc, ImageLocation(0, 0), srcSize, srcDir, op);
    }
    void write(
        const BppImage * const src,
        const ImageLocation &dest,
        Direction srcDir = HorizInc,
        Operation op = OpSet
    );
    void write(
        const std::shared_ptr<const BppImage> &src,
        const ImageLocation &dest,
        Direction srcDir = HorizInc,
        Operation op = OpSet
    ) {
        write(src.get(), dest, srcDir, op);
    }
    void drawBox(
        ImageLocation ul,
        ImageDimensions id,
        Operation op = OpSet
    );
    void drawBox(
        ImageLocation ul,
        ImageDimensions id,
        bool state
    ) {
        drawBox(ul, id, state ? OpSet : OpNot);
    }
    void drawBox(
        int x,
        int y,
        int w,
        int h = 1,
        Operation op = OpSet
    ) {
        drawBox(ImageLocation(x, y), ImageDimensions(w, h), op);
    }
    void drawBox(
        int x,
        int y,
        int w,
        int h,
        bool state
    ) {
        drawBox(ImageLocation(x, y), ImageDimensions(w, h), state ? OpSet : OpNot);
    }
    // https://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm
};

inline void swap(BppImage &bi0, BppImage &bi1) {
    bi0.swap(bi1);
}

typedef std::shared_ptr<BppImage>  BppImageSptr;
typedef std::shared_ptr<const BppImage>  ConstBppImageSptr;
typedef std::weak_ptr<BppImage>  BppImageWptr;
typedef std::weak_ptr<const BppImage>  ConstBppImageWptr;

ImageDimensions MaxExtent(const BppImage *i0, const BppImage *i1);

inline ImageDimensions MaxExtent(
    const BppImage &i0,
    const BppImage &i1
) {
    return MaxExtent(&i0, &i1);
}

inline ImageDimensions MaxExtent(
    const ConstBppImageSptr &i0,
    const ConstBppImageSptr &i1
) {
    return MaxExtent(i0.get(), i1.get());
}

} } }

#endif        //  #ifndef BPPIMAGE_HPP