void KisStrokeBenchmark::benchmarkRandomLines(QString presetFileName)
{
KisPaintOpPresetSP preset = new KisPaintOpPreset(m_dataPath + presetFileName);
bool loadedOk = preset->load();
if (!loadedOk){
dbgKrita << "The preset was not loaded correctly. Done.";
return;
}else{
dbgKrita << "preset : " << presetFileName;
}
m_painter->setPaintOpPreset(preset, m_layer, m_image);
QBENCHMARK{
KisDistanceInformation currentDistance;
for (int i = 0; i < LINES; i++){
KisPaintInformation pi1(m_startPoints[i], 0.0);
KisPaintInformation pi2(m_endPoints[i], 1.0);
m_painter->paintLine(pi1, pi2, ¤tDistance);
}
}
#ifdef SAVE_OUTPUT
m_layer->paintDevice()->convertToQImage(0).save(m_outputPath + presetFileName + "_randomLines" + OUTPUT_FORMAT);
#endif
}
void KisFavoriteResourceManager::updateFavoritePresets()
{
m_favoritePresetsList.clear();
KisPaintOpPresetResourceServer* rServer = KisResourceServerProvider::instance()->paintOpPresetServer(false);
QStringList presetFilenames = rServer->searchTag(m_currentTag);
for(int i = 0; i < qMin(m_maxPresets, presetFilenames.size()); i++) {
KisPaintOpPresetSP pr = rServer->resourceByFilename(presetFilenames.at(i));
m_favoritePresetsList.append(pr.data());
qSort(m_favoritePresetsList.begin(), m_favoritePresetsList.end(), sortPresetByName);
}
emit updatePalettes();
}
void KisCanvasResourceProvider::setPreviousPaintOpPreset(const KisPaintOpPresetSP preset)
{
Q_ASSERT(preset->valid());
Q_ASSERT(!preset->paintOp().id().isEmpty());
Q_ASSERT(preset->settings());
if (!preset) return;
dbgUI << "setPreviousPaintOpPreset" << preset->paintOp();
QVariant v;
v.setValue(preset);
m_resourceManager->setResource(PreviousPaintOpPreset, v);
}
void KisStrokeBenchmark::benchmarkCircle(QString presetFileName)
{
dbgKrita << "(circle)preset : " << presetFileName;
KisPaintOpPresetSP preset = new KisPaintOpPreset(m_dataPath + presetFileName);
if (!preset->load()){
dbgKrita << "Preset was not loaded";
return;
}
m_painter->setPaintOpPreset(preset, m_layer, m_image);
QBENCHMARK{
qreal radius = 300;
qreal randomOffset = 300 * 0.4;
int rounds = 20;
int steps = 20;
qreal step = 1.0 / steps;
QPointF center(m_image->width() * 0.5, m_image->height() * 0.5);
QPointF first(center.x()+radius,center.y());
srand48(0);
for (int k = 0; k < rounds; k++){
KisDistanceInformation currentDistance;
m_painter->paintLine(center, first, ¤tDistance);
QPointF prev = first;
for (int i = 1; i < steps; i++) {
qreal cx = cos(i * step * 2 * M_PI);
qreal cy = sin(i * step * 2 * M_PI);
cx *= (radius + drand48() * randomOffset);
cy *= (radius + drand48() * randomOffset);
cx += center.x();
cy += center.y();
m_painter->paintLine(prev, QPointF(cx,cy), ¤tDistance);
prev = QPointF(cx,cy);
}
m_painter->paintLine(prev, first, ¤tDistance);
}
}
#ifdef SAVE_OUTPUT
m_layer->paintDevice()->convertToQImage(0).save(m_outputPath + presetFileName + "_circle" + OUTPUT_FORMAT);
#endif
}
KisPaintOpPresetSP defaultPreset(const KoID& paintOp)
{
QString defaultName = paintOp.id() + ".kpp";
QString path = KGlobal::mainComponent().dirs()->findResource("kis_defaultpresets", defaultName);
KisPaintOpPresetSP preset = new KisPaintOpPreset(path);
if (!preset->load())
preset = KisPaintOpRegistry::instance()->defaultPreset(paintOp);
Q_ASSERT(preset);
Q_ASSERT(preset->valid());
return preset;
}
void KisCanvasResourceProvider::slotPaintOpPresetActivated(const KisPaintOpPresetSP preset)
{
Q_ASSERT(preset->valid());
Q_ASSERT(!preset->paintOp().id().isEmpty());
Q_ASSERT(preset->settings());
if (!preset) return;
dbgUI << "slotPaintOpPresetActivated" << preset->paintOp();
QVariant v;
v.setValue(preset);
m_resourceManager->setResource(CurrentPaintOpPreset, v);
emit sigPaintOpPresetChanged(preset);
}
void setCurrentPaintop(const KoID& paintop, KisPaintOpPresetSP preset)
{
preset = (!preset) ? defaultPreset(paintop) : preset;
Q_ASSERT(preset && preset->settings());
// handle the settings and expose it through a a simple QObject property
//m_optionWidget->setConfiguration(preset->settings());
#if 0
preset->settings()->setNode(view->resourceProvider()->currentNode());
#endif
KisPaintOpFactory* paintOp = KisPaintOpRegistry::instance()->get(paintop.id());
QString pixFilename = KisFactory::componentData().dirs()->findResource("kis_images", paintOp->pixmap());
view->resourceProvider()->setPaintOpPreset(preset);
}
int main(int argc, char** argv)
{
KAboutData aboutData("scratchpad",
0,
ki18n("scratchpad"),
"1.0",
ki18n("Test application for the single paint device scratchpad canvas"),
KAboutData::License_LGPL,
ki18n("(c) 2010 Boudewijn Rempt"),
KLocalizedString(),
"www.krita.org",
"*****@*****.**");
KCmdLineArgs::init(argc, argv, &aboutData);
KCmdLineOptions options;
options.add("+preset", ki18n("preset to load"));
KCmdLineArgs::addCmdLineOptions(options);
KApplication app;
KisScratchPad *scratchpad = new KisScratchPad();
KCmdLineArgs *args = KCmdLineArgs::parsedArgs();
if (args->count() > 0 ) {
QString fileName = args->arg(0);
if (QFile::exists(fileName)) {
KisPaintOpPresetSP preset = new KisPaintOpPreset(fileName);
preset->load();
if (preset->valid()) {
scratchpad->setPreset(preset);
}
}
}
const KoColorProfile* profile = KoColorSpaceRegistry::instance()->rgb8()->profile();
scratchpad->setColorSpace(KoColorSpaceRegistry::instance()->rgb16());
scratchpad->setDisplayProfile(profile);
scratchpad->setCanvasColor(Qt::white);
scratchpad->setPaintColor(Qt::black);
scratchpad->show();
return app.exec();
}
inline void KisStrokeBenchmark::benchmarkLine(QString presetFileName)
{
KisPaintOpPresetSP preset = new KisPaintOpPreset(m_dataPath + presetFileName);
preset->load();
m_painter->setPaintOpPreset(preset, m_layer, m_image);
QPointF startPoint(0.10 * TEST_IMAGE_WIDTH, 0.5 * TEST_IMAGE_HEIGHT);
QPointF endPoint(0.90 * TEST_IMAGE_WIDTH, 0.5 * TEST_IMAGE_HEIGHT);
KisDistanceInformation currentDistance;
KisPaintInformation pi1(startPoint, 0.0);
KisPaintInformation pi2(endPoint, 1.0);
QBENCHMARK{
m_painter->paintLine(pi1, pi2, ¤tDistance);
}
#ifdef SAVE_OUTPUT
m_layer->paintDevice()->convertToQImage(0).save(m_outputPath + presetFileName + "_line" + OUTPUT_FORMAT);
#endif
}
void KisStrokeBenchmark::benchmarkStroke(QString presetFileName)
{
KisPaintOpPresetSP preset = new KisPaintOpPreset(m_dataPath + presetFileName);
bool loadedOk = preset->load();
if (!loadedOk){
dbgKrita << "The preset was not loaded correctly. Done.";
return;
} else {
dbgKrita << "preset : " << presetFileName;
}
m_painter->setPaintOpPreset(preset, m_layer, m_image);
QBENCHMARK{
KisDistanceInformation currentDistance;
m_painter->paintBezierCurve(m_pi1, m_c1, m_c1, m_pi2, ¤tDistance);
m_painter->paintBezierCurve(m_pi2, m_c2, m_c2, m_pi3, ¤tDistance);
}
#ifdef SAVE_OUTPUT
dbgKrita << "Saving output " << m_outputPath + presetFileName + ".png";
m_layer->paintDevice()->convertToQImage(0).save(m_outputPath + presetFileName + OUTPUT_FORMAT);
#endif
}
KisRecordedPaintAction::KisRecordedPaintAction(const QString & id,
const QString & name,
const KisNodeQueryPath& path,
const KisPaintOpPresetSP paintOpPreset,
KoColor foregroundColor,
KoColor backgroundColor,
int opacity,
bool paintIncremental,
const KoCompositeOp * compositeOp)
: KisRecordedAction(id, name, path)
, d(new Private)
{
d->paintOpPreset = paintOpPreset ? d->paintOpPreset = paintOpPreset->clone() : 0;
d->foregroundColor = foregroundColor;
d->backgroundColor = backgroundColor;
d->opacity = opacity;
d->paintIncremental = paintIncremental;
d->compositeOp = compositeOp;
}
bool sortPresetByName(KisPaintOpPresetSP preset1, KisPaintOpPresetSP preset2)
{
return preset1->name() < preset2->name();
}
KoCanvasResourceManager* utils::createResourceManager(KisImageWSP image,
KisNodeSP node,
const QString &presetFileName)
{
KoCanvasResourceManager *manager = new KoCanvasResourceManager();
QVariant i;
i.setValue(KoColor(Qt::black, image->colorSpace()));
manager->setResource(KoCanvasResourceManager::ForegroundColor, i);
i.setValue(KoColor(Qt::white, image->colorSpace()));
manager->setResource(KoCanvasResourceManager::BackgroundColor, i);
i.setValue(static_cast<void*>(0));
manager->setResource(KisCanvasResourceProvider::CurrentPattern, i);
manager->setResource(KisCanvasResourceProvider::CurrentGradient, i);
manager->setResource(KisCanvasResourceProvider::CurrentGeneratorConfiguration, i);
if(!node) {
node = image->root();
while(node && !dynamic_cast<KisPaintLayer*>(node.data())) {
node = node->firstChild();
}
Q_ASSERT(node && dynamic_cast<KisPaintLayer*>(node.data()));
}
i.setValue(node);
manager->setResource(KisCanvasResourceProvider::CurrentKritaNode, i);
KisPaintOpPresetSP preset;
if (!presetFileName.isEmpty()) {
QString fullFileName = TestUtil::fetchDataFileLazy(presetFileName);
preset = new KisPaintOpPreset(fullFileName);
bool presetValid = preset->load();
Q_ASSERT(presetValid); Q_UNUSED(presetValid);
i.setValue(preset);
manager->setResource(KisCanvasResourceProvider::CurrentPaintOpPreset, i);
}
i.setValue(COMPOSITE_OVER);
manager->setResource(KisCanvasResourceProvider::CurrentCompositeOp, i);
i.setValue(false);
manager->setResource(KisCanvasResourceProvider::MirrorHorizontal, i);
i.setValue(false);
manager->setResource(KisCanvasResourceProvider::MirrorVertical, i);
i.setValue(1.0);
manager->setResource(KisCanvasResourceProvider::Opacity, i);
i.setValue(1.0);
manager->setResource(KisCanvasResourceProvider::HdrExposure, i);
i.setValue(QPoint());
manager->setResource(KisCanvasResourceProvider::MirrorAxesCenter, i);
return manager;
}
void test(bool mirrorX, bool mirrorY, qreal rotation, bool mirrorDabX, bool mirrorDabY, qreal dabRotation) {
KisSurrogateUndoStore *undoStore = new KisSurrogateUndoStore();
KisImageSP image = createTrivialImage(undoStore);
image->initialRefreshGraph();
KisNodeSP paint1 = findNode(image->root(), "paint1");
QVERIFY(paint1->extent().isEmpty());
KisPainter gc(paint1->paintDevice());
QScopedPointer<KoCanvasResourceManager> manager(
utils::createResourceManager(image, 0, m_presetFileName));
KisPaintOpPresetSP preset =
manager->resource(KisCanvasResourceProvider::CurrentPaintOpPreset).value<KisPaintOpPresetSP>();
preset->settings()->setCanvasRotation(rotation);
preset->settings()->setCanvasMirroring(mirrorY, mirrorX);
if (mirrorDabX || mirrorDabY) {
KisPaintOpSettingsSP settings = preset->settings()->clone();
KisPressureMirrorOption mirrorOption;
mirrorOption.readOptionSetting(settings);
mirrorOption.setChecked(true);
mirrorOption.setCurveUsed(false);
mirrorOption.enableHorizontalMirror(mirrorDabX);
mirrorOption.enableVerticalMirror(mirrorDabY);
mirrorOption.writeOptionSetting(settings.data());
preset->setSettings(settings);
}
if (dabRotation != 0.0) {
KisPaintOpSettingsSP settings = preset->settings()->clone();
KisPressureRotationOption rotationOption;
rotationOption.readOptionSetting(settings);
rotationOption.setChecked(true);
rotationOption.setCurveUsed(false);
rotationOption.setValue(dabRotation / 360.0);
rotationOption.writeOptionSetting(settings.data());
preset->setSettings(settings);
}
QString testName =
QString("%7_cmY_%1_cmX_%2_cR_%3_dmX_%4_dmY_%5_dR_%6")
.arg(mirrorY)
.arg(mirrorX)
.arg(rotation)
.arg(mirrorDabX)
.arg(mirrorDabY)
.arg(std::fmod(360.0 - dabRotation, 360.0))
.arg(m_prefix);
KisResourcesSnapshotSP resources =
new KisResourcesSnapshot(image,
paint1,
manager.data());
resources->setupPainter(&gc);
doPaint(gc);
checkOneLayer(image, paint1, testName);
}
