You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
359 lines
7.2 KiB
359 lines
7.2 KiB
/* This file is part of the KDE project
|
|
Copyright (C) 2001, The Karbon Developers
|
|
Copyright (C) 2002, The Karbon Developers
|
|
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Library General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 2 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
|
|
Library General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Library General Public License
|
|
along with this library; see the file COPYING.LIB. If not, write to
|
|
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
|
|
#include <tqdom.h>
|
|
|
|
#include "vcolor.h"
|
|
#include "vglobal.h"
|
|
|
|
|
|
VColor::VColor( VColorSpace colorSpace )
|
|
{
|
|
m_colorSpace = colorSpace;
|
|
m_opacity = 1.0;
|
|
|
|
m_value[0] = 0.0;
|
|
m_value[1] = 0.0;
|
|
m_value[2] = 0.0;
|
|
m_value[3] = 0.0;
|
|
}
|
|
|
|
VColor::VColor( const VColor& color )
|
|
{
|
|
m_colorSpace = color.m_colorSpace;
|
|
m_opacity = color.m_opacity;
|
|
|
|
m_value[0] = color.m_value[0];
|
|
m_value[1] = color.m_value[1];
|
|
m_value[2] = color.m_value[2];
|
|
m_value[3] = color.m_value[3];
|
|
}
|
|
|
|
VColor::VColor( const TQColor& color )
|
|
{
|
|
m_colorSpace = rgb;
|
|
m_opacity = 1.0;
|
|
|
|
m_value[0] = color.red() / 255.0;
|
|
m_value[1] = color.green() / 255.0;
|
|
m_value[2] = color.blue() / 255.0;
|
|
}
|
|
|
|
VColor::operator TQColor() const
|
|
{
|
|
VColor copy( *this );
|
|
copy.convertToColorSpace( rgb );
|
|
|
|
TQColor color;
|
|
color.setRgb( int( 255 * copy[0] ), int( 255 * copy[1] ), int( 255 * copy[2] ) );
|
|
|
|
return color;
|
|
}
|
|
|
|
void
|
|
VColor::setColorSpace( const VColorSpace colorSpace, bool convert )
|
|
{
|
|
if( convert )
|
|
convertToColorSpace( colorSpace );
|
|
|
|
m_colorSpace = colorSpace;
|
|
}
|
|
|
|
void
|
|
VColor::convertToColorSpace( const VColorSpace colorSpace )
|
|
{
|
|
// TODO: numerical stability.
|
|
// TODO: undercolor removal with cmyk.
|
|
|
|
if( colorSpace == rgb )
|
|
{
|
|
if( m_colorSpace == rgb )
|
|
{
|
|
// Do nothing.
|
|
}
|
|
else if( m_colorSpace == cmyk )
|
|
{
|
|
m_value[0] = 1.0 - kMin( 1.0f, m_value[0] + m_value[3] );
|
|
m_value[1] = 1.0 - kMin( 1.0f, m_value[1] + m_value[3] );
|
|
m_value[2] = 1.0 - kMin( 1.0f, m_value[2] + m_value[3] );
|
|
}
|
|
else if( m_colorSpace == hsb )
|
|
{
|
|
// Achromatic case (saturation == 0.0).
|
|
if( m_value[1] == 0.0 )
|
|
{
|
|
// Set to brightness:
|
|
m_value[0] = m_value[2];
|
|
m_value[1] = m_value[2];
|
|
m_value[2] = m_value[2]; // For readability.
|
|
}
|
|
else
|
|
{
|
|
float hue6 = 6.0 * m_value[0];
|
|
uint i = static_cast<uint>( hue6 );
|
|
float f = hue6 - i;
|
|
|
|
float m = m_value[2] * ( 1.0 - m_value[1] );
|
|
float n = m_value[2] * ( 1.0 - m_value[1] * f );
|
|
float k = m_value[2] * ( 1.0 - m_value[1] * ( 1.0 - f ) );
|
|
|
|
float r;
|
|
float g;
|
|
float b;
|
|
|
|
switch( i )
|
|
{
|
|
case 1:
|
|
r = n;
|
|
g = m_value[2];
|
|
b = m;
|
|
break;
|
|
case 2:
|
|
r = m;
|
|
g = m_value[2];
|
|
b = k;
|
|
break;
|
|
case 3:
|
|
r = m;
|
|
g = n;
|
|
b = m_value[2];
|
|
break;
|
|
case 4:
|
|
r = k;
|
|
g = m;
|
|
b = m_value[2];
|
|
break;
|
|
case 5:
|
|
r = m_value[2];
|
|
g = m;
|
|
b = n;
|
|
break;
|
|
default:
|
|
r = m_value[2];
|
|
g = k;
|
|
b = m;
|
|
}
|
|
|
|
m_value[0] = r;
|
|
m_value[1] = g;
|
|
m_value[2] = b;
|
|
}
|
|
}
|
|
else if( m_colorSpace == gray )
|
|
{
|
|
m_value[0] = m_value[0]; // For readability.
|
|
m_value[1] = m_value[0];
|
|
m_value[2] = m_value[0];
|
|
}
|
|
}
|
|
else if( colorSpace == cmyk )
|
|
{
|
|
if( m_colorSpace == rgb )
|
|
{
|
|
m_value[0] = 1.0 - m_value[0];
|
|
m_value[1] = 1.0 - m_value[1];
|
|
m_value[2] = 1.0 - m_value[2];
|
|
m_value[3] = 0.0;
|
|
}
|
|
else if( m_colorSpace == cmyk )
|
|
{
|
|
// Do nothing.
|
|
}
|
|
else if( m_colorSpace == hsb )
|
|
{
|
|
// TODO
|
|
}
|
|
else if( m_colorSpace == gray )
|
|
{
|
|
m_value[1] = 0.0;
|
|
m_value[2] = 0.0;
|
|
m_value[3] = 1.0 - m_value[0];
|
|
m_value[0] = 0.0;
|
|
}
|
|
}
|
|
else if( colorSpace == hsb )
|
|
{
|
|
if( m_colorSpace == rgb )
|
|
{
|
|
if(
|
|
m_value[0] == m_value[1] &&
|
|
m_value[1] == m_value[2] )
|
|
{
|
|
// Arbitrary:
|
|
m_value[3] = m_value[0];
|
|
m_value[1] = 0.0;
|
|
m_value[2] = 0.0;
|
|
}
|
|
else
|
|
{
|
|
float max;
|
|
float min;
|
|
|
|
// Find maximum + minimum rgb component:
|
|
if( m_value[0] > m_value[1] )
|
|
{
|
|
max = m_value[0];
|
|
min = m_value[1];
|
|
}
|
|
else
|
|
{
|
|
max = m_value[1];
|
|
min = m_value[0];
|
|
}
|
|
|
|
if( m_value[2] > max )
|
|
max = m_value[2];
|
|
|
|
if( m_value[2] < min )
|
|
min = m_value[2];
|
|
|
|
|
|
float hue;
|
|
const float diff = max - min;
|
|
|
|
// Which rgb component is maximum?
|
|
if( max == m_value[0] )
|
|
// Red:
|
|
hue = ( m_value[1] - m_value[2] ) * VGlobal::one_6 / diff;
|
|
else if( max == m_value[1] )
|
|
// Green:
|
|
hue = ( m_value[2] - m_value[0] ) * VGlobal::one_6 / diff + VGlobal::one_3;
|
|
else
|
|
// Blue:
|
|
hue = ( m_value[0] - m_value[1] ) * VGlobal::one_6 / diff + VGlobal::two_3;
|
|
|
|
if( hue < 0.0 )
|
|
hue += 1.0;
|
|
|
|
|
|
m_value[0] = hue;
|
|
m_value[1] = diff / max;
|
|
m_value[2] = max;
|
|
}
|
|
}
|
|
else if( m_colorSpace == cmyk )
|
|
{
|
|
// TODO
|
|
}
|
|
else if( m_colorSpace == hsb )
|
|
{
|
|
// Do nothing.
|
|
}
|
|
else if( m_colorSpace == gray )
|
|
{
|
|
m_value[1] = 0.0;
|
|
m_value[2] = m_value[0];
|
|
m_value[0] = 0.0;
|
|
}
|
|
}
|
|
else if( colorSpace == gray )
|
|
{
|
|
if( m_colorSpace == rgb )
|
|
{
|
|
m_value[0] =
|
|
0.3 * m_value[0] +
|
|
0.59 * m_value[1] +
|
|
0.11 * m_value[2];
|
|
}
|
|
else if( m_colorSpace == cmyk )
|
|
{
|
|
m_value[0] =
|
|
1.0 - kMin( 1.0,
|
|
0.3 * m_value[0] +
|
|
0.59 * m_value[1] +
|
|
0.11 * m_value[2] +
|
|
m_value[3] );
|
|
}
|
|
else if( m_colorSpace == hsb )
|
|
{
|
|
m_value[0] = m_value[2];
|
|
}
|
|
else if( m_colorSpace == gray )
|
|
{
|
|
// Do nothing.
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
VColor::save( TQDomElement& element ) const
|
|
{
|
|
TQDomElement me = element.ownerDocument().createElement( "COLOR" );
|
|
element.appendChild( me );
|
|
|
|
if( m_colorSpace != rgb )
|
|
me.setAttribute( "colorSpace", m_colorSpace );
|
|
if( m_opacity != 1.0 )
|
|
me.setAttribute( "opacity", m_opacity );
|
|
|
|
if( m_colorSpace == gray )
|
|
me.setAttribute( "v", m_value[0] );
|
|
else
|
|
{
|
|
me.setAttribute( "v1", m_value[0] );
|
|
me.setAttribute( "v2", m_value[1] );
|
|
me.setAttribute( "v3", m_value[2] );
|
|
|
|
if( m_colorSpace == cmyk )
|
|
me.setAttribute( "v4", m_value[3] );
|
|
}
|
|
}
|
|
|
|
void
|
|
VColor::load( const TQDomElement& element )
|
|
{
|
|
switch( element.attribute( "colorSpace" ).toUShort() )
|
|
{
|
|
case 1:
|
|
m_colorSpace = cmyk; break;
|
|
case 2:
|
|
m_colorSpace = hsb; break;
|
|
case 3:
|
|
m_colorSpace = gray; break;
|
|
default:
|
|
m_colorSpace = rgb;
|
|
}
|
|
|
|
m_opacity = element.attribute( "opacity", "1.0" ).toFloat();
|
|
|
|
if( m_colorSpace == gray )
|
|
m_value[0] = element.attribute( "v", "0.0" ).toFloat();
|
|
else
|
|
{
|
|
m_value[0] = element.attribute( "v1", "0.0" ).toFloat();
|
|
m_value[1] = element.attribute( "v2", "0.0" ).toFloat();
|
|
m_value[2] = element.attribute( "v3", "0.0" ).toFloat();
|
|
|
|
if( m_colorSpace == cmyk )
|
|
m_value[3] = element.attribute( "v4", "0.0" ).toFloat();
|
|
}
|
|
|
|
if( m_value[0] < 0.0 || m_value[0] > 1.0 )
|
|
m_value[0] = 0.0;
|
|
if( m_value[1] < 0.0 || m_value[1] > 1.0 )
|
|
m_value[1] = 0.0;
|
|
if( m_value[2] < 0.0 || m_value[2] > 1.0 )
|
|
m_value[2] = 0.0;
|
|
if( m_value[3] < 0.0 || m_value[3] > 1.0 )
|
|
m_value[3] = 0.0;
|
|
}
|
|
|