TDE
/
koffice
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/koffice
0
0
Fork 0
Code Issues Releases Wiki Activity
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.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '63f984a752'
${ noResults }
koffice/chalk/plugins/filters/cubismfilter/kis_cubism_filter.cc

454 lines
17 KiB
Raw Blame History

/*
* 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 ) );
}
}
View Git Blame Copy Permalink