void ut_load::testQImage()
{
QFile file("/usr/share/quillimagefilter-tests/images/16_color_palette.png");
QuillImageFilter *filter =
new QuillImageFilter("com.meego.load");
QVERIFY(filter);
QCOMPARE(filter->name(), QString("com.meego.load"));
QVERIFY(filter->supportsOption(QuillImageFilter::FileName));
QVERIFY(filter->supportsOption(QuillImageFilter::FileFormat));
QVERIFY(filter->supportsOption(QuillImageFilter::DisableUndo));
QVERIFY(filter->supportsOption(QuillImageFilter::SizeAfter));
filter->setOption(QuillImageFilter::FileName,
QVariant(file.fileName()));
filter->setOption(QuillImageFilter::MimeType,
QVariant("image/png"));
QCOMPARE(filter->option(QuillImageFilter::FileName).toString(),
file.fileName());
QCOMPARE(filter->option(QuillImageFilter::MimeType).toString(),
QString("image/png"));
QCOMPARE(filter->option(QuillImageFilter::FileFormat).toString(),
QString("png"));
QImage image(file.fileName());
QImage loadedImage = filter->apply(image);
QVERIFY(Unittests::compareImage(loadedImage, QuillImage(image)));
delete filter;
}
void ut_load::testFileNotFound()
{
QFile fooFile("/usr/share/quillimagefilter-tests/images/fooxxx.png");
QVERIFY(!fooFile.exists());
QImage fooImage(fooFile.fileName());
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter("org.maemo.load");
QVERIFY(filter);
QCOMPARE(filter->name(), QString("com.meego.load"));
QVERIFY(filter->supportsOption(QuillImageFilter::FileName));
QVERIFY(filter->supportsOption(QuillImageFilter::FileFormat));
QVERIFY(filter->supportsOption(QuillImageFilter::DisableUndo));
QVERIFY(filter->supportsOption(QuillImageFilter::SizeAfter));
filter->setOption(QuillImageFilter::FileName,
QVariant(fooFile.fileName()));
filter->setOption(QuillImageFilter::MimeType,
QVariant("image/png"));
filter->apply(fooImage);
QCOMPARE(filter->error(),QuillImageFilter::FileNotFoundError);
fooFile.close();
delete filter;
}
void ut_scale::testScaleFilter()
{
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter("org.maemo.scale");
QVERIFY(filter);
QVERIFY(filter->supportsOption(QuillImageFilter::SizeAfter));
// Assuming full image, rescaling to half size
QVERIFY(filter->setOption(QuillImageFilter::SizeAfter, QSize(4, 1)));
QCOMPARE(filter->option(QuillImageFilter::SizeAfter),
QVariant(QSize(4, 1)));
QImage image = Unittests::generatePaletteImage();
QCOMPARE(image.size(), QSize(8, 2));
QImage filteredImage = filter->apply(image);
QCOMPARE(filteredImage, image.scaled(QSize(4, 1), Qt::IgnoreAspectRatio,
Qt::SmoothTransformation));
// full image, rescaling to different aspect ratio
QVERIFY(filter->setOption(QuillImageFilter::SizeAfter, QSize(2, 8)));
filteredImage = filter->apply(image);
QCOMPARE(filteredImage, image.scaled(QSize(2, 8), Qt::IgnoreAspectRatio,
Qt::SmoothTransformation));
delete filter;
}
void ut_crop::testFullImage()
{
QuillImageFilter *filter = //new QuillImageFilter("org.maemo.crop");
QuillImageFilterFactory::createImageFilter("org.maemo.crop");
QVERIFY(filter);
QCOMPARE(filter->name(), QString("com.meego.crop"));
QVERIFY(filter->supportsOption(QuillImageFilter::CropRectangle));
// Full image cropped from right into 6x2
QVERIFY(filter->setOption(QuillImageFilter::CropRectangle,
QRect(QPoint(2, 0), QPoint(7, 1))));
QCOMPARE(filter->option(QuillImageFilter::CropRectangle),
QVariant(QRect(QPoint(2, 0), QPoint(7, 1))));
QImage image = Unittests::generatePaletteImage();
QCOMPARE(image.size(), QSize(8, 2));
QImage filteredImage = filter->apply(image);
QCOMPARE(filteredImage, image.copy(2, 0, 6, 2));
delete filter;
}
void ut_rotate::testRotateFilter()
{
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter("org.maemo.rotate");
QVERIFY(filter);
QVERIFY(filter->supportsOption(QuillImageFilter::Angle));
QVERIFY(filter->setOption(QuillImageFilter::Angle, QVariant(90)));
bool bOK = true;
QCOMPARE(filter->option(QuillImageFilter::Angle).toDouble(&bOK), 90.0);
QVERIFY(bOK);
QuillImage image = Unittests::generatePaletteImage();
QCOMPARE(image.size(), QSize(8, 2));
QuillImage filteredImage = filter->apply(image);
QCOMPARE(filteredImage.size(), QSize(2, 8));
// Get reference image with QImage::transformed()
QuillImage compareToQImage = image.transformed(QTransform().rotate(90));
QCOMPARE(filteredImage, compareToQImage);
// Four rotates should produce the original image
QCOMPARE(filter->apply(filter->apply(filter->apply(filteredImage))),
image);
delete filter;
}
void ut_flip::testFlip()
{
QuillImageFilter *filter = new QuillImageFilter("org.maemo.flip");
QVERIFY(filter->isValid());
QCOMPARE(filter->name(), QString("com.meego.flip"));
QVERIFY(filter->supportsOption(QuillImageFilter::Horizontal));
QVERIFY(filter->setOption(QuillImageFilter::Horizontal, QVariant(true)));
QCOMPARE(filter->option(QuillImageFilter::Horizontal).toBool(), true);
QImage image = Unittests::generatePaletteImage();
QCOMPARE(image.size(), QSize(8, 2));
QImage filteredImage = filter->apply(image);
QCOMPARE(filteredImage.size(), QSize(8, 2));
// Verify against Qt's own flip
QCOMPARE(filteredImage,
image.transformed(QTransform().scale(-1, 1)));
QVERIFY(filter->setOption(QuillImageFilter::Horizontal, QVariant(false)));
filteredImage = filter->apply(image);
QCOMPARE(filteredImage.size(), QSize(8, 2));
// Verify against Qt's own flip
QCOMPARE(filteredImage,
image.transformed(QTransform().scale(1, -1)));
delete filter;
}
void ut_redeyereduction::testRedEyeForCircularArea()
{
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter("org.maemo.red-eye-reduction");
QVERIFY(filter);
QCOMPARE(filter->name(), QString("com.meego.red-eye-reduction"));
QPoint center(100, 100);
QVERIFY(filter->supportsOption(QuillImageFilter::Center));
QVERIFY(filter->setOption(QuillImageFilter::Center, QVariant(center)));
QVariantList list0 = filter->option(QuillImageFilter::SelectionArea).value<QVariantList>();
QVERIFY(list0.count() == 0); // No radius set yet
for (int r = 1; r < 101; r+=20)
{
QVERIFY(filter->supportsOption(QuillImageFilter::Radius));
QVERIFY(filter->setOption(QuillImageFilter::Radius, QVariant(r)));
bool bOK = true;
QCOMPARE(filter->option(QuillImageFilter::Radius).toList().first().toInt(&bOK), r);
QCOMPARE(filter->option(QuillImageFilter::Center).toList().first().toPoint(), center);
QVERIFY(bOK);
QVERIFY(filter->supportsOption(QuillImageFilter::SelectionArea));
QPolygon polygon = filter->option(QuillImageFilter::SelectionArea).value<QPolygon>();
float pi = 3.14159265;
float margin = 1;
for (int phi = 0; phi < 360; phi += 10)
{
float x = r * cos( 2.0 * pi * phi / 360.0);
if (fabs(x) > margin)
x = (x>0 ? 1 : -1) * floor(fabs(x) - margin);
else
x = 0;
float y = r * sin( 2.0 * pi * phi / 360.0);
if (fabs(y) > margin)
y = (y>0 ? 1 : -1) * floor(fabs(y) - margin);
else
y = 0;
QPoint pt(x, y);
pt += center;
QVERIFY(polygon.containsPoint(pt, Qt::WindingFill));
}
for (int phi = 0; phi < 360; phi += 10)
{
float x = r * cos( 2.0 * pi * phi / 360.0);
x = (x>0 ? 1 : -1) * ceil(fabs(x) + margin);
float y = r * sin( 2.0 * pi * phi / 360.0);
y = (y>0 ? 1 : -1) * ceil(fabs(y) + margin);
QPoint pt(x, y);
pt += center;
QVERIFY(polygon.containsPoint(pt, Qt::WindingFill) == false);
}
}
delete filter;
}
void ut_redeyereduction::testRedEyeForMultipleCircularAreas()
{
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter("org.maemo.red-eye-reduction");
QVERIFY(filter);
QCOMPARE(filter->name(), QString("com.meego.red-eye-reduction"));
QVariantList centerPoints;
for (int i = 100; i < 110; i++)
centerPoints << QPoint(i, i);
QVERIFY(filter->supportsOption(QuillImageFilter::Center));
QVERIFY(filter->setOption(QuillImageFilter::Center, QVariant(centerPoints)));
QVariantList list0 = filter->option(QuillImageFilter::SelectionArea).value<QVariantList>();
QVERIFY(list0.count() == 0); // No radius set yet
QVERIFY(filter->supportsOption(QuillImageFilter::Radius));
QVariantList radii;
for (int r = 1; r < 101; r++)
radii << QVariant(r);
QVERIFY(filter->setOption(QuillImageFilter::Radius, QVariant(radii)));
QVariantList outRadii = filter->option(QuillImageFilter::Radius).value<QVariantList>();
for (int i = 0; i < radii.count(); i++) {
bool bOK = true;
QCOMPARE(outRadii[i].toInt(), radii[i].toInt(&bOK));
QVERIFY(bOK);
}
QVariantList outCenter = filter->option(QuillImageFilter::Center).value<QVariantList>();
for (int i = 0; i < centerPoints.count(); i++) {
QCOMPARE(outCenter[i].toPoint(), centerPoints[i].toPoint());
}
QVERIFY(filter->supportsOption(QuillImageFilter::SelectionArea));
QVariantList polygonList = filter->option(QuillImageFilter::SelectionArea).value<QVariantList>();
QCOMPARE( polygonList.count(), ( radii.count() < centerPoints.count() ? radii.count() : centerPoints.count() ) );
for (int i = 0; i < polygonList.count(); i++)
{
QPolygon polygon = polygonList[i].value<QPolygon>();
float pi = 3.14159265;
float margin = 1;
for (int phi = 0; phi < 360; phi += 10)
{
float x = radii[i].toInt() * cos( 2.0 * pi * phi / 360.0);
if (fabs(x) > margin)
x = (x>0 ? 1 : -1) * floor(fabs(x) - margin);
else
x = 0;
float y = radii[i].toInt() * sin( 2.0 * pi * phi / 360.0);
if (fabs(y) > margin)
y = (y>0 ? 1 : -1) * floor(fabs(y) - margin);
else
y = 0;
QPoint pt(x, y);
pt += centerPoints[i].toPoint();
QVERIFY(polygon.containsPoint(pt, Qt::WindingFill));
}
for (int phi = 0; phi < 360; phi += 10)
{
float x = radii[i].toInt() * cos( 2.0 * pi * phi / 360.0);
x = (x>0 ? 1 : -1) * ceil(fabs(x) + margin);
float y = radii[i].toInt() * sin( 2.0 * pi * phi / 360.0);
y = (y>0 ? 1 : -1) * ceil(fabs(y) + margin);
QPoint pt(x, y);
pt += centerPoints[i].toPoint();
QVERIFY(polygon.containsPoint(pt, Qt::WindingFill) == false);
}
}
delete filter;
}
