Discussion :

[loupium]

Bonjour à tous,

Je refléchis au passage à Qt5 mais certains points me posent problèmes comme le rendu OpenGL.
A mes début sur Qt Quick 1, j'avais choisi le rendu soft plutôt qu'OpenGL.
Mais maintenant avec Qt Quick 2, OpenGL devient un passage obligé.
Malheureusement il y a une dégradation du rendu.

Pour du texte, on peut encore forcer le rendu soft avec "renderType: Text.NativeRendering".
Observer la différence de rendu avec cet exemple ci-dessous :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
import QtQuick 2.0
 
Rectangle {
	width: 1200
    height: 1000
    //  scale: 4
    Row {
        anchors.centerIn: parent
        spacing: 20
        Column {
            Repeater {
                model: 56
                Text {
                    text: qsTr("But while the distance fields have many advantages,  ") + (8.0 + index/10)
                    font.family: "Arial"
					font.pointSize: 8.0 + index/10
                }
            }
        }
        Column {
            Repeater {
                model: 56
                Text {
                    text: qsTr("But while the distance fields have many advantages,  ") + (8.0 + index/10)
                    font.family: "Arial"
                    font.pointSize: 8.0 + index/10
					renderType: Text.NativeRendering
					//antialiasing: true
                }
            }
        }
		Column {
			spacing: 30
			Rectangle {
				x: 25; y: 25
				width: 50; height: 50
				border.width: 1
 
				Text {
					anchors.centerIn: parent
					text: "Box"
				}
			}
			Rectangle {
				x: 25; y: 25
				width: 50; height: 50
				border.width: 1
				antialiasing: true
 
				Text {
					anchors.centerIn: parent
					text: "Box"
				}
			}
			Rectangle {
				x: 25; y: 25
				width: 50; height: 50
				border.width: 1
				smooth: true
 
				Text {
					anchors.centerIn: parent
					text: "Box"
				}
			}
			Rectangle {
				x: 25; y: 25
				width: 50; height: 50
				border.width: 1
				antialiasing: true
				smooth: true
 
				Text {
					anchors.centerIn: parent
					text: "Box"
				}
			}
			Rectangle {
				x: 25; y: 25
				width: 50; height: 50
				rotation: 45
				border.width: 1
 
				Text {
					anchors.centerIn: parent
					text: "Box"
				}
			}
			Rectangle {
				x: 25; y: 25
				width: 50; height: 50
				rotation: 45
				border.width: 1
				antialiasing: true
 
				Text {
					anchors.centerIn: parent
					text: "Box"
				}
			}
			Rectangle {
				x: 25; y: 25
				width: 50; height: 50
				rotation: 45
				border.width: 1
				smooth: true
 
				Text {
					anchors.centerIn: parent
					text: "Box"
				}
			}
			Rectangle {
				x: 25; y: 25
				width: 50; height: 50
				rotation: 45
				border.width: 1
				antialiasing: true
				smooth: true
 
				Text {
					anchors.centerIn: parent
					text: "Box"
				}
			}
		}
    }
}

Je trouve le rendu OpenGL est plus homogène mais le rendu soft me semble plus nette surtout pour les petits caractères.

Pour le reste comme un rectangle par exemple, on peut utiliser "antialiasing: true".
Le rendu du rectangle diffère avec Qt4 mais le problème me semble moins important et moins génant.

Est-il possible d'améliorer le rendu du texte ?
J'ai le souvenir d'avoir lu qu'on pouvait augmenter la résolution du rendu OpenGL mais je n'arrive pas à remettre la main dessus.
Cette augmentation est-elle possible ? Si oui, est-elle efficace ?

Merci

Environnement : Windows 7 64b, Qt 5.0.1 Mingw

[gbdivers]

Salut

J'ai du mal à comprendre ton soucis. Tu arrives bien à désactiver le rendu pour obtenir le resultat souhaité. Et OpenGL n'est pas un passage obligatoire.

Si tu veux augmenter la taille de la zone de rendu, tu peux peut utiliser la fonction QQuickWindow::setRenderTarget pour créer un FBO à la taille souhaitée. Par contre, comme je sais pas quel résultat tu attends de différent par rapport à ce que tu as déjà, je peux pas dire si c'est efficace

Bon courage

[loupium]

Merci pour ta reponse.

OpenGL n'est pas un passage obligatoire, mais il est maintenant plus approprié grâce à Qt Quick Scene Graph.
D'ailleurs l'exemple pour Qt4 était basé sur QPainter http://qt-project.org/doc/qt-4.8/qml...ial-index.html alors que pour Qt5 il est basé sur QSGGeometry http://qt-project.org/doc/qt-5.0/qtq...mgeometry.html
Il serait donc dommage de ne pas profiter de l'OpenGL, surtout pour des personnes comme moi qui ont besoin de tracer des courbes de plusieurs milliers de points par secondes.
Et je trouve tout aussi dommage de devoir repasser sur un rendu soft pour du texte de petites tailles.

Pour le test de QQuickWindow::setRenderTarget, j'ai encore besoin de digérer les changements de Qt5, mais c'est une piste à tester.

[gbdivers]

J'ai l'impression qu'il y a confusion sur certains points.

Pour OpenGL, il y a plusieurs choses :
* le rendu de la scène
* la génération d'un pixmap d'un caractère (glyphe) à partir d'une police de caractères

Dans tous les cas, le second point n'est pas réalisé sur le GPU. Je me souviens plus des détails de la génération (il y a des articles traduis dessus de mémoire), mais il me semble que l'on dessine les caractères dans une texture (soft pour NativeRendering et SIMD pour QtRendering), la texture est mise en cache (dans la mémoire GPU ?) puis OpenGL l'utilise pour afficher le texte.

Le rendu des courbes correspond au premier point

Donc dans tous les cas, le mode de rendu du texte et l'utilisation d'OpenGL pour dessiner les courbes est indépendant (tu te doutes bien que tu vas pas désactiver le rendu d'une scène dans OpenGL simplement en changement une option dans un élément Text ; il faut changer les paramètres de QQuickWindow).

Sinon, dans l'absolue, "plusieurs milliers de points par secondes", c'est rien du tout Tu prend même un simple téléphone portable qui affiche des images 2D, tu as plusieurs milliers de points par seconde

J'ai déjà eu un problème similaire (affichage d'un nombre de points important, plus de 80k par courbes, 200 courbes). L'utilisation des Qt Polygones était correct, mais j'ai rapidement eu des problèmes de performances.
La raison est que pour ce type de problématique, le ratio "temps de calcul / temps de transfert de données" est très mauvais : les calculs sont très simple (un simple changement de repère) alors que le transfert de données est important.

J'ai utilisé un algo simple pour éliminer un nombre de points important avant l'envoi des données au GPU. L'idée est simplement que lorsque tu as plusieurs millions de points à afficher, cela veut dire que tu as plusieurs points par pixels. En réduisant les points à un point par pixel au maximum, tu gagnes du temps sur le transfert des données au GPU.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
in -> tableau de points 2D trié
out -> tableau de points 2D
resize(out, largeur windows * 2) // 2 points par abscisse, pour min et max
 
col = 0 // colonne
min = +inf
max = -inf
Pour (chaque points de in) {
    (x,y) = transform (point) // récupère les coordonnées du point
    si (x > col) { 
        out.push_back (col, min)
        out.push_back (col, max)
        col = x
        min = +inf
        max = -inf
    } 
    si (y > max) { max = y }
    si (y < min) { min = y }
}

Le mieux est alors de créer sa propre classe QML en C++ dédiée. Tu peux même probablement optimiser en utiliser le SSE, mais pas j'ai pas testé

[loupium]

J'ai évoqué le rendu des courbes seulement pour souligner l'orientation OpenGL des nouvelles versions de Qt.

J'ai aussi relu l'article "Text Rendering in the QML Scene Graph" (http://blog.qt.digia.com/blog/2011/0...l-scene-graph/)
et notamment les commentaires qui relevaient ce problème de rendu sur les textes de petites tailles. L'article date de l'été 2011 et il ne semblait pas avoir de solution. Presque 2 ans après, j'aurai pensé que le problème était résolu. D'où l'ouverture de cette discussion.

En ce qui concerne les courbes, mes ordres de grandeur sont 20 courbes avec jusqu'à 8k de points par courbes. Et du point de vue dynamique, c'est 2k de points renouvelés par secondes et par courbe. Et le tout doit visuellement rester fluide (au moins 25 rafraichissements par secondes).
A l'époque sur QML1, j'utilisais aussi Qt Polygones et j'ai aussi eu rapidement des problèmes de performances.
Pour l'optimisation, j'avais opté comme stratégie de réduire au minimum les surfaces du graphe à redessiner. Une stratégie qui convient bien pour des courbe non dynamique ( courbe de donnée par rapport au temps par exemple). Il a donc fallu jongler entre une bonne configuration du QGraphicsView (QGraphicsView::SmartViewportUpdate par ex), l'utilisation du cache (QGraphicsItem::ItemCoordinateCache), la sélection précise des zone à redessiner et l'utilisation des translations du QPainter.
J'avais aussi pensé à la décimation mais l'optimisation précédente suffisait donc je n'ai pas été plus loin.
D'ailleurs, je me demandais si une décimation n'était pas déjà réalisée par Qt mais d'après ton expérience, il semblerait que non.

"(affichage d'un nombre de points importants, plus de 80k par courbes, 200 courbes)"
C'est assez impressionnant. Ce sont des courbes dynamiques ? Quelle est la quantité de points rafraichit par secondes ?