picture-props.cpp

Go to the documentation of this file.

#include "config.h"
#include "libnebular.hpp"
#include "libnebular-plugin.hpp"

#include <set>

namespace libnebular{
    using namespace std;

    // @class PictureProps
    // {

#define CHECK_PROP_COND_MSG(CONDITION, PROP_NAME, COND_MSG)         \
if(!(CONDITION)){                                   \
    throw LIBNEBULAR_ERROR(Log::getWrongValueMsg(   \
        String("\"")+PROP_NAME+"\"", ( isSet(PROP_NAME) ? get<String>(PROP_NAME) : "<unset>" ), \
        COND_MSG ,                                                      \
        "", "Invalid"                                   \
        )                                                               \
    );                                              \
}                                                       \
/* Swallowing the semicolon */                          \
while(false)                                            \


#define CHECK_PROP(CONDITION, PROP_NAME) CHECK_PROP_COND_MSG(CONDITION, PROP_NAME, #CONDITION)

    class PictureProps::Impl_{
    private:
        friend class PictureProps;

        PictureProps &p;

        static Integer dpiToDotsPerM(Integer xInDpi){
            Integer DotsPerMPerDpiNumerator = 5000;
            Integer DotsPerMPerDpiDenominator = 127;
            return roundDiv(
                xInDpi * DotsPerMPerDpiNumerator,
                DotsPerMPerDpiDenominator
            );
        }

        static Integer dotsPerMToDpi(Integer xInDotsPerM){
            Integer DpiPerDotsPerMNumerator = 127;
            Integer DpiPerDotsPerMDenominator = 5000;
            return roundDiv(
                xInDotsPerM * DpiPerDotsPerMNumerator,
                DpiPerDotsPerMDenominator
            );
        }

        template <typename What> void calculateUnchecked();

        Impl_(PictureProps &newP):
            p(newP)
        {}
    };

    template <> void PictureProps::Impl_::calculateUnchecked<PictureProps::PropCalcBmColorsUsed>(){
        std::set<Integer> usedColors;

        const char *pixel = p.get<Blob>("bm/data").getDataReadOnly();
        Integer size[2] = {
            p.get<Integer>("bm/x-size"),
            p.get<Integer>("bm/y-size")
        };
        const Integer bmBytesPerPixel = checkedBitsToIntBytes(
            p.get<Integer>("bm/bpp")
        );
        const Integer bmScanlineSkipInBytes = checkedBitsToIntBytes(
            p.get<Integer>("bm/scanline-skip")
        );
        Integer coord[2];

        Integer bmPixelMaskColor;
        if(p.get<String>("bm/pixel-format-type") == "rgb"){
            bmPixelMaskColor =
                p.get<Integer>("bm/pixel-mask/r") |
                p.get<Integer>("bm/pixel-mask/g") |
                p.get<Integer>("bm/pixel-mask/b");
        }else if(p.get<String>("bm/pixel-format-type") == "pal"){
            bmPixelMaskColor = p.get<Integer>("bm/pixel-mask/pal");
        }else if(p.get<String>("bm/pixel-format-type") == "gray"){
            bmPixelMaskColor = p.get<Integer>("bm/pixel-mask/gray");
        }else{
            throw logic_error("Assumption have failed");
        }

        if(p.get<String>("bm/scanline-axis") != "x"){
            std::swap(size[0], size[1]);
        }

        for(
            coord[0] = 0;
            coord[0] < size[0];
            ++coord[0]
        ){
            for(
                coord[1] = 0;
                coord[1] < size[1];
                ++coord[1]
            ){
                usedColors.insert(
                    getBytes<Integer>(pixel, bmBytesPerPixel) & bmPixelMaskColor
                );
                pixel += bmBytesPerPixel;
            }
            pixel += bmScanlineSkipInBytes;
        }

        p.set<Integer>("calc/bm/colors-used", usedColors.size());

    }

    template <> void PictureProps::Impl_::calculateUnchecked<PictureProps::PropCalcBmDataSize>(){
        p.set("calc/bm/data-size", checkedBitsToIntBytes(
            p.get<Integer>("calc/bm/scanline-pitch-bits")*
            p.get<Integer>("bm/y-size")
        ));
    }

    template <> void PictureProps::Impl_::calculateUnchecked<PictureProps::PropCalcBmSizeLengthUnits>(){
        if(p.isSet("bm/x-dpi")){
            p.set<Real>(
                "calc/bm/x-size-in-inch",
                p.get<Real>("bm/x-size")/p.get<Real>("bm/x-dpi")
            );
        }
        if(p.isSet("bm/y-dpi")){
            p.set<Real>(
                "calc/bm/y-size-in-inch",
                p.get<Real>("bm/y-size")/p.get<Real>("bm/y-dpi")
            );
        }
        if(p.isSet("bm/x-dots-per-m")){
            p.set<Real>(
                "calc/bm/x-size-in-m",
                p.get<Real>("bm/x-size")/p.get<Real>("bm/x-dots-per-m")
            );
        }
        if(p.isSet("bm/y-dots-per-m")){
            p.set<Real>(
                "calc/bm/y-size-in-m",
                p.get<Real>("bm/y-size")/p.get<Real>("bm/y-dots-per-m")
            );
        }
    }

    PictureProps::PictureProps():
        pimpl_(new Impl_(*this))
    {
        setDefaults();
    }

    PictureProps::~PictureProps() {}

    void PictureProps::setDefaults(){
        setDefault(*this, "file/loaded-info", "false");
        setDefault(*this, "file/loaded-bm-data", "false");

        setDefault(*this, "bm/x-size", "0");
        setDefault(*this, "bm/y-size", "0");
        setDefault(*this, "bm/scanline-skip", "0");
        setDefault(*this, "bm/scanline-axis", "x");

        setDefault(*this, "bm/bpp", "32");
        setDefault(*this, "bm/pixel-format-type", "rgb");
        setDefault(*this, "bm/pixel-mask/a", "0xff000000");
        setDefault(*this, "bm/pixel-mask/r", "0xff");
        setDefault(*this, "bm/pixel-mask/g", "0xff00");
        setDefault(*this, "bm/pixel-mask/b", "0xff0000");

        setDefault(*this, "bm/orient-left", "true");
        setDefault(*this, "bm/orient-top", "true");
    }


    template <> void PictureProps::check<PictureProps::PropBmData>(){
        calculate<PropCalcBmDataSize>();

        if(
            !(get<Blob>("bm/data").getDataSize() == get<Integer>("calc/bm/data-size"))
        ){
            throw LIBNEBULAR_ERROR(Log::getWrongValueMsg(
                "<Data size of blob keyed \"bm/data\">", get<Blob>("bm/data").getDataSize(), "\" == get<Integer>(\"calc/bm/data-size\")\"",
                "PictureProps key", "Invalid"
            ));
        }
    }

    // @note Pixel mask that doesn't correspond to "bm/pixel-format-type" here will be unset
    template <> void PictureProps::check<PictureProps::PropBmPixelFormat>(){
        CHECK_PROP(get<Integer>("bm/bpp") > 0, "bm/bpp");

        const String pixMaskPrefix = "bm/pixel-mask/";

        CHECK_PROP(isSet("bm/pixel-format-type"), "bm/pixel-format-type");

        Integer bmPixelMaskColor = 0;
        if(isSet(pixMaskPrefix+"pal")){
            // Palettized
            if(get<String>("bm/pixel-format-type") == "pal"){
                CHECK_PROP(bits::areContig(get<Integer>(pixMaskPrefix+"pal")), pixMaskPrefix+"pal");

                bmPixelMaskColor = get<Integer>(pixMaskPrefix+"pal");
            }else{
                unSet(pixMaskPrefix+"pal");
            }
        }
        if(isSet(pixMaskPrefix+"gray")){
            if(get<String>("bm/pixel-format-type") == "gray"){
                CHECK_PROP(bits::areContig(get<Integer>(pixMaskPrefix+"gray")), pixMaskPrefix+"gray");

                bmPixelMaskColor = get<Integer>(pixMaskPrefix+"gray");
            }else{
                unSet(pixMaskPrefix+"gray");
            }
        }
        if(
            isSet(pixMaskPrefix+"r") ||
            isSet(pixMaskPrefix+"g") ||
            isSet(pixMaskPrefix+"b")
        ){
            if(get<String>("bm/pixel-format-type") == "rgb"){
                CHECK_PROP(isSet(pixMaskPrefix+"r"), pixMaskPrefix+"r");
                CHECK_PROP(isSet(pixMaskPrefix+"g"), pixMaskPrefix+"g");
                CHECK_PROP(isSet(pixMaskPrefix+"b"), pixMaskPrefix+"b");

                CHECK_PROP(bits::areContig(get<Integer>(pixMaskPrefix+"r")), pixMaskPrefix+"r");
                CHECK_PROP(bits::areContig(get<Integer>(pixMaskPrefix+"g")), pixMaskPrefix+"g");
                CHECK_PROP(bits::areContig(get<Integer>(pixMaskPrefix+"b")), pixMaskPrefix+"b");

                if(
                    (get<Integer>(pixMaskPrefix+"r") & get<Integer>(pixMaskPrefix+"g")) != 0 ||
                    (get<Integer>(pixMaskPrefix+"g") & get<Integer>(pixMaskPrefix+"b")) != 0 ||
                    (get<Integer>(pixMaskPrefix+"b") & get<Integer>(pixMaskPrefix+"r")) != 0
                ){
                    throw LIBNEBULAR_ERROR(Log::getWrongValueMsg(
                        "\"bm/pixel-mask/{r, g, b}\"", "<overlapping>", "not overlapping",
                        "PictureProps keys", "Conflicting"
                    ));
                }

                bmPixelMaskColor =
                    get<Integer>(pixMaskPrefix+"r") |
                    get<Integer>(pixMaskPrefix+"g") |
                    get<Integer>(pixMaskPrefix+"b");
            }else{
                unSet(pixMaskPrefix+"r");
                unSet(pixMaskPrefix+"g");
                unSet(pixMaskPrefix+"b");
            }

        }

        set< HexInteger<Integer> >("calc/bm/pixel-mask/color", bmPixelMaskColor);

        {
            CHECK_PROP(isSet(pixMaskPrefix+"a"), pixMaskPrefix+"a");
            CHECK_PROP(bits::areContig(get<Integer>(pixMaskPrefix+"a")), pixMaskPrefix+"a");

            if(
                (get<Integer>(pixMaskPrefix+"a") & bmPixelMaskColor) != 0
            ){
                throw LIBNEBULAR_ERROR(Log::getWrongValueMsg(
                    "\"bm/pixel-mask/a\"", "<overlapping>", "not overlapping with \"bm/pixel-mask/color\"",
                    "PictureProps keys", "Conflicting"
                ));
            }
        }

        if(
            ~bits::generateContig<Integer>(get<Integer>("bm/bpp")) & (
                bmPixelMaskColor | get<Integer>(pixMaskPrefix+"a")
            )
        ){
            throw LIBNEBULAR_ERROR(Log::getWrongValueMsg(
                "Union of \"bm/pixel-mask/{r, g, b, a, pal, gray}\"", bmPixelMaskColor | get<Integer>(pixMaskPrefix+"a"), String("not exceeding ")+get<String>("bm/bpp")+" bits length" ,
                "PictureProps keys", "Conflicting"
            ));
        }

        set< HexInteger<Integer> >(
            "calc/bm/pixel-mask/x",
            bits::generateContig<Integer>(get<Integer>("bm/bpp")) &
            ~(bmPixelMaskColor | get<Integer>(pixMaskPrefix+"a"))
        );
        
    }

    template <> void PictureProps::check<PictureProps::PropBmMiscDisplayParams>(){
        CHECK_PROP_COND_MSG(
            get<bool>("bm/orient-left") == true || get<bool>("bm/orient-left") == false,
            "bm/orient-left",
            "boolean"
        );
        CHECK_PROP_COND_MSG(
            get<bool>("bm/orient-top") == true || get<bool>("bm/orient-top") == false,
            "bm/orient-top",
            "boolean"
        );
    }

    template <> void PictureProps::check<PictureProps::PropBmMiscStorageParams>(){
        CHECK_PROP(get<Integer>("bm/x-size") >= 0, "bm/x-size");
        CHECK_PROP(get<Integer>("bm/y-size") >= 0, "bm/y-size");

        CHECK_PROP(get<Integer>("bm/scanline-skip") >= 0, "bm/scanline-skip");
        CHECK_PROP(
            get<String>("bm/scanline-axis") == "x" ||
            get<String>("bm/scanline-axis") == "y",
            "bm/scanline-axis"
        );

        CHECK_PROP(get<Integer>("bm/bpp") >= 0, "bm/bpp");

        Integer bmScanlinePitchBits = 
            (
                get<String>("bm/scanline-axis") == "x" ?
                get<Integer>("bm/x-size") :
                get<Integer>("bm/y-size")
            )*get<Integer>("bm/bpp") +
            get<Integer>("bm/scanline-skip")
        ;

        set<Integer>("calc/bm/scanline-pitch-bits", bmScanlinePitchBits);

        if(!( bmScanlinePitchBits % bitsPerByte == 0 )){
            throw LIBNEBULAR_ERROR(Log::getWrongValueMsg(
                "<value \"bmScanlinePitchBits\" calculated from PictureProps>", bmScanlinePitchBits, "\"bmScanlinePitchBits % bitsPerByte == 0\"",
                "calculated from PictureProps keys", "Invalid"
            ));
        }
    }

    template <> void PictureProps::check<PictureProps::PropBmPixelsPerLength>(){
        const Integer numAxes = 2;
        const String axisPrefix[numAxes] = {
            "bm/x-",
            "bm/y-"
        };
        for(
            Integer indexAxis = 0;
            indexAxis < numAxes;
            indexAxis++
        ){
            const String prefix = axisPrefix[indexAxis];
            
            if(isSet(prefix+"dots-per-m")){
                CHECK_PROP(get<Integer>(prefix+"dots-per-m") > 0, prefix+"dots-per-m");
            }

            if(isSet(prefix+"dpi")){
                CHECK_PROP(get<Integer>(prefix+"dpi") > 0, prefix+"dpi");

                if(isSet(prefix+"dots-per-m")){
                    CHECK_PROP_COND_MSG(
                        Impl_::dotsPerMToDpi(get<Integer>(prefix+"dots-per-m")) == 
                        get<Integer>(prefix+"dpi"),
                        prefix+"dots-per-m",
                        "not conflicting with \"" + prefix + "dpi\""
                    );
                }else{
                    set(
                        prefix+"dots-per-m",
                        Impl_::dpiToDotsPerM(get<Integer>(prefix+"dpi"))
                    );
                }
                    
            }else{
                
                if(isSet(prefix+"dots-per-m")){
                    set(prefix+"dpi", Impl_::dotsPerMToDpi(get<Integer>(prefix+"dots-per-m")));
                }
            }
        }

        pimpl_->calculateUnchecked<PropCalcBmSizeLengthUnits>();
    }

    template <> void PictureProps::calculate<PictureProps::PropCalcBmSizeLengthUnits>(){
        check<PropBmPixelsPerLength>();
    }

    template <> void PictureProps::calculate<PictureProps::PropCalcBmPixelMaskMisc>(){
        check<PictureProps::PropBmPixelFormat>();
    }

    template <> void PictureProps::calculate<PictureProps::PropCalcBmColorsUsed>(){
        check<PropBmData>();
        check<PropBmPixelFormat>();

        pimpl_->calculateUnchecked<PropCalcBmColorsUsed>();
    }

    template <> void PictureProps::calculate<PictureProps::PropCalcBmDataSize>(){
        check<PropBmMiscStorageParams>();
        CHECK_PROP(get<Integer>("bm/bpp") > 0, "bm/bpp");

        pimpl_->calculateUnchecked<PictureProps::PropCalcBmDataSize>();
    }

    template <> void PictureProps::check<PictureProps::PropBmInfo>(){
        check<PropBmPixelFormat>();
        check<PropBmMiscStorageParams>();
        // Not "info": check<PropBmData>();

        check<PropBmPixelsPerLength>();
        check<PropBmMiscDisplayParams>();
    }


    void PictureProps::prepareReproduceBmInfo(PictureProps &src){
        if(&src == this){
            return;
        }

        check<PropBmInfo>();

        src.check<PropBmInfo>();
        src.check<PropBmData>();

        setDefaults();

        {
            acceptOpt("bm/scanline-axis");
            acceptOpt("bm/scanline-skip");
            acceptOpt("bm/orient-left");
            acceptOpt("bm/orient-top");
            acceptOpt("bm/bpp");
            acceptOpt("bm/pixel-format-type");

            if(get<String>("bm/pixel-format-type") != "rgb"){
                throw LIBNEBULAR_ERROR(Log::getWrongValueMsg(
                    "\"bm/pixel-format-type\"", get<String>("bm/pixel-format-type"), "\"rgb\"",
                    "PictureProps key of \"*this\"", "Unsupported"
                ));
            }
            if(src.get<String>("bm/pixel-format-type") != "rgb"){
                throw LIBNEBULAR_ERROR(Log::getWrongValueMsg(
                    "\"bm/pixel-format-type\"", src.get<String>("bm/pixel-format-type"), "\"rgb\"",
                    "PictureProps key of \"src\"", "Unsupported"
                ));
            }

            {
                acceptOpt("bm/pixel-mask/r");
                acceptOpt("bm/pixel-mask/g");
                acceptOpt("bm/pixel-mask/b");
            }
            acceptOpt("bm/pixel-mask/a");

            set(
                "bm/x-size",
                src.get<Integer>("bm/x-size")
            );
            set(
                "bm/y-size",
                src.get<Integer>("bm/y-size")
            );
            copyFromIfSet<Integer>("bm/x-dpi", src);
            copyFromIfSet<Integer>("bm/y-dpi", src);
            copyFromIfSet<Integer>("bm/x-dots-per-m", src);
            copyFromIfSet<Integer>("bm/y-dots-per-m", src);

            if(isSetAndTrue("opt/bm/transpose")){
                swap<Integer>("bm/x-size", "bm/y-size");
                swap<Integer>("bm/x-dpi", "bm/y-dpi");
                swap<Integer>("bm/x-dots-per-m", "bm/y-dots-per-m");
            }

            acceptOpt("bm/x-dpi");
            acceptOpt("bm/y-dpi");
            acceptOpt("bm/x-dots-per-m");
            acceptOpt("bm/y-dots-per-m");
        }

        bool isBmIdentical =
            (get<String>("bm/scanline-axis") == src.get<String>("bm/scanline-axis")) && 
            (get<Integer>("bm/scanline-skip") == src.get<Integer>("bm/scanline-skip")) && 
            (get<bool>("bm/orient-top") == src.get<bool>("bm/orient-top")) && 
            (get<bool>("bm/orient-left") == src.get<bool>("bm/orient-left")) && 
            (get<Integer>("bm/bpp") == src.get<Integer>("bm/bpp")) && 
            (get<String>("bm/pixel-format-type") == src.get<String>("bm/pixel-format-type")) &&
            // @note Only for "rgb"
            (get<Integer>("bm/pixel-mask/r") == src.get<Integer>("bm/pixel-mask/r")) && 
            (get<Integer>("bm/pixel-mask/g") == src.get<Integer>("bm/pixel-mask/g")) && 
            (get<Integer>("bm/pixel-mask/b") == src.get<Integer>("bm/pixel-mask/b")) && 
            (get<Integer>("bm/pixel-mask/a") == src.get<Integer>("bm/pixel-mask/a")) &&

            !isSetAndTrue("opt/bm/transpose") &&
            !isSetAndTrue("opt/bm/flip-vertical") &&
            !isSetAndTrue("opt/bm/flip-horizontal")
            ;

        if(!isBmIdentical){
            calculate<PropCalcBmDataSize>();
        }else{
            set<Integer>("calc/bm/data-size", 0);
        }
        set("opt/bm/identical", isBmIdentical);
    }

    void PictureProps::reproduce(PictureProps &src){
        if(&src == this){
            checkUnusedOpts();
            return;
        }

        prepareReproduceBmInfo(src);

        if(get<bool>("opt/bm/identical")){
            set(
                "bm/data",
                src.get<Blob>("bm/data")
            );

        }else{

            Blob bmData;
            if(isSet("bm/data")){
                bmData = get<Blob>("bm/data");
                unSet("bm/data");
                bmData.forsakeData();
            }
            bmData.prepareForSize(get<Integer>("calc/bm/data-size"));

            if(!src.isSet("bm/data")){
                Log::warning("Reproduced image haven\'t \"bm/data\"");
                return;
            }

            const char *srcData = src.get<Blob>("bm/data").getDataReadOnly();
            char *destData = bmData.getDataReadWrite();

            Integer srcIncrement[2], destIncrement[2];

            const Integer numAxes = 2;
            bool haveToFlip[numAxes];
            Integer size[numAxes];
            {

                bool haveToFlipVertical = (
                    Integer(get<bool>("bm/orient-top") != src.get<bool>("bm/orient-top")) + 
                    Integer(
                        isSetAndTrue("opt/bm/flip-vertical")
                    )
                ) % 2;
                bool haveToFlipHorizontal = (
                    Integer(get<bool>("bm/orient-left") != src.get<bool>("bm/orient-left")) + 
                    Integer(
                        isSetAndTrue("opt/bm/flip-horizontal")
                    )
                ) % 2;
                bool haveToTranspose = (
                    Integer(get<String>("bm/scanline-axis") != src.get<String>("bm/scanline-axis")) + 
                    Integer(
                        isSetAndTrue("opt/bm/transpose")
                    )
                ) % 2;

                if(isSet("opt/bm/flip-vertical")){
                    unSet("opt/bm/flip-vertical");
                }
                if(isSet("opt/bm/flip-horizontal")){
                    unSet("opt/bm/flip-horizontal");
                }
                if(isSet("opt/bm/transpose")){
                    unSet("opt/bm/transpose");
                }

                if(get<String>("bm/scanline-axis") == "x"){
                    size[0] = src.get<Integer>("bm/x-size");
                    size[1] = src.get<Integer>("bm/y-size");

                    haveToFlip[0] = haveToFlipHorizontal;
                    haveToFlip[1] = haveToFlipVertical;
                }else{
                    size[0] = src.get<Integer>("bm/y-size");
                    size[1] = src.get<Integer>("bm/x-size");

                    haveToFlip[0] = haveToFlipVertical;
                    haveToFlip[1] = haveToFlipHorizontal;
                }
            
                Integer increment[numAxes] = {
                    checkedBitsToIntBytes(src.get<Integer>("bm/bpp")),
                    checkedBitsToIntBytes(src.get<Integer>("bm/bpp")*size[0]+
                    src.get<Integer>("bm/scanline-skip"))
                };
                Integer return_[numAxes] = {
                    increment[0]*size[0],
                    increment[1]*size[1]
                };

                if(haveToFlip[0]){
                    srcData += increment[0]*(size[0]-1);
                    increment[0] = -increment[0];
                    return_[0] = -return_[0];
                }
                if(haveToFlip[1]){
                    srcData += increment[1]*(size[1]-1);
                    increment[1] = -increment[1];
                    return_[1] = -return_[1];
                }
                if(haveToTranspose){
                    std::swap(increment[0], increment[1]);
                    std::swap(return_[0], return_[1]);
                    std::swap(size[0], size[1]);
                }

                srcIncrement[0] = increment[0];
                srcIncrement[1] = increment[1]-return_[0];
            }

            {
                destIncrement[0] = checkedBitsToIntBytes(
                    get<Integer>("bm/bpp")
                );
                destIncrement[1] = checkedBitsToIntBytes(
                    get<Integer>("bm/scanline-skip")
                );
            }

            static const Integer numComponents = 4;
            class PixelConverter{
            private:
                String componentId[numComponents];

                PictureProps &src, &dest;
                Integer
                srcMask[numComponents],
                destMask[numComponents],
                shift[numComponents],
                default_[numComponents];

                Integer bitShiftLeft(Integer a, Integer amount){
                    if(amount > 0){
                        return a << amount;
                    }else{
                        return a >> -amount;
                    }
                }

            public:
                PixelConverter(
                    PictureProps &newSrc,
                    PictureProps &newDest
                ):
                    src(newSrc),
                    dest(newDest)
                {

                    componentId[0] = "r";
                    componentId[1] = "g";
                    componentId[2] = "b";
                    componentId[3] = "a";

                    for(
                        Integer indexComponent = 0;
                        indexComponent < numComponents;
                        ++indexComponent
                    ){
                        srcMask[indexComponent] = src.get<Integer>(
                            String("bm/pixel-mask/")+componentId[indexComponent]
                        );
                        destMask[indexComponent] = dest.get<Integer>(
                            String("bm/pixel-mask/")+componentId[indexComponent]
                        );
                        shift[indexComponent] = bits::getHighestBitIndex(destMask[indexComponent])-
                            bits::getHighestBitIndex(srcMask[indexComponent]);
                    }

                    default_[0] = 0;
                    default_[1] = 0;
                    default_[2] = 0;
                    // Alpha channel
                    default_[3] = destMask[3];
                }

                Integer convert(Integer srcPixel){
                    Integer destPixel = 0;

                    for(
                        Integer indexComponent = 0;
                        indexComponent < numComponents;
                        ++indexComponent
                    ){
                        if(srcMask[indexComponent] != 0){
                            destPixel +=
                                bitShiftLeft(
                                    srcPixel &
                                    srcMask[indexComponent],
                                    shift[indexComponent]
                                )
                                & destMask[indexComponent];
                        }else{
                            destPixel += default_[indexComponent];
                        }
                    }

                    return destPixel;
                }
            } pixelConverter(src, *this);

            Integer index[numAxes];
            const Integer srcBmBytesPerPixel =
                checkedBitsToIntBytes(src.get<Integer>("bm/bpp"));
            const Integer destBmBytesPerPixel =
                checkedBitsToIntBytes(get<Integer>("bm/bpp"));
            for(
                index[1] = 0;
                index[1] < size[1];
                ++index[1]
            ){
                for(
                    index[0] = 0;
                    index[0] < size[0];
                    ++index[0]
                ){
                    Integer
                        srcPix = getBytes<Integer>(srcData, srcBmBytesPerPixel),
                        destPix = pixelConverter.convert(srcPix);

                    setBytes(destData, destBmBytesPerPixel, destPix);

                    srcData += srcIncrement[0];
                    destData += destIncrement[0];
                }
                srcData += srcIncrement[1];
                // Destination "scanline-skip" is skipped (and not zeroized) here
                destData += destIncrement[1];
            }
            set("bm/data", bmData);
        }
        unSet("opt/bm/identical");

        checkUnusedOpts();
    }

    // }

    void PictureProps::checkUnusedOpts(){
        boost::shared_ptr<PicturePropContainer> subtree =
            createSubtreeProxy<PicturePropContainer>(
                *this,
                "opt/"
            );
        PicturePropContainer::PropKeyIterator key = subtree->propKeyBegin();
        while(key != subtree->propKeyEnd()){
            Log::warning(
                Log::getWrongValueMsg(
                    string("\"") + *key + "\"", get<String>(*key), "<used and unset>",
                    "PictureProps key", "Unused option"
                )
            );

            PicturePropContainer::PropKeyIterator prevKey = key;
            ++key;
            unSet(*prevKey);
        }
    }
        

}

---