QGraphicsView et QGraphicsItem: dont l'échelle de l'élément lors de la mise à l'échelle de la vue rect

Je suis en utilisant Qts QGraphicsView - et QGraphicsItem-les sous-classes.
est-il un moyen de ne pas l'échelle de la représentation graphique de l'élément dans la vue lorsque le cadrage est modifié, par exemple lors d'un zoom. Le comportement par défaut, c'est que mes articles échelle par rapport à mon point de vue rectangulaire.

Je voudrais visualiser en 2d des points qui devrait être représenté par un mince rectangle, ce qui ne devrait pas l'échelle lorsque vous effectuez un zoom dans la vue. Voir typique d'un logiciel de modélisation 3d de référence où les vertex points sont toujours affichés à la même taille.

Merci!

Également prendre un pic à doc.trolltech.com/4.5/qpen.html#setCosmetic si vous utilisez une peinture personnalisée de routine

OriginalL'auteur Lars Bilke | 2009-08-03

c++qgraphicsview qt transformation

10

Définir la QGraphicItem'drapeau QGraphicsItem::ItemIgnoresTransformations à vrai ne fonctionne pas pour vous?

En effet, s'assure de la taille de l'élément est correct, mais au moins dans mon cas, les positions sont éteints après la transformation. Par exemple, lorsque je dessine un polygone dans mon application, et ajouter un enfant rectangle éléments non mis à l'échelle (1:1) vue, j'obtiens le résultat suivant: grafit.mchtr.pw.edu.pl/~szczedar/nozoom.png . Après mise à l'échelle et avec l'indicateur est défini, il ressemble à ceci: grafit.mchtr.pw.edu.pl/~szczedar/zoomout.png
Les docs disent que l'élément avec le drapeau reste ancré à la société mère, mais j'ai créé l'objet rect avec le polygone en tant que parent et ça ne fonctionne pas. Essayé sous-jacents pixmap élément en tant que parent ainsi, pas de changement.

OriginalL'auteur Ariya Hidayat

Je suis dans le même problème, et il m'a fallu un certain temps pour comprendre. C'est comment je l'ai résolu.

Étendre un QGraphicsItem classe, remplacer paint().
À l'intérieur de la peinture (le), la réinitialisation de la transformation du facteur d'échelle de 1(m11 et m22), et enregistrer la m11(x facteur d'échelle) et m22(y facteur d'échelle) avant la réinitialisation.
Ensuite, dessinez comme vous le feriez normalement, mais de multiplier vos x avec m11 et y avec m22. Cela évite de dessin avec la valeur par défaut de la transformation, mais explicitement calcule les positions en fonction de la scène de la transformation.

void MyItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *item, QWidget *widget)
{
    QTransform t = painter->transform();
    qreal m11 = t.m11(), m22 = t.m22();
    painter->save(); //save painter state
    painter->setTransform(QTransform(m11, t.m12(), t.m13(),
                                     t.m21(), 1, t.m23(), t.m31(),
                                     t.m32(), t.m33()));
    int x = 0, y = 0; //item's coordinates
    painter->drawText(x*m11, y*m22, "Text"); //the text itself will not be scaled, but when the scene is transformed, this text will still anchor correctly
    painter->restore(); //restore painter state
}

Le bloc de code suivant est dessin par défaut transformation

void MyItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *item, QWidget *widget)
{
    int x = 0, y = 0;
    painter->drawText(x, y, "Text"); 
}

Vous pouvez essayer les deux pour voir la différence. Espérons que cette aide.

OriginalL'auteur JLin

Comment à ce sujet:

#include <QtGui/QApplication>
#include <QtGui/QGraphicsScene>
#include <QtGui/QGraphicsView>
#include <QtGui/QGraphicsRectItem>

int main(int argc, char* argv[]) {
    QApplication app(argc, argv);
    QGraphicsScene scene;
    scene.addText("Hello, world!");
    QRect rect(50, 50, 100, 100);
    QGraphicsRectItem* recti = scene.addRect(rect);
    QGraphicsView view(&scene);

    //Set scale for the view
    view.scale(10.0, 5.0);

    //Set the inverse transformation for the item
    recti->setTransform(view.transform().inverted());

    view.show();
    return app.exec();
}

Comme vous pouvez le voir, le texte est mis à l'échelle, mais le rectangle n'est pas. Notez que ce n'est pas seulement d'empêcher la mise à l'échelle pour le rectangle et d'autres de la transformation.

OriginalL'auteur stribika

1

J'ai trouvé que si je tire une nouvelle classe et reimpliment la fonction de dessin que je peux faire
```
void MyDerivedQGraphicsItem::paint(QPainter *painter, 
                                   const QStyleOptionGraphicsItem *option, 
                                   QWidget *widget)
{
  double scaleValue = scale();
  double scaleX = painter->transform().m11();
  setScale(scaleValue / scaleX);
  QGraphicsSvgItem::paint(painter,option,widget);
}
```
C'est la meilleure façon de le faire que j'ai trouvé jusqu'à présent, mais je suis encore bricoler.

Hm. Cela n'a pas fonctionné pour moi (dans mon cas, je suis sous-classement QGraphicsEllipseItem). L'élément devient encore plus grande lorsque je zoom de la vue. Avez-vous quelque chose en plus de ce qui précède?
Bah désolé, il a effectivement fait le travail. Mais je serais intéressé si vous avez trouvé une autre manière? Parce que quand je zoom de la vue rapide (à l'aide de la molette de défilement) je peut remarquer un certain scintillement :/
Désolé, aucun, je suis toujours avoir des problèmes avec elle, mais il a été abandonné.
setScale scedules un renouvellement de l'élément, donc je suppose que votre code peut conduire à une boucle infinie. Et le peintre->transform().m11() donne l'échelle si et seulement si pas de rotation est appliquée à l'élément.

OriginalL'auteur enriched

La solution suivante a parfaitement fonctionné pour moi:

void MyDerivedQGraphicsItem::paint(QPainter *painter, const StyleOptionGraphicsItem *option, QWidget *widget)
{
    double scaleValue = scale()/painter->transform().m11();
    painter->save();
    painter->scale(scaleValue, scaleValue);
    painter->drawText(...);
    painter->restore();
    ...
}

On peut aussi multiplier les scaleValue par d'autres mesures, nous voulons garder sa taille constante à l'extérieur de la sauvegarde/restauration de l'environnement.

    QPointF ref(500, 500);
    QPointF vector = scaleValue * QPointF(100, 100);
    painter->drawLine(ref+vector, ref-vector);

OriginalL'auteur Adriel Jr

Vous devez vous connecter pour publier un commentaire.