void GfxCanvasImage::paint(GfxPainter &p)
{
if(_img.isNull())
return;
qreal op = p.opacity();
p.setOpacity(op * layerVisible());
if(_rotate.value() || 1. != layerScale()) {
QMatrix m;
m.translate(layerX(), layerY());
m.rotate(_rotate.value());
m.scale(layerScale(), layerScale());
m.translate(-_s.width() / 2, -_s.height() / 2);
p.drawImageTransformed(m, _img, quality().value() != 0.);
} else {
if(subPixelPlacement()) {
p.drawImage(qreal(layerX() - qreal(_s.width()) / 2.),
int(layerY() - qreal(_s.height()) / 2.), _img);
} else {
p.drawImage(int(layerX() - qreal(_s.width()) / 2.),
int(layerY() - qreal(_s.height()) / 2.), _img);
}
if(gfx_show_image_bounds) {
QRect r(int(layerX() - qreal(_s.width()) / 2.),
int(layerY() - qreal(_s.height()) / 2.),
_s.width(), _s.height());
p.fillRect(r, QColor(0, 0, 255, 127));
}
}
p.setOpacity(op);
GfxCanvasItem::paint(p);
}
void GfxCanvasText::paint(GfxPainter &p)
{
if(_img.isNull())
return;
qreal op = p.opacity();
p.setOpacity(op * layerVisible());
QSize _s = _img.size();
QPoint point = getImgPoint();
if(1. != layerScale()) {
QMatrix m;
m.translate(layerX(), layerY());
m.scale(layerScale(), layerScale());
m.translate(-_size.width() / 2, -_size.height() / 2);
m.translate(point.x(), point.y());
p.drawImageTransformed(m, _img, quality().value() != 0.);
} else {
p.drawImage(int(layerX()) + point.x() - _size.width() / 2,
int(layerY()) + point.y() - _size.height() / 2, _img);
if(gfx_show_image_bounds) {
QRect r(int(layerX()) + point.x() - _size.width() / 2,
int(layerY()) + point.y() - _size.height() / 2,
_img.width(),
_img.height());
p.fillRect(r, QColor(0, 0, 255, 127));
}
}
p.setOpacity(op);
GfxCanvasItem::paint(p);
}
void GfxCanvasMipImage::paint(GfxPainter &p)
{
if(_imgs.isEmpty() || scale().value() == 0.) return;
qreal op = p.opacity();
p.setOpacity(op * layerVisible());
// Find correct image
QSize s = layerScale() * _s;
int imgNum;
for(imgNum = 0; imgNum < _imgs.count(); ++imgNum)
if(_imgs.at(imgNum).width() >= s.width())
break;
if(imgNum == _imgs.count())
imgNum = _imgs.count() - 1;
const QImage &img = _imgs.at(imgNum);
// Adjust zoom
qreal zoom = qreal(s.width()) / qreal(img.width());
qreal rotate = _rotate.value();
int x = int(layerX());
int y = int(layerY());
if(zoom == 1. && rotate == 0.) {
if(subPixelPlacement()) {
p.drawImage(qreal(layerX() - qreal(s.width()) / 2.),
int(layerY() - qreal(s.height()) / 2.), img);
} else {
p.drawImage(x - s.width() / 2, y - s.height() / 2, img);
}
if(gfx_show_mip_matches) {
QRect r(x - s.width() / 2, y - s.height() / 2, s.width(), s.height());
p.fillRect(r, QColor(255, 0, 0, 127));
}
} else {
QMatrix m;
m.translate(x, y);
if(rotate)
m.rotate(rotate);
if(zoom != 1.)
m.scale(zoom, zoom);
m.translate(-img.width() / 2, -img.height() / 2);
p.drawImageTransformed(m, img, _quality.value() != 0.);
}
p.setOpacity(op);
GfxCanvasItem::paint(p);
}
void GfxCanvasReflection::paint(GfxPainter &p)
{
enum State { Yes, No, Unknown };
static State blur = Unknown;
if(blur == Unknown) {
bool b = QString(getenv("GFX_REFLECTION_NO_BLUR")).isEmpty();
blur = b?Yes:No;
}
int vals[2];
vals[0] = int(layerY());
vals[1] = _s.height();
qreal op = p.opacity();
p.setOpacity(op * layerVisible());
p.setHorizontalOpacityFunction(reflectFunc, (void *)vals);
QRect rect = reflectRect();
p.drawImageFlipped(int(layerX()), int(layerY()), p.imgRef(rect));
p.setHorizontalOpacityFunction(0, 0);
if(blur == Yes && !p.usingQt()) {
QRect br = internalBoundingRect();
QImage img = p.img(br);
Gfx::blur(img, 3);
p.setOpacity(op);
GfxCanvasItem::paint(p);
}
}
QRect GfxCanvasRoundedRect::boundingRect()
{
int x = int(layerX()) - int(_width.value() / 2);
int y = int(layerY()) - int(_height.value() / 2);
int width = int(_width.value());
int height = int(_height.value());
QRect rv(x, y, width, height);
return rv | GfxCanvasItem::boundingRect();;
}
void GfxCanvasColor::paint(GfxPainter &p)
{
qreal op = p.opacity();
p.setOpacity(op * layerVisible());
QSize s(int(_s.width() * layerScale()), int(_s.height() * layerScale()));
if(_rotate.value()) {
QMatrix m;
m.translate(layerX(), layerY());
m.rotate(_rotate.value());
m.translate(-s.width() / 2, -s.height() / 2);
p.fillRectTransformed(m, s, color(), quality().value() != 0.);
} else {
p.fillRect(QRect(QPoint(int(layerX() - qreal(s.width()) / 2.),
int(layerY() - qreal(s.height()) / 2.)), s), color());
}
p.setOpacity(op);
GfxCanvasItem::paint(p);
}
QRect GfxCanvasImage::boundingRect()
{
QMatrix m;
m.translate(layerX(), layerY());
m.rotate(_rotate.value());
m.scale(layerScale(), layerScale());
m.translate(-_s.width() / 2, -_s.height() / 2);
QRect r(QPoint(0, 0), _s);
r = m.mapRect(r);
r.setX(r.x() - 1);
r.setY(r.y() - 1);
r.setWidth(r.width() + 2);
r.setHeight(r.height() + 2);
return r | GfxCanvasItem::boundingRect();;
}
void GfxCanvasRoundedRect::paint(GfxPainter &g)
{
qreal opacity = layerVisible();
init();
int x = int(layerX()) - int(_width.value() / 2);
int y = int(layerY()) - int(_height.value() / 2);
int width = qMax(int(_width.value()) - _cornerCurve * 2, 0);
int height = qMax(int(_height.value()) - _cornerCurve * 2, 0);
if(opacity != 1.)
g.setOpacity(opacity);
if(_cornerCurve) {
g.drawImage(x, y, ul);
g.drawImage(width + x + _cornerCurve, y, ur);
g.drawImage(x, height + _cornerCurve + y, ll);
g.drawImage(width + x + _cornerCurve, height + _cornerCurve + y, lr);
}
int drawWidth = width;
while(drawWidth > 0) {
g.drawImage(x + _cornerCurve + width - drawWidth, y, GfxImageRef(upper, QRect(0, 0, qMin(drawWidth, 15), _lineWidth)));
g.drawImage(x + _cornerCurve + width - drawWidth, y + height + 2 * _cornerCurve - _lineWidth, GfxImageRef(lower, QRect(0, 0, qMin(drawWidth, 15), _lineWidth)));
drawWidth -= 15;
}
if(_filled) {
int cfill = _cornerCurve - _lineWidth;
if(cfill > 0) {
g.fillRect(QRect(x + _cornerCurve, y + _lineWidth, width, cfill), _color);
g.fillRect(QRect(x + _cornerCurve, y + height + _cornerCurve ,width,cfill), _color);
}
g.fillRect(QRect(x + _lineWidth, y + _cornerCurve, width + _cornerCurve * 2 - _lineWidth * 2, height),
_color);
}
int drawHeight = height;
while(drawHeight > 0) {
g.drawImage(x, y + _cornerCurve + height - drawHeight, GfxImageRef(left, QRect(0, 0, _lineWidth, qMin(drawHeight, 15))));
g.drawImage(x + width + 2 * _cornerCurve - _lineWidth, y + _cornerCurve + height - drawHeight, GfxImageRef(left, QRect(0, 0, _lineWidth, qMin(drawHeight, 15))));
drawHeight -= 15;
}
g.setOpacity(1.);
GfxCanvasItem::paint(g);
}
void GfxCanvasCacheLayer::paint(GfxPainter &p)
{
zOrderChildren();
if(_children.isEmpty())
return;
if(Add == _optState && !_children.isEmpty() &&
_children.last() == _addItem) {
GfxPainter p(_img);
if(_addItem->visible().value() != 0.)
_addItem->paint(p);
} else if(None != _optState) {
if(_img.format() == QImage::Format_RGB32)
_img.fill(0xFF000000);
else
_img.fill(0x0);
GfxPainter p(_img);
for(int ii = 0; ii < _children.count(); ++ii) {
GfxCanvasItem *c = _children.at(ii);
if(c->visible().value() != 0.)
c->paint(p);
}
}
_optState = None;
_addItem = 0;
qreal op = p.opacity();
p.setOpacity(op * GfxCanvasItem::layerVisible() * visible().value());
qreal s = GfxCanvasItem::layerScale();
if(1. != s) {
QMatrix m;
m.translate(layerX() + _s.width() / 2, layerY() + _s.height() / 2);
m.scale(s, s);
m.translate(-_s.width() / 2, -_s.height() / 2);
p.drawImageTransformed(m, _img, quality().value() != 0.);
} else {
p.drawImage(int(GfxCanvasItem::layerX()),
int(GfxCanvasItem::layerY()),
_img);
}
p.setOpacity(op);
}
QRect GfxCanvasText::boundingRect()
{
checkCache();
if(_img.isNull())
return QRect();
QMatrix m;
m.translate(layerX(), layerY());
m.scale(layerScale(), layerScale());
m.translate(-_size.width() / 2, -_size.height() / 2);
QRect r(getImgPoint(), _img.size());
r = m.mapRect(r);
r.setX(r.x() - 1);
r.setY(r.y() - 1);
r.setWidth(r.width() + 2);
r.setHeight(r.height() + 2);
return r | GfxCanvasItem::boundingRect();;
}
QRect GfxCanvasReflection::internalBoundingRect()
{
return QRect(QPoint(int(layerX()), int(layerY())), _s);
}
QRect GfxCanvasClip::clip()
{
return QRect(int(layerX()), int(layerY()), int(_width.value()), int(_height.value()));
}
bool StudentLocalization::stepFindHead(const IntensityImage &image, FeatureMap &features) const {
Histogram AxisY(image, 50, 50, 0, 0, Axis::y);
//determine top of the head
int topHead = -1;
for (int i = 0; i < AxisY.getSize(); ++i) {
if (AxisY.getValue(i) > 2) {
topHead = i;
break;
}
}
if (topHead == -1) {
return false;
}
//determine sides
int lastLeftX = -1;
int lastRightX = -1;
for (int y = topHead; y < image.getHeight(); y += 20) {
Histogram layerX(image, 0, 0, y, (image.getHeight() - y - 20), Axis::x);
//determine leftside of the head
int leftX = -1;
for (int i = 0; i < layerX.getSize(); ++i) {
if (layerX.getValue(i) > 2) {
leftX = i;
break;
}
}
//determine rightside of the head
int rightX = -1;
for (int i = layerX.getSize() - 1; i >= 0 ; --i) {
if (layerX.getValue(i) > 2) {
rightX = i;
break;
}
}
// if not both sides are found skip the rest of the loop
if (leftX == -1 || rightX == -1) {
continue;
}
int currentHeadWidth = rightX - leftX;
int lastHeadWidth = lastRightX - lastLeftX;
if (currentHeadWidth < lastHeadWidth) {
Feature * headUpperBound = new Feature(Feature::FEATURE_HEAD_TOP, Point2D<double>(lastRightX - (currentHeadWidth / 2), topHead));
Feature * headLeftBound = new Feature(Feature::FEATURE_HEAD_LEFT_SIDE, Point2D<double>(lastLeftX, y));
Feature * headRightBound = new Feature(Feature::FEATURE_HEAD_RIGHT_SIDE, Point2D<double>(lastRightX, y));
features.putFeature(*headUpperBound);
features.putFeature(*headLeftBound);
features.putFeature(*headRightBound);
return true;
}
lastLeftX = leftX;
lastRightX = rightX;
}
return false;
}
