Discussion :

[May01]

bonsoir,
J'utilise Qt/C++ pour créer une application qui doit fonctionner comme suit :

Je crée un container Qt avec des régions qui contiennent des graphiques en 2D.
ces graphiques correspondent à des coordonnées telles que (temps, valeur) et peuvent être agrandies avec une méthode de zoom écrite en C++.
le problème c'est que la méthode de zoomprésente un seuil, du coup si le niveau de zoom actuel est inférieur à ce seuil, nous utiliserons alors les coordonnées (temps 1, valeur1) pour dessiner un certain graphique sinon il sera dessiné avec d'autres, (time2, valeur2 ) par exemple.

Y at-il un moyen d'y parvenir?
Merci d'avance !

[koala01]

Salut,

Vu que tu travailles avec Qt, tu peux te contenter de faire travailler la classe QGraphicsView pour toi.

Elle présente en effet des fonctions membres scale(qreal sx, qreal sy) qui permet de définir les échelles horizontale et verticale à appliquer et
scale(qreal sx, qreal sy) .

Le truc, c'est qu'il n'y a pas moyen de définir une limite pour l'échelle appliquée. Il va donc falloir que tu rajoutes cette possibilité à une classe personnelle qui hérite de QGraphicsView.

La première chose à faire, c'est de définir la classe en question. Elle pourrait prendre la forme de

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
class LimitedScaleView : public QGraphicsView{
    public:
        LimitedScaleView(qreal limit = 1.0, QWidget * parent = 0):QGraphicsView(parent),
            multiplier_(limit), limit_(limit){
            scale(multiplier_,multiplier_);
        }
        qreal scaleLimit() const{return limit_;}
        /* j'aime pas fort l'idée de placer un mutateur, mais cela risque d'être
         * utile ;)
         */
        void setLimit(qreal newLimit){limit_ = newLimit;}
    private:
        /* le "niveau" de zoom actuel */
        qreal multiplier_;
        /* la limite à ne pas dépasser */
        qreal limit_;
};

Avec ce code, tu obtiens plusieurs choses :

1. la limite à ne pas dépasser est définie
2. la vue est automatiquement mise à l'échelle limite
3. tu peut à tout moment savoir quel est le rapport appliqué à la vue (du moins, dans toutes les fonctions membres de la classe LimitedScaleView)
4. tu peux interroger la vue pour savoir quelle est sa limite et, au besoin, modifier cette limite

Avoues c'est pas mal pour 17 lignes de code, hein

Tu pourras déjà créer cette vue sous une forme proche de

Code :

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

LimitedScaleView * myFirstView = new LimitedScaleView(); // utilise la limite à 1.0 et défini le zoom à 1.0 par défaut

ou de

Code :

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

LimitedScaleView * myFirstView = new LimitedScaleView(2.0);//fixe la limite à 2.0 et définis le zoom à 2.0

Il n'y a plus qu'à faire en sorte que le zoom s'effectue dans une situation particulière (qu'il t'appartient de définir).

Une situation régulièrement choisie est de faire augmenter / diminuer le niveau de zoom avec la molette centrale.

Pour ce faire, tu peux définir la réaction de ta vue en modifiant le comportement de la fonction membre wheelEvent(QWheelEvent * event)On va donc modifier la définition de la classe LimitedScaleView afin de prévenir le compilateur que l'on s'apprête à redéfinir cette fonction sous la forme de

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
class LimitedScaleView : public QGraphicsView{
    public:
        LimitedScaleView(qreal limit = 1.0, QWidget * parent = 0):QGraphicsView(parent),
            multiplier_(limit), limit_(limit){
            scale(multiplier_,multiplier_);
        }
        qreal scaleLimit() const{return limit_;}
        /* j'aime pas fort l'idée de placer un mutateur, mais cela risque d'être
         * utile ;)
         */
        void setLimit(qreal newLimit){limit_ = newLimit;}
        void wheelEvent(QWheelEvent * event);
    private:
        /* le "niveau" de zoom actuel */
        qreal multiplier_;
        /* la limite à ne pas dépasser */
        qreal limit_;
};

Et on implémente cette fonction sous la forme de

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
void LimitedScaleView::wheelEvent(QWheelEvent * event){
    // calculs typiques (voir la doc Qt)
    const int degrees = event->delta() / 8;
    int steps = degrees / 15;
    double factor = 1.0; //on modifie à chaque fois le facteur par 1 (valeur à adapter à tes besoins)
    if(steps > 0)
    {
        /* si c'est le zoom avant, on augmente la valeur */
        multiplier_+=factor;
    }
    else
    {
         /* si c'est le zoom arrière, on diminue la valeur */
        multiplier_-=factor;
    }
    /* on force le multiplier à respecter la limite imposée*/
    multiplier_ = (multiplier_< limit_? limit : multplier);
    /* détermine la position de la vue dans la scene pendant les modification (ici,
     * elle est déterminée par la position de la souris)
     */
    setTransformationAnchor((QGraphicsView::AnchorUnderMouse);
    /* applique les les transformations (le zoom) */
   setTransform(QTransform(0, multiplier, 0, multiplier, 0, 0));
}

Par la suite, on peut envisager de placer une limite haute, de faire varier le zoom horizontal à une allure différente du zoom vertical, ou plein de choses vachement sympa...

Mais tu as ici une implémentation rapide de ce que tu cherches à faire

[May01]

Merci !