QRangeSlider::ELEMENT getElement(const QRect& bbox,
const QPair<int, int>& range,
const QPair<int, int>& cutoffRange,
const QPoint& pos)
{
QPolygon p = getMarkerArea(bbox, range, cutoffRange, FIRST);
if (p.containsPoint(pos, Qt::OddEvenFill))
return QRangeSlider::FIRST;
p = getMarkerArea(bbox, range, cutoffRange, SECOND);
if (p.containsPoint(pos, Qt::OddEvenFill))
return QRangeSlider::SECOND;
return QRangeSlider::NONE;
}
QStyle::SubControl hitTestComplexControl(QStyle::ComplexControl control,
const QStyleOptionComplex* option,
const QPoint& position,
const QWidget* widget) const
{
if (control == QStyle::CC_CustomBase) {
QRect bbox = static_cast<const QRangeSlider*>(widget)->getBBox();
const QRangeSlider* rSlider = static_cast<const QRangeSlider*>(widget);
QPolygon p = getMarkerArea(bbox, rSlider->range(),
rSlider->cutoffRange(), FIRST);
if (p.containsPoint(position, Qt::OddEvenFill))
return QStyle::SC_SliderHandle;
p = getMarkerArea(bbox, rSlider->range(),
rSlider->cutoffRange(), SECOND);
if (p.containsPoint(position, Qt::OddEvenFill))
return SC_SliderHandle2;
return QStyle::SC_None;
}
return realStyle_->hitTestComplexControl(control,
option,
position,
widget);
}
bool Mesh::contains(const QPoint& point) const {
int n = anchor_points.size();
for (int i = 0; i < n - 1; ++i) {
QPolygon polygon;
polygon << QPoint(anchor_points[i][0].x, anchor_points[i][0].y);
polygon << QPoint(anchor_points[i][1].x, anchor_points[i][1].y);
polygon << QPoint(anchor_points[i + 1][1].x, anchor_points[i + 1][1].y);
polygon << QPoint(anchor_points[i + 1][0].x, anchor_points[i + 1][0].y);
if (polygon.containsPoint(point, Qt::FillRule::OddEvenFill)) {
return true;
}
}
return false;
}
/*----------------------------------------------------------------------------*/
void ChannelEdit :: mousePressEvent(QMouseEvent *event)
{
if(m_audioOpened)
{
qreal dX = (qreal)width() / (qreal) m_windowSize;
if(effectController->mode() == EffectController::SelectMode)
{
int size = effects.size();
int i;
for(i = 0; i < size; i++)
{
EffectProperties *prop = effects[i];
if(prop->channel() == m_channelId)
{
int pos = (int)(dX * (audioController->duration2quants(prop->timeStart()) - m_startPosition));
QPolygon pol = createPolygon(pos);
if(pol.containsPoint(event->pos(),Qt::OddEvenFill))
{
effectController->selectEffect(prop->id());
m_selected = prop->id();
break;
}
}
}
if(i >= size)
{
effectController->selectEffect(-1);
m_selected = -1;
}
}
else
if(effectController->mode() == EffectController::AddMode)
{
qreal d = (qreal) m_windowSize/ (qreal)width();
EffectProperties *prop = effectController->newEffect(effectController->effectToAdd(), m_channelId);
prop->setTimeStart(audioController->quants2duration(m_startPosition + (qint64)(event->pos().x() * d)));
effectController->selectEffect(prop->id());
effectController->setMode(EffectController::SelectMode);
}
}
Inherited::mousePressEvent(event);
}
void SaxsviewMask::Private::setValue(SaxsviewMask *mask, const QPolygonF& p, double value) {
if (SaxsviewFrameData *d = (SaxsviewFrameData*)(mask->data())) {
// QPolygonF::toPolygon() internally uses toPoint() rounding, see above.
QPolygon polygon;
foreach (QPointF pt, p)
polygon << QPoint((int)pt.x(), (int)pt.y());
const QRect r = polygon.boundingRect();
if (polygon.size() > 2) {
for (int x = r.x(); x <= r.x() + r.width(); ++x)
for (int y = r.y(); y <= r.y() + r.height(); ++y)
if (polygon.containsPoint(QPoint(x, y), Qt::OddEvenFill))
d->setValue(x, y, value);
} else
bresenham(polygon[0].x(), polygon[0].y(),
polygon[1].x(), polygon[1].y(),
d, value);
modified = true;
mask->plot()->replot();
}
}
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;
}
