Precisa de ajuda para otimizar um código de desenho…

Question

Eu precisava de ajuda para tentar otimizar essa parte do código...Basicamente, aqui está a coisa ..Estou fazendo esta 'caneta de caligrafia' que dá o efeito de caligrafia simplesmente desenhando muitas linhas inclinadas adjacentes...O problema é este:Quando atualizo a região de desenho usando update() após cada desenho de uma linha inclinada, a saída está correta, no sentido de que as atualizações são feitas em tempo hábil, para que tudo que foi 'desenhado' com a caneta seja imediatamente 'visto' o desenho..no entanto, porque um muito (100 delas) de atualizações foram feitas, o programa fica um pouco lento quando rodado no N900...

Quando tento fazer uma pequena otimização executando update após desenhar todos as linhas inclinadas (para que todas as linhas sejam atualizadas na prancheta através de um único update() ), a saída é ...chance ....Ou seja, logo após traçar as linhas, elas parecem quebradas (têm áreas vazias onde o desenho também deveria ter acontecido) ...entretanto, se eu acionar um redesenho da janela do formulário (digamos, alterando o tamanho do formulário), os patches quebrados serão corrigidos imediatamente!!Quando executo este programa no meu N900, ele obtém a saída inicial quebrada e fica assim, já que não sei como forçar um redesenho neste caso...

Aqui está o primeiro código e saída 'otimizados' (parcialmente correto/incorreto)

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

Imagem logo após rabiscar na tela:

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

Depois de reajustar o tamanho da janela, todos os links quebrados acima são corrigidos como deveriam.

Aqui está o segundo código não otimizado (sua saída está correta logo após o desenho, assim como na segunda imagem acima):

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

Alguém pode ver qual pode ser o problema?

Answer 1

Pelo que entendi, você deve encontrar o mínimo e o máximo de x e y processados ​​em seu loop for e usá-los em update(QRect(QPoint(minX-5, minY-5), QPoint(maxX+5, maxY+5)).normalized());

Answer 2

Desculpe se eu entendi mal, mas você já tentou usar a abordagem "buffer duplo"? Em vez de desenhar diretamente na tela, você "desenha" seus pontos e linhas para um buffer de memória. Depois disso, você apenas copia o buffer para a tela. Isso é mais rápido e evita a sacola.

Answer 3

Não sei exatamente qual é o seu problema com as linhas quebradas, mas posso oferecer esse conselho: mantenha sua caneta. Em vez disso:

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

fazem isto:

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

Ainda mais, se você estiver chamando repetidamente sua função de alerta com a mesma caneta todas as vezes, guarde a caneta em sua classe e mantenha -a por perto. Na minha empresa, descobrimos que reduzir bastante os tempos de desenho, onde podemos tirar proveito disso. (Uma instância em uma grande imagem cortada tempos de desenho ao meio.)

Uma outra nota: não tenho certeza de que tipo image Você está pintando é, mas estou assumindo que é uma Qimage. Quando você terminar de desenhar, se você usar a imagem não modificada repetidamente, poderá convertê -la uma vez em um QPIXMAP. A classe QPIXMAP é armazenada de uma maneira que deve estar pronta para explodir diretamente na tela (mas muito mais lenta para modificar em muitos casos, por causa disso).