Gleiche Funktion mit verschiedenem Interface liefert unterschiedliche Ergebnisse



  • Hi,

    Ich habe hier zwei Funktionen die an sich gleich sind nur ein unterschiedliches Interface haben

    Variante 1:

    void Ploter::plot_line(std::shared_ptr<QwtPlotCurve>&myLine, std::vector<punkt<double>> &points, ploting_range &std, bool show, QPen pen)
    {
    	QwtSplineCurveFitter *fitter = new QwtSplineCurveFitter();
    	fitter->setFitMode(QwtSplineCurveFitter::Spline);
    	fitter->setSplineSize(points.size());
    	QVector<double> x, y;
    	for (size_t i = 0; i < points.size(); i++) {
    		x.push_back(points.at(i).get_x());
    		y.push_back(points.at(i).get_y());
    	}
    
    	myLine->setSamples(x, y);
    	myLine->setCurveFitter(fitter);
    
    	draw_spline(myLine, pen, show);
    }
    

    Variante 2:

    void Ploter::plot_line(std::shared_ptr<QwtPlotCurve>&myLine, funktion &q ,ploting_range &std, bool show, QPen pen )
    {
    std::vector<punkt<double>>fkt_werte = q.werte(std.von, std.bis, std.schrittweite);
    	QwtSplineCurveFitter *fitter = new QwtSplineCurveFitter();
    	fitter->setFitMode(QwtSplineCurveFitter::Spline);
    	fitter->setSplineSize(fkt_werte.size());
    	QVector<double> x, y;
    	for (size_t i = 0; i < fkt_werte.size(); i++) {
    		x.push_back(fkt_werte.at(i).get_x());
    		y.push_back(fkt_werte.at(i).get_y());
    	}
    
    	myLine->setSamples(x, y);
    	myLine->setCurveFitter(fitter);
    
    	draw_spline(myLine, pen, show);
    }
    

    Beide Funktionen machen das gleiche. Der Unterschied besteht nur darin das Variante 1 ein vector mit Punkten übergeben wird und Variante 2 eine Funtkion um sich die Punkte selbst zu errechnen.
    Es wird dabei eine QwtPlotCurve mit Werten gefüttert. Die QwtPlotCurve wird durch den Aufrufer erstellt und als shared_ptr übergeben.
    Die draw_spline - Methode ist nur dazu da die QwtPlotCurve in einem QwtPlot zu zeichen.

    void Ploter::draw_spline(std::shared_ptr<QwtPlotCurve>&myLine,QPen pen, bool show) {
    	myLine->setPen(pen);
    	myLine->attach(plot);
    	myLine->setVisible(show);
    	plot->replot();
    }
    

    Die Klasse "Plotter" enthält hierbei den QwtPlot als pointer.

    Das eigentliche Problem ist das Variante 1 von "plot_line" nichts im Plot darstellt, obwohl sämtliche Wertepaare in der QwtPlotCurve enthalten sind (zumindest laut dem Debugger).

    Was mich zur Verzweiflung bringt ist das ich einfach nicht verstehe warum, denn die Funktionen sind vom Prinzip her gleich.

    Wo liegt denn der Fehler? Was übersehe ich seit zwei Tagen?



  • axels. schrieb:

    denn die Funktionen sind vom Prinzip her gleich.

    Wo liegt denn der Fehler? Was übersehe ich seit zwei Tagen?

    Das ist schon schlecht. Doppelter Code bedeutet doppelter Aufwand und doppelte Fehlermöglichkeiten => DRY

    Hast du mal versucht, das Ergebnis der Funktion q dem Aufruf der ersten Funktion plot_line zu übergeben?



  • Hast du denn fkt_werte bzw. fkt_werte.size() mal überprüft?

    Wenn du sowieso beide Varianten hast, dann verwende doch:

    void Ploter::plot_line(std::shared_ptr<QwtPlotCurve>&myLine, funktion &q ,ploting_range &std, bool show, QPen pen)
    {
      std::vector<punkt<double>> fkt_werte = q.werte(std.von, std.bis, std.schrittweite);
    
      plot_line(myLine, fkt_werte, std, show, pen);
    }
    

    (wobei 'std' ja in der ersten Variante gar nicht als Parameter benutzt wird - und außerdem noch namensgleich mit dem Namespace "std" ist).

    PS: Es heißt korrekt "Plotter".



  • Mal davon abgesehen, dass eine Referenz auf einen shared_ptr ziemlicher Mist ist: dein draw_spline Funktion kann ja offensichtlich auch nicht gleich sein.



  • manni66 schrieb:

    Mal davon abgesehen, dass eine Referenz auf einen shared_ptr ziemlicher Mist ist

    Ja das war nur ein verzweifelter Versuch...

    Th69 schrieb:

    Hast du denn fkt_werte bzw. fkt_werte.size() mal überprüft?

    Ja habe ich, enthält exakt die übergebenen Werte. Auch die QwtPlotCurve enhält intern die übergebenen Punkte.

    Habe das ganze jetzt so umgebaut wie TH69 es vorgeschlagen hat, das ich nur noch eine Variante von plot_line habe. Das macht das ganze jetzt aber noch konfuser, denn es hat sich dadurch nichts geändert. Jetzt ist der aufruf von "plot_line" in allen "create_spline" - Methoden gleich. Die create_spline Methode dient als public Funktion dazu den Plotter aufzurufen.

    create_spline Varainte 1:

    std::shared_ptr<QwtPlotCurve> Plotter::create_spline(std::vector<punkt<double>> points, bool show, QPen pen)
    {
    	std::shared_ptr<QwtPlotCurve>myLine(new QwtPlotCurve(QString("")));
    	std::thread t(static_cast<void(Plotter::*)(std::shared_ptr<QwtPlotCurve>, std::vector<punkt<double>>&, bool, QPen)>(&Plotter::plot_line), this, std::ref(myLine), std::ref(points), show, pen);
    	t.join();
    	return myLine;
    }
    

    create_spline Variante 2:

    std::shared_ptr<QwtPlotCurve> Plotter::create_spline(funktion &q, ploting_range &range, bool show, QPen pen) {
    	std::shared_ptr<QwtPlotCurve>myLine(new QwtPlotCurve(QString("")));
    	std::vector<punkt<double>>points = q.werte(range.von, range.bis, range.schrittweite);
    
    	std::thread t(static_cast<void(Plotter::*)(std::shared_ptr<QwtPlotCurve>, std::vector<punkt<double>>&, bool, QPen)>(&Plotter::plot_line), this, std::ref(myLine), std::ref(points), show, pen);
    	t.join();
    	return myLine;
    }
    

    Damit bleibt für mich nur noch der Aufruf von "create_spline" als Fehlerquelle.
    Variante 1 wird so aufgerufen:

    void datatable::draw() {
    	QColor color = Plotter::randomColor();
    	for (punkt<double>&t : m_points) {
    		m_plot->create_point(t.get_x(), t.get_y(),color);
    	}
    
    	m_plot->create_spline(m_points,true,QPen(color,3));
    }
    

    Dabei ist die Klasse "datatable" eine UI für eine Wertetabelle.

    Variante 2 wird aus der Klasse des MainWindows heraus aufgerufen

    QVariant data;
    		data.setValue(plot->create_spline(function, function.range, true, Plotter::stdPen));
    

    Dabei wird der shared_ptr<QwtPlotCurve> in einem QVariant gespeichert.

    Ich komm einfach nicht drauf wo jetzt der Fehler liegt, denn der aufruf aus der MainWindow-Klasse klappt wunderbar, nur der aus der datatable-Klasse nicht.



  • Wo kommen denn auf einmal die Threads her? Und welchen Sinn macht es, einen Thread zu starten und dann gleich mit join darauf zu warten?



  • manni66 schrieb:

    Wo kommen denn auf einmal die Threads her? Und welchen Sinn macht es, einen Thread zu starten und dann gleich mit join darauf zu warten?

    Weil es unterm Strich ein paar ms Laufzeit ausmacht, was sich bei einem just-in-time plotting smother anfühlt.

    Es ändert aber nichts. Auch ohne Thread passiert nichts anderes. Also der Fehler ist mit und ohne Thread da.



  • axels. schrieb:

    Weil es unterm Strich ein paar ms Laufzeit ausmacht, was sich bei einem just-in-time plotting smother anfühlt.

    Du startest einen Thread und hältst den andern an - das fühlt sich bestimmt smoother an.



  • manni66 schrieb:

    axels. schrieb:

    Weil es unterm Strich ein paar ms Laufzeit ausmacht, was sich bei einem just-in-time plotting smother anfühlt.

    Du startest einen Thread und hältst den andern an - das fühlt sich bestimmt smoother an.

    Das ist doch jetzt nicht das Thema.



  • axels. schrieb:

    Das ist doch jetzt nicht das Thema.

    Was hier letztendlich das Thema ist, ist völlig unklar. Du führst hier mit jedem Post komplett anderen Code ein.



  • manni66 schrieb:

    axels. schrieb:

    Das ist doch jetzt nicht das Thema.

    Was hier letztendlich das Thema ist, ist völlig unklar. Du führst hier mit jedem Post komplett anderen Code ein.

    Es ist doch wohl klar das man sich dem Fehler stück für Stück nähern muss, und eventuelle Fehlerquellen nach und nach eliminieren muss, deswegen immer wieder anderer Code der aber im zusammenhang mit allem anderen steht.

    Also jetzt hier für den manni den aktuellen Stand zusammengefasst:

    Zwei Funktionen die sich nur durch ihr Interface unterscheiden liefern verschiedene Ergebnisse.

    Variante 1

    std::shared_ptr<QwtPlotCurve> Plotter::create_spline(std::vector<punkt<double>> points, bool show, QPen pen)
    {
    	std::shared_ptr<QwtPlotCurve>myLine(new QwtPlotCurve(QString("")));
    	plot_line(myLine, points, show, pen);
    	return myLine;
    }
    

    Variante 2

    std::shared_ptr<QwtPlotCurve> Plotter::create_spline(funktion &q, ploting_range &range, bool show, QPen pen) {
    	std::shared_ptr<QwtPlotCurve>myLine(new QwtPlotCurve(QString("")));
    	std::vector<punkt<double>>points = q.werte(range.von, range.bis, range.schrittweite);
    	plot_line(myLine, points,show, pen);
    	return myLine;
    }
    

    Beim aufruf von Varainte 2 wird die Kurve gezeichnet, bei Varainte 1 nicht.
    Alles war vorher in dem Thread diskutiert wurde ist das was in der Funktion "create_spline" passiert. Da dies jetzt identisch ist, muss der Fehler nicht innerhalb der Funktion liegen. Ich verstehe aber nicht wo! Und genau das ist das aktuelle Thema!
    Also nochmals die Frage, was ist falsch das eben jenes Verhalten auftritt?



  • Tja, wenn man jetzt wüsste was plot_line macht ...



  • manni66 schrieb:

    Tja, wenn man jetzt wüsste was plot_line macht ...

    Hier bitte. Da diese in beiden Fällen gleich ist, würde ich in meiner naivität diese als Fehlerquelle ausschließen.

    void Plotter::plot_line(std::shared_ptr<QwtPlotCurve>myLine, std::vector<punkt<double>> &points, bool show, QPen pen)
    {
    	QwtSplineCurveFitter *fitter = new QwtSplineCurveFitter();
    	fitter->setFitMode(QwtSplineCurveFitter::Spline);
    
    	fitter->setSplineSize(points.size());
    	QVector<double> x, y;
    	for (size_t i = 0; i < points.size(); i++) {
    		x.push_back(points.at(i).get_x());
    		y.push_back(points.at(i).get_y());
    	}
    
    	myLine->setSamples(x, y);
    	myLine->setRenderHint(QwtPlotCurve::RenderAntialiased);
    	myLine->setCurveFitter(fitter);
    
    	draw_spline(myLine, pen, show);
    }
    

    Für den Falls das du "draw_spline" auch noch sehen willst
    Hier bitte:

    void Plotter::draw_spline(std::shared_ptr<QwtPlotCurve>myLine,QPen pen, bool show) {
    	myLine->setPen(pen);
    	myLine->attach(plot.get());
    	myLine->setVisible(show);
    	plot->replot();
    }
    


  • Prüfe doch einmal, ob die Eingangsdaten in Variante 1

    std::vector<punkt<double>> points
    

    identisch zu denen sind, die dieser Aufruf liefert:

    std::vector<punkt<double>>points = q.werte(range.von, range.bis, range.schrittweite);
    

    Mir scheint, dass dieser Aufruf nicht das liefert, was du haben möchtest.



  • foobar schrieb:

    Mir scheint, dass dieser Aufruf nicht das liefert, was du haben möchtest.

    Doch genau das tut er. Wenn ich mir die Daten im vector anschaue finde ich exakt die ich eingeben habe. Das ist es ja was mich so verrückt macht.



  • Was passiert denn, wenn du aus Variante 2, Variante 1 aufrufst? Also sowas:

    std::shared_ptr<QwtPlotCurve> Plotter::create_spline(funktion &q, ploting_range &range, bool show, QPen pen) {
        std::shared_ptr<QwtPlotCurve>myLine(new QwtPlotCurve(QString("")));
        std::vector<punkt<double>>points = q.werte(range.von, range.bis, range.schrittweite);
        return create_spline(points, show, pen);
    }
    

    Dann würdest du in Variante 1 garantiert den selben Vector benutzen, den du sonst in Variante 2 verwendet hast.

    Edit: Gibt es einen Grund, dass du in create_spline keine Referenz auf den Vektor übergibst?



  • Schlangenmensch schrieb:

    Was passiert denn, wenn du aus Variante 2, Variante 1 aufrufst?

    Dann tritt ebenfalls der Fehler auf.
    Dennoch weiß ich jetzt noch nicht woran es liegt.
    Demnach muss es irgendwo in der Funktion

    std::shared_ptr<QwtPlotCurve> Plotter::create_spline(std::vector<punkt<double>>& points, bool show, QPen pen)
    {
    	std::shared_ptr<QwtPlotCurve>myLine(new QwtPlotCurve(QString("")));
    	plot_line(myLine, points, show, pen);
    	return myLine;
    }
    

    ein Problem geben, aber welches?

    Schlangenmensch schrieb:

    Edit: Gibt es einen Grund, dass du in create_spline keine Referenz auf den Vektor
    übergibst?

    Keinen expliziten...



  • Wie sieht denn QwtPlotCurve::setSamples aus?



  • http://qwt.sourceforge.net/class_qwt_plot_curve.html#aa51cd3fa00f2a046ca5a9889c5db2413

    Gibt es drei überladene Funktionen, in meinem Fall wird die zweite Verwendet.



  • hustbaer schrieb:

    Wie sieht denn QwtPlotCurve::setSamples aus?

    Ich bin der Meinung, es spielt überhaupt keine Rolle, was in plotLine oder noch tiefer in setSamples passiert.

    axels. schrieb:

    Variante 1

    std::shared_ptr<QwtPlotCurve> Plotter::create_spline(std::vector<punkt<double>> points, bool show, QPen pen)
    {
        std::shared_ptr<QwtPlotCurve>myLine(new QwtPlotCurve(QString("")));
        plot_line(myLine, points, show, pen);
        return myLine;
    }
    

    Variante 2

    std::shared_ptr<QwtPlotCurve> Plotter::create_spline(funktion &q, ploting_range &range, bool show, QPen pen) {
        std::shared_ptr<QwtPlotCurve>myLine(new QwtPlotCurve(QString("")));
        std::vector<punkt<double>>points = q.werte(range.von, range.bis, range.schrittweite);
        plot_line(myLine, points,show, pen);
        return myLine;
    }
    

    plot_line bekommt 4 parameter. Aus deinem Post geht hervor, dass der erste ( myLine ) bei beiden identisch ist, weil innerhalb von create_spline identisch erzeugt. Wenn die beiden Varianten mit demselben show und demselben pen aufgerufen werden, kann der Fehler doch nur beim Parameter points liegen.

    Ich bleibe dabei: stelle sicher, dass die 4 Parameter, die plot_line nimmt bei beiden Aufrufen identisch sind, dann muss auch dasselbe rauskommen. (Ist vielleicht beim einen Aufruf, bei dem kein Plot angezeigt wird, show == false ...?)


Log in to reply