void SprayBrush::paintRectangle(KisPainter& painter, qreal x, qreal y, int width, int height, qreal angle, int steps) {
QVector <QPointF> points;
QTransform transform;
qreal halfWidth = width / 2.0;
qreal halfHeight = height / 2.0;
qreal tx, ty;
transform.reset();
transform.rotateRadians( angle );
// top left
transform.map( - halfWidth, - halfHeight, &tx, &ty);
points.append(QPointF(tx + x,ty + y));
// top right
transform.map( + halfWidth, - halfHeight, &tx, &ty);
points.append(QPointF(tx + x,ty + y));
// bottom right
transform.map( + halfWidth, + halfHeight, &tx, &ty);
points.append(QPointF(tx + x,ty + y));
// botom left
transform.map( - halfWidth, + halfHeight, &tx, &ty);
points.append(QPointF(tx + x,ty + y));
painter.setOpacity( int( ( 255 * drand48() ) + 0.5 ) );
painter.setFillStyle(KisPainter::FillStyleForegroundColor);
painter.paintPolygon( points );
}
foreach(PainterInfo *info, m_painterInfos) {
KisPainter *painter = info->painter;
painter->begin(targetDevice, !hasIndirectPainting ? selection : 0);
m_resources->setupPainter(painter);
if(hasIndirectPainting) {
painter->setCompositeOp(targetDevice->colorSpace()->compositeOp(indirectPaintingCompositeOp));
painter->setOpacity(OPACITY_OPAQUE_U8);
painter->setChannelFlags(QBitArray());
}
}
void KisSmudgeOption::apply(KisPainter& painter, const KisPaintInformation& info, qreal scaleMin, qreal scaleMax, qreal multiplicator) const
{
if (!isChecked()) {
painter.setOpacity((quint8)(scaleMax * 255.0));
return;
}
qreal rate = scaleMin + (scaleMax - scaleMin) * multiplicator * computeValue(info); // scale m_rate into the range scaleMin - scaleMax
quint8 opacity = qBound(OPACITY_TRANSPARENT_U8, (quint8)(rate * 255.0), OPACITY_OPAQUE_U8);
painter.setOpacity(opacity);
}
void copyFromDevice(KisView2 *view, KisPaintDeviceSP device) {
KisImageWSP image = view->image();
KisSelectionSP selection = view->selection();
QRect rc = (selection) ? selection->selectedExactRect() : image->bounds();
KisPaintDeviceSP clip = new KisPaintDevice(device->colorSpace());
Q_CHECK_PTR(clip);
const KoColorSpace *cs = clip->colorSpace();
// TODO if the source is linked... copy from all linked layers?!?
// Copy image data
KisPainter gc;
gc.begin(clip);
gc.setCompositeOp(COMPOSITE_COPY);
gc.bitBlt(0, 0, device, rc.x(), rc.y(), rc.width(), rc.height());
gc.end();
if (selection) {
// Apply selection mask.
KisPaintDeviceSP selectionProjection = selection->projection();
KisHLineIteratorSP layerIt = clip->createHLineIteratorNG(0, 0, rc.width());
KisHLineConstIteratorSP selectionIt = selectionProjection->createHLineIteratorNG(rc.x(), rc.y(), rc.width());
for (qint32 y = 0; y < rc.height(); y++) {
for (qint32 x = 0; x < rc.width(); x++) {
cs->applyAlphaU8Mask(layerIt->rawData(), selectionIt->oldRawData(), 1);
layerIt->nextPixel();
selectionIt->nextPixel();
}
layerIt->nextRow();
selectionIt->nextRow();
}
}
KisClipboard::instance()->setClip(clip, rc.topLeft());
}
void SprayBrush::paintEllipse(KisPainter& painter, qreal x, qreal y, int a, int b, qreal angle, int steps) {
QVector <QPointF> points;
qreal beta = -angle;
qreal sinbeta = sin(beta);
qreal cosbeta = cos(beta);
for (int i = 0; i < 360; i += 360.0 / steps)
{
qreal alpha = i * (M_PI / 180) ;
qreal sinalpha = sin(alpha);
qreal cosalpha = cos(alpha);
qreal X = x + (a * cosalpha * cosbeta - b * sinalpha * sinbeta);
qreal Y = y + (a * cosalpha * sinbeta + b * sinalpha * cosbeta);
points.append( QPointF(X, Y) );
}
painter.setOpacity( int( ( 255 * drand48() ) + 0.5 ) );
painter.setFillStyle(KisPainter::FillStyleForegroundColor);
painter.paintPolygon( points );
}
void ImageBuilder::createImageFromClipboardDelayed()
{
DocumentManager::instance()->disconnect(this, SLOT(createImageFromClipboardDelayed()));
KisConfig cfg;
cfg.setPasteBehaviour(PASTE_ASSUME_MONITOR);
QSize sz = KisClipboard::instance()->clipSize();
KisPaintDeviceSP clipDevice = KisClipboard::instance()->clip(QRect(0, 0, sz.width(), sz.height()), false);
KisImageWSP image = DocumentManager::instance()->document()->image();
if (image && image->root() && image->root()->firstChild()) {
KisLayer * layer = dynamic_cast<KisLayer*>(image->root()->firstChild().data());
Q_ASSERT(layer);
layer->setOpacity(OPACITY_OPAQUE_U8);
QRect r = clipDevice->exactBounds();
KisPainter painter;
painter.begin(layer->paintDevice());
painter.setCompositeOp(COMPOSITE_COPY);
painter.bitBlt(QPoint(0, 0), clipDevice, r);
layer->setDirty(QRect(0, 0, sz.width(), sz.height()));
}
}
void doPaint(KisPainter &gc) override {
QVector<KisPaintInformation> vector;
vector << KisPaintInformation(QPointF(100, 100));
vector << KisPaintInformation(QPointF(200, 150));
vector << KisPaintInformation(QPointF(100, 350));
KisDistanceInformation dist;
for (int i = 1; i < vector.size(); i++) {
gc.paintLine(vector[i - 1], vector[i], &dist);
}
}
void SprayBrush::paintCircle(KisPainter& painter, qreal x, qreal y, int radius, int steps) {
QVector<QPointF> points;
// circle x, circle y
qreal cx, cy;
qreal length = 2.0 * M_PI;
qreal step = 1.0 / steps;
for (int i = 0; i < steps; i++){
cx = cos(i * step * length);
cy = sin(i * step * length);
cx *= radius;
cy *= radius;
cx += x;
cy += y;
points.append( QPointF(cx, cy) );
}
painter.setOpacity( qRound( OPACITY_OPAQUE * drand48() ) );
painter.setFillStyle( KisPainter::FillStyleForegroundColor );
painter.paintPolygon( points );
}
/**
* This benchmark runs a series of huge strokes on a canvas with a
* particular configuration of the swapper/pooler and history
* management. After the test is done you can visualize the results
* with the GNU Octave. Please use kis_low_memory_show_report.m file
* for that.
*/
void KisLowMemoryBenchmark::benchmarkWideArea(const QString presetFileName,
const QRectF &rect, qreal vstep,
int numCycles,
bool createTransaction,
int hardLimitMiB,
int softLimitMiB,
int poolLimitMiB,
int index)
{
KisPaintOpPresetSP preset = new KisPaintOpPreset(QString(FILES_DATA_DIR) + QDir::separator() + presetFileName);
LOAD_PRESET_OR_RETURN(preset, presetFileName);
/**
* Initialize image and painter
*/
const KoColorSpace *colorSpace = KoColorSpaceRegistry::instance()->rgb8();
KisImageSP image = new KisImage(0, HUGE_IMAGE_SIZE, HUGE_IMAGE_SIZE, colorSpace, "stroke sample image", true);
KisLayerSP layer = new KisPaintLayer(image, "temporary for stroke sample", OPACITY_OPAQUE_U8, colorSpace);
KisLayerSP layerExtra = new KisPaintLayer(image, "temporary for threading", OPACITY_OPAQUE_U8, colorSpace);
image->addNode(layer, image->root());
image->addNode(layerExtra, image->root());
KisPainter *painter = new KisPainter(layer->paintDevice());
painter->setPaintColor(KoColor(Qt::black, colorSpace));
painter->setPaintOpPreset(preset, layer, image);
/**
* A simple adapter that will store all the transactions for us
*/
KisSurrogateUndoAdapter undoAdapter;
/**
* Reset configuration to the desired settings
*/
KisImageConfig config;
qreal oldHardLimit = config.memoryHardLimitPercent();
qreal oldSoftLimit = config.memorySoftLimitPercent();
qreal oldPoolLimit = config.memoryPoolLimitPercent();
const qreal _MiB = 100.0 / KisImageConfig::totalRAM();
config.setMemoryHardLimitPercent(hardLimitMiB * _MiB);
config.setMemorySoftLimitPercent(softLimitMiB * _MiB);
config.setMemoryPoolLimitPercent(poolLimitMiB * _MiB);
KisTileDataStore::instance()->testingRereadConfig();
/**
* Create an empty the log file
*/
QString fileName;
fileName = QString("log_%1_%2_%3_%4_%5.txt")
.arg(createTransaction)
.arg(hardLimitMiB)
.arg(softLimitMiB)
.arg(poolLimitMiB)
.arg(index);
QFile logFile(fileName);
logFile.open(QFile::WriteOnly | QFile::Truncate);
QTextStream logStream(&logFile);
logStream.setFieldWidth(10);
logStream.setFieldAlignment(QTextStream::AlignRight);
/**
* Start painting on the image
*/
QTime cycleTime;
QTime lineTime;
cycleTime.start();
lineTime.start();
qreal rectBottom = rect.y() + rect.height();
for (int i = 0; i < numCycles; i++) {
cycleTime.restart();
QLineF line(rect.topLeft(), rect.topLeft() + QPointF(rect.width(), 0));
if (createTransaction) {
painter->beginTransaction();
}
KisDistanceInformation currentDistance;
while(line.y1() < rectBottom) {
lineTime.restart();
KisPaintInformation pi1(line.p1(), 0.0);
KisPaintInformation pi2(line.p2(), 1.0);
painter->paintLine(pi1, pi2, ¤tDistance);
painter->device()->setDirty(painter->takeDirtyRegion());
logStream << "L 1" << i << lineTime.elapsed()
<< KisTileDataStore::instance()->numTilesInMemory() * 16
<< KisTileDataStore::instance()->numTiles() * 16
<< createTransaction << endl;
line.translate(0, vstep);
}
painter->device()->setDirty(painter->takeDirtyRegion());
if (createTransaction) {
painter->endTransaction(&undoAdapter);
}
// comment/uncomment to emulate user waiting after the stroke
QTest::qSleep(1000);
logStream << "C 2" << i << cycleTime.elapsed()
<< KisTileDataStore::instance()->numTilesInMemory() * 16
<< KisTileDataStore::instance()->numTiles() * 16
<< createTransaction
<< config.memoryHardLimitPercent() / _MiB
<< config.memorySoftLimitPercent() / _MiB
<< config.memoryPoolLimitPercent() / _MiB << endl;
}
config.setMemoryHardLimitPercent(oldHardLimit * _MiB);
config.setMemorySoftLimitPercent(oldSoftLimit * _MiB);
config.setMemoryPoolLimitPercent(oldPoolLimit * _MiB);
delete painter;
}
virtual void doPaint(KisPainter &gc) {
KisPaintInformation pi(QPointF(100, 100), 1.0);
KisDistanceInformation dist;
gc.paintAt(pi, &dist);
}
void KisSmudgeRadiusOption::apply(KisPainter& painter, const KisPaintInformation& info, qreal scale, qreal posx, qreal posy,KisPaintDeviceSP dev) const
{
double sliderValue = computeValue(info);
int smudgeRadius = ((sliderValue * scale)*0.5)/100.0;//scale is diameter?
KoColor color = painter.paintColor();
if (smudgeRadius == 1) {
dev->pixel(posx, posy, &color);
painter.setPaintColor(color);
} else {
const KoColorSpace* cs = dev->colorSpace();
int pixelSize = cs->pixelSize();
quint8* data = new quint8[pixelSize];
static quint8** pixels = new quint8*[2];
qint16* weights = new qint16[2];
pixels[1] = new quint8[pixelSize];
pixels[0] = new quint8[pixelSize];
int loop_increment = 1;
if(smudgeRadius >= 8)
{
loop_increment = (2*smudgeRadius)/16;
}
int i = 0;
int k = 0;
int j = 0;
KisRandomConstAccessorSP accessor = dev->createRandomConstAccessorNG(0, 0);
KisCrossDeviceColorPickerInt colorPicker(painter.device(), color);
colorPicker.pickColor(posx, posy, color.data());
for (int y = 0; y <= smudgeRadius; y = y + loop_increment) {
for (int x = 0; x <= smudgeRadius; x = x + loop_increment) {
for(j = 0;j < 2;j++)
{
if(j == 1)
{
y = y*(-1);
}
for(k = 0;k < 2;k++)
{
if(k == 1)
{
x = x*(-1);
}
accessor->moveTo(posx + x, posy + y);
memcpy(pixels[1], accessor->rawDataConst(), pixelSize);
if(i == 0)
{
memcpy(pixels[0],accessor->rawDataConst(),pixelSize);
}
if (x == 0 && y == 0) {
// Because the sum of the weights must be 255,
// we cheat a bit, and weigh the center pixel differently in order
// to sum to 255 in total
// It's -(counts -1), because we'll add the center one implicitly
// through that calculation
weights[1] = (255 - ((i + 1) * (255 /(i+2) )) );
} else {
weights[1] = 255 /(i+2);
}
i++;
if (i>smudgeRadius){i=0;}
weights[0] = 255 - weights[1];
const quint8** cpixels = const_cast<const quint8**>(pixels);
cs->mixColorsOp()->mixColors(cpixels, weights,2, data);
memcpy(pixels[0],data,pixelSize);
}
x = x*(-1);
}
y = y*(-1);
}
}
KoColor color = KoColor(pixels[0],cs);
painter.setPaintColor(color);
for (int l = 0; l < 2; l++){
delete[] pixels[l];
}
// delete[] pixels;
delete[] data;
}
}