|
|
|
/*
|
|
|
|
* This file is part of Chalk
|
|
|
|
*
|
|
|
|
* Copyright (c) 2005 Michael Thaler <michael.thaler@physik.tu-muenchen.de>
|
|
|
|
*
|
|
|
|
* ported from Gimp, Copyright (C) 1997 Eiichi Takamori <taka@ma1.seikyou.ne.jp>
|
|
|
|
* original pixelize.c for GIMP 0.54 by Tracy Scott
|
|
|
|
*
|
|
|
|
* 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 <time.h>
|
|
|
|
#include <vector>
|
|
|
|
|
|
|
|
#include <tqpoint.h>
|
|
|
|
#include <tqspinbox.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_painter.h>
|
|
|
|
#include <kis_meta_registry.h>
|
|
|
|
#include <kis_colorspace_factory_registry.h>
|
|
|
|
#include <kis_doc.h>
|
|
|
|
#include <kis_image.h>
|
|
|
|
#include <kis_iterators_pixel.h>
|
|
|
|
#include <kis_layer.h>
|
|
|
|
#include <kis_filter_registry.h>
|
|
|
|
#include <kis_global.h>
|
|
|
|
#include <kis_types.h>
|
|
|
|
#include <kis_progress_display_interface.h>
|
|
|
|
#include <kis_vec.h>
|
|
|
|
|
|
|
|
#include "kis_multi_integer_filter_widget.h"
|
|
|
|
#include "kis_cubism_filter.h"
|
|
|
|
#include "kis_polygon.h"
|
|
|
|
#include "kis_point.h"
|
|
|
|
|
|
|
|
#define RANDOMNESS 5
|
|
|
|
#define SUPERSAMPLE 4
|
|
|
|
#define CLAMP(x,l,u) ((x)<(l)?(l):((x)>(u)?(u):(x)))
|
|
|
|
#define SQR(x) ((x) * (x))
|
|
|
|
|
|
|
|
KisCubismFilter::KisCubismFilter() : KisFilter(id(), "artistic", i18n("&Cubism..."))
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
bool KisCubismFilter::workWith(KisColorSpace* /*cs*/)
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void KisCubismFilter::process(KisPaintDeviceSP src, KisPaintDeviceSP dst,
|
|
|
|
KisFilterConfiguration* configuration, const TQRect& rect)
|
|
|
|
{
|
|
|
|
Q_ASSERT(src);
|
|
|
|
Q_ASSERT(dst);
|
|
|
|
Q_ASSERT(configuration);
|
|
|
|
|
|
|
|
//read the filter configuration values from the KisFilterConfiguration object
|
|
|
|
TQ_UINT32 tileSize = ((KisCubismFilterConfiguration*)configuration)->tileSize();
|
|
|
|
TQ_UINT32 tileSaturation = ((KisCubismFilterConfiguration*)configuration)->tileSaturation();
|
|
|
|
|
|
|
|
KisColorSpace * cs = src->colorSpace();
|
|
|
|
TQString id = cs->id().id();
|
|
|
|
|
|
|
|
if (id == "RGBA" || id == "GRAY" || id == "CMYK") {
|
|
|
|
cubism(src, dst, rect, tileSize, tileSaturation);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (src->image()) src->image()->lock();
|
|
|
|
|
|
|
|
KisPaintDeviceSP dev = new KisPaintDevice(KisMetaRegistry::instance()->csRegistry()->getRGB8(), "temporary");
|
|
|
|
KisPainter gc(dev);
|
|
|
|
gc.bitBlt(0, 0, COMPOSITE_COPY, src, rect.x(), rect.y(), rect.width(), rect.height());
|
|
|
|
gc.end();
|
|
|
|
|
|
|
|
kdDebug() << src->colorSpace()->id().id() << endl;
|
|
|
|
cubism(dev, dev, TQRect(0, 0, rect.width(), rect.height()), tileSize, tileSaturation);
|
|
|
|
|
|
|
|
gc.begin(dst);
|
|
|
|
gc.bitBlt(rect.x(), rect.y(), COMPOSITE_COPY, dev, 0, 0, rect.width(), rect.height());
|
|
|
|
gc.end();
|
|
|
|
if (src->image()) src->image()->unlock();
|
|
|
|
|
|
|
|
kdDebug() << src->colorSpace()->id().id() << endl;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void KisCubismFilter::randomizeIndices (TQ_INT32 count, TQ_INT32* indices)
|
|
|
|
{
|
|
|
|
TQ_INT32 index1, index2;
|
|
|
|
TQ_INT32 tmp;
|
|
|
|
|
|
|
|
//initialize random number generator with time
|
|
|
|
srand(static_cast<unsigned int>(time(0)));
|
|
|
|
|
|
|
|
for (TQ_INT32 i = 0; i < count * RANDOMNESS; i++)
|
|
|
|
{
|
|
|
|
index1 = randomIntNumber(0, count);
|
|
|
|
index2 = randomIntNumber(0, count);
|
|
|
|
tmp = indices[index1];
|
|
|
|
indices[index1] = indices[index2];
|
|
|
|
indices[index2] = tmp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
TQ_INT32 KisCubismFilter::randomIntNumber(TQ_INT32 lowestNumber, TQ_INT32 highestNumber)
|
|
|
|
{
|
|
|
|
if(lowestNumber > highestNumber)
|
|
|
|
{
|
|
|
|
TQ_INT32 temp = lowestNumber;
|
|
|
|
lowestNumber = highestNumber;
|
|
|
|
highestNumber = temp;
|
|
|
|
}
|
|
|
|
|
|
|
|
return lowestNumber + (( highestNumber - lowestNumber ) * rand() )/ RAND_MAX;
|
|
|
|
}
|
|
|
|
|
|
|
|
double KisCubismFilter::randomDoubleNumber(double lowestNumber, double highestNumber)
|
|
|
|
{
|
|
|
|
if(lowestNumber > highestNumber)
|
|
|
|
{
|
|
|
|
double temp = lowestNumber;
|
|
|
|
lowestNumber = highestNumber;
|
|
|
|
highestNumber = temp;
|
|
|
|
}
|
|
|
|
|
|
|
|
double range = highestNumber - lowestNumber;
|
|
|
|
return lowestNumber + range * rand() / (double)RAND_MAX;
|
|
|
|
}
|
|
|
|
|
|
|
|
double KisCubismFilter::calcAlphaBlend (double* vec, double oneOverDist, double x, double y)
|
|
|
|
{
|
|
|
|
|
|
|
|
if ( oneOverDist==0 )
|
|
|
|
return 1.0;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
double r = (vec[0] * x + vec[1] * y) * oneOverDist;
|
|
|
|
if (r < 0.2)
|
|
|
|
r = 0.2;
|
|
|
|
else if (r > 1.0)
|
|
|
|
r = 1.0;
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void KisCubismFilter::convertSegment (TQ_INT32 x1, TQ_INT32 y1, TQ_INT32 x2, TQ_INT32 y2, TQ_INT32 offset, TQ_INT32* min, TQ_INT32* max, TQ_INT32 xmin, TQ_INT32 xmax)
|
|
|
|
{
|
|
|
|
if (y1 > y2)
|
|
|
|
{
|
|
|
|
TQ_INT32 tmp = y2; y2 = y1; y1 = tmp;
|
|
|
|
tmp = x2; x2 = x1; x1 = tmp;
|
|
|
|
}
|
|
|
|
TQ_INT32 ydiff = (y2 - y1);
|
|
|
|
|
|
|
|
if (ydiff)
|
|
|
|
{
|
|
|
|
double xinc = static_cast<double>(x2 - x1) / static_cast<double>(ydiff);
|
|
|
|
double xstart = x1 + 0.5 * xinc;
|
|
|
|
for (TQ_INT32 y = y1 ; y < y2; y++)
|
|
|
|
{
|
|
|
|
if(xstart >= xmin && xstart <= xmax)
|
|
|
|
{
|
|
|
|
if (xstart < min[y - offset])
|
|
|
|
{
|
|
|
|
min[y-offset] = (int)xstart;
|
|
|
|
}
|
|
|
|
if (xstart > max[y - offset])
|
|
|
|
{
|
|
|
|
max[y-offset] = (int)xstart;
|
|
|
|
}
|
|
|
|
xstart += xinc;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#define USE_READABLE_BUT_SLOW_CODE
|
|
|
|
|
|
|
|
void KisCubismFilter::fillPolyColor (KisPaintDeviceSP src, KisPaintDeviceSP dst, KisPolygon* poly, const TQ_UINT8* col, TQ_UINT8* /*s*/, TQRect rect)
|
|
|
|
{
|
|
|
|
TQ_INT32 val;
|
|
|
|
TQ_INT32 alpha;
|
|
|
|
TQ_UINT8 buf[4];
|
|
|
|
TQ_INT32 x, y;
|
|
|
|
double xx, yy;
|
|
|
|
double vec[2];
|
|
|
|
TQ_INT32 x1 = rect.left(), y1 = rect.top(), x2 = rect.right(), y2 = rect.bottom();
|
|
|
|
// TQ_INT32 selWidth, selHeight;
|
|
|
|
TQ_INT32 *vals, *valsIter, *valsEnd;
|
|
|
|
TQ_INT32 b;
|
|
|
|
TQ_INT32 xs, ys, xe, ye;
|
|
|
|
|
|
|
|
|
|
|
|
TQ_INT32 sx = (TQ_INT32) (*poly)[0].x();
|
|
|
|
TQ_INT32 sy = (TQ_INT32) (*poly)[0].y();
|
|
|
|
TQ_INT32 ex = (TQ_INT32) (*poly)[1].x();
|
|
|
|
TQ_INT32 ey = (TQ_INT32) (*poly)[1].y();
|
|
|
|
|
|
|
|
double dist = sqrt (SQR (ex - sx) + SQR (ey - sy));
|
|
|
|
double oneOverDist = 0.0;
|
|
|
|
if (dist > 0.0)
|
|
|
|
{
|
|
|
|
double oneOverDist = 1/dist;
|
|
|
|
vec[0] = (ex - sx) * oneOverDist;
|
|
|
|
vec[1] = (ey - sy) * oneOverDist;
|
|
|
|
}
|
|
|
|
|
|
|
|
TQ_INT32 pixelSize = src->pixelSize();
|
|
|
|
//get the extents of the polygon
|
|
|
|
double dMinX, dMinY, dMaxX, dMaxY;
|
|
|
|
poly->extents (dMinX, dMinY, dMaxX, dMaxY);
|
|
|
|
TQ_INT32 minX = static_cast<TQ_INT32>(dMinX);
|
|
|
|
TQ_INT32 minY = static_cast<TQ_INT32>(dMinY);
|
|
|
|
TQ_INT32 maxX = static_cast<TQ_INT32>(dMaxX);
|
|
|
|
TQ_INT32 maxY = static_cast<TQ_INT32>(dMaxY);
|
|
|
|
TQ_INT32 sizeX = (maxX - minX) * SUPERSAMPLE;
|
|
|
|
TQ_INT32 sizeY = (maxY - minY) * SUPERSAMPLE;
|
|
|
|
|
|
|
|
TQ_INT32 *minScanlines = new TQ_INT32[sizeY];
|
|
|
|
TQ_INT32 *minScanlinesIter = minScanlines;
|
|
|
|
TQ_INT32 *maxScanlines = new TQ_INT32[sizeY];
|
|
|
|
TQ_INT32 *maxScanlinesIter = maxScanlines;
|
|
|
|
|
|
|
|
for (TQ_INT32 i = 0; i < sizeY; i++)
|
|
|
|
{
|
|
|
|
minScanlines[i] = maxX * SUPERSAMPLE;
|
|
|
|
maxScanlines[i] = minX * SUPERSAMPLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( poly->numberOfPoints() )
|
|
|
|
{
|
|
|
|
TQ_INT32 polyNpts = poly->numberOfPoints();
|
|
|
|
|
|
|
|
xs = static_cast<TQ_INT32>((*poly)[polyNpts-1].x());
|
|
|
|
ys = static_cast<TQ_INT32>((*poly)[polyNpts-1].y());
|
|
|
|
xe = static_cast<TQ_INT32>((*poly)[0].x());
|
|
|
|
ye = static_cast<TQ_INT32>((*poly)[0].y());
|
|
|
|
|
|
|
|
xs *= SUPERSAMPLE;
|
|
|
|
ys *= SUPERSAMPLE;
|
|
|
|
xe *= SUPERSAMPLE;
|
|
|
|
ye *= SUPERSAMPLE;
|
|
|
|
|
|
|
|
convertSegment (xs, ys, xe, ye, minY * SUPERSAMPLE, minScanlines, maxScanlines, minX* SUPERSAMPLE, maxX* SUPERSAMPLE);
|
|
|
|
|
|
|
|
KisPolygon::iterator it;
|
|
|
|
|
|
|
|
for ( it = poly->begin(); it != poly->end(); )
|
|
|
|
{
|
|
|
|
xs = static_cast<TQ_INT32>((*it).x());
|
|
|
|
ys = static_cast<TQ_INT32>((*it).y());
|
|
|
|
++it;
|
|
|
|
|
|
|
|
if( it != poly->end() )
|
|
|
|
{
|
|
|
|
xe = static_cast<TQ_INT32>((*it).x());
|
|
|
|
ye = static_cast<TQ_INT32>((*it).y());
|
|
|
|
|
|
|
|
xs *= SUPERSAMPLE;
|
|
|
|
ys *= SUPERSAMPLE;
|
|
|
|
xe *= SUPERSAMPLE;
|
|
|
|
ye *= SUPERSAMPLE;
|
|
|
|
|
|
|
|
convertSegment (xs, ys, xe, ye, minY * SUPERSAMPLE, minScanlines, maxScanlines, minX* SUPERSAMPLE, maxX* SUPERSAMPLE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
vals = new TQ_INT32[sizeX];
|
|
|
|
// x1 = minX; x2 = maxX; y1 = minY; y2 = maxY;
|
|
|
|
for (TQ_INT32 i = 0; i < sizeY; i++, minScanlinesIter++, maxScanlinesIter++)
|
|
|
|
{
|
|
|
|
if (! (i % SUPERSAMPLE))
|
|
|
|
{
|
|
|
|
memset (vals, 0, sizeof( TQ_INT32 ) * sizeX);
|
|
|
|
}
|
|
|
|
|
|
|
|
yy = static_cast<double>(i) / static_cast<double>(SUPERSAMPLE) + minY;
|
|
|
|
|
|
|
|
for (TQ_INT32 j = *minScanlinesIter; j < *maxScanlinesIter; j++)
|
|
|
|
{
|
|
|
|
x = j - minX * SUPERSAMPLE;
|
|
|
|
vals[x] += 255;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (! ((i + 1) % SUPERSAMPLE))
|
|
|
|
{
|
|
|
|
y = (i / SUPERSAMPLE) + minY;
|
|
|
|
if (y >= y1 && y <= y2)
|
|
|
|
{
|
|
|
|
for (TQ_INT32 j = 0; j < sizeX; j += SUPERSAMPLE)
|
|
|
|
{
|
|
|
|
x = (j / SUPERSAMPLE) + minX;
|
|
|
|
|
|
|
|
if (x >= x1 && x <= x2)
|
|
|
|
{
|
|
|
|
for (val = 0, valsIter = &vals[j], valsEnd = &valsIter[SUPERSAMPLE]; valsIter < valsEnd; valsIter++)
|
|
|
|
{
|
|
|
|
val += *valsIter;
|
|
|
|
}
|
|
|
|
val /= SQR(SUPERSAMPLE);
|
|
|
|
|
|
|
|
if (val > 0)
|
|
|
|
{
|
|
|
|
xx = static_cast<double>(j) / static_cast<double>(SUPERSAMPLE) + minX;
|
|
|
|
alpha = static_cast<TQ_INT32>(val * calcAlphaBlend (vec, oneOverDist, xx - sx, yy - sy));
|
|
|
|
|
|
|
|
// KisRectIteratorPixel srcIt = src->createRectIterator(x,y,1,1, false);
|
|
|
|
// const TQ_UINT8* srcPixel = srcIt.oldRawData();
|
|
|
|
// memcpy( buf, srcPixel, sizeof(TQ_UINT8) * pixelSize );
|
|
|
|
src->readBytes(buf, x, y, 1, 1);
|
|
|
|
#ifndef USE_READABLE_BUT_SLOW_CODE
|
|
|
|
TQ_UINT8 *bufIter = buf;
|
|
|
|
const TQ_UINT8 *colIter = col;
|
|
|
|
TQ_UINT8 *bufEnd = buf+pixelSize;
|
|
|
|
|
|
|
|
for(; bufIter < bufEnd; bufIter++, colIter++)
|
|
|
|
*bufIter = (static_cast<TQ_UINT8>(*colIter * alpha)
|
|
|
|
+ (static_cast<TQ_UINT8>(*bufIter)
|
|
|
|
* (256 - alpha))) >> 8;
|
|
|
|
#else //original, pre-ECL code
|
|
|
|
for (b = 0; b < pixelSize; b++)
|
|
|
|
{
|
|
|
|
buf[b] = ((col[b] * alpha) + (buf[b] * (255 - alpha))) / 255;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
dst->writeBytes(buf, x, y, 1, 1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
delete[] vals;
|
|
|
|
delete[] minScanlines;
|
|
|
|
delete[] maxScanlines;
|
|
|
|
}
|
|
|
|
|
|
|
|
void KisCubismFilter::cubism(KisPaintDeviceSP src, KisPaintDeviceSP dst, const TQRect& rect, TQ_UINT32 tileSize, TQ_UINT32 tileSaturation)
|
|
|
|
{
|
|
|
|
Q_ASSERT(src);
|
|
|
|
Q_ASSERT(dst);
|
|
|
|
|
|
|
|
//fill the destination image with the background color (black for now)
|
|
|
|
KisRectIteratorPixel dstIt = dst->createRectIterator(rect.x(), rect.y(), rect.width(), rect.height(), true );
|
|
|
|
TQ_INT32 depth = src->colorSpace()->nColorChannels();
|
|
|
|
while( ! dstIt.isDone() )
|
|
|
|
{
|
|
|
|
for( TQ_INT32 i = 0; i < depth; i++)
|
|
|
|
{
|
|
|
|
dstIt.rawData()[i] = 0;
|
|
|
|
}
|
|
|
|
++dstIt;
|
|
|
|
}
|
|
|
|
|
|
|
|
//compute number of rows and columns
|
|
|
|
TQ_INT32 cols = ( rect.width() + tileSize - 1) / tileSize;
|
|
|
|
TQ_INT32 rows = ( rect.height() + tileSize - 1) / tileSize;
|
|
|
|
TQ_INT32 numTiles = (rows + 1) * (cols + 1);
|
|
|
|
|
|
|
|
setProgressTotalSteps(numTiles);
|
|
|
|
setProgressStage(i18n("Applying cubism filter..."),0);
|
|
|
|
|
|
|
|
TQ_INT32* randomIndices = new TQ_INT32[numTiles];
|
|
|
|
for (TQ_INT32 i = 0; i < numTiles; i++)
|
|
|
|
{
|
|
|
|
randomIndices[i] = i;
|
|
|
|
}
|
|
|
|
randomizeIndices (numTiles, randomIndices);
|
|
|
|
|
|
|
|
TQ_INT32 count = 0;
|
|
|
|
TQ_INT32 i, j, ix, iy;
|
|
|
|
double x, y, width, height, theta;
|
|
|
|
KisPolygon *poly = new KisPolygon();
|
|
|
|
TQ_INT32 pixelSize = src->pixelSize();
|
|
|
|
const TQ_UINT8 *srcPixel /*= new TQ_UINT8[ pixelSize ]*/;
|
|
|
|
TQ_UINT8 *dstPixel = 0;
|
|
|
|
while (count < numTiles)
|
|
|
|
{
|
|
|
|
i = randomIndices[count] / (cols + 1);
|
|
|
|
j = randomIndices[count] % (cols + 1);
|
|
|
|
x = j * tileSize + (tileSize / 4.0) - randomDoubleNumber(0, tileSize/2.0) + rect.x();
|
|
|
|
y = i * tileSize + (tileSize / 4.0) - randomDoubleNumber(0, tileSize/2.0) + rect.y();
|
|
|
|
width = (tileSize + randomDoubleNumber(0, tileSize / 4.0) - tileSize / 8.0) * tileSaturation;
|
|
|
|
height = (tileSize + randomDoubleNumber (0, tileSize / 4.0) - tileSize / 8.0) * tileSaturation;
|
|
|
|
theta = randomDoubleNumber(0, 2*M_PI);
|
|
|
|
poly->clear();
|
|
|
|
poly->addPoint( -width / 2.0, -height / 2.0 );
|
|
|
|
poly->addPoint( width / 2.0, -height / 2.0 );
|
|
|
|
poly->addPoint( width / 2.0, height / 2.0 );
|
|
|
|
poly->addPoint( -width / 2.0, height / 2.0 );
|
|
|
|
poly->rotate( theta );
|
|
|
|
poly->translate ( x, y );
|
|
|
|
// bounds check on x, y
|
|
|
|
ix = (TQ_INT32) CLAMP (x, rect.x(), rect.x() + rect.width() - 1);
|
|
|
|
iy = (TQ_INT32) CLAMP (y, rect.y(), rect.y() + rect.height() - 1);
|
|
|
|
|
|
|
|
//read the pixel at ix, iy
|
|
|
|
KisRectIteratorPixel srcIt = src->createRectIterator(ix,iy,1,1, false);
|
|
|
|
srcPixel = srcIt.oldRawData();
|
|
|
|
if (srcPixel[pixelSize - 1])
|
|
|
|
{
|
|
|
|
fillPolyColor (src, dst, poly, srcPixel, dstPixel, rect);
|
|
|
|
}
|
|
|
|
count++;
|
|
|
|
if ((count % 5) == 0) setProgress(count);
|
|
|
|
}
|
|
|
|
setProgressDone();
|
|
|
|
}
|
|
|
|
|
|
|
|
KisFilterConfigWidget * KisCubismFilter::createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP /*dev*/)
|
|
|
|
{
|
|
|
|
vKisIntegerWidgetParam param;
|
|
|
|
param.push_back( KisIntegerWidgetParam( 2, 40, 10, i18n("Tile size"), "tileSize" ) );
|
|
|
|
param.push_back( KisIntegerWidgetParam( 2, 40, 10, i18n("Tile saturation"), "tileSaturation" ) );
|
|
|
|
return new KisMultiIntegerFilterWidget(parent, id().id().ascii(), id().id().ascii(), param );
|
|
|
|
}
|
|
|
|
|
|
|
|
KisFilterConfiguration* KisCubismFilter::configuration(TQWidget* nwidget)
|
|
|
|
{
|
|
|
|
KisMultiIntegerFilterWidget* widget = (KisMultiIntegerFilterWidget*) nwidget;
|
|
|
|
if( widget == 0 )
|
|
|
|
{
|
|
|
|
return new KisCubismFilterConfiguration( 10, 10);
|
|
|
|
} else {
|
|
|
|
return new KisCubismFilterConfiguration( widget->valueAt( 0 ), widget->valueAt( 1 ) );
|
|
|
|
}
|
|
|
|
}
|