Besoin d'aide dans l'optimisation d'un code de dessin ...

Question

Je avais besoin d'aide pour essayer d'optimiser cette partie de code ... Au fond est ici la chose .. Je fais ce « stylo de calligraphie » qui donne l'effet de la calligraphie en dessinant simplement un grand nombre de lignes obliques adjacentes ... La problème est le suivant: Lorsque je mets à jour la région du tirage en utilisant la mise à jour () après chaque tirage d'une ligne oblique, la sortie est correcte, en ce sens que les mises à jour sont effectuées en temps opportun, de sorte que tout « dessiné » à l'aide du stylo est immédiatement « vu » le dessin .. cependant, parce que beaucoup (100s d'entre eux) des mises à jour sont faites, les slows du programme vers le bas un peu quand courrez sur le N900 ...

Lorsque je tente de faire une petite optimisation en cours d'exécution mise à jour après le dessin tous les lignes obliques (de sorte que toutes les lignes sont mises à jour sur la planche à dessin par le biais d'une mise à jour unique ()), la sortie est. .. bizarre .... C'est, immédiatement après avoir dessiné les lignes, ils semblent les lignes brisées (ils ont des taches vides où le dessin aurait dû se produire aussi bien) ... mais, si je déclenche un redécoupage de la fenêtre de formulaire (par exemple , en changeant la taille de la forme), les plaques brisées sont immédiatement fixés !! Quand je lance ce programme sur mon N900, il obtient la sortie cassée initiale et reste comme ça, puisque je ne sais pas comment appliquer un nouveau tracé dans ce cas ...

Voici le premier 'optimisé' code et de sortie (partiellement correct / incorrect)

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;
}

Image à droite après griffonner sur l'écran:

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

Après le réajustement de la taille de la fenêtre, tous les liens brisés ci-dessus sont fixés comme ils devraient être ..

Voici le second code non optimisé (sa sortie est juste correct après étirage, comme dans la deuxième image ci-dessus):

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;
}

Quelqu'un peut-il voir ce que la question pourrait être?

Answer 1

Si je comprends bien, vous devriez trouver min et max de x et y traitées dans votre boucle for et les utiliser dans update(QRect(QPoint(minX-5, minY-5), QPoint(maxX+5, maxY+5)).normalized());

Answer 2

approche

Désolé si je mal compris, mais avez-vous essayé d'utiliser le « double tampon »? Au lieu de dessiner directement sur l'écran, vous « dessiner » des points et des lignes à un tampon de mémoire. Après cela, vous copiez simplement le tampon à l'écran. Ceci est plus rapide et évite vacillante.

Answer 3

Je ne sais pas exactement ce que votre problème est avec les lignes brisées, mais je peux vous offrir ce conseil: garder votre stylo autour. Au lieu de cela:

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

faire ceci:

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**
    // ...
}

Encore plus, si vous appelez à plusieurs reprises votre fonction drawLineTo avec le même stylo chaque fois, placez le stylet dans votre classe et le garder autour. Lors de mon entreprise, nous avons constaté que de réduire considérablement les temps de dessin où l'on peut en tirer profit. (Un exemple sur un grand temps de dessin d'image coupe en deux.)

Une autre note: Je ne suis pas sûr du type de la image vous peignez est, mais je suppose que c'est un QImage. Lorsque vous êtes dessin fait, si vous utilisez l'image non modifiée à plusieurs reprises, vous pouvez convertir une fois à un QPixmap. La classe QPixmap est stocké d'une manière qui est censé être prêt pour blitting directement à l'écran (mais beaucoup plus lent à modifier dans de nombreux cas, à cause de cela).