lib/icon_pixel.cc

Go to the documentation of this file.

//
// canola - canon canola 1614p emulator
// Copyright (C) 2011 Peter Miller
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License, version 3, as
// published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include <lib/icon_pixel.h>
#include <lib/std_string_printf.h>


const icon_pixel icon_pixel::black(0., 0., 0., 1.);
const icon_pixel icon_pixel::white(1., 1., 1., 1.);
const icon_pixel icon_pixel::transparent;


std::string
icon_pixel::representation(void)
    const
{
    return
        std_string_printf
        (
            "{ r=%g, g=%g, b=%g, a=%g }",
            get_red(),
            get_green(),
            get_blue(),
            get_alpha()
        );
}


bool
icon_pixel::operator==(const icon_pixel &rhs)
    const
{
    if (get_alpha_short() == 0 && rhs.get_alpha_short() == 0)
        return true;
    return
        (
            get_red_short() == rhs.get_red_short()
        &&
            get_green_short() == rhs.get_green_short()
        &&
            get_blue_short() == rhs.get_blue_short()
        &&
            get_alpha_short() == rhs.get_alpha_short()
        );
}


void
icon_pixel::operator*=(const icon_pixel &rhs)
{
    if (is_transparent())
        return;
    if (!real_valid)
        convert_short_to_real();
    if (rhs.is_transparent())
    {
        *this = transparent;
        return;
    }
    short_valid = false;
    red_real *= rhs.get_red();
    green_real *= rhs.get_green();
    blue_real *= rhs.get_blue();
    alpha_real *= rhs.get_alpha();
}


icon_pixel
icon_pixel::operator*(const icon_pixel &rhs)
    const
{
    icon_pixel result(*this);
    result *= rhs;
    return result;
}


void
icon_pixel::operator*=(double rhs)
{
    //
    // The alpha channel is deliberately left unchanged.
    // This operates on the intensity only.
    //
    if (is_transparent())
        return;
    if (!real_valid)
        convert_short_to_real();
    short_valid = false;

    red_real *= rhs;
    if (red_real < 0)
        red_real = 0.;
    else if (red_real > 1.)
        red_real = 1.;

    green_real *= rhs;
    if (green_real < 0)
        green_real = 0.;
    else if (green_real > 1.)
        green_real = 1.;

    blue_real *= rhs;
    if (blue_real < 0)
        blue_real = 0.;
    else if (blue_real > 1.)
        blue_real = 1.;
}


icon_pixel
icon_pixel::operator*(double rhs)
    const
{
    icon_pixel result(*this);
    result *= rhs;
    return result;
}


icon_pixel::real_type
icon_pixel::get_intensity()
    const
{
    if (!real_valid)
        convert_short_to_real();
    return (0.299 * red_real + 0.587 * green_real + 0.114 * blue_real);
}


icon_pixel
icon_pixel::monochrome()
    const
{
    real_type y = get_intensity();
    return icon_pixel(y, y, y, alpha_real);
}