//void Object::paintImage(QPainter &painter, int frameNumber, const QRectF &source, const QRectF &target, bool background, qreal curveOpacity, bool antialiasing, bool niceGradients) {
void Object::paintImage(QPainter& painter, int frameNumber, bool background, qreal curveOpacity, bool antialiasing, int gradients)
{
painter.setRenderHint(QPainter::Antialiasing, true);
painter.setRenderHint(QPainter::SmoothPixmapTransform, true);
//painter.setWorldMatrix(matrix);
painter.setCompositionMode(QPainter::CompositionMode_SourceOver);
// paints the background
if (background)
{
painter.setPen(Qt::NoPen);
painter.setBrush(Qt::white);
painter.setWorldMatrixEnabled(false);
painter.drawRect( QRect(0,0, painter.device()->width(), painter.device()->height() ) );
painter.setWorldMatrixEnabled(true);
}
for(int i=0; i < getLayerCount(); i++)
{
Layer* layer = getLayer(i);
if (layer->visible)
{
painter.setOpacity(1.0);
// paints the bitmap images
if (layer->type == Layer::BITMAP)
{
LayerBitmap* layerBitmap = (LayerBitmap*)layer;
/*BitmapImage* bitmapImage = layerBitmap->getLastBitmapImageAtFrame(frameNumber, 0);
// TO BE FIXED
if (bitmapImage != NULL) {
if ( mirror) {
painter.drawImage(target, (*(bitmapImage->image)).mirrored(true, false), source);
} else {
painter.drawImage(target, *(bitmapImage->image), source);
}
}*/
layerBitmap->getLastBitmapImageAtFrame(frameNumber, 0)->paintImage(painter);
}
// paints the vector images
if (layer->type == Layer::VECTOR)
{
LayerVector* layerVector = (LayerVector*)layer;
layerVector->getLastVectorImageAtFrame(frameNumber, 0)->paintImage(painter, false, false, curveOpacity, antialiasing, gradients);
}
}
}
}
void CanvasRenderer::paintGrid( QPainter& painter )
{
int gridSize = mOptions.nGridSize;
QRectF rect = painter.viewport();
QRectF boundingRect = mViewTransform.inverted().mapRect( rect );
int w = boundingRect.width();
int h = boundingRect.height();
//qDebug() << mViewTransform;
//qDebug() << mViewTransform.inverted();
int left = round100( boundingRect.left(), gridSize ) - gridSize;
int right = round100( boundingRect.right(), gridSize ) + gridSize;
int top = round100( boundingRect.top(), gridSize ) - gridSize;
int bottom = round100( boundingRect.bottom(), gridSize ) + gridSize;
QPen pen( Qt::lightGray );
pen.setCosmetic( true );
painter.setPen( pen );
painter.setWorldMatrixEnabled( true );
painter.setBrush( Qt::NoBrush );
QPainter::RenderHints previous_renderhints = painter.renderHints();
painter.setRenderHint( QPainter::Antialiasing, false );
for ( int x = left; x < right; x += gridSize )
{
painter.drawLine( x, top, x, bottom );
}
for ( int y = top; y < bottom; y += gridSize )
{
painter.drawLine( left, y, right, y );
}
painter.setRenderHints(previous_renderhints);
}
void CanvasRenderer::paintTransformedSelection( QPainter& painter )
{
// Make sure there is something selected
//
if (mSelection.width() == 0 || mSelection.height() == 0) {
return;
}
Layer* layer = mObject->getLayer( mLayerIndex );
if (layer->type() == Layer::BITMAP) {
// Get the transformed image
//
BitmapImage* bitmapImage = dynamic_cast< LayerBitmap* >( layer )->getLastBitmapImageAtFrame( mFrameNumber, 0 );
BitmapImage transformedImage = bitmapImage->transformed(mSelection, mSelectionTransform, mOptions.bAntiAlias);
// Paint the transformation output
//
painter.setWorldMatrixEnabled( true );
transformedImage.paintImage(painter);
}
}
void Object::paintImage( QPainter& painter, int frameNumber,
bool background,
bool antialiasing )
{
painter.setRenderHint( QPainter::Antialiasing, true );
painter.setRenderHint( QPainter::SmoothPixmapTransform, true );
//painter.setTransform(matrix);
painter.setCompositionMode( QPainter::CompositionMode_SourceOver );
// paints the background
if ( background )
{
painter.setPen( Qt::NoPen );
painter.setBrush( Qt::white );
painter.setWorldMatrixEnabled( false );
painter.drawRect( QRect( 0, 0, painter.device()->width(), painter.device()->height() ) );
painter.setWorldMatrixEnabled( true );
}
for ( int i = 0; i < getLayerCount(); i++ )
{
Layer* layer = getLayer( i );
if ( layer->visible )
{
painter.setOpacity( 1.0 );
// paints the bitmap images
if ( layer->type() == Layer::BITMAP )
{
LayerBitmap* layerBitmap = ( LayerBitmap* )layer;
layerBitmap->getLastBitmapImageAtFrame( frameNumber, 0 )->paintImage( painter );
}
// paints the vector images
if ( layer->type() == Layer::VECTOR )
{
LayerVector* layerVector = ( LayerVector* )layer;
layerVector->getLastVectorImageAtFrame( frameNumber, 0 )->paintImage( painter,
false,
false,
antialiasing );
}
}
}
}
void
DewarpingView::paintXSpline(
QPainter& painter, InteractionState const& interaction,
InteractiveXSpline const& ispline)
{
XSpline const& spline = ispline.spline();
painter.save();
painter.setBrush(Qt::NoBrush);
#if 0 // No point in drawing the curve itself - we already draw the grid.
painter.setWorldTransform(imageToVirtual() * virtualToWidget());
QPen curve_pen(Qt::blue);
curve_pen.setWidthF(1.5);
curve_pen.setCosmetic(true);
painter.setPen(curve_pen);
std::vector<QPointF> const polyline(spline.toPolyline());
painter.drawPolyline(&polyline[0], polyline.size());
#endif
// Drawing cosmetic points in transformed coordinates seems unreliable,
// so let's draw them in widget coordinates.
painter.setWorldMatrixEnabled(false);
QPen existing_point_pen(Qt::red);
existing_point_pen.setWidthF(4.0);
existing_point_pen.setCosmetic(true);
painter.setPen(existing_point_pen);
int const num_control_points = spline.numControlPoints();
for (int i = 0; i < num_control_points; ++i) {
painter.drawPoint(sourceToWidget(spline.controlPointPosition(i)));
}
QPointF pt;
if (ispline.curveIsProximityLeader(interaction, &pt)) {
QPen new_point_pen(existing_point_pen);
new_point_pen.setColor(QColor(0x00ffff));
painter.setPen(new_point_pen);
painter.drawPoint(pt);
}
painter.restore();
}
void CanvasRenderer::paintCameraBorder(QPainter &painter)
{
for ( int i = 0; i < mObject->getLayerCount(); ++i )
{
Layer* layer = mObject->getLayer( i );
if ( layer->type() == Layer::CAMERA && (i == mLayerIndex || mOptions.nShowAllLayers > 0) && layer->visible() ) {
if ( i == mLayerIndex || mOptions.nShowAllLayers != 1 )
{
painter.setOpacity( 1.0 );
}
else {
painter.setOpacity( 0.8 );
}
QRectF viewRect = painter.viewport();
QRect boundingRect = mViewTransform.inverted().mapRect( viewRect ).toRect();
LayerCamera* cameraLayer = dynamic_cast< LayerCamera* >( layer );
QRect cameraRect = cameraLayer->getViewRect();
painter.setWorldMatrixEnabled( true );
painter.setPen( Qt::NoPen );
painter.setBrush( QColor( 0, 0, 0, 160 ) );
QRegion rg1(boundingRect);
QRegion rg2(cameraRect);
QRegion rg3=rg1.subtracted(rg2);
painter.setClipRegion(rg3);
painter.drawRect( boundingRect );
painter.setClipping(false);
painter.setPen( Qt::black );
painter.setBrush( Qt::NoBrush );
painter.drawRect( cameraRect );
}
}
}
void
ImageView::onPaint(QPainter& painter, InteractionState const& interaction)
{
painter.setWorldMatrixEnabled(false);
painter.setRenderHints(QPainter::Antialiasing, false);
double const w = maxViewportRect().width();
double const h = maxViewportRect().height();
QPointF const center(getImageRotationOrigin());
// Draw the semi-transparent grid.
QPen pen(QColor(0, 0, 255, 90));
pen.setCosmetic(true);
pen.setWidth(1);
painter.setPen(pen);
QVector<QLineF> lines;
for (double y = center.y(); (y -= m_cellSize) > 0.0;) {
lines.push_back(QLineF(0.5, y, w - 0.5, y));
}
for (double y = center.y(); (y += m_cellSize) < h;) {
lines.push_back(QLineF(0.5, y, w - 0.5, y));
}
for (double x = center.x(); (x -= m_cellSize) > 0.0;) {
lines.push_back(QLineF(x, 0.5, x, h - 0.5));
}
for (double x = center.x(); (x += m_cellSize) < w;) {
lines.push_back(QLineF(x, 0.5, x, h - 0.5));
}
painter.drawLines(lines);
// Draw the horizontal and vertical line crossing at the center.
pen.setColor(QColor(0, 0, 255));
painter.setPen(pen);
painter.setBrush(Qt::NoBrush);
painter.drawLine(
QPointF(0.5, center.y()),
QPointF(w - 0.5, center.y())
);
painter.drawLine(
QPointF(center.x(), 0.5),
QPointF(center.x(), h - 0.5)
);
// Draw the rotation arcs.
// Those will look like this ( )
QRectF const arc_square(getRotationArcSquare());
painter.setRenderHints(QPainter::Antialiasing, true);
pen.setWidthF(1.5);
painter.setPen(pen);
painter.setBrush(Qt::NoBrush);
painter.drawArc(
arc_square,
qRound(16 * -m_maxRotationDeg),
qRound(16 * 2 * m_maxRotationDeg)
);
painter.drawArc(
arc_square,
qRound(16 * (180 - m_maxRotationDeg)),
qRound(16 * 2 * m_maxRotationDeg)
);
std::pair<QPointF, QPointF> const handles(
getRotationHandles(arc_square)
);
QRectF rect(m_handlePixmap.rect());
rect.moveCenter(handles.first);
painter.drawPixmap(rect.topLeft(), m_handlePixmap);
rect.moveCenter(handles.second);
painter.drawPixmap(rect.topLeft(), m_handlePixmap);
}
void
ZoneDefaultInteraction::onPaint(QPainter& painter, InteractionState const& interaction)
{
painter.setWorldMatrixEnabled(false);
painter.setRenderHint(QPainter::Antialiasing);
QTransform const to_screen(m_rContext.imageView().imageToWidget());
BOOST_FOREACH(EditableZoneSet::Zone const& zone, m_rContext.zones()) {
EditableSpline::Ptr const& spline = zone.spline();
m_visualizer.prepareForSpline(painter, spline);
QPolygonF points;
if (!interaction.captured() && interaction.proximityLeader(m_vertexProximity)
&& spline == m_ptrNearestVertexSpline) {
SplineVertex::Ptr vertex(m_ptrNearestVertex->next(SplineVertex::LOOP));
for (; vertex != m_ptrNearestVertex; vertex = vertex->next(SplineVertex::LOOP)) {
points.push_back(to_screen.map(vertex->point()));
}
painter.drawPolyline(points);
} else if (!interaction.captured() && interaction.proximityLeader(m_segmentProximity)
&& spline == m_ptrNearestSegmentSpline) {
SplineVertex::Ptr vertex(m_nearestSegment.prev);
do {
vertex = vertex->next(SplineVertex::LOOP);
points.push_back(to_screen.map(vertex->point()));
} while (vertex != m_nearestSegment.prev);
painter.drawPolyline(points);
} else {
m_visualizer.drawSpline(painter, to_screen, spline);
}
}
if (interaction.proximityLeader(m_vertexProximity)) {
// Draw the two adjacent edges in gradient red-to-orange.
QLinearGradient gradient; // From inactive to active point.
gradient.setColorAt(0.0, m_visualizer.solidColor());
gradient.setColorAt(1.0, m_visualizer.highlightDarkColor());
QPen pen(painter.pen());
QPointF const prev(to_screen.map(m_ptrNearestVertex->prev(SplineVertex::LOOP)->point()));
QPointF const pt(to_screen.map(m_ptrNearestVertex->point()));
QPointF const next(to_screen.map(m_ptrNearestVertex->next(SplineVertex::LOOP)->point()));
gradient.setStart(prev);
gradient.setFinalStop(pt);
pen.setBrush(gradient);
painter.setPen(pen);
painter.drawLine(prev, pt);
gradient.setStart(next);
pen.setBrush(gradient);
painter.setPen(pen);
painter.drawLine(next, pt);
// Visualize the highlighted vertex.
QPointF const screen_vertex(to_screen.map(m_ptrNearestVertex->point()));
m_visualizer.drawVertex(painter, screen_vertex, m_visualizer.highlightBrightColor());
} else if (interaction.proximityLeader(m_segmentProximity)) {
QLineF const line(to_screen.map(m_nearestSegment.toLine()));
// Draw the highglighed edge in orange.
QPen pen(painter.pen());
pen.setColor(m_visualizer.highlightDarkColor());
painter.setPen(pen);
painter.drawLine(line);
m_visualizer.drawVertex(painter, m_screenPointOnSegment, m_visualizer.highlightBrightColor());
} else if (!interaction.captured()) {
m_visualizer.drawVertex(painter, m_screenMousePos, m_visualizer.solidColor());
}
}
void View::drawTickRaster(QPainter& p, int x, int y, int w, int h, int raster)
{
// Changed to draw in device coordinate space instead of virtual, transformed space. Tim. p4.0.30
//int mx = mapx(x);
int my = mapy(y);
//int mw = mapx(x + w) - mx;
//int mw = mapx(x + w) - mx - 1;
//int mh = mapy(y + h) - my;
//int mh = mapy(y + h) - my - 1;
//p.save();
bool wmtxen = p.worldMatrixEnabled();
p.setWorldMatrixEnabled(false);
int xx,bar1, bar2, beat;
unsigned tick;
AL::sigmap.tickValues(x, &bar1, &beat, &tick);
AL::sigmap.tickValues(x+w, &bar2, &beat, &tick);
++bar2;
///int y2 = y + h;
//int y2 = my + mh;
int y2 = mapy(y + h) - 1;
//printf("View::drawTickRaster x:%d y:%d w:%d h:%d mx:%d my:%d mw:%d mh:%d y2:%d bar1:%d bar2:%d\n", x, y, w, h, mx, my, mw, mh, y2, bar1, bar2);
//printf("View::drawTickRaster x:%d y:%d w:%d h:%d my:%d mh:%d y2:%d bar1:%d bar2:%d\n", x, y, w, h, my, mh, y2, bar1, bar2);
for (int bar = bar1; bar < bar2; ++bar) {
///unsigned x = AL::sigmap.bar2tick(bar, 0, 0);
unsigned xb = AL::sigmap.bar2tick(bar, 0, 0);
int xt = mapx(xb);
p.setPen(Qt::black);
///p.drawLine(x, y, x, y2);
p.drawLine(xt, my, xt, y2);
int z, n;
///AL::sigmap.timesig(x, z, n);
AL::sigmap.timesig(xb, z, n);
///int q = p.xForm(QPoint(raster, 0)).x() - p.xForm(QPoint(0, 0)).x();
///int q = p.combinedTransform().map(QPoint(raster, 0)).x() - p.combinedTransform().map(QPoint(0, 0)).x();
//int q = rmapx(raster);
int qq = raster;
//if (q < 8) // grid too dense
if (rmapx(raster) < 8) // grid too dense
qq *= 2;
p.setPen(Qt::lightGray);
if (raster>=4) {
///int xx = x + qq;
//int xx = mapx(xb + qq);
xx = xb + qq;
int xxx = AL::sigmap.bar2tick(bar, z, 0);
//int xxx = mapx(AL::sigmap.bar2tick(bar, z, 0));
while (xx <= xxx) {
///p.drawLine(xx, y, xx, y2);
int x = mapx(xx);
p.drawLine(x, my, x, y2);
xx += qq;
//xx += rmapx(qq);
}
//xx = xxx;
}
p.setPen(Qt::darkGray);
for (int beat = 1; beat < z; beat++) {
///int xx = AL::sigmap.bar2tick(bar, beat, 0);
xx = mapx(AL::sigmap.bar2tick(bar, beat, 0));
//printf(" bar:%d z:%d beat:%d xx:%d\n", bar, z, beat, xx);
///p.drawLine(xx, y, xx, y2);
p.drawLine(xx, my, xx, y2);
}
}
//p.setWorldMatrixEnabled(true);
p.setWorldMatrixEnabled(wmtxen);
//p.restore();
}
void WaveformRenderMark::generateMarkImage(WaveformMark* pMark) {
const WaveformMarkProperties& markProperties = pMark->getProperties();
// Load the pixmap from file -- takes precedence over text.
if (!markProperties.m_pixmapPath.isEmpty()) {
QString path = markProperties.m_pixmapPath;
QImage image = *WImageStore::getImage(path, scaleFactor());
//QImage image = QImage(path);
// If loading the image didn't fail, then we're done. Otherwise fall
// through and render a label.
if (!image.isNull()) {
pMark->m_image = image.convertToFormat(QImage::Format_ARGB32_Premultiplied);
//WImageStore::correctImageColors(&pMark->m_image);
return;
}
}
QPainter painter;
// If no text is provided, leave m_markImage as a null image
if (!markProperties.m_text.isNull()) {
// Determine mark text.
QString label = markProperties.m_text;
if (pMark->getHotCue() >= 0) {
if (!label.isEmpty()) {
label.prepend(": ");
}
label.prepend(QString::number(pMark->getHotCue() + 1));
if (label.size() > kMaxCueLabelLength) {
label = label.left(kMaxCueLabelLength - 3) + "...";
}
}
//QFont font("Bitstream Vera Sans");
//QFont font("Helvetica");
QFont font; // Uses the application default
font.setPointSizeF(10 * scaleFactor());
font.setStretch(100);
font.setWeight(75);
QFontMetrics metrics(font);
//fixed margin ...
QRect wordRect = metrics.tightBoundingRect(label);
const int marginX = 1;
const int marginY = 1;
wordRect.moveTop(marginX + 1);
wordRect.moveLeft(marginY + 1);
wordRect.setHeight(wordRect.height() + (wordRect.height()%2));
wordRect.setWidth(wordRect.width() + (wordRect.width())%2);
//even wordrect to have an even Image >> draw the line in the middle !
int labelRectWidth = wordRect.width() + 2 * marginX + 4;
int labelRectHeight = wordRect.height() + 2 * marginY + 4 ;
QRectF labelRect(0, 0,
(float)labelRectWidth, (float)labelRectHeight);
int width;
int height;
if (m_waveformRenderer->getOrientation() == Qt::Horizontal) {
width = 2 * labelRectWidth + 1;
height = m_waveformRenderer->getHeight();
} else {
width = m_waveformRenderer->getWidth();
height = 2 * labelRectHeight + 1;
}
pMark->m_image = QImage(width, height, QImage::Format_ARGB32_Premultiplied);
Qt::Alignment markAlignH = markProperties.m_align & Qt::AlignHorizontal_Mask;
Qt::Alignment markAlignV = markProperties.m_align & Qt::AlignVertical_Mask;
if (markAlignH == Qt::AlignHCenter) {
labelRect.moveLeft((width - labelRectWidth) / 2);
} else if (markAlignH == Qt::AlignRight) {
labelRect.moveRight(width - 1);
}
if (markAlignV == Qt::AlignVCenter) {
labelRect.moveTop((height - labelRectHeight) / 2);
} else if (markAlignV == Qt::AlignBottom) {
labelRect.moveBottom(height - 1);
}
// Fill with transparent pixels
pMark->m_image.fill(QColor(0,0,0,0).rgba());
painter.begin(&pMark->m_image);
painter.setRenderHint(QPainter::TextAntialiasing);
painter.setWorldMatrixEnabled(false);
// Draw marker lines
if (m_waveformRenderer->getOrientation() == Qt::Horizontal) {
int middle = width / 2;
if (markAlignH == Qt::AlignHCenter) {
if (labelRect.top() > 0) {
painter.setPen(markProperties.fillColor());
painter.drawLine(middle, 0, middle, labelRect.top());
painter.setPen(markProperties.borderColor());
painter.drawLine(middle - 1, 0, middle - 1, labelRect.top());
painter.drawLine(middle + 1, 0, middle + 1, labelRect.top());
}
if (labelRect.bottom() < height) {
painter.setPen(markProperties.fillColor());
painter.drawLine(middle, labelRect.bottom(), middle, height);
painter.setPen(markProperties.borderColor());
painter.drawLine(middle - 1, labelRect.bottom(), middle - 1, height);
painter.drawLine(middle + 1, labelRect.bottom(), middle + 1, height);
}
} else { // AlignLeft || AlignRight
painter.setPen(markProperties.fillColor());
painter.drawLine(middle, 0, middle, height);
painter.setPen(markProperties.borderColor());
painter.drawLine(middle - 1, 0, middle - 1, height);
painter.drawLine(middle + 1, 0, middle + 1, height);
}
} else { // Vertical
int middle = height / 2;
if (markAlignV == Qt::AlignVCenter) {
if (labelRect.left() > 0) {
painter.setPen(markProperties.fillColor());
painter.drawLine(0, middle, labelRect.left(), middle);
painter.setPen(markProperties.borderColor());
painter.drawLine(0, middle - 1, labelRect.left(), middle - 1);
painter.drawLine(0, middle + 1, labelRect.left(), middle + 1);
}
if (labelRect.right() < width) {
painter.setPen(markProperties.fillColor());
painter.drawLine(labelRect.right(), middle, width, middle);
painter.setPen(markProperties.borderColor());
painter.drawLine(labelRect.right(), middle - 1, width, middle - 1);
painter.drawLine(labelRect.right(), middle + 1, width, middle + 1);
}
} else { // AlignTop || AlignBottom
painter.setPen(markProperties.fillColor());
painter.drawLine(0, middle, width, middle);
painter.setPen(markProperties.borderColor());
painter.drawLine(0, middle - 1, width, middle - 1);
painter.drawLine(0, middle + 1, width, middle + 1);
}
}
// Draw the label rect
painter.setPen(markProperties.borderColor());
painter.setBrush(QBrush(markProperties.fillColor()));
painter.drawRoundedRect(labelRect, 2.0, 2.0);
// Draw text
painter.setBrush(QBrush(QColor(0,0,0,0)));
painter.setFont(font);
painter.setPen(markProperties.labelColor());
painter.drawText(labelRect, Qt::AlignCenter, label);
}
else //no text draw triangle
{
float triangleSize = 9.0;
float markLength = triangleSize + 1.0;
float markBreadth = m_waveformRenderer->getBreadth();
int width, height;
if (m_waveformRenderer->getOrientation() == Qt::Horizontal) {
width = markLength;
height = markBreadth;
} else {
width = markBreadth;
height = markLength;
}
pMark->m_image = QImage(width, height, QImage::Format_ARGB32_Premultiplied);
pMark->m_image.fill(QColor(0,0,0,0).rgba());
painter.begin(&pMark->m_image);
painter.setRenderHint(QPainter::TextAntialiasing);
painter.setWorldMatrixEnabled(false);
// Rotate if drawing vertical waveforms
if (m_waveformRenderer->getOrientation() == Qt::Vertical) {
painter.setTransform(QTransform(0, 1, 1, 0, 0, 0));
}
QColor triangleColor = markProperties.fillColor();
painter.setPen(QColor(0,0,0,0));
painter.setBrush(QBrush(triangleColor));
//vRince: again don't ask about the +-0.1 0.5 ...
// just to make it nice in Qt ...
QPolygonF triangle;
triangle.append(QPointF(0.5,0));
triangle.append(QPointF(triangleSize+0.5,0));
triangle.append(QPointF(triangleSize*0.5 + 0.1, triangleSize*0.5));
painter.drawPolygon(triangle);
triangle.clear();
triangle.append(QPointF(0.0,markBreadth));
triangle.append(QPointF(triangleSize+0.5,markBreadth));
triangle.append(QPointF(triangleSize*0.5 + 0.1, markBreadth - triangleSize*0.5 - 2.1));
painter.drawPolygon(triangle);
//TODO vRince duplicated code make a method
//draw line
QColor lineColor = markProperties.fillColor();
painter.setPen(lineColor);
float middle = markLength / 2.0;
float lineTop = triangleSize * 0.5 + 1;
float lineBottom = markBreadth - triangleSize * 0.5 - 1;
painter.drawLine(middle, lineTop, middle, lineBottom);
//other lines to increase contrast
painter.setPen(QColor(0,0,0,100));
painter.drawLine(middle - 1, lineTop, middle - 1, lineBottom);
painter.drawLine(middle + 1, lineTop, middle + 1, lineBottom);
}
}
void CanvasRenderer::paintVectorFrame( QPainter& painter,
int layerId,
int nFrame,
bool colorize,
bool useLastKeyFrame )
{
Layer* layer = mObject->getLayer( layerId );
if ( !layer->visible() )
{
return;
}
LayerVector* vectorLayer = dynamic_cast< LayerVector* >( layer );
if ( vectorLayer == nullptr )
{
Q_ASSERT( vectorLayer );
return;
}
qCDebug( mLog ) << "Paint Onion skin vector, Frame = " << nFrame;
VectorImage* vectorImage;
if (useLastKeyFrame)
{
vectorImage = vectorLayer->getLastVectorImageAtFrame( nFrame, 0 );
}
else
{
vectorImage = vectorLayer->getVectorImageAtFrame( nFrame );
}
if ( vectorImage == nullptr )
{
return;
}
QImage* pImage = new QImage( mCanvas->size(), QImage::Format_ARGB32_Premultiplied );
vectorImage->outputImage( pImage, mViewTransform, mOptions.bOutlines, mOptions.bThinLines, mOptions.bAntiAlias );
//painter.drawImage( QPoint( 0, 0 ), *pImage );
// Go through a Bitmap image to paint the onion skin colour
//
BitmapImage* tempBitmapImage = new BitmapImage();
tempBitmapImage->setImage(pImage);
if ( colorize )
{
QBrush colorBrush = QBrush(Qt::transparent); //no color for the current frame
if (nFrame < mFrameNumber)
{
colorBrush = QBrush(Qt::red);
}
else if (nFrame > mFrameNumber)
{
colorBrush = QBrush(Qt::blue);
}
tempBitmapImage->drawRect( pImage->rect(),
Qt::NoPen,
colorBrush,
QPainter::CompositionMode_SourceIn,
false);
}
painter.setWorldMatrixEnabled( false ); //Don't tranform the image here as we used the viewTransform in the image output
tempBitmapImage->paintImage( painter );
delete tempBitmapImage;
}
void CanvasRenderer::paintBitmapFrame( QPainter& painter,
int layerId,
int nFrame,
bool colorize,
bool useLastKeyFrame )
{
Layer* layer = mObject->getLayer( layerId );
if ( !layer->visible() )
{
return;
}
LayerBitmap* bitmapLayer = dynamic_cast< LayerBitmap* >( layer );
if ( bitmapLayer == nullptr )
{
Q_ASSERT( bitmapLayer );
return;
}
qCDebug( mLog ) << "Paint Onion skin bitmap, Frame = " << nFrame;
BitmapImage* bitmapImage;
if (useLastKeyFrame) {
bitmapImage = bitmapLayer->getLastBitmapImageAtFrame( nFrame, 0 );
}
else {
bitmapImage = bitmapLayer->getBitmapImageAtFrame( nFrame );
}
if ( bitmapImage == nullptr )
{
return;
}
BitmapImage* tempBitmapImage = new BitmapImage;
tempBitmapImage->paste(bitmapImage);
if ( colorize )
{
QBrush colorBrush = QBrush(Qt::transparent); //no color for the current frame
if (nFrame < mFrameNumber)
{
colorBrush = QBrush(Qt::red);
}
else if (nFrame > mFrameNumber)
{
colorBrush = QBrush(Qt::blue);
}
tempBitmapImage->drawRect( bitmapImage->bounds(),
Qt::NoPen,
colorBrush,
QPainter::CompositionMode_SourceIn,
false);
}
// If the current frame on the current layer has a transformation, we apply it.
//
if (mRenderTransform && nFrame == mFrameNumber && layerId == mLayerIndex ) {
tempBitmapImage->clear(mSelection);
paintTransformedSelection(painter);
}
painter.setWorldMatrixEnabled( true );
if (mRenderTransform && nFrame) {
painter.setOpacity( bitmapLayer->getOpacity() );
}
tempBitmapImage->paintImage( painter );
delete tempBitmapImage;
}
void WaveformRenderMark::generateMarkImage(WaveformMark& mark) {
// Load the pixmap from file -- takes precedence over text.
if (mark.m_pixmapPath != "") {
QString path = mark.m_pixmapPath;
QImage image = QImage(path);
// If loading the image didn't fail, then we're done. Otherwise fall
// through and render a label.
if (!image.isNull()) {
mark.m_image = image.convertToFormat(QImage::Format_ARGB32_Premultiplied);
WImageStore::correctImageColors(&mark.m_image);
return;
}
}
QPainter painter;
int labelRectWidth = 0;
int labelRectHeight = 0;
// If no text is provided, leave m_markImage as a null image
if (!mark.m_text.isNull()) {
//QFont font("Bitstream Vera Sans");
//QFont font("Helvetica");
QFont font; // Uses the application default
font.setPointSize(10);
font.setStretch(100);
QFontMetrics metrics(font);
//fixed margin ...
QRect wordRect = metrics.tightBoundingRect(mark.m_text);
const int marginX = 1;
const int marginY = 1;
wordRect.moveTop(marginX + 1);
wordRect.moveLeft(marginY + 1);
wordRect.setWidth(wordRect.width() + (wordRect.width())%2);
//even wordrect to have an even Image >> draw the line in the middle !
labelRectWidth = wordRect.width() + 2*marginX + 4;
labelRectHeight = wordRect.height() + 2*marginY + 4 ;
QRectF labelRect(0, 0,
(float)labelRectWidth, (float)labelRectHeight);
mark.m_image = QImage(labelRectWidth+1,
m_waveformRenderer->getHeight(),
QImage::Format_ARGB32_Premultiplied);
if (mark.m_align == Qt::AlignBottom) {
labelRect.moveBottom(mark.m_image.height()-1);
}
// Fill with transparent pixels
mark.m_image.fill(QColor(0,0,0,0).rgba());
painter.begin(&mark.m_image);
painter.setRenderHint(QPainter::TextAntialiasing);
painter.setWorldMatrixEnabled(false);
//draw the label rect
QColor rectColor = mark.m_color;
rectColor.setAlpha(150);
painter.setPen(mark.m_color);
painter.setBrush(QBrush(rectColor));
painter.drawRoundedRect(labelRect, 2.0, 2.0);
//painter.drawRect(labelRect);
//draw text
painter.setBrush(QBrush(QColor(0,0,0,0)));
font.setWeight(75);
painter.setFont(font);
painter.setPen(mark.m_textColor);
painter.drawText(labelRect, Qt::AlignCenter, mark.m_text);
//draw line
QColor lineColor = mark.m_color;
lineColor.setAlpha(200);
painter.setPen(lineColor);
float middle = mark.m_image.width() / 2.0;
//Default line align top
float lineTop = labelRectHeight + 1;
float lineBottom = mark.m_image.height();
if (mark.m_align == Qt::AlignBottom) {
lineTop = 0.0;
lineBottom = mark.m_image.height() - labelRectHeight - 1;
}
painter.drawLine(middle, lineTop, middle, lineBottom);
//other lines to increase contrast
painter.setPen(QColor(0,0,0,120));
painter.drawLine(middle - 1, lineTop, middle - 1, lineBottom);
painter.drawLine(middle + 1, lineTop, middle + 1, lineBottom);
}
else //no text draw triangle
{
float triangleSize = 9.0;
mark.m_image = QImage(labelRectWidth+1,
m_waveformRenderer->getHeight(),
QImage::Format_ARGB32_Premultiplied);
mark.m_image.fill(QColor(0,0,0,0).rgba());
painter.begin(&mark.m_image);
painter.setRenderHint(QPainter::TextAntialiasing);
painter.setWorldMatrixEnabled(false);
QColor triangleColor = mark.m_color;
triangleColor.setAlpha(140);
painter.setPen(QColor(0,0,0,0));
painter.setBrush(QBrush(triangleColor));
//vRince: again don't ask about the +-0.1 0.5 ...
// just to make it nice in Qt ...
QPolygonF triangle;
triangle.append(QPointF(0.5,0));
triangle.append(QPointF(triangleSize+0.5,0));
triangle.append(QPointF(triangleSize*0.5 + 0.1, triangleSize*0.5));
painter.drawPolygon(triangle);
triangle.clear();
triangle.append(QPointF(0.0,mark.m_image.height()));
triangle.append(QPointF(triangleSize+0.5,mark.m_image.height()));
triangle.append(QPointF(triangleSize*0.5 + 0.1, mark.m_image.height() - triangleSize*0.5 - 2.1));
painter.drawPolygon(triangle);
//TODO vRince duplicated code make a method
//draw line
QColor lineColor = mark.m_color;
lineColor.setAlpha(140);
painter.setPen(lineColor);
float middle = mark.m_image.width() / 2.0;
float lineTop = triangleSize * 0.5 + 1;
float lineBottom = mark.m_image.height() - triangleSize * 0.5 - 1;
painter.drawLine(middle, lineTop, middle, lineBottom);
//other lines to increase contrast
painter.setPen(QColor(0,0,0,100));
painter.drawLine(middle - 1, lineTop, middle - 1, lineBottom);
painter.drawLine(middle + 1, lineTop, middle + 1, lineBottom);
}
}