Hai bisogno di aiuto per l'ottimizzazione di un codice di disegno ...

Question

avevo bisogno di un certo aiuto nel cercare di ottimizzare questa porzione di codice ... Fondamentalmente qui è la cosa .. Sto facendo questo 'penna stilografica', che dà l'effetto calligrafia semplicemente disegnando un sacco di linee oblique adiacenti ... La problema è questo: quando aggiorno la regione pareggio usando update () dopo ogni singola estrazione di una linea obliqua, l'output è corretto, nel senso che gli aggiornamenti sono fatte in modo tempestivo, in modo che tutto 'disegnato' usando la penna è subito 'visto' il disegno .. comunque, perché un lotto (100s di loro) di aggiornamenti sono fatto, il programma rallenta un po 'quando corsa sul N900 ...

Quando provo a fare un po ottimizzazione eseguendo aggiornamento dopo disegno tutti le linee inclinate (in modo che tutte le linee sono aggiornate sul tavolo da disegno attraverso un singolo aggiornamento ()), l'uscita è. .. strano .... Cioè, subito dopo aver disegnato le linee, sono le linee sembrano rotti (hanno patch vacanti dove il disegno dovrebbe essere accaduto così) ... però, se mi innescare un ridisegno della finestra di modulo (ad esempio , modificando la dimensione della forma), i cerotti rotti vengono immediatamente fissati !! Quando ho eseguito questo programma sul mio N900, ottiene l'uscita rotta iniziale e soggiorni del genere, dal momento che io non so come applicare un ridisegno in questo caso ...

Ecco il primo codice 'ottimizzato' ed uscita (parzialmente corretto / errato)

void Canvas::drawLineTo(const QPoint &endPoint)
{
QPainter painter(&image);
painter.setPen(QPen(Qt::black,1,Qt::SolidLine,Qt::RoundCap,Qt::RoundJoin));
int fx=0,fy=0,k=0;
qPoints.clear();
connectingPointsCalculator2(qPoints,lastPoint.x(),lastPoint.y(),endPoint.x(),endPoint.y());
int i=0;
int x,y;
for(i=0;i<qPoints.size();i++)
{
x=qPoints.at(i).x();
y=qPoints.at(i).y();
painter.setPen(Qt::black);
painter.drawLine(x-5,y-5,x+5,y+5); **// Drawing slanted lines**
}
**//Updating only once after many draws:**
update (QRect(QPoint(lastPoint.x()-5,lastPoint.y()-5), QPoint(endPoint.x()+5,endPoint.y()+5)).normalized());

modified = true;
lastPoint = endPoint;
}

Immagine subito dopo scarabocchiare sullo schermo:

http://img823.imageshack.us/img823/8755/59943912.png

Dopo aver ri-regolare la dimensione della finestra, tutti i collegamenti interrotti sopra sono fissati come dovrebbero essere ..

Ecco il secondo codice non-ottimizzato (la sua uscita è corretto subito dopo il disegno, proprio come nella seconda foto in alto):

void Canvas::drawLineTo(const QPoint &endPoint)
{
QPainter painter(&image);
painter.setPen(QPen(Qt::black,1,Qt::SolidLine,Qt::RoundCap,Qt::RoundJoin));
int fx=0,fy=0,k=0;
qPoints.clear();
connectingPointsCalculator2(qPoints,lastPoint.x(),lastPoint.y(),endPoint.x(),endPoint.y());
int i=0;
int x,y;
for(i=0;i<qPoints.size();i++)
{
x=qPoints.at(i).x();
y=qPoints.at(i).y();
painter.setPen(Qt::black);
painter.drawLine(x-5,y-5,x+5,y+5); **// Drawing slanted lines**
**//Updating repeatedly during the for loop:**
update(QRect(QPoint(x-5,y-5), QPoint(x+5,y+5)).normalized());//.adjusted(-rad,-rad,rad,rad));
}
modified = true;
int rad = (myPenWidth / 2) + 2;
lastPoint = endPoint;
}

Qualcuno può vedere ciò che il problema potrebbe essere?

Answer 1

A quanto ho capito si dovrebbe trovare min e max di x e y elaborati nella for-loop e utilizzarli in update(QRect(QPoint(minX-5, minY-5), QPoint(maxX+5, maxY+5)).normalized());

Answer 2

Scusate se ho capito male, ma hai provato a utilizzare l'approccio "doppio buffer"? Invece di disegnare direttamente sullo schermo, è "disegnare" i punti e le linee per un buffer di memoria. Dopo di che, basta copiare il buffer sullo schermo. Questo è più veloce ed evita tremolante.

Answer 3

Non sono sicuro esattamente che cosa il vostro problema è con le linee spezzate, ma posso offrirvi questo consiglio: tenere la penna in giro. Invece di questo:

for(i=0;i<qPoints.size();i++)
{
    // ...
    painter.setPen(Qt::black);
    painter.drawLine(x-5,y-5,x+5,y+5); **// Drawing slanted lines**
    // ...
}

fare questo:

QPen black_pen(Qt::black);
for(i=0;i<qPoints.size();i++)
{
    // ...
    painter.setPen(black_pen);
    painter.drawLine(x-5,y-5,x+5,y+5); **// Drawing slanted lines**
    // ...
}

Ancora di più, se si è più volte chiamando la funzione drawLineTo con la stessa penna ogni volta, conservare la penna nella tua classe e tenerlo intorno. Alla mia azienda, abbiamo scoperto che per ridurre notevolmente i tempi di disegno in cui possiamo prendere vantaggio. (Un esempio su un grande taglio un'immagine volte disegno a metà.)

Un'altra nota: Non sono sicuro di che tipo la image si sta disegnando è, ma sto supponendo che è un QImage. Quando si è disegno fatto, se si prevede di utilizzare l'immagine non modificata più volte, si potrebbe convertire una volta per un QPixmap. La classe QPixmap viene memorizzato in un modo che dovrebbe essere pronto per copiarlo sul video direttamente sullo schermo (ma è molto più lento di modificare, in molti casi, a causa di questo).