summaryrefslogtreecommitdiffstats
path: root/chalk/plugins/viewplugins/dropshadow/kis_dropshadow.cc
diff options
context:
space:
mode:
Diffstat (limited to 'chalk/plugins/viewplugins/dropshadow/kis_dropshadow.cc')
-rw-r--r--chalk/plugins/viewplugins/dropshadow/kis_dropshadow.cc758
1 files changed, 758 insertions, 0 deletions
diff --git a/chalk/plugins/viewplugins/dropshadow/kis_dropshadow.cc b/chalk/plugins/viewplugins/dropshadow/kis_dropshadow.cc
new file mode 100644
index 00000000..207c86c3
--- /dev/null
+++ b/chalk/plugins/viewplugins/dropshadow/kis_dropshadow.cc
@@ -0,0 +1,758 @@
+/*
+ * 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 <klocale.h>
+#include <kiconloader.h>
+#include <kinstance.h>
+#include <kmessagebox.h>
+#include <kstandarddirs.h>
+#include <ktempfile.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 tqparent = image->rootLayer();
+ if (image->activeLayer())
+ tqparent = image->activeLayer()->tqparent().data();
+
+ KisPaintLayerSP l = new KisPaintLayer(image, i18n("Drop Shadow"), opacity, shadowDev);
+ image->addLayer( l.data(), tqparent, src->siblingBelow() );
+
+ if (allowResize)
+ {
+ TQRect shadowBounds = shadowDev->exactBounds();
+
+ if (!image->bounds().tqcontains(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"