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.
724 lines
22 KiB
724 lines
22 KiB
/*
|
|
* Copyright (c) 2004 Adrian Page <adrian@pagenet.plus.com>
|
|
*
|
|
* 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 <stdlib.h>
|
|
#include <string.h>
|
|
#include <cfloat>
|
|
|
|
#include "tqbrush.h"
|
|
#include "tqcolor.h"
|
|
#include "tqfontinfo.h"
|
|
#include "tqfontmetrics.h"
|
|
#include "tqpen.h"
|
|
#include "tqregion.h"
|
|
#include "tqwmatrix.h"
|
|
#include <tqimage.h>
|
|
#include <tqmap.h>
|
|
#include <tqpainter.h>
|
|
#include <tqpixmap.h>
|
|
#include <tqpointarray.h>
|
|
#include <tqrect.h>
|
|
#include <tqstring.h>
|
|
|
|
#include <kdebug.h>
|
|
#include <tdelocale.h>
|
|
|
|
#include "kis_brush.h"
|
|
#include "kis_debug_areas.h"
|
|
#include "kis_gradient.h"
|
|
#include "kis_image.h"
|
|
#include "kis_iterators_pixel.h"
|
|
#include "kis_layer.h"
|
|
#include "kis_paint_device.h"
|
|
#include "kis_pattern.h"
|
|
#include "kis_rect.h"
|
|
#include "kis_colorspace.h"
|
|
#include "kis_types.h"
|
|
#include "kis_vec.h"
|
|
#include "kis_selection.h"
|
|
#include "kis_gradient_painter.h"
|
|
#include "kis_meta_registry.h"
|
|
#include "kis_colorspace_factory_registry.h"
|
|
|
|
namespace {
|
|
|
|
class GradientShapeStrategy {
|
|
public:
|
|
GradientShapeStrategy(const KisPoint& gradientVectorStart, const KisPoint& gradientVectorEnd);
|
|
virtual ~GradientShapeStrategy() {}
|
|
|
|
virtual double valueAt(double x, double y) const = 0;
|
|
|
|
protected:
|
|
KisPoint m_gradientVectorStart;
|
|
KisPoint m_gradientVectorEnd;
|
|
};
|
|
|
|
GradientShapeStrategy::GradientShapeStrategy(const KisPoint& gradientVectorStart, const KisPoint& gradientVectorEnd)
|
|
: m_gradientVectorStart(gradientVectorStart), m_gradientVectorEnd(gradientVectorEnd)
|
|
{
|
|
}
|
|
|
|
|
|
class LinearGradientStrategy : public GradientShapeStrategy {
|
|
typedef GradientShapeStrategy super;
|
|
public:
|
|
LinearGradientStrategy(const KisPoint& gradientVectorStart, const KisPoint& gradientVectorEnd);
|
|
|
|
virtual double valueAt(double x, double y) const;
|
|
|
|
protected:
|
|
double m_normalisedVectorX;
|
|
double m_normalisedVectorY;
|
|
double m_vectorLength;
|
|
};
|
|
|
|
LinearGradientStrategy::LinearGradientStrategy(const KisPoint& gradientVectorStart, const KisPoint& gradientVectorEnd)
|
|
: super(gradientVectorStart, gradientVectorEnd)
|
|
{
|
|
double dx = gradientVectorEnd.x() - gradientVectorStart.x();
|
|
double dy = gradientVectorEnd.y() - gradientVectorStart.y();
|
|
|
|
m_vectorLength = sqrt((dx * dx) + (dy * dy));
|
|
|
|
if (m_vectorLength < DBL_EPSILON) {
|
|
m_normalisedVectorX = 0;
|
|
m_normalisedVectorY = 0;
|
|
}
|
|
else {
|
|
m_normalisedVectorX = dx / m_vectorLength;
|
|
m_normalisedVectorY = dy / m_vectorLength;
|
|
}
|
|
}
|
|
|
|
double LinearGradientStrategy::valueAt(double x, double y) const
|
|
{
|
|
double vx = x - m_gradientVectorStart.x();
|
|
double vy = y - m_gradientVectorStart.y();
|
|
|
|
// Project the vector onto the normalised gradient vector.
|
|
double t = vx * m_normalisedVectorX + vy * m_normalisedVectorY;
|
|
|
|
if (m_vectorLength < DBL_EPSILON) {
|
|
t = 0;
|
|
}
|
|
else {
|
|
// Scale to 0 to 1 over the gradient vector length.
|
|
t /= m_vectorLength;
|
|
}
|
|
|
|
return t;
|
|
}
|
|
|
|
|
|
class BiLinearGradientStrategy : public LinearGradientStrategy {
|
|
typedef LinearGradientStrategy super;
|
|
public:
|
|
BiLinearGradientStrategy(const KisPoint& gradientVectorStart, const KisPoint& gradientVectorEnd);
|
|
|
|
virtual double valueAt(double x, double y) const;
|
|
};
|
|
|
|
BiLinearGradientStrategy::BiLinearGradientStrategy(const KisPoint& gradientVectorStart, const KisPoint& gradientVectorEnd)
|
|
: super(gradientVectorStart, gradientVectorEnd)
|
|
{
|
|
}
|
|
|
|
double BiLinearGradientStrategy::valueAt(double x, double y) const
|
|
{
|
|
double t = super::valueAt(x, y);
|
|
|
|
// Reflect
|
|
if (t < -DBL_EPSILON) {
|
|
t = -t;
|
|
}
|
|
|
|
return t;
|
|
}
|
|
|
|
|
|
class RadialGradientStrategy : public GradientShapeStrategy {
|
|
typedef GradientShapeStrategy super;
|
|
public:
|
|
RadialGradientStrategy(const KisPoint& gradientVectorStart, const KisPoint& gradientVectorEnd);
|
|
|
|
virtual double valueAt(double x, double y) const;
|
|
|
|
protected:
|
|
double m_radius;
|
|
};
|
|
|
|
RadialGradientStrategy::RadialGradientStrategy(const KisPoint& gradientVectorStart, const KisPoint& gradientVectorEnd)
|
|
: super(gradientVectorStart, gradientVectorEnd)
|
|
{
|
|
double dx = gradientVectorEnd.x() - gradientVectorStart.x();
|
|
double dy = gradientVectorEnd.y() - gradientVectorStart.y();
|
|
|
|
m_radius = sqrt((dx * dx) + (dy * dy));
|
|
}
|
|
|
|
double RadialGradientStrategy::valueAt(double x, double y) const
|
|
{
|
|
double dx = x - m_gradientVectorStart.x();
|
|
double dy = y - m_gradientVectorStart.y();
|
|
|
|
double distance = sqrt((dx * dx) + (dy * dy));
|
|
|
|
double t;
|
|
|
|
if (m_radius < DBL_EPSILON) {
|
|
t = 0;
|
|
}
|
|
else {
|
|
t = distance / m_radius;
|
|
}
|
|
|
|
return t;
|
|
}
|
|
|
|
|
|
class SquareGradientStrategy : public GradientShapeStrategy {
|
|
typedef GradientShapeStrategy super;
|
|
public:
|
|
SquareGradientStrategy(const KisPoint& gradientVectorStart, const KisPoint& gradientVectorEnd);
|
|
|
|
virtual double valueAt(double x, double y) const;
|
|
|
|
protected:
|
|
double m_normalisedVectorX;
|
|
double m_normalisedVectorY;
|
|
double m_vectorLength;
|
|
};
|
|
|
|
SquareGradientStrategy::SquareGradientStrategy(const KisPoint& gradientVectorStart, const KisPoint& gradientVectorEnd)
|
|
: super(gradientVectorStart, gradientVectorEnd)
|
|
{
|
|
double dx = gradientVectorEnd.x() - gradientVectorStart.x();
|
|
double dy = gradientVectorEnd.y() - gradientVectorStart.y();
|
|
|
|
m_vectorLength = sqrt((dx * dx) + (dy * dy));
|
|
|
|
if (m_vectorLength < DBL_EPSILON) {
|
|
m_normalisedVectorX = 0;
|
|
m_normalisedVectorY = 0;
|
|
}
|
|
else {
|
|
m_normalisedVectorX = dx / m_vectorLength;
|
|
m_normalisedVectorY = dy / m_vectorLength;
|
|
}
|
|
}
|
|
|
|
double SquareGradientStrategy::valueAt(double x, double y) const
|
|
{
|
|
double px = x - m_gradientVectorStart.x();
|
|
double py = y - m_gradientVectorStart.y();
|
|
|
|
double distance1 = 0;
|
|
double distance2 = 0;
|
|
|
|
if (m_vectorLength > DBL_EPSILON) {
|
|
|
|
// Point to line distance is:
|
|
// distance = ((l0.y() - l1.y()) * p.x() + (l1.x() - l0.x()) * p.y() + l0.x() * l1.y() - l1.x() * l0.y()) / m_vectorLength;
|
|
//
|
|
// Here l0 = (0, 0) and |l1 - l0| = 1
|
|
|
|
distance1 = -m_normalisedVectorY * px + m_normalisedVectorX * py;
|
|
distance1 = fabs(distance1);
|
|
|
|
// Rotate point by 90 degrees and get the distance to the perpendicular
|
|
distance2 = -m_normalisedVectorY * -py + m_normalisedVectorX * px;
|
|
distance2 = fabs(distance2);
|
|
}
|
|
|
|
double t = TQMAX(distance1, distance2) / m_vectorLength;
|
|
|
|
return t;
|
|
}
|
|
|
|
|
|
class ConicalGradientStrategy : public GradientShapeStrategy {
|
|
typedef GradientShapeStrategy super;
|
|
public:
|
|
ConicalGradientStrategy(const KisPoint& gradientVectorStart, const KisPoint& gradientVectorEnd);
|
|
|
|
virtual double valueAt(double x, double y) const;
|
|
|
|
protected:
|
|
double m_vectorAngle;
|
|
};
|
|
|
|
ConicalGradientStrategy::ConicalGradientStrategy(const KisPoint& gradientVectorStart, const KisPoint& gradientVectorEnd)
|
|
: super(gradientVectorStart, gradientVectorEnd)
|
|
{
|
|
double dx = gradientVectorEnd.x() - gradientVectorStart.x();
|
|
double dy = gradientVectorEnd.y() - gradientVectorStart.y();
|
|
|
|
// Get angle from 0 to 2 PI.
|
|
m_vectorAngle = atan2(dy, dx) + M_PI;
|
|
}
|
|
|
|
double ConicalGradientStrategy::valueAt(double x, double y) const
|
|
{
|
|
double px = x - m_gradientVectorStart.x();
|
|
double py = y - m_gradientVectorStart.y();
|
|
|
|
double angle = atan2(py, px) + M_PI;
|
|
|
|
angle -= m_vectorAngle;
|
|
|
|
if (angle < 0) {
|
|
angle += 2 * M_PI;
|
|
}
|
|
|
|
double t = angle / (2 * M_PI);
|
|
|
|
return t;
|
|
}
|
|
|
|
|
|
class ConicalSymetricGradientStrategy : public GradientShapeStrategy {
|
|
typedef GradientShapeStrategy super;
|
|
public:
|
|
ConicalSymetricGradientStrategy(const KisPoint& gradientVectorStart, const KisPoint& gradientVectorEnd);
|
|
|
|
virtual double valueAt(double x, double y) const;
|
|
|
|
protected:
|
|
double m_vectorAngle;
|
|
};
|
|
|
|
ConicalSymetricGradientStrategy::ConicalSymetricGradientStrategy(const KisPoint& gradientVectorStart, const KisPoint& gradientVectorEnd)
|
|
: super(gradientVectorStart, gradientVectorEnd)
|
|
{
|
|
double dx = gradientVectorEnd.x() - gradientVectorStart.x();
|
|
double dy = gradientVectorEnd.y() - gradientVectorStart.y();
|
|
|
|
// Get angle from 0 to 2 PI.
|
|
m_vectorAngle = atan2(dy, dx) + M_PI;
|
|
}
|
|
|
|
double ConicalSymetricGradientStrategy::valueAt(double x, double y) const
|
|
{
|
|
double px = x - m_gradientVectorStart.x();
|
|
double py = y - m_gradientVectorStart.y();
|
|
|
|
double angle = atan2(py, px) + M_PI;
|
|
|
|
angle -= m_vectorAngle;
|
|
|
|
if (angle < 0) {
|
|
angle += 2 * M_PI;
|
|
}
|
|
|
|
double t;
|
|
|
|
if (angle < M_PI) {
|
|
t = angle / M_PI;
|
|
}
|
|
else {
|
|
t = 1 - ((angle - M_PI) / M_PI);
|
|
}
|
|
|
|
return t;
|
|
}
|
|
|
|
|
|
class GradientRepeatStrategy {
|
|
public:
|
|
GradientRepeatStrategy() {}
|
|
virtual ~GradientRepeatStrategy() {}
|
|
|
|
virtual double valueAt(double t) const = 0;
|
|
};
|
|
|
|
|
|
class GradientRepeatNoneStrategy : public GradientRepeatStrategy {
|
|
public:
|
|
static GradientRepeatNoneStrategy *instance();
|
|
|
|
virtual double valueAt(double t) const;
|
|
|
|
private:
|
|
GradientRepeatNoneStrategy() {}
|
|
|
|
static GradientRepeatNoneStrategy *m_instance;
|
|
};
|
|
|
|
GradientRepeatNoneStrategy *GradientRepeatNoneStrategy::m_instance = 0;
|
|
|
|
GradientRepeatNoneStrategy *GradientRepeatNoneStrategy::instance()
|
|
{
|
|
if (m_instance == 0) {
|
|
m_instance = new GradientRepeatNoneStrategy();
|
|
TQ_CHECK_PTR(m_instance);
|
|
}
|
|
|
|
return m_instance;
|
|
}
|
|
|
|
// Output is clamped to 0 to 1.
|
|
double GradientRepeatNoneStrategy::valueAt(double t) const
|
|
{
|
|
double value = t;
|
|
|
|
if (t < DBL_EPSILON) {
|
|
value = 0;
|
|
}
|
|
else
|
|
if (t > 1 - DBL_EPSILON) {
|
|
value = 1;
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
|
|
class GradientRepeatForwardsStrategy : public GradientRepeatStrategy {
|
|
public:
|
|
static GradientRepeatForwardsStrategy *instance();
|
|
|
|
virtual double valueAt(double t) const;
|
|
|
|
private:
|
|
GradientRepeatForwardsStrategy() {}
|
|
|
|
static GradientRepeatForwardsStrategy *m_instance;
|
|
};
|
|
|
|
GradientRepeatForwardsStrategy *GradientRepeatForwardsStrategy::m_instance = 0;
|
|
|
|
GradientRepeatForwardsStrategy *GradientRepeatForwardsStrategy::instance()
|
|
{
|
|
if (m_instance == 0) {
|
|
m_instance = new GradientRepeatForwardsStrategy();
|
|
TQ_CHECK_PTR(m_instance);
|
|
}
|
|
|
|
return m_instance;
|
|
}
|
|
|
|
// Output is 0 to 1, 0 to 1, 0 to 1...
|
|
double GradientRepeatForwardsStrategy::valueAt(double t) const
|
|
{
|
|
int i = static_cast<int>(t);
|
|
|
|
if (t < DBL_EPSILON) {
|
|
i--;
|
|
}
|
|
|
|
double value = t - i;
|
|
|
|
return value;
|
|
}
|
|
|
|
|
|
class GradientRepeatAlternateStrategy : public GradientRepeatStrategy {
|
|
public:
|
|
static GradientRepeatAlternateStrategy *instance();
|
|
|
|
virtual double valueAt(double t) const;
|
|
|
|
private:
|
|
GradientRepeatAlternateStrategy() {}
|
|
|
|
static GradientRepeatAlternateStrategy *m_instance;
|
|
};
|
|
|
|
GradientRepeatAlternateStrategy *GradientRepeatAlternateStrategy::m_instance = 0;
|
|
|
|
GradientRepeatAlternateStrategy *GradientRepeatAlternateStrategy::instance()
|
|
{
|
|
if (m_instance == 0) {
|
|
m_instance = new GradientRepeatAlternateStrategy();
|
|
TQ_CHECK_PTR(m_instance);
|
|
}
|
|
|
|
return m_instance;
|
|
}
|
|
|
|
// Output is 0 to 1, 1 to 0, 0 to 1, 1 to 0...
|
|
double GradientRepeatAlternateStrategy::valueAt(double t) const
|
|
{
|
|
if (t < 0) {
|
|
t = -t;
|
|
}
|
|
|
|
int i = static_cast<int>(t);
|
|
|
|
double value = t - i;
|
|
|
|
if (i % 2 == 1) {
|
|
value = 1 - value;
|
|
}
|
|
|
|
return value;
|
|
}
|
|
}
|
|
|
|
KisGradientPainter::KisGradientPainter()
|
|
: super()
|
|
{
|
|
m_gradient = 0;
|
|
}
|
|
|
|
KisGradientPainter::KisGradientPainter(KisPaintDeviceSP device) : super(device), m_gradient(0)
|
|
{
|
|
}
|
|
|
|
bool KisGradientPainter::paintGradient(const KisPoint& gradientVectorStart,
|
|
const KisPoint& gradientVectorEnd,
|
|
enumGradientShape shape,
|
|
enumGradientRepeat repeat,
|
|
double antiAliasThreshold,
|
|
bool reverseGradient,
|
|
TQ_INT32 startx,
|
|
TQ_INT32 starty,
|
|
TQ_INT32 width,
|
|
TQ_INT32 height)
|
|
{
|
|
m_cancelRequested = false;
|
|
|
|
if (!m_gradient) return false;
|
|
|
|
GradientShapeStrategy *shapeStrategy = 0;
|
|
|
|
switch (shape) {
|
|
case GradientShapeLinear:
|
|
shapeStrategy = new LinearGradientStrategy(gradientVectorStart, gradientVectorEnd);
|
|
break;
|
|
case GradientShapeBiLinear:
|
|
shapeStrategy = new BiLinearGradientStrategy(gradientVectorStart, gradientVectorEnd);
|
|
break;
|
|
case GradientShapeRadial:
|
|
shapeStrategy = new RadialGradientStrategy(gradientVectorStart, gradientVectorEnd);
|
|
break;
|
|
case GradientShapeSquare:
|
|
shapeStrategy = new SquareGradientStrategy(gradientVectorStart, gradientVectorEnd);
|
|
break;
|
|
case GradientShapeConical:
|
|
shapeStrategy = new ConicalGradientStrategy(gradientVectorStart, gradientVectorEnd);
|
|
break;
|
|
case GradientShapeConicalSymetric:
|
|
shapeStrategy = new ConicalSymetricGradientStrategy(gradientVectorStart, gradientVectorEnd);
|
|
break;
|
|
}
|
|
TQ_CHECK_PTR(shapeStrategy);
|
|
|
|
GradientRepeatStrategy *repeatStrategy = 0;
|
|
|
|
switch (repeat) {
|
|
case GradientRepeatNone:
|
|
repeatStrategy = GradientRepeatNoneStrategy::instance();
|
|
break;
|
|
case GradientRepeatForwards:
|
|
repeatStrategy = GradientRepeatForwardsStrategy::instance();
|
|
break;
|
|
case GradientRepeatAlternate:
|
|
repeatStrategy = GradientRepeatAlternateStrategy::instance();
|
|
break;
|
|
}
|
|
Q_ASSERT(repeatStrategy != 0);
|
|
|
|
|
|
//If the device has a selection only iterate over that selection
|
|
TQRect r;
|
|
if( m_device->hasSelection() ) {
|
|
r = m_device->selection()->selectedExactRect();
|
|
startx = r.x();
|
|
starty = r.y();
|
|
width = r.width();
|
|
height = r.height();
|
|
}
|
|
|
|
TQ_INT32 endx = startx + width - 1;
|
|
TQ_INT32 endy = starty + height - 1;
|
|
|
|
TQImage layer (width, height, 32);
|
|
layer.setAlphaBuffer(true);
|
|
|
|
int pixelsProcessed = 0;
|
|
int lastProgressPercent = 0;
|
|
|
|
emit notifyProgressStage(i18n("Rendering gradient..."), 0);
|
|
|
|
int totalPixels = width * height;
|
|
|
|
if (antiAliasThreshold < 1 - DBL_EPSILON) {
|
|
totalPixels *= 2;
|
|
}
|
|
|
|
for (int y = starty; y <= endy; y++) {
|
|
for (int x = startx; x <= endx; x++) {
|
|
|
|
double t = shapeStrategy->valueAt( x, y);
|
|
t = repeatStrategy->valueAt(t);
|
|
|
|
if (reverseGradient) {
|
|
t = 1 - t;
|
|
}
|
|
|
|
TQColor color;
|
|
TQ_UINT8 opacity;
|
|
|
|
m_gradient->colorAt(t, &color, &opacity);
|
|
|
|
layer.setPixel(x - startx, y - starty,
|
|
tqRgba(color.red(), color.green(), color.blue(), opacity));
|
|
|
|
pixelsProcessed++;
|
|
|
|
int progressPercent = (pixelsProcessed * 100) / totalPixels;
|
|
|
|
if (progressPercent > lastProgressPercent) {
|
|
emit notifyProgress(progressPercent);
|
|
lastProgressPercent = progressPercent;
|
|
|
|
if (m_cancelRequested) {
|
|
break;
|
|
}
|
|
}
|
|
if (m_cancelRequested) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!m_cancelRequested && antiAliasThreshold < 1 - DBL_EPSILON) {
|
|
|
|
TQColor color;
|
|
emit notifyProgressStage(i18n("Anti-aliasing gradient..."), lastProgressPercent);
|
|
TQ_UINT8 * layerPointer = layer.bits();
|
|
for (int y = starty; y <= endy; y++) {
|
|
for (int x = startx; x <= endx; x++) {
|
|
|
|
double maxDistance = 0;
|
|
|
|
TQ_UINT8 redThis = layerPointer[2];
|
|
TQ_UINT8 greenThis = layerPointer[1];
|
|
TQ_UINT8 blueThis = layerPointer[0];
|
|
TQ_UINT8 thisPixelOpacity = layerPointer[3];
|
|
|
|
for (int yOffset = -1; yOffset < 2; yOffset++) {
|
|
for (int xOffset = -1; xOffset < 2; xOffset++) {
|
|
|
|
if (xOffset != 0 || yOffset != 0) {
|
|
int sampleX = x + xOffset;
|
|
int sampleY = y + yOffset;
|
|
|
|
if (sampleX >= startx && sampleX <= endx && sampleY >= starty && sampleY <= endy) {
|
|
uint x = sampleX - startx;
|
|
uint y = sampleY - starty;
|
|
TQ_UINT8 * pixelPos = layer.bits() + (y * width * 4) + (x * 4);
|
|
TQ_UINT8 red = *(pixelPos +2);
|
|
TQ_UINT8 green = *(pixelPos + 1);
|
|
TQ_UINT8 blue = *pixelPos;
|
|
TQ_UINT8 opacity = *(pixelPos + 3);
|
|
|
|
double dRed = (red * opacity - redThis * thisPixelOpacity) / 65535.0;
|
|
double dGreen = (green * opacity - greenThis * thisPixelOpacity) / 65535.0;
|
|
double dBlue = (blue * opacity - blueThis * thisPixelOpacity) / 65535.0;
|
|
|
|
#define SQRT_3 1.7320508
|
|
|
|
double distance =/* sqrt(*/dRed * dRed + dGreen * dGreen + dBlue * dBlue/*) / SQRT_3*/;
|
|
|
|
if (distance > maxDistance) {
|
|
maxDistance = distance;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (maxDistance > 3.*antiAliasThreshold*antiAliasThreshold) {
|
|
const int numSamples = 4;
|
|
|
|
int totalRed = 0;
|
|
int totalGreen = 0;
|
|
int totalBlue = 0;
|
|
int totalOpacity = 0;
|
|
|
|
for (int ySample = 0; ySample < numSamples; ySample++) {
|
|
for (int xSample = 0; xSample < numSamples; xSample++) {
|
|
|
|
double sampleWidth = 1.0 / numSamples;
|
|
|
|
double sampleX = x - 0.5 + (sampleWidth / 2) + xSample * sampleWidth;
|
|
double sampleY = y - 0.5 + (sampleWidth / 2) + ySample * sampleWidth;
|
|
|
|
double t = shapeStrategy->valueAt(sampleX, sampleY);
|
|
t = repeatStrategy->valueAt(t);
|
|
|
|
if (reverseGradient) {
|
|
t = 1 - t;
|
|
}
|
|
|
|
TQ_UINT8 opacity;
|
|
|
|
m_gradient->colorAt(t, &color, &opacity);
|
|
|
|
totalRed += color.red();
|
|
totalGreen += color.green();
|
|
totalBlue += color.blue();
|
|
totalOpacity += opacity;
|
|
}
|
|
}
|
|
|
|
int red = totalRed / (numSamples * numSamples);
|
|
int green = totalGreen / (numSamples * numSamples);
|
|
int blue = totalBlue / (numSamples * numSamples);
|
|
int opacity = totalOpacity / (numSamples * numSamples);
|
|
|
|
layer.setPixel(x - startx, y - starty, tqRgba(red, green, blue, opacity));
|
|
}
|
|
|
|
pixelsProcessed++;
|
|
|
|
int progressPercent = (pixelsProcessed * 100) / totalPixels;
|
|
|
|
if (progressPercent > lastProgressPercent) {
|
|
emit notifyProgress(progressPercent);
|
|
lastProgressPercent = progressPercent;
|
|
|
|
if (m_cancelRequested) {
|
|
break;
|
|
}
|
|
}
|
|
layerPointer += 4;
|
|
}
|
|
|
|
if (m_cancelRequested) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!m_cancelRequested) {
|
|
kdDebug() << "Have we got a selection? " << m_device->hasSelection() << endl;
|
|
KisPaintDeviceSP dev = new KisPaintDevice(KisMetaRegistry::instance()->csRegistry()->getRGB8(), "temporary device for gradient");
|
|
dev->writeBytes(layer.bits(), startx, starty, width, height);
|
|
bltSelection(startx, starty, m_compositeOp, dev, m_opacity, startx, starty, width, height);
|
|
}
|
|
delete shapeStrategy;
|
|
|
|
emit notifyProgressDone();
|
|
|
|
return !m_cancelRequested;
|
|
}
|