QGraphicsView und QGraphicsItem: DO NOT Skala Punkt beim Skalieren der Ansicht rect

Question

Ich bin mit Qt's QGraphicsView - und QGraphicsItem-Subklassen. gibt es eine Möglichkeit ist die grafische Darstellung des Punktes in der Ansicht, wenn die Ansicht Rechteck verändert nicht maßstäblich, z.B. beim Zoomen. Das Standardverhalten ist, dass meine Artikel in Bezug auf meine Ansicht Rechteck skalieren.

Ich mag 2d Punkte sichtbar zu machen, die durch ein dünnes Rechteck dargestellt werden soll, die nicht maßstab sollten, wenn in der Ansicht zoomen. Hier finden Sie eine typische 3D-Modellierungssoftware für Referenz wo Scheitelpunkte sind immer in der gleichen Größe angezeigt.

Danke!

Answer 1

Setzen Sie das Kennzeichen QGraphicItem des QGraphicsItem::ItemIgnoresTransformations auf true für Sie funktioniert nicht?

Answer 2

Ich habe in das gleiche Problem, und es dauerte eine Weile, um es herauszufinden. Dies ist, wie ich es gelöst.

Erweitern einer QGraphicsItem Klasse, außer Kraft setzen paint (). Innerhalb der paint (), setzen Sie den Skalierungsfaktor der Transformation bis 1 (die m11 und m22 sind), und die m11 speichern (x Skalierungsfaktor) und m22 (y Skalierungsfaktor) vor dem Reset. Dann ziehen wie Sie es normalerweise tun würde, aber Ihre x mit m11 und y mit m22 multiplizieren. Dadurch wird vermieden, mit der Standard-Transformation zeichnen, sondern berechnet explizit die Positionen nach der Transformation der Szene.

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
}

Der folgende Code-Block wird mit Standard Transformation Zeichnung

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

Sie können beide versuchen, den Unterschied zu sehen. Hoffe das hilft.

Answer 3

Wie wäre es damit:

#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();
}

Wie Sie den Text zu sehen ist verkalkt, aber das Rechteck nicht. Beachten Sie, dass dies nicht nur die Skalierung für das Rechteck verhindern, sondern und andere Transformation.

Answer 4

fand ich, dass, wenn ich eine neue Klasse ableiten und reimpliment die Farbe Funktion, die ich tun kann,

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

Dies ist der beste Weg, es zu tun, die ich bisher gefunden habe, aber ich bin bastle immer noch rund.

Answer 5

Die folgende Lösung funktionierte perfekt für mich:

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();
    ...
}

Wir können auch die scalevalue von anderen mesures multiplizieren wir seine Größe konstant außerhalb des Speichern / Wiederherstellen der Umgebung beibehalten möchten.

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