static void dabSizeHelper(KisBrushSP const& brush,
QString const& name, KisDabShape const& shape, int expectedWidth, int expectedHeight)
{
qDebug() << name;
QCOMPARE(brush->maskWidth(shape, 0.0, 0.0, KisPaintInformation()), expectedWidth);
QCOMPARE(brush->maskHeight(shape, 0.0, 0.0, KisPaintInformation()), expectedHeight);
}
KisHairyPaintOp::KisHairyPaintOp(const KisBrushBasedPaintOpSettings *settings, KisPainter * painter, KisNodeSP node, KisImageSP image)
: KisPaintOp(painter)
{
Q_UNUSED(image)
Q_ASSERT(settings);
m_dev = node ? node->paintDevice() : 0;
KisBrushOption brushOption;
brushOption.readOptionSetting(settings);
KisBrushSP brush = brushOption.brush();
KisFixedPaintDeviceSP dab = cachedDab(painter->device()->compositionSourceColorSpace());
if (brush->brushType() == IMAGE || brush->brushType() == PIPE_IMAGE) {
dab = brush->paintDevice(source()->colorSpace(), 1.0, 0.0, KisPaintInformation());
}
else {
brush->mask(dab, painter->paintColor(), 1.0, 1.0, 0.0, KisPaintInformation());
}
m_brush.fromDabWithDensity(dab, settings->getDouble(HAIRY_BRISTLE_DENSITY) * 0.01);
m_brush.setInkColor(painter->paintColor());
loadSettings(settings);
m_brush.setProperties(&m_properties);
m_rotationOption.readOptionSetting(settings);
m_opacityOption.readOptionSetting(settings);
m_sizeOption.readOptionSetting(settings);
m_rotationOption.resetAllSensors();
m_opacityOption.resetAllSensors();
m_sizeOption.resetAllSensors();
}
void KisRecordedPathPaintAction::addPolyLine(const QList<QPointF>& points)
{
QPointF previousPoint = points[0];
for(int i = 1; i < points.size(); ++i) {
QPointF pt = points[i];
addLine(KisPaintInformation(previousPoint), KisPaintInformation(pt));
previousPoint = pt;
}
}
void KisStrokeBenchmark::initCurvePoints(int width, int height)
{
QPointF p1(0 , 7.0 / 12.0 * height);
QPointF p2(1.0 / 2.0 * width , 7.0 / 12.0 * height);
QPointF p3(width - 4.0, height - 4.0);
m_c1 = QPointF(1.0 / 4.0 * width, height - 2.0);
m_c2 = QPointF(3.0 / 4.0 * width, 0);
m_pi1 = KisPaintInformation(p1, 0.0);
m_pi2 = KisPaintInformation(p2, 0.95);
m_pi3 = KisPaintInformation(p3, 0.0);
}
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 addPaintingJobs(KisImageWSP image, KisResourcesSnapshotSP resources, KisPainter *painter) {
Q_ASSERT(painter == m_painterInfo->painter);
Q_UNUSED(painter);
KisPaintInformation pi1;
KisPaintInformation pi2;
pi1 = KisPaintInformation(QPointF(200, 200));
pi2 = KisPaintInformation(QPointF(300, 300));
image->addJob(strokeId(),
new FreehandStrokeStrategy::Data(resources->currentNode(),
m_painterInfo, pi1, pi2));
}
QImage KisAutoBrush::createBrushPreview()
{
srand(0);
srand48(0);
int width = maskWidth(1.0, 0.0, 0.0, 0.0, KisPaintInformation());
int height = maskHeight(1.0, 0.0, 0.0, 0.0, KisPaintInformation());
KisPaintInformation info(QPointF(width * 0.5, height * 0.5), 0.5, 0, 0, 0, 0);
KisFixedPaintDeviceSP fdev = new KisFixedPaintDevice( KoColorSpaceRegistry::instance()->rgb8() );
fdev->setRect(QRect(0, 0, width, height));
fdev->initialize();
mask(fdev,KoColor(Qt::black, fdev->colorSpace()),1.0, 1.0, 0.0, info);
return fdev->convertToQImage(0);
}
void KisBrush::generateBoundary() const
{
KisFixedPaintDeviceSP dev;
KisDabShape inverseTransform(1.0 / scale(), 1.0, -angle());
if (brushType() == IMAGE || brushType() == PIPE_IMAGE) {
dev = paintDevice(KoColorSpaceRegistry::instance()->rgb8(),
inverseTransform, KisPaintInformation());
}
else {
const KoColorSpace* cs = KoColorSpaceRegistry::instance()->rgb8();
dev = new KisFixedPaintDevice(cs);
mask(dev, KoColor(Qt::black, cs), inverseTransform, KisPaintInformation());
}
d->boundary = new KisBoundary(dev);
d->boundary->generateBoundary();
}
void KisToolLineHelper::start(KoPointerEvent *event, KoCanvasResourceManager *resourceManager)
{
if (!m_d->enabled) return;
KisPaintInformation pi =
m_d->infoBuilder->startStroke(event, elapsedStrokeTime(), resourceManager);
if (!m_d->useSensors) {
pi = KisPaintInformation(pi.pos());
}
m_d->linePoints.append(pi);
}
//#define SAVE_OUTPUT_IMAGES
void KisAutoBrushTest::testCopyMasking()
{
int w = 64;
int h = 64;
int x = 0;
int y = 0;
QRect rc(x, y, w, h);
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
KoColor black(Qt::black, cs);
KoColor red(Qt::red, cs);
KisPaintDeviceSP tempDev = new KisPaintDevice(cs);
tempDev->fill(0, 0, w, h, red.data());
#ifdef SAVE_OUTPUT_IMAGES
tempDev->convertToQImage(0).save("tempDev.png");
#endif
KisCircleMaskGenerator * mask = new KisCircleMaskGenerator(w, 1.0, 0.5, 0.5, 2, true);
KisAutoBrush brush(mask, 0, 0);
KisFixedPaintDeviceSP maskDab = new KisFixedPaintDevice(cs);
brush.mask(maskDab, black, KisDabShape(), KisPaintInformation());
maskDab->convertTo(KoColorSpaceRegistry::instance()->alpha8());
#ifdef SAVE_OUTPUT_IMAGES
maskDab->convertToQImage(0, 0, 0, 64, 64).save("maskDab.png");
#endif
QCOMPARE(tempDev->exactBounds(), rc);
QCOMPARE(maskDab->bounds(), rc);
KisFixedPaintDeviceSP dev2fixed = new KisFixedPaintDevice(cs);
dev2fixed->setRect(rc);
dev2fixed->initialize();
tempDev->readBytes(dev2fixed->data(), rc);
dev2fixed->convertToQImage(0).save("converted-tempDev-to-fixed.png");
KisPaintDeviceSP dev = new KisPaintDevice(cs);
KisPainter painter(dev);
painter.setCompositeOp(COMPOSITE_COPY);
painter.bltFixedWithFixedSelection(x, y, dev2fixed, maskDab, 0, 0, 0, 0, rc.width(), rc.height());
//painter.bitBltWithFixedSelection(x, y, tempDev, maskDab, 0, 0, 0, 0, rc.width(), rc.height());
#ifdef SAVE_OUTPUT_IMAGES
dev->convertToQImage(0).save("final.png");
#endif
}
KisPaintInformation KisPaintingInformationBuilder::createPaintingInformation(KoPointerEvent *event,
int timeElapsed)
{
QPointF adjusted = adjustDocumentPoint(event->point);
QPointF imagePoint = documentToImage(adjusted);
qreal perspective = calculatePerspective(adjusted);
return KisPaintInformation(imagePoint,
pressureToCurve(event->pressure()),
event->xTilt(), event->yTilt(),
event->rotation(),
event->tangentialPressure(),
perspective,
timeElapsed);
}
KisPaintInformation KisPaintingInformationBuilder::createPaintingInformation(KoPointerEvent *event,
int timeElapsed)
{
QPointF adjusted = adjustDocumentPoint(event->point, m_startPoint);
QPointF imagePoint = documentToImage(adjusted);
qreal perspective = calculatePerspective(adjusted);
qreal speed = m_speedSmoother->getNextSpeed(imageToView(imagePoint));
return KisPaintInformation(imagePoint,
!m_pressureDisabled ? 1.0 : pressureToCurve(event->pressure()),
event->xTilt(), event->yTilt(),
event->rotation(),
event->tangentialPressure(),
perspective,
timeElapsed,
speed);
}
void KisToolLineHelper::addPoint(KoPointerEvent *event, const QPointF &overridePos)
{
if (!m_d->enabled) return;
KisPaintInformation pi =
m_d->infoBuilder->continueStroke(event, elapsedStrokeTime());
if (!m_d->useSensors) {
pi = KisPaintInformation(pi.pos());
}
if (!overridePos.isNull()) {
pi.setPos(overridePos);
}
if (m_d->linePoints.size() > 1) {
const QPointF startPos = m_d->linePoints.first().pos();
const QPointF endPos = pi.pos();
const qreal maxDistance = kisDistance(startPos, endPos);
const QPointF unit = (endPos - startPos) / maxDistance;
QVector<KisPaintInformation>::iterator it = m_d->linePoints.begin();
++it;
while (it != m_d->linePoints.end()) {
qreal dist = kisDistance(startPos, it->pos());
if (dist < maxDistance) {
QPointF pos = startPos + unit * dist;
it->setPos(pos);
++it;
} else {
it = m_d->linePoints.erase(it);
}
}
}
m_d->linePoints.append(pi);
}
