pixel.cpp

Go to the documentation of this file.

/*
  CLAW - a C++ Library Absolutely Wonderful

  CLAW is a free library without any particular aim but being useful to 
  anyone.

  Copyright (C) 2005-2011 Julien Jorge

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library 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
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

  contact: julien.jorge@gamned.org
*/
#include <claw/pixel.hpp>

#include <claw/types.hpp>

#include <stdexcept>
#include <limits>
#include <climits>
#include <sstream>

namespace claw
{
  namespace graphic
  {
    rgba_pixel transparent_pixel( 0, 0, 0, 0 );

    rgba_pixel black_pixel
    ( 0, 0, 0, std::numeric_limits<rgba_pixel::component_type>::max() );
    rgba_pixel white_pixel
    ( std::numeric_limits<rgba_pixel::component_type>::max(),
      std::numeric_limits<rgba_pixel::component_type>::max(),
      std::numeric_limits<rgba_pixel::component_type>::max(),
      std::numeric_limits<rgba_pixel::component_type>::max() );

    rgba_pixel blue_pixel
    ( 0, 0, std::numeric_limits<rgba_pixel::component_type>::max(),
      std::numeric_limits<rgba_pixel::component_type>::max() );
    rgba_pixel green_pixel
    ( 0, std::numeric_limits<rgba_pixel::component_type>::max(), 0,
      std::numeric_limits<rgba_pixel::component_type>::max() );
    rgba_pixel red_pixel
    ( std::numeric_limits<rgba_pixel::component_type>::max(), 0, 0,
      std::numeric_limits<rgba_pixel::component_type>::max() );

    rgba_pixel yellow_pixel
    ( std::numeric_limits<rgba_pixel::component_type>::max(),
      std::numeric_limits<rgba_pixel::component_type>::max(), 0,
      std::numeric_limits<rgba_pixel::component_type>::max() );
    rgba_pixel magenta_pixel
    ( std::numeric_limits<rgba_pixel::component_type>::max(), 0,
      std::numeric_limits<rgba_pixel::component_type>::max(),
      std::numeric_limits<rgba_pixel::component_type>::max() );
    rgba_pixel cyan_pixel
    ( 0, std::numeric_limits<rgba_pixel::component_type>::max(),
      std::numeric_limits<rgba_pixel::component_type>::max(),
      std::numeric_limits<rgba_pixel::component_type>::max() );

  } // namespace graphic
} // namespace claw

/*----------------------------------------------------------------------------*/
claw::graphic::rgb_pixel::rgb_pixel()
{

} // rgb_pixel::rgb_pixel()

/*----------------------------------------------------------------------------*/
claw::graphic::rgb_pixel::rgb_pixel
( component_type r, component_type g, component_type b )
{ 
  components.red = r;
  components.green = g;
  components.blue = b;
} // rgb_pixel::rgb_pixel()

/*----------------------------------------------------------------------------*/
claw::graphic::rgb_pixel::rgb_pixel( const rgba_pixel& p )
{ 
  components.red = p.components.red;
  components.green = p.components.green;
  components.blue = p.components.blue;
} // rgb_pixel::rgb_pixel()

/*----------------------------------------------------------------------------*/
claw::graphic::rgb_pixel::rgb_pixel( const std::string& c )
{
  std::istringstream iss(c);
  u_int_32 color;

  if ( c[0] == '#' )
    iss.ignore(1);

  if ( !(iss >> std::hex >> color) )
    throw std::invalid_argument(c);

  components.red = (color & 0xFF0000) >> (CHAR_BIT * 2);
  components.green = (color & 0x00FF00) >> CHAR_BIT;
  components.blue = color & 0x0000FF;
} // rgb_pixel::rgb_pixel()

/*----------------------------------------------------------------------------*/
bool claw::graphic::rgb_pixel::operator==(const rgb_pixel& that) const
{ 
  return (components.red == that.components.red)
    && (components.green == that.components.green)
    && (components.blue == that.components.blue);
} // rgb_pixel::operator==()

/*----------------------------------------------------------------------------*/
bool claw::graphic::rgb_pixel::operator==(const rgba_pixel& that) const
{ 
  return *this == rgb_pixel(that);
} // rgb_pixel::operator==()

/*----------------------------------------------------------------------------*/
bool claw::graphic::rgb_pixel::operator!=(const rgb_pixel& that) const
{ 
  return !(*this == that);
} // rgb_pixel::operator!=()

/*----------------------------------------------------------------------------*/
bool claw::graphic::rgb_pixel::operator!=(const rgba_pixel& that) const
{ 
  return !(*this == that);
} // rgb_pixel::operator!=()




/*----------------------------------------------------------------------------*/
claw::graphic::rgba_pixel::rgba_pixel()
{

} // rgba_pixel::rgba_pixel()

/*----------------------------------------------------------------------------*/
claw::graphic::rgba_pixel::rgba_pixel( const rgb_pixel& that )
{
  components.red = that.components.red;
  components.green = that.components.green;
  components.blue = that.components.blue;
  components.alpha = 255;
} // rgba_pixel::rgba_pixel()

/*----------------------------------------------------------------------------*/
claw::graphic::rgba_pixel::rgba_pixel
( component_type r, component_type g, component_type b, component_type a )
{ 
  components.red = r;
  components.green = g;
  components.blue = b;
  components.alpha = a;
} // rgba_pixel::rgba_pixel()

/*----------------------------------------------------------------------------*/
claw::graphic::rgba_pixel::rgba_pixel( const std::string& c )
{
  std::istringstream iss(c);
  u_int_32 color;
  bool has_alpha;

  if ( c[0] == '#' )
    {
      iss.ignore(1);
      has_alpha = c.length() > 7;
    }
  else
    has_alpha = c.length() > 6;

  if ( !((iss >> std::hex >> color) && (iss.rdbuf()->in_avail() == 0)) )
    throw std::invalid_argument(c);

  if ( has_alpha )
    components.alpha = (color & 0xFF000000) >> (CHAR_BIT * 3);
  else
    components.alpha = std::numeric_limits<component_type>::max();

  components.red = (color & 0xFF0000) >> (CHAR_BIT * 2);
  components.green = (color & 0x00FF00) >> CHAR_BIT;
  components.blue = color & 0x0000FF;
} // rgba_pixel::rgba_pixel()

/*----------------------------------------------------------------------------*/
claw::graphic::rgba_pixel&
claw::graphic::rgba_pixel::operator=( const rgb_pixel& that )
{
  components.red = that.components.red;
  components.green = that.components.green;
  components.blue = that.components.blue;
  components.alpha = 255;

  return *this;
} // rgba_pixel::operator=()

/*----------------------------------------------------------------------------*/
bool claw::graphic::rgba_pixel::operator==( const rgba_pixel& that ) const
{
  return pixel == that.pixel;
} // rgba_pixel::operator==()

/*----------------------------------------------------------------------------*/
bool claw::graphic::rgba_pixel::operator!=( const rgba_pixel& that ) const
{
  return pixel != that.pixel;
} // rgba_pixel::operator!=()

/*----------------------------------------------------------------------------*/
claw::graphic::rgba_pixel::component_type
claw::graphic::rgba_pixel::luminosity() const
{
  return ((unsigned int)components.red * 183 
          + (unsigned int)components.green * 54 
          + (unsigned int)components.blue * 18
          ) / 256;
} // rgba_pixel::luminosity()