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.
koffice/chalk/plugins/viewplugins/dropshadow/kis_dropshadow.cpp

759 lines
23 KiB

/*
* This file is part of Chalk
*
* Copyright (c) 2005 Michael Thaler <michael.thaler@physik.tu-muenchen.de>
*
* The gaussian blur algoithm is ported from gimo
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* 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 <limits.h>
#include <stdlib.h>
#include <vector>
#include <tqcolor.h>
#include <tdelocale.h>
#include <kiconloader.h>
#include <kinstance.h>
#include <tdemessagebox.h>
#include <kstandarddirs.h>
#include <tdetempfile.h>
#include <kdebug.h>
#include <kgenericfactory.h>
#include <knuminput.h>
#include <kis_doc.h>
#include <kis_image.h>
#include <kis_iterators_pixel.h>
#include <kis_layer.h>
#include <kis_paint_layer.h>
#include <kis_group_layer.h>
#include "kis_meta_registry.h"
#include <kis_transaction.h>
#include <kis_undo_adapter.h>
#include <kis_global.h>
#include <kis_types.h>
#include <kis_progress_subject.h>
#include <kis_progress_display_interface.h>
#include <kis_colorspace.h>
#include <kis_colorspace_factory_registry.h>
#include <kis_view.h>
#include <kis_paint_device.h>
#include <kis_channelinfo.h>
#include <kis_convolution_painter.h>
#include "kis_rgb_colorspace.h"
#include "kis_dropshadow.h"
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#define MAX(a, b) (((a) > (b)) ? (a) : (b))
KisDropshadow::KisDropshadow(KisView * view)
: m_view(view)
{
}
void KisDropshadow::dropshadow(KisProgressDisplayInterface * progress, TQ_INT32 xoffset, TQ_INT32 yoffset, TQ_INT32 blurradius, TQColor color, TQ_UINT8 opacity, bool allowResize)
{
KisImageSP image = m_view->canvasSubject()->currentImg();
if (!image) return;
KisLayerSP src = image->activeLayer();
if (!src) return;
KisPaintDeviceSP dev = image->activeDevice();
if (!dev) return;
m_cancelRequested = false;
if ( progress )
progress->setSubject(this, true, true);
emit notifyProgressStage(i18n("Add drop shadow..."), 0);
if (image->undo()) {
image->undoAdapter()->beginMacro(i18n("Add Drop Shadow"));
}
KisPaintDeviceSP shadowDev = new KisPaintDevice( KisMetaRegistry::instance()->csRegistry()->getColorSpace(KisID("RGBA",""),"" ), "Shadow");
KisPaintDeviceSP bShadowDev;
KisRgbColorSpace *rgb8cs = static_cast<KisRgbColorSpace *>(shadowDev->colorSpace());
TQRect rect = dev->exactBounds();
for (TQ_INT32 row = 0; row < rect.height(); ++row)
{
KisHLineIteratorPixel srcIt = dev->createHLineIterator(rect.x(), rect.y() + row, rect.width(), false);
KisHLineIteratorPixel dstIt = shadowDev->createHLineIterator(rect.x(), rect.y() + row, rect.width(), true);
while( ! srcIt.isDone() )
{
if (srcIt.isSelected())
{
//set the shadow color
TQ_UINT8 alpha = dev->colorSpace()->getAlpha(srcIt.rawData());
rgb8cs->setPixel(dstIt.rawData(), color.red(), color.green(), color.blue(), alpha);
}
++srcIt;
++dstIt;
}
emit notifyProgress((row * 100) / rect.height() );
}
if( blurradius > 0 )
{
bShadowDev = new KisPaintDevice( KisMetaRegistry::instance()->csRegistry()->getColorSpace(KisID("RGBA",""),"" ), "bShadow");
gaussianblur(shadowDev, bShadowDev, rect, blurradius, blurradius, BLUR_RLE, progress);
shadowDev = bShadowDev;
}
if (!m_cancelRequested) {
shadowDev->move (xoffset,yoffset);
KisGroupLayerSP parent = image->rootLayer();
if (image->activeLayer())
parent = image->activeLayer()->parent().data();
KisPaintLayerSP l = new KisPaintLayer(image, i18n("Drop Shadow"), opacity, shadowDev);
image->addLayer( l.data(), parent, src->siblingBelow() );
if (allowResize)
{
TQRect shadowBounds = shadowDev->exactBounds();
if (!image->bounds().contains(shadowBounds)) {
TQRect newImageSize = image->bounds() | shadowBounds;
image->resize(newImageSize.width(), newImageSize.height());
if (shadowBounds.left() < 0 || shadowBounds.top() < 0) {
TQ_INT32 newRootX = image->rootLayer()->x();
TQ_INT32 newRootY = image->rootLayer()->y();
if (shadowBounds.left() < 0) {
newRootX += -shadowBounds.left();
}
if (shadowBounds.top() < 0) {
newRootY += -shadowBounds.top();
}
KCommand *moveCommand = image->rootLayer()->moveCommand(TQPoint(image->rootLayer()->x(), image->rootLayer()->y()),
TQPoint(newRootX, newRootY));
Q_ASSERT(moveCommand != 0);
if (moveCommand) {
moveCommand->execute();
if (image->undo()) {
image->undoAdapter()->addCommand(moveCommand);
} else {
delete moveCommand;
}
}
}
}
}
m_view->canvasSubject()->document()->setModified(true);
}
if (image->undo()) {
image->undoAdapter()->endMacro();
}
emit notifyProgressDone();
}
void KisDropshadow::gaussianblur (KisPaintDeviceSP srcDev, KisPaintDeviceSP dstDev, TQRect& rect, double horz, double vert, BlurMethod method, KisProgressDisplayInterface *)
{
TQ_INT32 width, height;
TQ_INT32 bytes;
TQ_UINT8 *dest, *dp;
TQ_UINT8 *src, *sp, *sp_p, *sp_m;
TQ_INT32 *buf = NULL;
TQ_INT32 *bb;
double n_p[5], n_m[5];
double d_p[5], d_m[5];
double bd_p[5], bd_m[5];
double *val_p = NULL;
double *val_m = NULL;
double *vp, *vm;
TQ_INT32 x1, y1, x2, y2;
TQ_INT32 i, j;
TQ_INT32 row, col, b;
TQ_INT32 terms;
double progress, max_progress;
TQ_INT32 initial_p[4];
TQ_INT32 initial_m[4];
double std_dev;
TQ_INT32 pixels;
TQ_INT32 total = 1;
TQ_INT32 start, end;
TQ_INT32 *curve;
TQ_INT32 *sum = NULL;
TQ_INT32 val;
TQ_INT32 length;
TQ_INT32 initial_pp, initial_mm;
x1 = (TQ_INT32)(rect.x() - horz);
y1 = (TQ_INT32)(rect.y() - vert);
width = (TQ_INT32)(rect.width() + 2 * horz);
height = (TQ_INT32)(rect.height() + 2 * vert);
x2 = x1 + width;
y2 = y1 + height;
if (width < 1 || height < 1) return;
emit notifyProgressStage(i18n("Blur..."), 0);
bytes = srcDev->pixelSize();
switch (method)
{
case BLUR_IIR:
val_p = new double[MAX (width, height) * bytes];
val_m = new double[MAX (width, height) * bytes];
break;
case BLUR_RLE:
buf = new TQ_INT32[MAX (width, height) * 2];
break;
}
src = new TQ_UINT8[MAX (width, height) * bytes];
dest = new TQ_UINT8[MAX (width, height) * bytes];
progress = 0.0;
max_progress = (horz <= 0.0 ) ? 0 : width * height * horz;
max_progress += (vert <= 0.0 ) ? 0 : width * height * vert;
/* First the vertical pass */
if (vert > 0.0)
{
vert = fabs (vert) + 1.0;
std_dev = sqrt (-(vert * vert) / (2 * log (1.0 / 255.0)));
switch (method)
{
case BLUR_IIR:
/* derive the constants for calculating the gaussian
* from the std dev
*/
find_constants (n_p, n_m, d_p, d_m, bd_p, bd_m, std_dev);
break;
case BLUR_RLE:
curve = make_curve (std_dev, &length);
sum = new TQ_INT32[2 * length + 1];
sum[0] = 0;
for (i = 1; i <= length*2; i++)
sum[i] = curve[i-length-1] + sum[i-1];
sum += length;
total = sum[length] - sum[-length];
break;
}
for (col = 0; col < width; col++)
{
switch (method)
{
case BLUR_IIR:
memset (val_p, 0, height * bytes * sizeof (double));
memset (val_m, 0, height * bytes * sizeof (double));
break;
case BLUR_RLE:
break;
}
//gimp_pixel_rgn_get_col (&src_rgn, src, col + x1, y1, height);
srcDev->readBytes(src, col+x1, y1, 1, height);
multiply_alpha (src, height, bytes);
switch (method)
{
case BLUR_IIR:
sp_p = src;
sp_m = src + (height - 1) * bytes;
vp = val_p;
vm = val_m + (height - 1) * bytes;
/* Set up the first vals */
for (i = 0; i < bytes; i++)
{
initial_p[i] = sp_p[i];
initial_m[i] = sp_m[i];
}
for (row = 0; row < height; row++)
{
double *vpptr, *vmptr;
terms = (row < 4) ? row : 4;
for (b = 0; b < bytes; b++)
{
vpptr = vp + b; vmptr = vm + b;
for (i = 0; i <= terms; i++)
{
*vpptr += n_p[i] * sp_p[(-i * bytes) + b] -
d_p[i] * vp[(-i * bytes) + b];
*vmptr += n_m[i] * sp_m[(i * bytes) + b] -
d_m[i] * vm[(i * bytes) + b];
}
for (j = i; j <= 4; j++)
{
*vpptr += (n_p[j] - bd_p[j]) * initial_p[b];
*vmptr += (n_m[j] - bd_m[j]) * initial_m[b];
}
}
sp_p += bytes;
sp_m -= bytes;
vp += bytes;
vm -= bytes;
}
transfer_pixels (val_p, val_m, dest, bytes, height);
break;
case BLUR_RLE:
sp = src;
dp = dest;
for (b = 0; b < bytes; b++)
{
initial_pp = sp[b];
initial_mm = sp[(height-1) * bytes + b];
/* Determine a run-length encoded version of the row */
run_length_encode (sp + b, buf, bytes, height);
for (row = 0; row < height; row++)
{
start = (row < length) ? -row : -length;
end = (height <= (row + length) ?
(height - row - 1) : length);
val = 0;
i = start;
bb = buf + (row + i) * 2;
if (start != -length)
val += initial_pp * (sum[start] - sum[-length]);
while (i < end)
{
pixels = bb[0];
i += pixels;
if (i > end)
i = end;
val += bb[1] * (sum[i] - sum[start]);
bb += (pixels * 2);
start = i;
}
if (end != length)
val += initial_mm * (sum[length] - sum[end]);
dp[row * bytes + b] = val / total;
}
}
break;
}
separate_alpha (src, height, bytes);
dstDev->writeBytes(dest, col + x1, y1, 1, height);
progress += height * vert;
if ((col % 5) == 0) emit notifyProgress( (TQ_UINT32)((progress * 100) / max_progress));
}
}
/* Now the horizontal pass */
if (horz > 0.0)
{
horz = fabs (horz) + 1.0;
if (horz != vert)
{
std_dev = sqrt (-(horz * horz) / (2 * log (1.0 / 255.0)));
switch (method)
{
case BLUR_IIR:
/* derive the constants for calculating the gaussian
* from the std dev
*/
find_constants (n_p, n_m, d_p, d_m, bd_p, bd_m, std_dev);
break;
case BLUR_RLE:
curve = make_curve (std_dev, &length);
sum = new TQ_INT32[2 * length + 1];
sum[0] = 0;
for (i = 1; i <= length*2; i++)
sum[i] = curve[i-length-1] + sum[i-1];
sum += length;
total = sum[length] - sum[-length];
break;
}
}
for (row = 0; row < height; row++)
{
switch (method)
{
case BLUR_IIR:
memset (val_p, 0, width * bytes * sizeof (double));
memset (val_m, 0, width * bytes * sizeof (double));
break;
case BLUR_RLE:
break;
}
//gimp_pixel_rgn_get_row (&src_rgn, src, x1, row + y1, width);
dstDev->readBytes(src, x1, row + y1, width, 1);
multiply_alpha (dest, width, bytes);
switch (method)
{
case BLUR_IIR:
sp_p = src;
sp_m = src + (width - 1) * bytes;
vp = val_p;
vm = val_m + (width - 1) * bytes;
/* Set up the first vals */
for (i = 0; i < bytes; i++)
{
initial_p[i] = sp_p[i];
initial_m[i] = sp_m[i];
}
for (col = 0; col < width; col++)
{
double *vpptr, *vmptr;
terms = (col < 4) ? col : 4;
for (b = 0; b < bytes; b++)
{
vpptr = vp + b; vmptr = vm + b;
for (i = 0; i <= terms; i++)
{
*vpptr += n_p[i] * sp_p[(-i * bytes) + b] -
d_p[i] * vp[(-i * bytes) + b];
*vmptr += n_m[i] * sp_m[(i * bytes) + b] -
d_m[i] * vm[(i * bytes) + b];
}
for (j = i; j <= 4; j++)
{
*vpptr += (n_p[j] - bd_p[j]) * initial_p[b];
*vmptr += (n_m[j] - bd_m[j]) * initial_m[b];
}
}
sp_p += bytes;
sp_m -= bytes;
vp += bytes;
vm -= bytes;
}
transfer_pixels (val_p, val_m, dest, bytes, width);
break;
case BLUR_RLE:
sp = src;
dp = dest;
for (b = 0; b < bytes; b++)
{
initial_pp = sp[b];
initial_mm = sp[(width-1) * bytes + b];
/* Determine a run-length encoded version of the row */
run_length_encode (sp + b, buf, bytes, width);
for (col = 0; col < width; col++)
{
start = (col < length) ? -col : -length;
end = (width <= (col + length)) ? (width - col - 1) : length;
val = 0;
i = start;
bb = buf + (col + i) * 2;
if (start != -length)
val += initial_pp * (sum[start] - sum[-length]);
while (i < end)
{
pixels = bb[0];
i += pixels;
if (i > end)
i = end;
val += bb[1] * (sum[i] - sum[start]);
bb += (pixels * 2);
start = i;
}
if (end != length)
val += initial_mm * (sum[length] - sum[end]);
dp[col * bytes + b] = val / total;
}
}
break;
}
separate_alpha (dest, width, bytes);
//gimp_pixel_rgn_set_row (&dest_rgn, dest, x1, row + y1, width);
dstDev->writeBytes(dest, x1, row + y1, width, 1);
progress += width * horz;
//if ((row % 5) == 0) gimp_progress_update (progress / max_progress);
if ((row % 5) == 0) emit notifyProgress( (TQ_UINT32)((progress * 100) / max_progress ));
}
}
/* free up buffers */
switch (method)
{
case BLUR_IIR:
delete[] val_p;
delete[] val_m;
break;
case BLUR_RLE:
delete[] buf;
break;
}
delete[] src;
delete[] dest;
}
void KisDropshadow::find_constants (double n_p[], double n_m[], double d_p[], double d_m[], double bd_p[], double bd_m[], double std_dev)
{
TQ_INT32 i;
double constants [8];
double div;
/* The constants used in the implemenation of a casual sequence
* using a 4th order approximation of the gaussian operator
*/
div = sqrt(2 * M_PI) * std_dev;
constants [0] = -1.783 / std_dev;
constants [1] = -1.723 / std_dev;
constants [2] = 0.6318 / std_dev;
constants [3] = 1.997 / std_dev;
constants [4] = 1.6803 / div;
constants [5] = 3.735 / div;
constants [6] = -0.6803 / div;
constants [7] = -0.2598 / div;
n_p [0] = constants[4] + constants[6];
n_p [1] = exp (constants[1]) *
(constants[7] * sin (constants[3]) -
(constants[6] + 2 * constants[4]) * cos (constants[3])) +
exp (constants[0]) *
(constants[5] * sin (constants[2]) -
(2 * constants[6] + constants[4]) * cos (constants[2]));
n_p [2] = 2 * exp (constants[0] + constants[1]) *
((constants[4] + constants[6]) * cos (constants[3]) * cos (constants[2]) -
constants[5] * cos (constants[3]) * sin (constants[2]) -
constants[7] * cos (constants[2]) * sin (constants[3])) +
constants[6] * exp (2 * constants[0]) +
constants[4] * exp (2 * constants[1]);
n_p [3] = exp (constants[1] + 2 * constants[0]) *
(constants[7] * sin (constants[3]) - constants[6] * cos (constants[3])) +
exp (constants[0] + 2 * constants[1]) *
(constants[5] * sin (constants[2]) - constants[4] * cos (constants[2]));
n_p [4] = 0.0;
d_p [0] = 0.0;
d_p [1] = -2 * exp (constants[1]) * cos (constants[3]) -
2 * exp (constants[0]) * cos (constants[2]);
d_p [2] = 4 * cos (constants[3]) * cos (constants[2]) * exp (constants[0] + constants[1]) +
exp (2 * constants[1]) + exp (2 * constants[0]);
d_p [3] = -2 * cos (constants[2]) * exp (constants[0] + 2 * constants[1]) -
2 * cos (constants[3]) * exp (constants[1] + 2 * constants[0]);
d_p [4] = exp (2 * constants[0] + 2 * constants[1]);
for (i = 0; i <= 4; i++)
d_m [i] = d_p [i];
n_m[0] = 0.0;
for (i = 1; i <= 4; i++)
n_m [i] = n_p[i] - d_p[i] * n_p[0];
{
double sum_n_p, sum_n_m, sum_d;
double a, b;
sum_n_p = 0.0;
sum_n_m = 0.0;
sum_d = 0.0;
for (i = 0; i <= 4; i++)
{
sum_n_p += n_p[i];
sum_n_m += n_m[i];
sum_d += d_p[i];
}
a = sum_n_p / (1.0 + sum_d);
b = sum_n_m / (1.0 + sum_d);
for (i = 0; i <= 4; i++)
{
bd_p[i] = d_p[i] * a;
bd_m[i] = d_m[i] * b;
}
}
}
void KisDropshadow::transfer_pixels (double *src1, double *src2, TQ_UINT8 *dest, TQ_INT32 bytes, TQ_INT32 width)
{
TQ_INT32 b;
TQ_INT32 bend = bytes * width;
double sum;
for(b = 0; b < bend; b++)
{
sum = *src1++ + *src2++;
if (sum > 255) sum = 255;
else if(sum < 0) sum = 0;
*dest++ = (TQ_UINT8) sum;
}
}
//The equations: g(r) = exp (- r^2 / (2 * sigma^2)), r = sqrt (x^2 + y ^2)
TQ_INT32 * KisDropshadow::make_curve(double sigma, TQ_INT32 *length)
{
int *curve;
double sigma2;
double l;
int temp;
int i, n;
sigma2 = 2 * sigma * sigma;
l = sqrt (-sigma2 * log (1.0 / 255.0));
n = (int)(ceil (l) * 2);
if ((n % 2) == 0)
n += 1;
curve = new TQ_INT32[n];
*length = n / 2;
curve += *length;
curve[0] = 255;
for (i = 1; i <= *length; i++)
{
temp = (TQ_INT32) (exp (- (i * i) / sigma2) * 255);
curve[-i] = temp;
curve[i] = temp;
}
return curve;
}
void KisDropshadow::run_length_encode (TQ_UINT8 *src, TQ_INT32 *dest, TQ_INT32 bytes, TQ_INT32 width)
{
TQ_INT32 start;
TQ_INT32 i;
TQ_INT32 j;
TQ_UINT8 last;
last = *src;
src += bytes;
start = 0;
for (i = 1; i < width; i++)
{
if (*src != last)
{
for (j = start; j < i; j++)
{
*dest++ = (i - j);
*dest++ = last;
}
start = i;
last = *src;
}
src += bytes;
}
for (j = start; j < i; j++)
{
*dest++ = (i - j);
*dest++ = last;
}
}
void KisDropshadow::multiply_alpha (TQ_UINT8 *buf, TQ_INT32 width, TQ_INT32 bytes)
{
TQ_INT32 i, j;
double alpha;
for (i = 0; i < width * bytes; i += bytes)
{
alpha = buf[i + bytes - 1] * (1.0 / 255.0);
for (j = 0; j < bytes - 1; j++) {
double a = (double)(buf[i + j]) * alpha;
buf[i + j] = (TQ_UINT8)a;
}
}
}
void KisDropshadow::separate_alpha (TQ_UINT8 *buf, TQ_INT32 width, TQ_INT32 bytes)
{
TQ_INT32 i, j;
TQ_UINT8 alpha;
double recip_alpha;
TQ_UINT32 new_val;
for (i = 0; i < width * bytes; i += bytes)
{
alpha = buf[i + bytes - 1];
if (alpha != 0 && alpha != 255)
{
recip_alpha = 255.0 / alpha;
for (j = 0; j < bytes - 1; j++)
{
new_val = (TQ_UINT32)(buf[i + j] * recip_alpha);
buf[i + j] = MIN (255, new_val);
}
}
}
}
#include "kis_dropshadow.moc"