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.
1502 lines
50 KiB
1502 lines
50 KiB
/*
|
|
* Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
|
|
* Copyright (c) 2004 Boudewijn Rempt <boud@valdyas.org>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* 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, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#include <config.h>
|
|
#include <limits.h>
|
|
#include <stdlib.h>
|
|
#include LCMS_HEADER
|
|
|
|
#include <tqimage.h>
|
|
#include <tqcolor.h>
|
|
|
|
#include <kdebug.h>
|
|
#include <tdelocale.h>
|
|
|
|
#include "kis_rgb_colorspace.h"
|
|
#include "kis_u8_base_colorspace.h"
|
|
#include "kis_color_conversions.h"
|
|
#include "kis_integer_maths.h"
|
|
#include "kis_colorspace_factory_registry.h"
|
|
|
|
#include "composite.h"
|
|
|
|
#define downscale(quantum) (quantum) //((unsigned char) ((quantum)/257UL))
|
|
#define upscale(value) (value) // ((TQ_UINT8) (257UL*(value)))
|
|
|
|
namespace {
|
|
const TQ_INT32 MAX_CHANNEL_RGB = 3;
|
|
const TQ_INT32 MAX_CHANNEL_RGBA = 4;
|
|
}
|
|
|
|
KisRgbColorSpace::KisRgbColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *p) :
|
|
KisU8BaseColorSpace(KisID("RGBA", i18n("RGB (8-bit integer/channel)")), TYPE_BGRA_8, icSigRgbData, parent, p)
|
|
{
|
|
m_channels.push_back(new KisChannelInfo(i18n("Red"), i18n("R"), 2, KisChannelInfo::COLOR, KisChannelInfo::UINT8, 1, TQColor(255,0,0)));
|
|
m_channels.push_back(new KisChannelInfo(i18n("Green"), i18n("G"), 1, KisChannelInfo::COLOR, KisChannelInfo::UINT8, 1, TQColor(0,255,0)));
|
|
m_channels.push_back(new KisChannelInfo(i18n("Blue"), i18n("B"), 0, KisChannelInfo::COLOR, KisChannelInfo::UINT8, 1, TQColor(0,0,255)));
|
|
m_channels.push_back(new KisChannelInfo(i18n("Alpha"), i18n("A"), 3, KisChannelInfo::ALPHA, KisChannelInfo::UINT8));
|
|
|
|
m_alphaPos = PIXEL_ALPHA;
|
|
init();
|
|
}
|
|
|
|
KisRgbColorSpace::~KisRgbColorSpace()
|
|
{
|
|
}
|
|
|
|
void KisRgbColorSpace::setPixel(TQ_UINT8 *pixel, TQ_UINT8 red, TQ_UINT8 green, TQ_UINT8 blue, TQ_UINT8 alpha) const
|
|
{
|
|
pixel[PIXEL_RED] = red;
|
|
pixel[PIXEL_GREEN] = green;
|
|
pixel[PIXEL_BLUE] = blue;
|
|
pixel[PIXEL_ALPHA] = alpha;
|
|
}
|
|
|
|
void KisRgbColorSpace::getPixel(const TQ_UINT8 *pixel, TQ_UINT8 *red, TQ_UINT8 *green, TQ_UINT8 *blue, TQ_UINT8 *alpha) const
|
|
{
|
|
*red = pixel[PIXEL_RED];
|
|
*green = pixel[PIXEL_GREEN];
|
|
*blue = pixel[PIXEL_BLUE];
|
|
*alpha = pixel[PIXEL_ALPHA];
|
|
}
|
|
|
|
void KisRgbColorSpace::mixColors(const TQ_UINT8 **colors, const TQ_UINT8 *weights, TQ_UINT32 nColors, TQ_UINT8 *dst) const
|
|
{
|
|
TQ_UINT32 totalRed = 0, totalGreen = 0, totalBlue = 0, totalAlpha = 0;
|
|
|
|
while (nColors--)
|
|
{
|
|
TQ_UINT32 alpha = (*colors)[PIXEL_ALPHA];
|
|
// although we only mult by weight and not by weight*256/255
|
|
// we divide by the same amount later, so there is no need
|
|
TQ_UINT32 alphaTimesWeight = alpha * *weights;
|
|
|
|
totalRed += (*colors)[PIXEL_RED] * alphaTimesWeight;
|
|
totalGreen += (*colors)[PIXEL_GREEN] * alphaTimesWeight;
|
|
totalBlue += (*colors)[PIXEL_BLUE] * alphaTimesWeight;
|
|
totalAlpha += alphaTimesWeight;
|
|
|
|
weights++;
|
|
colors++;
|
|
}
|
|
|
|
// note this is correct - if you look at the above calculation
|
|
if (totalAlpha > 255*255) totalAlpha = 255*255;
|
|
|
|
// Divide by 255.
|
|
dst[PIXEL_ALPHA] =(((totalAlpha + 0x80)>>8)+totalAlpha + 0x80) >>8;
|
|
|
|
if (totalAlpha > 0) {
|
|
totalRed = totalRed / totalAlpha;
|
|
totalGreen = totalGreen / totalAlpha;
|
|
totalBlue = totalBlue / totalAlpha;
|
|
} // else the values are already 0 too
|
|
|
|
TQ_UINT32 dstRed = totalRed;
|
|
//Q_ASSERT(dstRed <= 255);
|
|
if (dstRed > 255) dstRed = 255;
|
|
dst[PIXEL_RED] = dstRed;
|
|
|
|
TQ_UINT32 dstGreen = totalGreen;
|
|
//Q_ASSERT(dstGreen <= 255);
|
|
if (dstGreen > 255) dstGreen = 255;
|
|
dst[PIXEL_GREEN] = dstGreen;
|
|
|
|
TQ_UINT32 dstBlue = totalBlue;
|
|
//Q_ASSERT(dstBlue <= 255);
|
|
if (dstBlue > 255) dstBlue = 255;
|
|
dst[PIXEL_BLUE] = dstBlue;
|
|
}
|
|
|
|
void KisRgbColorSpace::convolveColors(TQ_UINT8** colors, TQ_INT32* kernelValues, KisChannelInfo::enumChannelFlags channelFlags, TQ_UINT8 *dst, TQ_INT32 factor, TQ_INT32 offset, TQ_INT32 nColors) const
|
|
{
|
|
TQ_INT64 totalRed = 0, totalGreen = 0, totalBlue = 0, totalAlpha = 0;
|
|
TQ_INT32 totalWeight = 0, totalWeightTransparent = 0;
|
|
while (nColors--)
|
|
{
|
|
TQ_INT32 weight = *kernelValues;
|
|
|
|
if (weight != 0) {
|
|
if((*colors)[PIXEL_ALPHA] == 0)
|
|
{
|
|
totalWeightTransparent += weight;
|
|
} else {
|
|
totalRed += (*colors)[PIXEL_RED] * weight;
|
|
totalGreen += (*colors)[PIXEL_GREEN] * weight;
|
|
totalBlue += (*colors)[PIXEL_BLUE] * weight;
|
|
}
|
|
totalAlpha += (*colors)[PIXEL_ALPHA] * weight;
|
|
totalWeight += weight;
|
|
}
|
|
colors++;
|
|
kernelValues++;
|
|
}
|
|
if(totalWeightTransparent == 0)
|
|
{
|
|
if (channelFlags & KisChannelInfo::FLAG_COLOR) {
|
|
dst[PIXEL_RED] = CLAMP((totalRed / factor) + offset, 0, TQ_UINT8_MAX);
|
|
dst[PIXEL_GREEN] = CLAMP((totalGreen / factor) + offset, 0, TQ_UINT8_MAX);
|
|
dst[PIXEL_BLUE] = CLAMP((totalBlue / factor) + offset, 0, TQ_UINT8_MAX);
|
|
}
|
|
if (channelFlags & KisChannelInfo::FLAG_ALPHA) {
|
|
dst[PIXEL_ALPHA] = CLAMP((totalAlpha/ factor) + offset, 0, TQ_UINT8_MAX);
|
|
}
|
|
} else if(totalWeightTransparent != totalWeight && (channelFlags & KisChannelInfo::FLAG_COLOR)) {
|
|
if(totalWeight == factor)
|
|
{
|
|
TQ_INT64 a = ( totalWeight - totalWeightTransparent );
|
|
dst[PIXEL_RED] = CLAMP((totalRed / a) + offset, 0, TQ_UINT8_MAX);
|
|
dst[PIXEL_GREEN] = CLAMP((totalGreen / a) + offset, 0, TQ_UINT8_MAX);
|
|
dst[PIXEL_BLUE] = CLAMP((totalBlue / a) + offset, 0, TQ_UINT8_MAX);
|
|
} else {
|
|
double a = totalWeight / ( factor * ( totalWeight - totalWeightTransparent ) ); // use double as it can saturate
|
|
dst[PIXEL_RED] = CLAMP( (TQ_UINT8)(totalRed * a) + offset, 0, TQ_UINT8_MAX);
|
|
dst[PIXEL_GREEN] = CLAMP( (TQ_UINT8)(totalGreen * a) + offset, 0, TQ_UINT8_MAX);
|
|
dst[PIXEL_BLUE] = CLAMP( (TQ_UINT8)(totalBlue * a) + offset, 0, TQ_UINT8_MAX);
|
|
}
|
|
}
|
|
if (channelFlags & KisChannelInfo::FLAG_ALPHA) {
|
|
dst[PIXEL_ALPHA] = CLAMP((totalAlpha/ factor) + offset, 0, TQ_UINT8_MAX);
|
|
}
|
|
}
|
|
|
|
|
|
void KisRgbColorSpace::invertColor(TQ_UINT8 * src, TQ_INT32 nPixels)
|
|
{
|
|
TQ_UINT32 psize = pixelSize();
|
|
|
|
while (nPixels--)
|
|
{
|
|
src[PIXEL_RED] = TQ_UINT8_MAX - src[PIXEL_RED];
|
|
src[PIXEL_GREEN] = TQ_UINT8_MAX - src[PIXEL_GREEN];
|
|
src[PIXEL_BLUE] = TQ_UINT8_MAX - src[PIXEL_BLUE];
|
|
|
|
src += psize;
|
|
}
|
|
}
|
|
|
|
|
|
void KisRgbColorSpace::darken(const TQ_UINT8 * src, TQ_UINT8 * dst, TQ_INT32 shade, bool compensate, double compensation, TQ_INT32 nPixels) const
|
|
{
|
|
TQ_UINT32 pSize = pixelSize();
|
|
|
|
while (nPixels--) {
|
|
if (compensate) {
|
|
dst[PIXEL_RED] = (TQ_INT8) TQMIN(255,((src[PIXEL_RED] * shade) / (compensation * 255)));
|
|
dst[PIXEL_GREEN] = (TQ_INT8) TQMIN(255,((src[PIXEL_GREEN] * shade) / (compensation * 255)));
|
|
dst[PIXEL_BLUE] = (TQ_INT8) TQMIN(255,((src[PIXEL_BLUE] * shade) / (compensation * 255)));
|
|
}
|
|
else {
|
|
dst[PIXEL_RED] = (TQ_INT8) TQMIN(255, (src[PIXEL_RED] * shade / 255));
|
|
dst[PIXEL_BLUE] = (TQ_INT8) TQMIN(255, (src[PIXEL_BLUE] * shade / 255));
|
|
dst[PIXEL_GREEN] = (TQ_INT8) TQMIN(255, (src[PIXEL_GREEN] * shade / 255));
|
|
}
|
|
dst += pSize;
|
|
src += pSize;
|
|
}
|
|
}
|
|
|
|
TQ_UINT8 KisRgbColorSpace::intensity8(const TQ_UINT8 * src) const
|
|
{
|
|
return (TQ_UINT8)((src[PIXEL_RED] * 0.30 + src[PIXEL_GREEN] * 0.59 + src[PIXEL_BLUE] * 0.11) + 0.5);
|
|
}
|
|
|
|
TQValueVector<KisChannelInfo *> KisRgbColorSpace::channels() const
|
|
{
|
|
return m_channels;
|
|
}
|
|
|
|
TQ_UINT32 KisRgbColorSpace::nChannels() const
|
|
{
|
|
return MAX_CHANNEL_RGBA;
|
|
}
|
|
|
|
TQ_UINT32 KisRgbColorSpace::nColorChannels() const
|
|
{
|
|
return MAX_CHANNEL_RGB;
|
|
}
|
|
|
|
TQ_UINT32 KisRgbColorSpace::pixelSize() const
|
|
{
|
|
return MAX_CHANNEL_RGBA;
|
|
}
|
|
|
|
TQImage KisRgbColorSpace::convertToTQImage(const TQ_UINT8 *data, TQ_INT32 width, TQ_INT32 height,
|
|
KisProfile * dstProfile,
|
|
TQ_INT32 renderingIntent, float /*exposure*/)
|
|
|
|
{
|
|
Q_ASSERT(data);
|
|
TQImage img = TQImage(const_cast<TQ_UINT8 *>(data), width, height, 32, 0, 0, TQImage::LittleEndian);
|
|
img.setAlphaBuffer(true);
|
|
// XXX: The previous version of this code used the quantum data directly
|
|
// as an optimisation. We're introducing a copy overhead here which could
|
|
// be factored out again if needed.
|
|
img = img.copy();
|
|
|
|
if (dstProfile != 0) {
|
|
KisColorSpace *dstCS = m_parent->getColorSpace(KisID("RGBA",""), dstProfile->productName());
|
|
convertPixelsTo(img.bits(),
|
|
img.bits(), dstCS,
|
|
width * height, renderingIntent);
|
|
}
|
|
|
|
return img;
|
|
}
|
|
|
|
|
|
|
|
|
|
void KisRgbColorSpace::compositeOver(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride,
|
|
const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride,
|
|
const TQ_UINT8 *maskRowStart, TQ_INT32 maskRowStride,
|
|
TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
|
|
{
|
|
while (rows > 0) {
|
|
|
|
const TQ_UINT8 *src = srcRowStart;
|
|
TQ_UINT8 *dst = dstRowStart;
|
|
const TQ_UINT8 *mask = maskRowStart;
|
|
TQ_INT32 columns = numColumns;
|
|
|
|
while (columns > 0) {
|
|
|
|
TQ_UINT8 srcAlpha = src[PIXEL_ALPHA];
|
|
|
|
// apply the alphamask
|
|
if(mask != 0)
|
|
{
|
|
if(*mask != OPACITY_OPAQUE)
|
|
srcAlpha = UINT8_MULT(srcAlpha, *mask);
|
|
mask++;
|
|
}
|
|
|
|
if (srcAlpha != OPACITY_TRANSPARENT) {
|
|
|
|
if (opacity != OPACITY_OPAQUE) {
|
|
srcAlpha = UINT8_MULT(srcAlpha, opacity);
|
|
}
|
|
|
|
if (srcAlpha == OPACITY_OPAQUE) {
|
|
memcpy(dst, src, MAX_CHANNEL_RGBA * sizeof(TQ_UINT8));
|
|
} else {
|
|
TQ_UINT8 dstAlpha = dst[PIXEL_ALPHA];
|
|
|
|
TQ_UINT8 srcBlend;
|
|
|
|
if (dstAlpha == OPACITY_OPAQUE) {
|
|
srcBlend = srcAlpha;
|
|
} else {
|
|
TQ_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
|
|
dst[PIXEL_ALPHA] = newAlpha;
|
|
|
|
if (newAlpha != 0) {
|
|
srcBlend = UINT8_DIVIDE(srcAlpha, newAlpha);
|
|
} else {
|
|
srcBlend = srcAlpha;
|
|
}
|
|
}
|
|
|
|
if (srcBlend == OPACITY_OPAQUE) {
|
|
memcpy(dst, src, MAX_CHANNEL_RGB * sizeof(TQ_UINT8));
|
|
} else {
|
|
dst[PIXEL_RED] = UINT8_BLEND(src[PIXEL_RED], dst[PIXEL_RED], srcBlend);
|
|
dst[PIXEL_GREEN] = UINT8_BLEND(src[PIXEL_GREEN], dst[PIXEL_GREEN], srcBlend);
|
|
dst[PIXEL_BLUE] = UINT8_BLEND(src[PIXEL_BLUE], dst[PIXEL_BLUE], srcBlend);
|
|
}
|
|
}
|
|
}
|
|
|
|
columns--;
|
|
src += MAX_CHANNEL_RGBA;
|
|
dst += MAX_CHANNEL_RGBA;
|
|
}
|
|
|
|
rows--;
|
|
srcRowStart += srcRowStride;
|
|
dstRowStart += dstRowStride;
|
|
if(maskRowStart)
|
|
maskRowStart += maskRowStride;
|
|
}
|
|
}
|
|
|
|
|
|
void KisRgbColorSpace::compositeAlphaDarken(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride,
|
|
const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride,
|
|
const TQ_UINT8 *maskRowStart, TQ_INT32 maskRowStride,
|
|
TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
|
|
{
|
|
while (rows > 0) {
|
|
|
|
const TQ_UINT8 *src = srcRowStart;
|
|
TQ_UINT8 *dst = dstRowStart;
|
|
const TQ_UINT8 *mask = maskRowStart;
|
|
TQ_INT32 columns = numColumns;
|
|
|
|
while (columns > 0) {
|
|
|
|
TQ_UINT8 srcAlpha = src[PIXEL_ALPHA];
|
|
TQ_UINT8 dstAlpha = dst[PIXEL_ALPHA];
|
|
|
|
// apply the alphamask
|
|
if(mask != 0)
|
|
{
|
|
if(*mask != OPACITY_OPAQUE)
|
|
srcAlpha = UINT8_MULT(srcAlpha, *mask);
|
|
mask++;
|
|
}
|
|
|
|
if (opacity != OPACITY_OPAQUE) {
|
|
srcAlpha = UINT8_MULT(srcAlpha, opacity);
|
|
}
|
|
|
|
if (srcAlpha != OPACITY_TRANSPARENT && srcAlpha >= dstAlpha) {
|
|
dst[PIXEL_ALPHA] = srcAlpha;
|
|
memcpy(dst, src, MAX_CHANNEL_RGB * sizeof(TQ_UINT8));
|
|
}
|
|
|
|
columns--;
|
|
src += MAX_CHANNEL_RGBA;
|
|
dst += MAX_CHANNEL_RGBA;
|
|
}
|
|
|
|
rows--;
|
|
srcRowStart += srcRowStride;
|
|
dstRowStart += dstRowStride;
|
|
if(maskRowStart)
|
|
maskRowStart += maskRowStride;
|
|
}
|
|
}
|
|
|
|
|
|
void KisRgbColorSpace::compositeMultiply(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride, const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride, const TQ_UINT8 *maskRowStart, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
|
|
{
|
|
while (rows > 0) {
|
|
|
|
const TQ_UINT8 *src = srcRowStart;
|
|
TQ_UINT8 *dst = dstRowStart;
|
|
TQ_INT32 columns = numColumns;
|
|
const TQ_UINT8 *mask = maskRowStart;
|
|
|
|
while (columns > 0) {
|
|
|
|
TQ_UINT8 srcAlpha = src[PIXEL_ALPHA];
|
|
TQ_UINT8 dstAlpha = dst[PIXEL_ALPHA];
|
|
|
|
srcAlpha = TQMIN(srcAlpha, dstAlpha);
|
|
|
|
// apply the alphamask
|
|
if(mask != 0)
|
|
{
|
|
if(*mask != OPACITY_OPAQUE)
|
|
srcAlpha = UINT8_MULT(srcAlpha, *mask);
|
|
mask++;
|
|
}
|
|
|
|
|
|
if (srcAlpha != OPACITY_TRANSPARENT) {
|
|
|
|
if (opacity != OPACITY_OPAQUE) {
|
|
srcAlpha = UINT8_MULT(src[PIXEL_ALPHA], opacity);
|
|
}
|
|
|
|
TQ_UINT8 srcBlend;
|
|
|
|
if (dstAlpha == OPACITY_OPAQUE) {
|
|
srcBlend = srcAlpha;
|
|
} else {
|
|
TQ_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
|
|
dst[PIXEL_ALPHA] = newAlpha;
|
|
|
|
if (newAlpha != 0) {
|
|
srcBlend = UINT8_DIVIDE(srcAlpha, newAlpha);
|
|
} else {
|
|
srcBlend = srcAlpha;
|
|
}
|
|
}
|
|
|
|
TQ_UINT8 srcColor = src[PIXEL_RED];
|
|
TQ_UINT8 dstColor = dst[PIXEL_RED];
|
|
|
|
srcColor = UINT8_MULT(srcColor, dstColor);
|
|
|
|
dst[PIXEL_RED] = UINT8_BLEND(srcColor, dstColor, srcBlend);
|
|
|
|
srcColor = src[PIXEL_GREEN];
|
|
dstColor = dst[PIXEL_GREEN];
|
|
|
|
srcColor = UINT8_MULT(srcColor, dstColor);
|
|
|
|
dst[PIXEL_GREEN] = UINT8_BLEND(srcColor, dstColor, srcBlend);
|
|
|
|
srcColor = src[PIXEL_BLUE];
|
|
dstColor = dst[PIXEL_BLUE];
|
|
|
|
srcColor = UINT8_MULT(srcColor, dstColor);
|
|
|
|
dst[PIXEL_BLUE] = UINT8_BLEND(srcColor, dstColor, srcBlend);
|
|
}
|
|
|
|
columns--;
|
|
src += MAX_CHANNEL_RGBA;
|
|
dst += MAX_CHANNEL_RGBA;
|
|
}
|
|
|
|
rows--;
|
|
srcRowStart += srcRowStride;
|
|
dstRowStart += dstRowStride;
|
|
if(maskRowStart)
|
|
maskRowStart += maskRowStride;
|
|
}
|
|
}
|
|
|
|
void KisRgbColorSpace::compositeDivide(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride, const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride, const TQ_UINT8 *maskRowStart, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
|
|
{
|
|
while (rows > 0) {
|
|
|
|
const TQ_UINT8 *src = srcRowStart;
|
|
TQ_UINT8 *dst = dstRowStart;
|
|
TQ_INT32 columns = numColumns;
|
|
const TQ_UINT8 *mask = maskRowStart;
|
|
|
|
while (columns > 0) {
|
|
|
|
TQ_UINT8 srcAlpha = src[PIXEL_ALPHA];
|
|
TQ_UINT8 dstAlpha = dst[PIXEL_ALPHA];
|
|
|
|
srcAlpha = TQMIN(srcAlpha, dstAlpha);
|
|
|
|
// apply the alphamask
|
|
if(mask != 0)
|
|
{
|
|
if(*mask != OPACITY_OPAQUE)
|
|
srcAlpha = UINT8_MULT(srcAlpha, *mask);
|
|
mask++;
|
|
}
|
|
|
|
if (srcAlpha != OPACITY_TRANSPARENT) {
|
|
|
|
if (opacity != OPACITY_OPAQUE) {
|
|
srcAlpha = UINT8_MULT(src[PIXEL_ALPHA], opacity);
|
|
}
|
|
|
|
TQ_UINT8 srcBlend;
|
|
|
|
if (dstAlpha == OPACITY_OPAQUE) {
|
|
srcBlend = srcAlpha;
|
|
} else {
|
|
TQ_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
|
|
dst[PIXEL_ALPHA] = newAlpha;
|
|
|
|
if (newAlpha != 0) {
|
|
srcBlend = UINT8_DIVIDE(srcAlpha, newAlpha);
|
|
} else {
|
|
srcBlend = srcAlpha;
|
|
}
|
|
}
|
|
|
|
for (int channel = 0; channel < MAX_CHANNEL_RGB; channel++) {
|
|
|
|
TQ_UINT8 srcColor = src[channel];
|
|
TQ_UINT8 dstColor = dst[channel];
|
|
|
|
srcColor = TQMIN((dstColor * (UINT8_MAX + 1u) + (srcColor / 2u)) / (1u + srcColor), UINT8_MAX);
|
|
|
|
TQ_UINT8 newColor = UINT8_BLEND(srcColor, dstColor, srcBlend);
|
|
|
|
dst[channel] = newColor;
|
|
}
|
|
}
|
|
|
|
columns--;
|
|
src += MAX_CHANNEL_RGBA;
|
|
dst += MAX_CHANNEL_RGBA;
|
|
}
|
|
|
|
rows--;
|
|
srcRowStart += srcRowStride;
|
|
dstRowStart += dstRowStride;
|
|
if(maskRowStart)
|
|
maskRowStart += maskRowStride;
|
|
}
|
|
}
|
|
|
|
void KisRgbColorSpace::compositeScreen(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride, const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride, const TQ_UINT8 *maskRowStart, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
|
|
{
|
|
while (rows > 0) {
|
|
|
|
const TQ_UINT8 *src = srcRowStart;
|
|
TQ_UINT8 *dst = dstRowStart;
|
|
TQ_INT32 columns = numColumns;
|
|
const TQ_UINT8 *mask = maskRowStart;
|
|
|
|
while (columns > 0) {
|
|
|
|
TQ_UINT8 srcAlpha = src[PIXEL_ALPHA];
|
|
TQ_UINT8 dstAlpha = dst[PIXEL_ALPHA];
|
|
|
|
srcAlpha = TQMIN(srcAlpha, dstAlpha);
|
|
|
|
// apply the alphamask
|
|
if(mask != 0)
|
|
{
|
|
if(*mask != OPACITY_OPAQUE)
|
|
srcAlpha = UINT8_MULT(srcAlpha, *mask);
|
|
mask++;
|
|
}
|
|
|
|
if (srcAlpha != OPACITY_TRANSPARENT) {
|
|
|
|
if (opacity != OPACITY_OPAQUE) {
|
|
srcAlpha = UINT8_MULT(src[PIXEL_ALPHA], opacity);
|
|
}
|
|
|
|
TQ_UINT8 srcBlend;
|
|
|
|
if (dstAlpha == OPACITY_OPAQUE) {
|
|
srcBlend = srcAlpha;
|
|
} else {
|
|
TQ_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
|
|
dst[PIXEL_ALPHA] = newAlpha;
|
|
|
|
if (newAlpha != 0) {
|
|
srcBlend = UINT8_DIVIDE(srcAlpha, newAlpha);
|
|
} else {
|
|
srcBlend = srcAlpha;
|
|
}
|
|
}
|
|
|
|
for (int channel = 0; channel < MAX_CHANNEL_RGB; channel++) {
|
|
|
|
TQ_UINT8 srcColor = src[channel];
|
|
TQ_UINT8 dstColor = dst[channel];
|
|
|
|
srcColor = UINT8_MAX - UINT8_MULT(UINT8_MAX - dstColor, UINT8_MAX - srcColor);
|
|
|
|
TQ_UINT8 newColor = UINT8_BLEND(srcColor, dstColor, srcBlend);
|
|
|
|
dst[channel] = newColor;
|
|
}
|
|
}
|
|
|
|
columns--;
|
|
src += MAX_CHANNEL_RGBA;
|
|
dst += MAX_CHANNEL_RGBA;
|
|
}
|
|
|
|
rows--;
|
|
srcRowStart += srcRowStride;
|
|
dstRowStart += dstRowStride;
|
|
if(maskRowStart)
|
|
maskRowStart += maskRowStride;
|
|
}
|
|
}
|
|
|
|
void KisRgbColorSpace::compositeOverlay(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride, const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride, const TQ_UINT8 *maskRowStart, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
|
|
{
|
|
while (rows > 0) {
|
|
|
|
const TQ_UINT8 *src = srcRowStart;
|
|
TQ_UINT8 *dst = dstRowStart;
|
|
TQ_INT32 columns = numColumns;
|
|
const TQ_UINT8 *mask = maskRowStart;
|
|
|
|
while (columns > 0) {
|
|
|
|
TQ_UINT8 srcAlpha = src[PIXEL_ALPHA];
|
|
TQ_UINT8 dstAlpha = dst[PIXEL_ALPHA];
|
|
|
|
srcAlpha = TQMIN(srcAlpha, dstAlpha);
|
|
|
|
// apply the alphamask
|
|
if(mask != 0)
|
|
{
|
|
if(*mask != OPACITY_OPAQUE)
|
|
srcAlpha = UINT8_MULT(srcAlpha, *mask);
|
|
mask++;
|
|
}
|
|
|
|
|
|
if (srcAlpha != OPACITY_TRANSPARENT) {
|
|
|
|
if (opacity != OPACITY_OPAQUE) {
|
|
srcAlpha = UINT8_MULT(src[PIXEL_ALPHA], opacity);
|
|
}
|
|
|
|
TQ_UINT8 srcBlend;
|
|
|
|
if (dstAlpha == OPACITY_OPAQUE) {
|
|
srcBlend = srcAlpha;
|
|
} else {
|
|
TQ_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
|
|
dst[PIXEL_ALPHA] = newAlpha;
|
|
|
|
if (newAlpha != 0) {
|
|
srcBlend = UINT8_DIVIDE(srcAlpha, newAlpha);
|
|
} else {
|
|
srcBlend = srcAlpha;
|
|
}
|
|
}
|
|
|
|
for (int channel = 0; channel < MAX_CHANNEL_RGB; channel++) {
|
|
|
|
TQ_UINT8 srcColor = src[channel];
|
|
TQ_UINT8 dstColor = dst[channel];
|
|
|
|
srcColor = UINT8_MULT(dstColor, dstColor + UINT8_MULT(2 * srcColor, UINT8_MAX - dstColor));
|
|
|
|
TQ_UINT8 newColor = UINT8_BLEND(srcColor, dstColor, srcBlend);
|
|
|
|
dst[channel] = newColor;
|
|
}
|
|
}
|
|
|
|
columns--;
|
|
src += MAX_CHANNEL_RGBA;
|
|
dst += MAX_CHANNEL_RGBA;
|
|
}
|
|
|
|
rows--;
|
|
srcRowStart += srcRowStride;
|
|
dstRowStart += dstRowStride;
|
|
if(maskRowStart)
|
|
maskRowStart += maskRowStride;
|
|
}
|
|
}
|
|
|
|
void KisRgbColorSpace::compositeDodge(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride, const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride, const TQ_UINT8 *maskRowStart, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
|
|
{
|
|
while (rows > 0) {
|
|
|
|
const TQ_UINT8 *src = srcRowStart;
|
|
TQ_UINT8 *dst = dstRowStart;
|
|
TQ_INT32 columns = numColumns;
|
|
const TQ_UINT8 *mask = maskRowStart;
|
|
|
|
while (columns > 0) {
|
|
|
|
TQ_UINT8 srcAlpha = src[PIXEL_ALPHA];
|
|
TQ_UINT8 dstAlpha = dst[PIXEL_ALPHA];
|
|
|
|
srcAlpha = TQMIN(srcAlpha, dstAlpha);
|
|
|
|
// apply the alphamask
|
|
if(mask != 0)
|
|
{
|
|
if(*mask != OPACITY_OPAQUE)
|
|
srcAlpha = UINT8_MULT(srcAlpha, *mask);
|
|
mask++;
|
|
}
|
|
|
|
|
|
if (srcAlpha != OPACITY_TRANSPARENT) {
|
|
|
|
if (opacity != OPACITY_OPAQUE) {
|
|
srcAlpha = UINT8_MULT(src[PIXEL_ALPHA], opacity);
|
|
}
|
|
|
|
TQ_UINT8 srcBlend;
|
|
|
|
if (dstAlpha == OPACITY_OPAQUE) {
|
|
srcBlend = srcAlpha;
|
|
} else {
|
|
TQ_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
|
|
dst[PIXEL_ALPHA] = newAlpha;
|
|
|
|
if (newAlpha != 0) {
|
|
srcBlend = UINT8_DIVIDE(srcAlpha, newAlpha);
|
|
} else {
|
|
srcBlend = srcAlpha;
|
|
}
|
|
}
|
|
|
|
for (int channel = 0; channel < MAX_CHANNEL_RGB; channel++) {
|
|
|
|
TQ_UINT8 srcColor = src[channel];
|
|
TQ_UINT8 dstColor = dst[channel];
|
|
|
|
srcColor = TQMIN((dstColor * (UINT8_MAX + 1)) / (UINT8_MAX + 1 - srcColor), UINT8_MAX);
|
|
|
|
TQ_UINT8 newColor = UINT8_BLEND(srcColor, dstColor, srcBlend);
|
|
|
|
dst[channel] = newColor;
|
|
}
|
|
}
|
|
|
|
columns--;
|
|
src += MAX_CHANNEL_RGBA;
|
|
dst += MAX_CHANNEL_RGBA;
|
|
}
|
|
|
|
rows--;
|
|
srcRowStart += srcRowStride;
|
|
dstRowStart += dstRowStride;
|
|
if(maskRowStart)
|
|
maskRowStart += maskRowStride;
|
|
}
|
|
}
|
|
|
|
void KisRgbColorSpace::compositeBurn(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride, const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride, const TQ_UINT8 *maskRowStart, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
|
|
{
|
|
while (rows > 0) {
|
|
|
|
const TQ_UINT8 *src = srcRowStart;
|
|
TQ_UINT8 *dst = dstRowStart;
|
|
TQ_INT32 columns = numColumns;
|
|
const TQ_UINT8 *mask = maskRowStart;
|
|
|
|
while (columns > 0) {
|
|
|
|
TQ_UINT8 srcAlpha = src[PIXEL_ALPHA];
|
|
TQ_UINT8 dstAlpha = dst[PIXEL_ALPHA];
|
|
|
|
srcAlpha = TQMIN(srcAlpha, dstAlpha);
|
|
|
|
// apply the alphamask
|
|
if(mask != 0)
|
|
{
|
|
if(*mask != OPACITY_OPAQUE)
|
|
srcAlpha = UINT8_MULT(srcAlpha, *mask);
|
|
mask++;
|
|
}
|
|
|
|
if (srcAlpha != OPACITY_TRANSPARENT) {
|
|
|
|
if (opacity != OPACITY_OPAQUE) {
|
|
srcAlpha = UINT8_MULT(src[PIXEL_ALPHA], opacity);
|
|
}
|
|
|
|
TQ_UINT8 srcBlend;
|
|
|
|
if (dstAlpha == OPACITY_OPAQUE) {
|
|
srcBlend = srcAlpha;
|
|
} else {
|
|
TQ_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
|
|
dst[PIXEL_ALPHA] = newAlpha;
|
|
|
|
if (newAlpha != 0) {
|
|
srcBlend = UINT8_DIVIDE(srcAlpha, newAlpha);
|
|
} else {
|
|
srcBlend = srcAlpha;
|
|
}
|
|
}
|
|
|
|
for (int channel = 0; channel < MAX_CHANNEL_RGB; channel++) {
|
|
|
|
TQ_UINT8 srcColor = src[channel];
|
|
TQ_UINT8 dstColor = dst[channel];
|
|
|
|
srcColor = TQMIN(((UINT8_MAX - dstColor) * (UINT8_MAX + 1)) / (srcColor + 1), UINT8_MAX);
|
|
if (UINT8_MAX - srcColor > UINT8_MAX) srcColor = UINT8_MAX;
|
|
|
|
TQ_UINT8 newColor = UINT8_BLEND(srcColor, dstColor, srcBlend);
|
|
|
|
dst[channel] = newColor;
|
|
}
|
|
}
|
|
|
|
columns--;
|
|
src += MAX_CHANNEL_RGBA;
|
|
dst += MAX_CHANNEL_RGBA;
|
|
}
|
|
|
|
rows--;
|
|
srcRowStart += srcRowStride;
|
|
dstRowStart += dstRowStride;
|
|
if(maskRowStart)
|
|
maskRowStart += maskRowStride;
|
|
}
|
|
}
|
|
|
|
void KisRgbColorSpace::compositeDarken(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride, const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride, const TQ_UINT8 *maskRowStart, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
|
|
{
|
|
while (rows > 0) {
|
|
|
|
const TQ_UINT8 *src = srcRowStart;
|
|
TQ_UINT8 *dst = dstRowStart;
|
|
TQ_INT32 columns = numColumns;
|
|
const TQ_UINT8 *mask = maskRowStart;
|
|
|
|
while (columns > 0) {
|
|
|
|
TQ_UINT8 srcAlpha = src[PIXEL_ALPHA];
|
|
TQ_UINT8 dstAlpha = dst[PIXEL_ALPHA];
|
|
|
|
srcAlpha = TQMIN(srcAlpha, dstAlpha);
|
|
|
|
// apply the alphamask
|
|
if(mask != 0)
|
|
{
|
|
if(*mask != OPACITY_OPAQUE)
|
|
srcAlpha = UINT8_MULT(srcAlpha, *mask);
|
|
mask++;
|
|
}
|
|
|
|
if (srcAlpha != OPACITY_TRANSPARENT) {
|
|
|
|
if (opacity != OPACITY_OPAQUE) {
|
|
srcAlpha = UINT8_MULT(src[PIXEL_ALPHA], opacity);
|
|
}
|
|
|
|
TQ_UINT8 srcBlend;
|
|
|
|
if (dstAlpha == OPACITY_OPAQUE) {
|
|
srcBlend = srcAlpha;
|
|
} else {
|
|
TQ_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
|
|
dst[PIXEL_ALPHA] = newAlpha;
|
|
|
|
if (newAlpha != 0) {
|
|
srcBlend = UINT8_DIVIDE(srcAlpha, newAlpha);
|
|
} else {
|
|
srcBlend = srcAlpha;
|
|
}
|
|
}
|
|
|
|
for (int channel = 0; channel < MAX_CHANNEL_RGB; channel++) {
|
|
|
|
TQ_UINT8 srcColor = src[channel];
|
|
TQ_UINT8 dstColor = dst[channel];
|
|
|
|
srcColor = TQMIN(srcColor, dstColor);
|
|
|
|
TQ_UINT8 newColor = UINT8_BLEND(srcColor, dstColor, srcBlend);
|
|
|
|
dst[channel] = newColor;
|
|
}
|
|
}
|
|
|
|
columns--;
|
|
src += MAX_CHANNEL_RGBA;
|
|
dst += MAX_CHANNEL_RGBA;
|
|
}
|
|
|
|
rows--;
|
|
srcRowStart += srcRowStride;
|
|
dstRowStart += dstRowStride;
|
|
if(maskRowStart)
|
|
maskRowStart += maskRowStride;
|
|
}
|
|
}
|
|
|
|
void KisRgbColorSpace::compositeLighten(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride, const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride, const TQ_UINT8 *maskRowStart, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
|
|
{
|
|
while (rows > 0) {
|
|
|
|
const TQ_UINT8 *src = srcRowStart;
|
|
TQ_UINT8 *dst = dstRowStart;
|
|
TQ_INT32 columns = numColumns;
|
|
const TQ_UINT8 *mask = maskRowStart;
|
|
|
|
while (columns > 0) {
|
|
|
|
TQ_UINT8 srcAlpha = src[PIXEL_ALPHA];
|
|
TQ_UINT8 dstAlpha = dst[PIXEL_ALPHA];
|
|
|
|
srcAlpha = TQMIN(srcAlpha, dstAlpha);
|
|
|
|
// apply the alphamask
|
|
if(mask != 0)
|
|
{
|
|
if(*mask != OPACITY_OPAQUE)
|
|
srcAlpha = UINT8_MULT(srcAlpha, *mask);
|
|
mask++;
|
|
}
|
|
|
|
if (srcAlpha != OPACITY_TRANSPARENT) {
|
|
|
|
if (opacity != OPACITY_OPAQUE) {
|
|
srcAlpha = UINT8_MULT(src[PIXEL_ALPHA], opacity);
|
|
}
|
|
|
|
TQ_UINT8 srcBlend;
|
|
|
|
if (dstAlpha == OPACITY_OPAQUE) {
|
|
srcBlend = srcAlpha;
|
|
} else {
|
|
TQ_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
|
|
dst[PIXEL_ALPHA] = newAlpha;
|
|
|
|
if (newAlpha != 0) {
|
|
srcBlend = UINT8_DIVIDE(srcAlpha, newAlpha);
|
|
} else {
|
|
srcBlend = srcAlpha;
|
|
}
|
|
}
|
|
|
|
for (int channel = 0; channel < MAX_CHANNEL_RGB; channel++) {
|
|
|
|
TQ_UINT8 srcColor = src[channel];
|
|
TQ_UINT8 dstColor = dst[channel];
|
|
|
|
srcColor = TQMAX(srcColor, dstColor);
|
|
|
|
TQ_UINT8 newColor = UINT8_BLEND(srcColor, dstColor, srcBlend);
|
|
|
|
dst[channel] = newColor;
|
|
}
|
|
}
|
|
|
|
columns--;
|
|
src += MAX_CHANNEL_RGBA;
|
|
dst += MAX_CHANNEL_RGBA;
|
|
}
|
|
|
|
rows--;
|
|
srcRowStart += srcRowStride;
|
|
dstRowStart += dstRowStride;
|
|
if(maskRowStart)
|
|
maskRowStart += maskRowStride;
|
|
}
|
|
}
|
|
|
|
void KisRgbColorSpace::compositeHue(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride, const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride, const TQ_UINT8 *maskRowStart, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
|
|
{
|
|
while (rows > 0) {
|
|
|
|
const TQ_UINT8 *src = srcRowStart;
|
|
TQ_UINT8 *dst = dstRowStart;
|
|
TQ_INT32 columns = numColumns;
|
|
const TQ_UINT8 *mask = maskRowStart;
|
|
|
|
while (columns > 0) {
|
|
|
|
TQ_UINT8 srcAlpha = src[PIXEL_ALPHA];
|
|
TQ_UINT8 dstAlpha = dst[PIXEL_ALPHA];
|
|
|
|
srcAlpha = TQMIN(srcAlpha, dstAlpha);
|
|
|
|
// apply the alphamask
|
|
if(mask != 0)
|
|
{
|
|
if(*mask != OPACITY_OPAQUE)
|
|
srcAlpha = UINT8_MULT(srcAlpha, *mask);
|
|
mask++;
|
|
}
|
|
|
|
if (srcAlpha != OPACITY_TRANSPARENT) {
|
|
|
|
if (opacity != OPACITY_OPAQUE) {
|
|
srcAlpha = UINT8_MULT(src[PIXEL_ALPHA], opacity);
|
|
}
|
|
|
|
TQ_UINT8 srcBlend;
|
|
|
|
if (dstAlpha == OPACITY_OPAQUE) {
|
|
srcBlend = srcAlpha;
|
|
} else {
|
|
TQ_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
|
|
dst[PIXEL_ALPHA] = newAlpha;
|
|
|
|
if (newAlpha != 0) {
|
|
srcBlend = UINT8_DIVIDE(srcAlpha, newAlpha);
|
|
} else {
|
|
srcBlend = srcAlpha;
|
|
}
|
|
}
|
|
|
|
int dstRed = dst[PIXEL_RED];
|
|
int dstGreen = dst[PIXEL_GREEN];
|
|
int dstBlue = dst[PIXEL_BLUE];
|
|
|
|
int srcHue;
|
|
int srcSaturation;
|
|
int srcValue;
|
|
int dstHue;
|
|
int dstSaturation;
|
|
int dstValue;
|
|
|
|
rgb_to_hsv(src[PIXEL_RED], src[PIXEL_GREEN], src[PIXEL_BLUE], &srcHue, &srcSaturation, &srcValue);
|
|
rgb_to_hsv(dstRed, dstGreen, dstBlue, &dstHue, &dstSaturation, &dstValue);
|
|
|
|
int srcRed;
|
|
int srcGreen;
|
|
int srcBlue;
|
|
|
|
hsv_to_rgb(srcHue, dstSaturation, dstValue, &srcRed, &srcGreen, &srcBlue);
|
|
|
|
dst[PIXEL_RED] = UINT8_BLEND(srcRed, dstRed, srcBlend);
|
|
dst[PIXEL_GREEN] = UINT8_BLEND(srcGreen, dstGreen, srcBlend);
|
|
dst[PIXEL_BLUE] = UINT8_BLEND(srcBlue, dstBlue, srcBlend);
|
|
}
|
|
|
|
columns--;
|
|
src += MAX_CHANNEL_RGBA;
|
|
dst += MAX_CHANNEL_RGBA;
|
|
}
|
|
|
|
rows--;
|
|
srcRowStart += srcRowStride;
|
|
dstRowStart += dstRowStride;
|
|
if(maskRowStart)
|
|
maskRowStart += maskRowStride;
|
|
}
|
|
}
|
|
|
|
void KisRgbColorSpace::compositeSaturation(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride, const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride, const TQ_UINT8 *maskRowStart, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
|
|
{
|
|
while (rows > 0) {
|
|
|
|
const TQ_UINT8 *src = srcRowStart;
|
|
TQ_UINT8 *dst = dstRowStart;
|
|
TQ_INT32 columns = numColumns;
|
|
const TQ_UINT8 *mask = maskRowStart;
|
|
|
|
while (columns > 0) {
|
|
|
|
TQ_UINT8 srcAlpha = src[PIXEL_ALPHA];
|
|
TQ_UINT8 dstAlpha = dst[PIXEL_ALPHA];
|
|
|
|
srcAlpha = TQMIN(srcAlpha, dstAlpha);
|
|
|
|
// apply the alphamask
|
|
if(mask != 0)
|
|
{
|
|
if(*mask != OPACITY_OPAQUE)
|
|
srcAlpha = UINT8_MULT(srcAlpha, *mask);
|
|
mask++;
|
|
}
|
|
|
|
if (srcAlpha != OPACITY_TRANSPARENT) {
|
|
|
|
if (opacity != OPACITY_OPAQUE) {
|
|
srcAlpha = UINT8_MULT(src[PIXEL_ALPHA], opacity);
|
|
}
|
|
|
|
TQ_UINT8 srcBlend;
|
|
|
|
if (dstAlpha == OPACITY_OPAQUE) {
|
|
srcBlend = srcAlpha;
|
|
} else {
|
|
TQ_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
|
|
dst[PIXEL_ALPHA] = newAlpha;
|
|
|
|
if (newAlpha != 0) {
|
|
srcBlend = UINT8_DIVIDE(srcAlpha, newAlpha);
|
|
} else {
|
|
srcBlend = srcAlpha;
|
|
}
|
|
}
|
|
|
|
int dstRed = dst[PIXEL_RED];
|
|
int dstGreen = dst[PIXEL_GREEN];
|
|
int dstBlue = dst[PIXEL_BLUE];
|
|
|
|
int srcHue;
|
|
int srcSaturation;
|
|
int srcValue;
|
|
int dstHue;
|
|
int dstSaturation;
|
|
int dstValue;
|
|
|
|
rgb_to_hsv(src[PIXEL_RED], src[PIXEL_GREEN], src[PIXEL_BLUE], &srcHue, &srcSaturation, &srcValue);
|
|
rgb_to_hsv(dstRed, dstGreen, dstBlue, &dstHue, &dstSaturation, &dstValue);
|
|
|
|
int srcRed;
|
|
int srcGreen;
|
|
int srcBlue;
|
|
|
|
hsv_to_rgb(dstHue, srcSaturation, dstValue, &srcRed, &srcGreen, &srcBlue);
|
|
|
|
dst[PIXEL_RED] = UINT8_BLEND(srcRed, dstRed, srcBlend);
|
|
dst[PIXEL_GREEN] = UINT8_BLEND(srcGreen, dstGreen, srcBlend);
|
|
dst[PIXEL_BLUE] = UINT8_BLEND(srcBlue, dstBlue, srcBlend);
|
|
}
|
|
|
|
columns--;
|
|
src += MAX_CHANNEL_RGBA;
|
|
dst += MAX_CHANNEL_RGBA;
|
|
}
|
|
|
|
rows--;
|
|
srcRowStart += srcRowStride;
|
|
dstRowStart += dstRowStride;
|
|
if(maskRowStart)
|
|
maskRowStart += maskRowStride;
|
|
}
|
|
}
|
|
|
|
void KisRgbColorSpace::compositeValue(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride, const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride, const TQ_UINT8 *maskRowStart, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
|
|
{
|
|
while (rows > 0) {
|
|
|
|
const TQ_UINT8 *src = srcRowStart;
|
|
TQ_UINT8 *dst = dstRowStart;
|
|
TQ_INT32 columns = numColumns;
|
|
const TQ_UINT8 *mask = maskRowStart;
|
|
|
|
while (columns > 0) {
|
|
|
|
TQ_UINT8 srcAlpha = src[PIXEL_ALPHA];
|
|
TQ_UINT8 dstAlpha = dst[PIXEL_ALPHA];
|
|
|
|
srcAlpha = TQMIN(srcAlpha, dstAlpha);
|
|
|
|
// apply the alphamask
|
|
if(mask != 0)
|
|
{
|
|
if(*mask != OPACITY_OPAQUE)
|
|
srcAlpha = UINT8_MULT(srcAlpha, *mask);
|
|
mask++;
|
|
}
|
|
|
|
if (srcAlpha != OPACITY_TRANSPARENT) {
|
|
|
|
if (opacity != OPACITY_OPAQUE) {
|
|
srcAlpha = UINT8_MULT(src[PIXEL_ALPHA], opacity);
|
|
}
|
|
|
|
TQ_UINT8 srcBlend;
|
|
|
|
if (dstAlpha == OPACITY_OPAQUE) {
|
|
srcBlend = srcAlpha;
|
|
} else {
|
|
TQ_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
|
|
dst[PIXEL_ALPHA] = newAlpha;
|
|
|
|
if (newAlpha != 0) {
|
|
srcBlend = UINT8_DIVIDE(srcAlpha, newAlpha);
|
|
} else {
|
|
srcBlend = srcAlpha;
|
|
}
|
|
}
|
|
|
|
int dstRed = dst[PIXEL_RED];
|
|
int dstGreen = dst[PIXEL_GREEN];
|
|
int dstBlue = dst[PIXEL_BLUE];
|
|
|
|
int srcHue;
|
|
int srcSaturation;
|
|
int srcValue;
|
|
int dstHue;
|
|
int dstSaturation;
|
|
int dstValue;
|
|
|
|
rgb_to_hsv(src[PIXEL_RED], src[PIXEL_GREEN], src[PIXEL_BLUE], &srcHue, &srcSaturation, &srcValue);
|
|
rgb_to_hsv(dstRed, dstGreen, dstBlue, &dstHue, &dstSaturation, &dstValue);
|
|
|
|
int srcRed;
|
|
int srcGreen;
|
|
int srcBlue;
|
|
|
|
hsv_to_rgb(dstHue, dstSaturation, srcValue, &srcRed, &srcGreen, &srcBlue);
|
|
|
|
dst[PIXEL_RED] = UINT8_BLEND(srcRed, dstRed, srcBlend);
|
|
dst[PIXEL_GREEN] = UINT8_BLEND(srcGreen, dstGreen, srcBlend);
|
|
dst[PIXEL_BLUE] = UINT8_BLEND(srcBlue, dstBlue, srcBlend);
|
|
}
|
|
|
|
columns--;
|
|
src += MAX_CHANNEL_RGBA;
|
|
dst += MAX_CHANNEL_RGBA;
|
|
}
|
|
|
|
rows--;
|
|
srcRowStart += srcRowStride;
|
|
dstRowStart += dstRowStride;
|
|
if(maskRowStart)
|
|
maskRowStart += maskRowStride;
|
|
}
|
|
}
|
|
|
|
void KisRgbColorSpace::compositeColor(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride, const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride, const TQ_UINT8 *maskRowStart, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
|
|
{
|
|
while (rows > 0) {
|
|
|
|
const TQ_UINT8 *src = srcRowStart;
|
|
TQ_UINT8 *dst = dstRowStart;
|
|
TQ_INT32 columns = numColumns;
|
|
const TQ_UINT8 *mask = maskRowStart;
|
|
|
|
while (columns > 0) {
|
|
|
|
TQ_UINT8 srcAlpha = src[PIXEL_ALPHA];
|
|
TQ_UINT8 dstAlpha = dst[PIXEL_ALPHA];
|
|
|
|
srcAlpha = TQMIN(srcAlpha, dstAlpha);
|
|
|
|
// apply the alphamask
|
|
if(mask != 0)
|
|
{
|
|
if(*mask != OPACITY_OPAQUE)
|
|
srcAlpha = UINT8_MULT(srcAlpha, *mask);
|
|
mask++;
|
|
}
|
|
|
|
if (srcAlpha != OPACITY_TRANSPARENT) {
|
|
|
|
if (opacity != OPACITY_OPAQUE) {
|
|
srcAlpha = UINT8_MULT(src[PIXEL_ALPHA], opacity);
|
|
}
|
|
|
|
TQ_UINT8 srcBlend;
|
|
|
|
if (dstAlpha == OPACITY_OPAQUE) {
|
|
srcBlend = srcAlpha;
|
|
} else {
|
|
TQ_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
|
|
dst[PIXEL_ALPHA] = newAlpha;
|
|
|
|
if (newAlpha != 0) {
|
|
srcBlend = UINT8_DIVIDE(srcAlpha, newAlpha);
|
|
} else {
|
|
srcBlend = srcAlpha;
|
|
}
|
|
}
|
|
|
|
int dstRed = dst[PIXEL_RED];
|
|
int dstGreen = dst[PIXEL_GREEN];
|
|
int dstBlue = dst[PIXEL_BLUE];
|
|
|
|
int srcHue;
|
|
int srcSaturation;
|
|
int srcLightness;
|
|
int dstHue;
|
|
int dstSaturation;
|
|
int dstLightness;
|
|
|
|
rgb_to_hls(src[PIXEL_RED], src[PIXEL_GREEN], src[PIXEL_BLUE], &srcHue, &srcLightness, &srcSaturation);
|
|
rgb_to_hls(dstRed, dstGreen, dstBlue, &dstHue, &dstLightness, &dstSaturation);
|
|
|
|
TQ_UINT8 srcRed;
|
|
TQ_UINT8 srcGreen;
|
|
TQ_UINT8 srcBlue;
|
|
|
|
hls_to_rgb(srcHue, dstLightness, srcSaturation, &srcRed, &srcGreen, &srcBlue);
|
|
|
|
dst[PIXEL_RED] = UINT8_BLEND(srcRed, dstRed, srcBlend);
|
|
dst[PIXEL_GREEN] = UINT8_BLEND(srcGreen, dstGreen, srcBlend);
|
|
dst[PIXEL_BLUE] = UINT8_BLEND(srcBlue, dstBlue, srcBlend);
|
|
}
|
|
|
|
columns--;
|
|
src += MAX_CHANNEL_RGBA;
|
|
dst += MAX_CHANNEL_RGBA;
|
|
}
|
|
|
|
rows--;
|
|
srcRowStart += srcRowStride;
|
|
dstRowStart += dstRowStride;
|
|
if(maskRowStart)
|
|
maskRowStart += maskRowStride;
|
|
}
|
|
}
|
|
|
|
void KisRgbColorSpace::compositeErase(TQ_UINT8 *dst,
|
|
TQ_INT32 dstRowSize,
|
|
const TQ_UINT8 *src,
|
|
TQ_INT32 srcRowSize,
|
|
const TQ_UINT8 *srcAlphaMask,
|
|
TQ_INT32 maskRowStride,
|
|
TQ_INT32 rows,
|
|
TQ_INT32 cols,
|
|
TQ_UINT8 /*opacity*/)
|
|
{
|
|
TQ_INT32 i;
|
|
TQ_UINT8 srcAlpha;
|
|
|
|
while (rows-- > 0)
|
|
{
|
|
const TQ_UINT8 *s = src;
|
|
TQ_UINT8 *d = dst;
|
|
const TQ_UINT8 *mask = srcAlphaMask;
|
|
|
|
for (i = cols; i > 0; i--, s+=MAX_CHANNEL_RGBA, d+=MAX_CHANNEL_RGBA)
|
|
{
|
|
srcAlpha = s[PIXEL_ALPHA];
|
|
// apply the alphamask
|
|
if(mask != 0)
|
|
{
|
|
if(*mask != OPACITY_OPAQUE)
|
|
srcAlpha = UINT8_BLEND(srcAlpha, OPACITY_OPAQUE, *mask);
|
|
mask++;
|
|
}
|
|
d[PIXEL_ALPHA] = UINT8_MULT(srcAlpha, d[PIXEL_ALPHA]);
|
|
}
|
|
|
|
dst += dstRowSize;
|
|
if(srcAlphaMask)
|
|
srcAlphaMask += maskRowStride;
|
|
src += srcRowSize;
|
|
}
|
|
}
|
|
|
|
void KisRgbColorSpace::bitBlt(TQ_UINT8 *dst,
|
|
TQ_INT32 dstRowStride,
|
|
const TQ_UINT8 *src,
|
|
TQ_INT32 srcRowStride,
|
|
const TQ_UINT8 *mask,
|
|
TQ_INT32 maskRowStride,
|
|
TQ_UINT8 opacity,
|
|
TQ_INT32 rows,
|
|
TQ_INT32 cols,
|
|
const KisCompositeOp& op)
|
|
{
|
|
|
|
switch (op.op()) {
|
|
case COMPOSITE_UNDEF:
|
|
// Undefined == no composition
|
|
break;
|
|
case COMPOSITE_OVER:
|
|
compositeOver(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
|
|
break;
|
|
case COMPOSITE_ALPHA_DARKEN:
|
|
compositeAlphaDarken(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
|
|
break;
|
|
case COMPOSITE_IN:
|
|
compositeIn(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
|
|
break;
|
|
case COMPOSITE_OUT:
|
|
compositeOut(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
|
|
break;
|
|
case COMPOSITE_ATOP:
|
|
compositeAtop(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
|
|
break;
|
|
case COMPOSITE_XOR:
|
|
compositeXor(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
|
|
break;
|
|
case COMPOSITE_PLUS:
|
|
compositePlus(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
|
|
break;
|
|
case COMPOSITE_MINUS:
|
|
compositeMinus(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
|
|
break;
|
|
case COMPOSITE_ADD:
|
|
compositeAdd(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
|
|
break;
|
|
case COMPOSITE_SUBTRACT:
|
|
compositeSubtract(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
|
|
break;
|
|
case COMPOSITE_DIFF:
|
|
compositeDiff(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
|
|
break;
|
|
case COMPOSITE_MULT:
|
|
compositeMultiply(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
|
|
break;
|
|
case COMPOSITE_DIVIDE:
|
|
compositeDivide(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
|
|
break;
|
|
case COMPOSITE_BUMPMAP:
|
|
compositeBumpmap(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
|
|
break;
|
|
case COMPOSITE_COPY:
|
|
compositeCopy(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
|
|
break;
|
|
case COMPOSITE_COPY_RED:
|
|
compositeCopyRed(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
|
|
break;
|
|
case COMPOSITE_COPY_GREEN:
|
|
compositeCopyGreen(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
|
|
break;
|
|
case COMPOSITE_COPY_BLUE:
|
|
compositeCopyBlue(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
|
|
break;
|
|
case COMPOSITE_COPY_OPACITY:
|
|
compositeCopyOpacity(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
|
|
break;
|
|
case COMPOSITE_CLEAR:
|
|
compositeClear(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
|
|
break;
|
|
case COMPOSITE_DISSOLVE:
|
|
compositeDissolve(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
|
|
break;
|
|
case COMPOSITE_DISPLACE:
|
|
compositeDisplace(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
|
|
break;
|
|
#if 0
|
|
case COMPOSITE_MODULATE:
|
|
compositeModulate(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
|
|
break;
|
|
case COMPOSITE_THRESHOLD:
|
|
compositeThreshold(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
|
|
break;
|
|
#endif
|
|
case COMPOSITE_NO:
|
|
// No composition.
|
|
break;
|
|
case COMPOSITE_DARKEN:
|
|
compositeDarken(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
|
|
break;
|
|
case COMPOSITE_LIGHTEN:
|
|
compositeLighten(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
|
|
break;
|
|
case COMPOSITE_HUE:
|
|
compositeHue(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
|
|
break;
|
|
case COMPOSITE_SATURATION:
|
|
compositeSaturation(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
|
|
break;
|
|
case COMPOSITE_VALUE:
|
|
compositeValue(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
|
|
break;
|
|
case COMPOSITE_COLOR:
|
|
compositeColor(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
|
|
break;
|
|
case COMPOSITE_COLORIZE:
|
|
compositeColorize(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
|
|
break;
|
|
case COMPOSITE_LUMINIZE:
|
|
compositeLuminize(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
|
|
break;
|
|
case COMPOSITE_SCREEN:
|
|
compositeScreen(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
|
|
break;
|
|
case COMPOSITE_OVERLAY:
|
|
compositeOverlay(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
|
|
break;
|
|
case COMPOSITE_ERASE:
|
|
compositeErase(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
|
|
break;
|
|
case COMPOSITE_DODGE:
|
|
compositeDodge(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
|
|
break;
|
|
case COMPOSITE_BURN:
|
|
compositeBurn(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
KisCompositeOpList KisRgbColorSpace::userVisiblecompositeOps() const
|
|
{
|
|
KisCompositeOpList list;
|
|
|
|
list.append(KisCompositeOp(COMPOSITE_OVER));
|
|
list.append(KisCompositeOp(COMPOSITE_ALPHA_DARKEN));
|
|
list.append(KisCompositeOp(COMPOSITE_MULT));
|
|
list.append(KisCompositeOp(COMPOSITE_BURN));
|
|
list.append(KisCompositeOp(COMPOSITE_DODGE));
|
|
list.append(KisCompositeOp(COMPOSITE_DIVIDE));
|
|
list.append(KisCompositeOp(COMPOSITE_SCREEN));
|
|
list.append(KisCompositeOp(COMPOSITE_OVERLAY));
|
|
list.append(KisCompositeOp(COMPOSITE_DARKEN));
|
|
list.append(KisCompositeOp(COMPOSITE_LIGHTEN));
|
|
list.append(KisCompositeOp(COMPOSITE_HUE));
|
|
list.append(KisCompositeOp(COMPOSITE_SATURATION));
|
|
list.append(KisCompositeOp(COMPOSITE_VALUE));
|
|
list.append(KisCompositeOp(COMPOSITE_COLOR));
|
|
list.append(KisCompositeOp(COMPOSITE_PLUS));
|
|
list.append(KisCompositeOp(COMPOSITE_MINUS));
|
|
list.append(KisCompositeOp(COMPOSITE_SUBTRACT));
|
|
list.append(KisCompositeOp(COMPOSITE_ADD));
|
|
|
|
return list;
|
|
}
|