ayuda para la optimización de un código de dibujo ...

Question

Yo necesitaba un poco de ayuda para tratar de optimizar esta porción de código ... Básicamente esta es la cosa .. Estoy haciendo esto 'lápiz de caligrafía' que da el efecto de la caligrafía simplemente dibujando una gran cantidad de líneas inclinadas adyacentes ... El problema es el siguiente: Cuando actualizo la región sorteo mediante la actualización () después de cada sorteo de una línea inclinada, la salida es correcta, en el sentido de que las actualizaciones se realizan de manera oportuna, para que todo 'dibujado' usando la pluma es inmediatamente 'visto' el dibujo .. Sin embargo, debido a un lot (100s de ellos) de las actualizaciones se llevan a cabo, el programa se ralentiza un poco cuando se ejecuta en el N900 ...

Cuando intento hacer un poco de optimización mediante la ejecución de actualización después de dibujo todos las líneas inclinadas (de modo que todas las líneas se actualizan en la mesa de dibujo a través de una sola actualización ()), la salida es. .. extraño .... es decir, inmediatamente después de dibujar las líneas, líneas que parecen roto (tienen parches vacantes en el dibujo debería haber ocurrido así ...) Sin embargo, si desencadenar un nuevo trazado de la ventana del formulario (por ejemplo , cambiando el tamaño de la forma), los parches rotos se fijan inmediatamente !! Cuando ejecuto este programa en mi N900, se pone la salida rota inicial y estancias así, ya que no sé cómo hacer cumplir un redibujado en este caso ...

Aquí es el primer código 'optimizado' y de salida (parcialmente correcta / incorrecta)

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

imagen justo después de hacer garabatos en la pantalla:

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

Después de volver a ajustar el tamaño de la ventana, todos los enlaces rotos anterior se fijan como deben ser ..

Aquí está el segundo código un-optimizado (su salida es correcta justo después de dibujo, al igual que en la segunda imagen de arriba):

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

Puede alguien ver lo que podría ser el problema?

Answer 1

Según entiendo que debe encontrar mínimo y máximo de x e y procesados ??en su ciclo for y utilizarlos en update(QRect(QPoint(minX-5, minY-5), QPoint(maxX+5, maxY+5)).normalized());

Answer 2

Lo siento si he entendido bien, pero has de utilizar el enfoque de "doble buffer"? En vez de dibujar directamente en la pantalla, que "dibujar" sus puntos y líneas para un búfer de memoria. Después de eso, sólo tienes que copiar el búfer de la pantalla. Esto es más rápido y evita el parpadeo.

Answer 3

No estoy seguro exactamente lo que su problema es con las líneas quebradas, pero puede ofrecer este consejo: mantener su pluma alrededor. En lugar de esto:

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

hacer esto:

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

Aún más, si está llamando repetidamente su función drawLineTo con la misma pluma cada vez, guarde la pluma en su clase y mantener a su alrededor. En mi empresa, hemos encontrado que para reducir considerablemente los tiempos de dibujo en el que podemos sacar provecho de ella. (Una instancia de un gran corte imagen veces dibujo en medio.)

Otra nota: No estoy seguro de qué tipo es el image se está pintando es, pero estoy suponiendo que se trata de un QImage. Cuando esté Dibujo hecho, si usted va a utilizar la imagen modificada en varias ocasiones, es posible convertir una vez a un QPixmap. La clase QPixmap se almacena de una manera que se supone que debe estar listo para blitting directamente a la pantalla (pero mucho más lento a modificar en muchos casos, a causa de eso).