void KisFillPainterTest::benchmarkFillingScanlineColor()
{
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
KisPaintDeviceSP dev = new KisPaintDevice(cs);
QImage srcImage(TestUtil::fetchDataFileLazy("heavy_labyrinth.png"));
QVERIFY(!srcImage.isNull());
QRect imageRect = srcImage.rect();
dev->convertFromQImage(srcImage, 0, 0, 0);
QBENCHMARK_ONCE {
KisScanlineFill gc(dev, QPoint(), imageRect);
gc.setThreshold(THRESHOLD);
gc.fillColor(KoColor(Qt::red, dev->colorSpace()));
}
QImage resultImage =
dev->convertToQImage(0,
imageRect.x(), imageRect.y(),
imageRect.width(), imageRect.height());
QVERIFY(TestUtil::checkQImage(resultImage,
"fill_painter",
"scanline_",
"heavy_labyrinth_top_left"));
}
static Photo debayerMask(const Photo &photo, u_int32_t filters)
{
Photo newPhoto(photo);
Magick::Image srcImage(newPhoto.image());
Magick::Image& dst = newPhoto.image();
ResetImage(dst);
int w = srcImage.columns();
int h = srcImage.rows();
std::shared_ptr<Ordinary::Pixels> src_cache(new Ordinary::Pixels(srcImage));
std::shared_ptr<Ordinary::Pixels> dst_cache(new Ordinary::Pixels(dst));
dfl_block bool error=false;
dfl_parallel_for(y, 0, h, 4, (srcImage, dst), {
Magick::PixelPacket *pixel = dst_cache->get(0, y, w, 1);
const Magick::PixelPacket *src = src_cache->getConst(0, y, w, 1);
if ( error || !pixel || !src ) {
if (!error)
dflError(DF_NULL_PIXELS);
error=true;
continue;
}
for (int x = 0 ; x < w ; ++x ) {
int c = FC(filters, y, x);
switch (c) {
case 0:
pixel[x].red = src[x].red; pixel[x].green = 0 ; pixel[x].blue = 0; break;
case 1:
case 3:
pixel[x].red = 0 ; pixel[x].green = src[x].green ; pixel[x].blue = 0; break;
case 2:
pixel[x].red = 0; pixel[x].green = 0; pixel[x].blue = src[x].blue; break;
}
}
dst_cache->sync();
});
std::shared_ptr<gameplay::Texture> OBJWriter::readTexture(const boost::filesystem::path& path) const
{
{
auto it = m_textureCache.find(path);
if(it != m_textureCache.end())
return it->second;
}
cimg_library::CImg<float> srcImage((m_basePath / path).string().c_str());
srcImage /= 255;
const auto w = srcImage.width();
const auto h = srcImage.height();
if(srcImage.spectrum() == 3)
{
srcImage.channels(0, 3);
BOOST_ASSERT(srcImage.spectrum() == 4);
srcImage.get_shared_channel(3).fill(1);
}
if(srcImage.spectrum() != 4)
{
BOOST_THROW_EXCEPTION(std::runtime_error("Can only use RGB and RGBA images"));
}
srcImage.permute_axes("cxyz");
auto image = std::make_shared<gameplay::Image>(w, h, reinterpret_cast<const glm::vec4*>(srcImage.data()));
return m_textureCache[path] = std::make_shared<gameplay::Texture>(image);
}
void KisGradientPainterTest::testSplitDisjointPaths()
{
QPainterPath path;
// small bug: the smaller rect is also merged
path.addRect(QRectF(323, 123, 4, 4));
path.addRect(QRectF(300, 100, 50, 50));
path.addRect(QRectF(320, 120, 10, 10));
path.addRect(QRectF(200, 100, 50, 50));
path.addRect(QRectF(240, 120, 70, 10));
path.addRect(QRectF(100, 100, 50, 50));
path.addRect(QRectF(120, 120, 10, 10));
path = path.simplified();
{
QImage srcImage(450, 250, QImage::Format_ARGB32);
srcImage.fill(0);
QPainter gc(&srcImage);
gc.fillPath(path, Qt::red);
//srcImage.save("src_disjoint_paths.png");
}
QList<QPainterPath> result = KritaUtils::splitDisjointPaths(path);
{
QImage dstImage(450, 250, QImage::Format_ARGB32);
dstImage.fill(0);
QPainter gc(&dstImage);
QVector<QBrush> brushes;
brushes << Qt::red;
brushes << Qt::green;
brushes << Qt::blue;
brushes << Qt::cyan;
brushes << Qt::magenta;
brushes << Qt::yellow;
brushes << Qt::black;
brushes << Qt::white;
int index = 0;
Q_FOREACH (const QPainterPath &p, result) {
gc.fillPath(p, brushes[index]);
index = (index + 1) % brushes.size();
}
TestUtil::checkQImageExternal(dstImage,
"shaped_gradient",
"test",
"disjoint_paths");
}
void KisFillPainterTest::benchmarkFillPainter(const QPoint &startPoint, bool useCompositioning)
{
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
KisPaintDeviceSP dev = new KisPaintDevice(cs);
QImage srcImage(TestUtil::fetchDataFileLazy("heavy_labyrinth.png"));
QVERIFY(!srcImage.isNull());
QRect imageRect = srcImage.rect();
dev->convertFromQImage(srcImage, 0, 0, 0);
QBENCHMARK_ONCE {
KisFillPainter gc(dev);
gc.setFillThreshold(THRESHOLD);
gc.setWidth(imageRect.width());
gc.setHeight(imageRect.height());
gc.setPaintColor(KoColor(Qt::red, dev->colorSpace()));
gc.setUseCompositioning(useCompositioning);
gc.fillColor(startPoint.x(), startPoint.y(), dev);
}
QImage resultImage =
dev->convertToQImage(0,
imageRect.x(), imageRect.y(),
imageRect.width(), imageRect.height());
QString testName = QString("heavy_labyrinth_%1_%2_%3")
.arg(startPoint.x())
.arg(startPoint.y())
.arg(useCompositioning ? "composed" : "direct");
QVERIFY(TestUtil::checkQImage(resultImage,
"fill_painter",
"general_",
testName));
}
void CViGrA_Watershed::Segmentation(TImage_In &Input, TImage_Out &Output, double Scale, bool bEdges)
{
typedef typename vigra::NumericTraits<typename TImage_In::value_type>::RealPromote TmpType;
vigra::BasicImage<TmpType> gradientx (Get_NX(), Get_NY());
vigra::BasicImage<TmpType> gradienty (Get_NX(), Get_NY());
vigra::FImage gradientmag (Get_NX(), Get_NY());
vigra::IImage labels (Get_NX(), Get_NY());
//-----------------------------------------------------
// calculate the x- and y-components of the image gradient at given scale
Process_Set_Text(_TL("calculate gradients"));
recursiveFirstDerivativeX (srcImageRange(Input) , destImage(gradientx), Scale);
recursiveSmoothY (srcImageRange(gradientx) , destImage(gradientx), Scale);
recursiveFirstDerivativeY (srcImageRange(Input) , destImage(gradienty), Scale);
recursiveSmoothX (srcImageRange(gradienty) , destImage(gradienty), Scale);
//-----------------------------------------------------
// transform components into gradient magnitude
Process_Set_Text(_TL("calculate gradient magnitude"));
combineTwoImages(
srcImageRange(gradientx),
srcImage(gradienty),
destImage(gradientmag),
GradientSquaredMagnitudeFunctor()
);
//-----------------------------------------------------
// find the local minima of the gradient magnitude (might be larger than one pixel)
Process_Set_Text(_TL("find local minima"));
labels = 0;
extendedLocalMinima(srcImageRange(gradientmag), destImage(labels), 1);
//-----------------------------------------------------
// label the minima just found
Process_Set_Text(_TL("label minima"));
int max_region_label = labelImageWithBackground(srcImageRange(labels), destImage(labels), false, 0);
//-----------------------------------------------------
// create a statistics functor for region growing
vigra::ArrayOfRegionStatistics<vigra::SeedRgDirectValueFunctor<float> >gradstat(max_region_label);
//-----------------------------------------------------
// perform region growing, starting from the minima of the gradient magnitude;
// as the feature (first input) image contains the gradient magnitude,
// this calculates the catchment basin of each minimum
Process_Set_Text(_TL("perform region growing"));
seededRegionGrowing(srcImageRange(gradientmag), srcImage(labels), destImage(labels), gradstat);
//-----------------------------------------------------
// initialize a functor to determine the average gray-value or color for each region (catchment basin) just found
vigra::ArrayOfRegionStatistics<vigra::FindAverage<TmpType> >averages(max_region_label);
//-----------------------------------------------------
// calculate the averages
Process_Set_Text(_TL("calculate averages"));
inspectTwoImages(srcImageRange(Input), srcImage(labels), averages);
//-----------------------------------------------------
// write the averages into the destination image (the functor 'averages' acts as a look-up table)
transformImage(srcImageRange(labels), destImage(Output), averages);
//-----------------------------------------------------
// mark the watersheds (region boundaries) black
if( bEdges )
{
regionImageToEdgeImage(srcImageRange(labels), destImage(Output), vigra::NumericTraits<typename TImage_Out::value_type>::zero());
}
}
void MainDialogImpl::on_pushButtonConvertImages_clicked()
{
int validated = 0;
if (lineEditSorceFolder->text().isEmpty())
validated = 1;
else if (lineEditTargetFolder->text().isEmpty())
validated = 2;
else if (!lineEditW->hasAcceptableInput())
validated = 3;
else if (!lineEditH->hasAcceptableInput())
validated = 4;
switch (validated)
{
case 0:{break;}
case 1:{QMessageBox::warning(0,"Image Converter::Validation Error #1","You need to select Source Path");break;}
case 2:{QMessageBox::warning(0,"Image Converter::Validation Error #2","You need to select Target Path");break;}
case 3:{QMessageBox::warning(0,"Image Converter::Validation Error #3","You need to set the Width of the Image");break;}
case 4:{QMessageBox::warning(0,"Image Converter::Validation Error #4","You need to set the Height of the Image");break;}
default:break;
}
if ( validated == 0)
{
// get the direcotry name for the sorce folder.
QDir SorceDirectory = QDir(lineEditSorceFolder->text());
QDir TargetDirectory = QDir(lineEditTargetFolder->text());
QStringList files;
QStringList fileTypes;
// just load Image files with this formats.
fileTypes << "*.tiff"<< "*.TIFF"<<"*.tif"<<"*.TIF" << "*.BMP" <<"*.GIF" <<"*.JPG" <<"*.JPEG" <<"*.MNG" <<"*.PNG" <<"*.PBM" <<"*.PGM" <<"*.PPM" <<"*.XBM"<<"*.XPM"<< "*.bmp" <<"*.gif" <<"*.jpg" <<"*.jpeg" <<"*.mng" <<"*.png" <<"*.pbm" <<"*.pgm" <<"*.ppm" <<"*.xbm"<<"*.xpm" ;
files = SorceDirectory.entryList(QStringList(fileTypes),
QDir::Files | QDir::NoSymLinks);
if (files.size()>0)
{
QProgressDialog progressDialog(this);
progressDialog.setCancelButtonText(tr("&Cancel"));
progressDialog.setRange(0, files.size());
progressDialog.setWindowTitle(tr("Converting Files"));
progressBar->setMaximum(files.size());
progressBar->setValue(0);
for (int i = 0; i < files.size(); ++i) {
progressDialog.setValue(i);
progressDialog.setLabelText(tr("Converting Image number %1 of %2...").arg(i).arg(files.size()));
qApp->processEvents();
progressBar->setValue(i+1);
if (progressDialog.wasCanceled())
break;
QImageReader srcImage(SorceDirectory.absoluteFilePath(files[i]));
QSize scaledSize(lineEditW->text().toInt(),lineEditH->text().toInt());
srcImage.setScaledSize(scaledSize);
QImage img = srcImage.read();
if( !img.isNull() )
{
QStringList fileName = files[i].split(".");
QString targetFileName = fileName[0]+"."+comboBoxFormat->currentText();
QImageWriter tarImage(TargetDirectory.absoluteFilePath(targetFileName),comboBoxFormat->currentText().toUtf8());
tarImage.setText("","");
tarImage.write(img);
}
}
}
else
{
QMessageBox::warning(0,"Image Converter::Validation Error #5","Source Path is Empty of supported Image files");
}
}
}
