Lineare Interpolation

[Six]

Hallo!

Also es geht um lineare Interpolation (zumindest glaube ich das :gruebel: ).
Ich zerbreche mir über das Problem nun schon seit längerer Zeit den Kopf und finde es eigentlich beschähment, nicht selber auf die Lösung zu kommen, aber was solls. Ich hoffe ihr könnt mir weiterhelfen.

Mein Problem: Ich möchte sowas wie in Bild 1 hinbekommen (Anhang). Ihr seht dort einen Ausschnitt aus einem Audioprogramm. Es geht aber eigentlich nur um die Abstände und Länge der Balken.
Wie ihr seht, werden die Balken und deren Abstände untereinander immer schmaler und genau so etwas versuche ich zu programmieren.
Es gibt als Vorgabe also nur eine Anfangsfrequenz (im Beispiel 5 Hz) und eine Endfrequenz (im Beispiel 20 Hz), sowie eine beliebige Zeitvorgabe. Nun soll zwischen den beiden Werten, wie gezeigt interpoliert werden.
Auch soll es absteigend möglich sein, also z.B. von 20 Hz auf 10 Hz und gleichbleibend (also für eine gewisse Zeit 5 Hz, dann wieder ansteigen auf 10 Hz absteigen auf 2 Hz etc.).

Was mir bislang gelungen ist, seht ihr in Bild zwei. Leider stimmen die Abstände in manchen Fällen nicht, wie zum Beispiel der dünne Streifen in der Mitte oder auch die beiden rechten Streifen. Ich glaube übrigens nicht, das dies an der "Auflösung" liegt.

Hier ist der zuständige Sourcecode:

Delphi-Quellcode:

procedure TForm1.XYZTest(P1x, P1y, P2x, P2y: integer);
var
  GesamtzahlEinheiten, AbstandAnfang, AktuellerAbstand,
  AnzahlDurchlaeufe: integer;
  Steigung, m: double;
  i, n:    integer;
begin
  Steigung      := ABS((P2y - P1y) / (P2x - P1x));
  AbstandAnfang := P1y;
  AktuellerAbstand := AbstandAnfang;

  for i := P1x to P2x do
  begin
    if i mod AktuellerAbstand = 0 then
    begin
      JvStringGrid2.Cells[1, Tabellenzeiger] := IntToStr(i);    
      if Aus then
        JvStringGrid2.Cells[0, Tabellenzeiger] := 'Aus'
      else
        JvStringGrid2.Cells[0, Tabellenzeiger] := 'An';
      JvStringGrid2.InsertRow(JvStringGrid2.RowCount + 1);
      Aus := not Aus;
      n   := Round(P1y - (Steigung * P1x));
      m   := Steigung;
      AktuellerAbstand := Round(m * i + n);
      Inc(Tabellenzeiger);
    end;
  end;
  // Tabelle Umsetzen
  JvStringGrid2.RemoveRow(JvStringGrid2.RowCount - 1);
  for i := 1 to JvStringGrid2.RowCount do
  begin
    PaintBox1.Canvas.Brush.Color := clblack;
    PaintBox1.Canvas.Brush.Style := bssolid;
    if JvStringGrid2.Cells[0, i] = 'An' then
      PaintBox1.Canvas.Rectangle(StrToInt(JvStringGrid2.Cells[1, i - 1]), 0,
        StrToInt(JvStringGrid2.Cells[1, i]), PaintBox1.Height);
  end;
end; //  XYZ  (TForm1)

Ich hoffe das ganze ist einigermaßen verständlich. Es wird quasi erst eine Tabelle mit den Werten erstellt und "An" und "Aus" bedeutet dann eben Balken zeichnen oder nicht.

das sieht dann z.B. so aus:

An 0
Aus 10
An 20
Aus 29
An 38 usw.

Diese Tabelle wird dann in die Zeichnung auf der Paintbox umgesetzt (Das geschieht alles nur zu Testzwecken, daher ist der Code auch noch unsauber, unschön etc. :wink: ).

Aufgerufen wurde das ganze für das Beispiel hiermit:
procedure TForm1.Button7Click(Sender: TObject);
begin
TabellenZeiger := 0;
Aus := False;
XYZTest(0, 5, 250, 10);
end;

Also, wie ihr seht versuche ich das ganze mit Hilfe einer Linearen Funktion zu lösen. Aufgrund der Aussetzer (wie oben beschrieben) bezweifele ich allerdings mittlerweile, das dies der Richtige Weg ist. Auch wenn ich die Richtung ändere, also beispielsweise von 10 auf 5 Hz RUNTER möchte, produziert die Funktion nur undefinierbaren "Müll". Das Problem ließe sich zwar mit einer anfänglichen Abfrage lösen, aber wie gesagt, ich bin überhaupt im Zweifel und vielleicht besteht ja auch nur ein klitzekleiner Fehler, etwas, dass ich übersehen habe...

Ich hoffe ihr versteht mein Problem.

Wäre toll, wenn ihr mir helfen könntet :thumb:

Six

[marabu]

Hallo Six,

du möchtest die Ein- und Ausschaltzeitpunkte für ein Signal mit linear gleitender Schaltfrequenz berechnen? Ich erwarte da ein festes Verhältnis von Ton- zu Pausendauer. Das Zeitfenster für einen Ton samt zugehöriger Pause ist der Kehrwert der Signalfrequenz. Die Zeitfenster bilden dann eine arithmetische Folge (nur bei linearem Gleiten, sonst eine geometrische). Über die allgemeine Summenformel für arithmetische Reihen sollte sich das Delta berechnen lassen. Damit kannst du dann das Zeitfenster für jedes Signal angeben und durch das Pausenverhältnis kannst du die exakten Schaltzeiten bestimmen.

Vergib mir, wenn ich Blödsinn verzapfe, aber meine Mathematik-Kenntnisse stammen aus grauer Vorzeit...

Grüße vom marabu

[Six]

Hi marabu,

danke für deine Hilfe, aber leider verstehe ich hier nur Bahnhof, ich bin Schüler und habe gerade mein Abitur gemacht, deswegen verzeihe mir bitte, dass ich Dinge wie: "lineare Gleiter", "arithmetische/geometrische Folge" oder "allgemeine Summenformel" noch nie gehört habe :?

Könntest du mir das vielleicht ein wenig genauer erklären?

Danke schonmal im Vorraus!

lg

Six

[Mystic]

Vielleicht hilft das ja weiter:
http://de.wikipedia.org/wiki/Arithmetische_Reihe
http://de.wikipedia.org/wiki/Arithmetische_Folge

[mschaefer]

Moin zusammen,

würde das mal in zwei einzelne Aufgaben zerlegen.

1. Funktion die bei einer gegebenen Freuqenz diese Frequenz zeichnet. Da die Frezenz in Hz angegeben ist,
und 1 Hz = "1 Schwingung pro Sekunde" ist so ist ein 1Hz ein schwarzer Balken/weißer Balken /schwarzer
Balken pro Sekunde: oder in Zahlen 10.

Für das grafikgelumpse habe ich noch nie viel übergehabt, das mag mal jemand anderes programmieren....

2. Funktion die drei Werte von Dir bekommt
Wert 1: Startfrequenz
Wert 2: Endfrequenz
Wert 3: Zeitschrittweite (in Sekunden/Minuten) (in welcher Zeit muß von Freuq. 1 zu Frequ. 2 gewechselt sein?)

Zunächst mal soweit, den jetzt kommt "Adelheid und ihre Mörder" und danach kommen wir dann zur Auflösung....

Grüße // Martin


/Edit: Thanks Mystik ! /Edit

[Mystic]

Zitat:

Zitat von mschaefer

1. Funktion die bei einer gegebenen Freuqenz diese Frequenz zeichnet. Da die Frezenz in Hz angegeben ist,
und 1 Hz = "1 Schwingung pro Sekunde" ist so ist ein 1Hz ein schwarzer Balken/weißer Balken /schwarzer
Balken pro Sekunde: oder in Zahlen 101.

Das ist ein schwarzer Balken zuviel. ;)

[Six]

Hi mschefer,

das was du sagst (2) geht genau in die richtige Richtung :thumb:

Das "Grafikgelumpse" ist im Grunde auch völlig egal, es diente mir nur dazu zu SEHEN, was ich da fabriziert habe. Die Prozedur um das am Ende in eine Soundfile umzuwandeln steht sowieso schon. Es geht eben nur darum diese Tabelle mit den Richtigen Werten zu füllen. Daraus entsteht dann am Ende das Soundfile.

Dann bin ich mal gespannt auf die Auflösung.

@ Mystik: Danke für die Links!

Six

[marabu]

Hallo Six,

Zitat:

Zitat von Six

aber leider verstehe ich hier nur Bahnhof, ich bin Schüler und habe gerade mein Abitur gemacht, deswegen verzeihe mir bitte, dass ich Dinge wie: "lineare Gleiter", "arithmetische/geometrische Folge" oder "allgemeine Summenformel" noch nie gehört habe

verstehe mich nicht falsch, aber WO hast du die allgemeine Hochschulreife erworben? Sind Folgen und Reihen kein Stoff der Klassen 11 bis 13?

Du musst jetzt solange Geduld haben bis Evelyn Hamann und Tilo Prückner den Martin aus ihrem Bann entlassen, dann schauen wir uns gemeinsam an, was er so produziert (GRÜNE Balken, Martin, mit Bäuchen an den Flanken...) und dann sehen wir weiter.

Heitere Grüße vom marabu

So ein Mist - jetzt hast du die Grafik rausgeredet - das hätte spannend werden können...

[Six]

Hi marabu,

Zitat:

verstehe mich nicht falsch, aber WO hast du die allgemeine Hochschulreife erworben? Sind Folgen und Reihen kein Stoff der Klassen 11 bis 13?

Nein, du hast schon recht, als ich's mir gerade bei Wiki angesehen habe fiel's mir dann auch wie Schuppen von den Augen, allein schon wegen der vollständigen Induktion (hatte sogar mathe LK :oops: ). Ich konnte einfach in dem Zusammenhang nichts damit anfangen und ehrlich gesagt, jetzt wo ich wieder weiß was es ist (ist ja eigentlich ne ganz selbstverständliche Sache) hilft mir das auch nicht viel weiter...

Delphi-Quellcode:

So ein Mist - jetzt hast du die Grafik rausgeredet - das hätte spannend werden können...

Wieso denn eigentlich, die Grafik war doch bereits (Stümperhaft) realisiert :zwinker:
Es ging halt nur um ne art Vorschau...

Tja, dann warten wir mal....

lg

Six

[mschaefer]

Moin, zusammen,

wie gesagt die Graphic mit Canvas zeichnen, das mögen mal andere machen. Jetzt bezeiehe ich mich mal banal
auf die Überschrift: lineare Interpolation! Gleich heisst es: Nein fürchterlich - so einfach?!!!!

Was haben wir zwei Zeitpunkte Y1 und Y2. Dann haben wir zwei Hertzzahleb X1 und X2 plus Linearität: Mehr nicht!
Linear ist eine Gerade und wir haben auf dieser jihuu zwei Punkte. Also: b + a*x = y
( "·" sind Tabulatorpunkte zum Einrücken)


I:
1. Gleichung: b + Hertz(1) * a = Zeitpunkt(1)
2. Gleichung: b + Hertz(2) * a = Zeitpunkt(2)
---------------------------------------------
2-1: ( Hertz(2)-Hertz(1) ) * a = Zeitpunkt(2) - Zeitpunkt(1)


II:
Daraus basteln wir uns nun die Geradensteigung a (oft wird die auch gerne m genannt)

····· Zeitpunkt(2)-Zeitpunkt(1)
a = -----------------------------
····· Hertz(2) - Hertz(1)


III:
Fein das gefundene a stezen wir mal in Gleichung 2 ein


···················· Zeitpunkt(2)-Zeitpunkt(1)
b + Hertz(2) * ----------------------------- = Zeitpunkt(2)
···················· Hertz(2) - Hertz(1)

und lösen das nach b auf

································· Zeitpunkt(2)-Zeitpunkt(1)
b = Zeitpunkt(2) - Hertz(2) * -----------------------------
······························· Hertz(2) - Hertz(1)


IV:
Da uns nun a und b bekannt sind stellen wir die allgemeine Funktionsgleichung auf:

·y ·········= ································b················· ······· +········· a* x ············


················································ Zeitpunkt(2)-Zeitpunkt(1)··· · Zeitpunkt(2)-Zeitpunkt(1)
Zeitpunkt(y) = Zeitpunkt(2) - Hertz(2) * -------------------------- + ----------------------- * Hertz(x)
·············································· Hertz(2) - Hertz(1) ···········Hertz(2) - Hertz(1)

etwas umstellen
·y ·········= ································a*x··············· ········· +········· b ············


········································Zeitpunkt( 2)-Zeitpunkt(1)····· Hertz(2)*Zeitpunkt(1)- Hertz(1) * Zeitpunkt(2)
Zeitpunkt(y) =··Hertz(x) * ----------------------------··+ -------------------------------------------------
·······································Hertz(2) - Hertz(1)························ Hertz(2) - Hertz(1) ·············



V:
Man kann das natürlich auch nach der Hertzzahl umstellen (die Zwischenritte nich mit dieser Eingabeform..)



··································Hertz(1) - Hertz(2)··
Hertz(x) =·(··Hertz(2) * ----------------------------- * ( Zeitpunkt(2) - Zeitpunkt(x) )
·······························Zeitpunkt(1)-Zeitpunkt(2)

Also das ist das ganze linear. Das umsetzen in Pascal dürfte wohl kaum das Problem sein. Wenn es dann
doch nicht mehr linear sein soll, sagt mal bescheid.





PS: Liebe Admins: könnte man in die Eingabe Tabulatorsprünge einbauen?

[Six]

Hi mschaefer,

danke für deine Antwort, aber ist das nicht im Grunde genau das, was ich auch schon implementiert habe?

Meine Erfolge damit kennst du ja...

lg

Six

[marabu]

Hallo Six,

dann wollen wir mal...

Sei f0 die Startfrequenz, fn die Endfrequenz, t0 = t(f0) die Dauer eines Schaltzyklus, n die Anzahl der Schaltzyklen, T das abzudeckende Zeitintervall und d die Zeitdifferenz zweier aufeinander folgender Schaltzyklen. Summe(i, 1, n) sei die Notation für die Summe der ersten n Zahlen.

Gesucht werden die Einschaltzeiten bei vorgegebenem T und der Randbedingung, dass die t(f) eine arithmetische Reihe bilden.

Nach der allgemeinen Summenformel für die arithmetische Reihe ist dann T = Summe(t0 + i*d, 0, n)
oder nach Gauss T = t0 (n + 1) + d (n (n + 1) / 2)
Das lässt sich auflösen nach d = (T - 2 t0 (n + 1)) / (n (n + 1))

Wenn du jetzt noch n vorgibst, dann kannst du d bestimmen und in die allgemeine Summenformel einsetzen. Dann kannst du iterativ die Einschaltzeiten berechnen und wenn du noch das konstante Verhältnis von Ein- zu Ausschaltdauer in Ansatz bringst, dann hast du auch noch deine Ausschaltzeiten. Mir ist bewusst, dass T mit einer Pause endet. Eventuell musst du beim Laufindex eine mögliche off-by-one Falle beachten. Jetzt müsste das noch einer Korrektur lesen.

Leg los.

marabu

[Six]

Hi marabu,

danke für deine Antwort, doch nach mehrmaligem durchlesen und verstehen versuchen, muss ich mir eingestehen, dass ich keinen blassen Schimmer habe, was ich machen soll. Bitte bedenke, ich habe bisher weder ein Mathe-, noch ein Informatikstudium hinter mich gebracht. :?

Bedeutet Summe(i,1,n) ganz einfach i+1+n?

Meinst du mit n die Herzzahl und wenn ja, welche der beiden? Ansonsten habe ich KEIN n.

Was ich habe ist die Startfrequenz, Endfrequenz und ein Zeitintervall, in dem das ganze ablaufen soll. Am Ende soll das ganze dann so aussehen, wie auf der grünen Zeichnung (nicht als Zeichnung sondern als Werte in einer Tabelle).Vielleicht habe ich mich da noch nicht deutlich genug ausgedrückt.

Was meinst du mit der "off-by-one Falle". Sorry, aber du sprichst hier mit einem Hobbyprogrammierer und keinem Experten.

Bitte formuliere das ganze doch ein wenig allgemeiner verständlich :zwinker:

Dankeschön!

Six

[marabu]

Hi Six,

Zitat:

Zitat von Six

danke für deine Antwort, doch nach mehrmaligem durchlesen und verstehen versuchen, muss ich mir eingestehen, dass ich keinen blassen Schimmer habe, was ich machen soll. Bitte bedenke, ich habe bisher weder ein Mathe-, noch ein Informatikstudium hinter mich gebracht.

ähm - das war die Fassung für Laien...

Zitat:

Zitat von Six

Bedeutet Summe(i,1,n) ganz einfach i+1+n?

Summe(i,1,n) steht für die Summe aller i, wobei du für i nacheinander die Werte 1 bis n einsetzt.

Zitat:

Zitat von Six

Meinst du mit n die Herzzahl

du denkst zuviel ans Kartenspiel...

Zitat:

Zitat von Six

Ansonsten habe ich KEIN n.

Das ist ja das Problem. Ich kann momentan nicht erkennen, wie die Aufgabe zu lösen sein soll, ohne dass du die Anzahl an Schaltzyklen vorgibst.

Zitat:

Zitat von Six

Vielleicht habe ich mich da noch nicht deutlich genug ausgedrückt.

Glaube mir, für mich reicht es.

Zitat:

Zitat von Six

Was meinst du mit der "off-by-one Falle".

Darüber reden wir noch, wenn du den Prototypen entwickelt hast.

So ein schöner thread und wir beide haben ihn ganz alleine für uns...

marabu

[Six]

Hi marabu,

Zitat:

ähm - das war die Fassung für Laien...

Zitat:

du denkst zuviel ans Kartenspiel...

Zitat:

Glaube mir, für mich reicht es.

Zitat:

So ein schöner thread und wir beide haben ihn ganz alleine für uns...

Ich weiß nicht was du mit diesen Aussagen bezwecken willst. Auf mich wirken sie jedenfalls ziemlich erniedrigend. Ich habe den Eindruck du findest das ganz lustig hier mit meiner "Unwissenheit" zu spielen, obwohl du die Lösung bereits kennst.

Wenn ich wüsste, wie es geht, hätte ich hier sicher nicht gefragt und deine "Laienversion" hilft mir ohne weitere Kenntnisse leider nicht weiter. Wenn du mir also wirklich helfen willst, sag was du weißt und nimm den Zeigefinger runter :wink:

Das Problem sollte sich meiner Ansicht nach mit einer Start- sowie Endfrequenz und einem Zeitintervall lösen lassen. Haufenweise anderer Programme lösen das Problem mit den gleichen Informationen.

mfg

Six

[marabu]

Zitat:

Zitat von Six

Ich habe den Eindruck du findest das ganz lustig hier mit meiner "Unwissenheit" zu spielen, obwohl du die Lösung bereits kennst.

Du täuschst dich. Es tut mir sehr leid, wenn mein Anflug von Humor diesen Eindruck bei dir hinterlässt. Nochmal mit allem Ernst: ich bemühe mich wirklich um eine Darstellung für Nicht-Mathematiker. Der Namensgeber für die Einheit der Frequenz schrieb sich mit tz und mein verschlüsselter Hinweis hat ein wunderbares Versmaß. Dann wollte ich dich von weiteren Versuchen abhalten mir dein Problem zu erklären, nachdem ich ziemlich sicher bin, dass ich es schon beim ersten Lesen verstanden habe. Und zuguterletzt würde ich mir wirklich wünschen eine Meinung von dritter Seite zum Stand meiner Überlegungen zu lesen.

Es ist so, wie ich es sage. Solange keine Anzahl für die (immer kleiner oder größer werdenden) Schaltzyklen vorgegeben wird, sehe ich keine Möglichkeit zur Berechnung einer eindeutigen Lösung. Mir fällt auf die Schnelle auch keine Optimierungsfunktion ein, an deren Haaren ich mich aus diesem Sumpf ziehen könnte.

marabu

[Six]

Zitat:

Du täuschst dich. Es tut mir sehr leid, wenn mein Anflug von Humor diesen Eindruck bei dir hinterlässt.

Ok, marabu, dann tut es mir leid, dich dessen verdächtigt zu haben! Bitte ab jetzt keine verschlüsselten Humorbotschaften mehr :wink:

Nun noch mal zum Problem. Da du es ja offenbar verstanden hast, kann ich mir zum Glück weitere Ausführungen sparen. Was sagst du denn zu meinem Code, der zumindest schon mal ein Ergebnis liefert, welches in die richtige Richtung geht (siehe Anhang). Kann man auf diese Weise nicht noch irgend etwas erreichen?

Six

[mschaefer]

Moin, moin,

also ehrlich gesagt habe ich mich jetzt mit den Reihen nicht beschäftigt. Denke schon das es damit irgendwie geht, aber der Aussetzter in obigen Bild hat nichts mit der linearen Interpolation zu tun. Da ist ein Umsetzungsfehler drin. Die Zeitindexe dürfen sich nicht überschneiden, dann kommen diese Zeichenfehler durch überzeichnen. Da ich wenig Zeit im Moment habe würde ich folgendes Vorschlagen. Six bau doch mal ein kurzes Projekt zusammen, was folgende Aufgabe erledigt.

Es soll eine Funktion haben die nur eine Schwingung zeichnet 01 halt. Die Zeichenstelle ergibt sich aus dem Zeitindex und die Zeichenbreite / Strichbreite und Leerbreite aus der übergebenen Hertzzahl.



Den Rest mit den Interpolationsfunktionen können wir dann zusammen einsetzten. Vielleicht auch mal was anderes als nur linear.
Das Problem an Deinem Beispiel oben ist in der Zeitindexansteuerung zu sehen. Du Interpolierst einen Zeitindex mit einer Schwingung
jetzt kommt der nächste Zeitindex. Wie lange der aktuelle Index allerdings ist hängt an der Hertzzahl. Das heißt Du würdest das allgemein folgend aufbauen.

Solage bis Endzeitindex erreicht
-Funktion 1: Ermittler Hertzzahl/Frequenz durch Interpolation aus den Start/Endwerten zum Zeitindexe x
-Funktion 2: Ermittle länge des Zeitindex x aus Hertzzahl
-Funktion 3: Setze Position aus Addition der letzten Zeitindexsumme plus des aktuellen Zeitindexes (marabus Reihenidee(?))
Solange Ende

Macht es Schrittweise, es ist schon der richtige Weg // Martin

[Six]

Ich hätte es zwar selber nicht mehr gedacht, aber ich habe eine Lösung gefunden. Für alle die es interessiert werde ich sie morgen posten. Vielen Dank noch mal an alle, die mir versucht haben zu helfen.

mfg

Six

[runger]

Hallo Six,

lineare Interpolation, Abitur und nie was davon gehört?
Da musst du aber schwer geschlafen haben. (Pisa lässt grüssen)
Sieh mal in deinen Schulbüchern nach unter lineare Funktionen f(x)=mx+b
Genau das ist es nämlich was du brauchst.

Rainer
(ich glaube hier will einer aus Klasse 9 seine Hausaufgaben lösen)

[mschaefer]

Moin, Grübel,

also vorsicht mit dem Sarkasmus,
da muß er nicht nachschauen: Das habe ich oben verwendet.
Allerdings fehlt ihm noch die Zeitschrittsteuerung.

// Martin

[runger]

Hallo,

ein bisschen Theorie und Verständnis würde ihm nichts schaden.

Rainer

[runger]

Hallo mschaefer,

1.) es heisst nicht Herz sondern Hertz.

2.) den Ausdruck Hertzzahl gibt es nicht, das ist die Frequenz.

Rainer

[mschaefer]

Uhps bei den vielen Hertzen ist mir doch ein T(ee) eintgangen. Rainer, da ist mein Motto
Mach es mit Herz, dann kommt Dein Leben auch ordentlich auf Frequenz und hohe Hertzzahl :wink:
Das Problem scheint sich inzwischen ja dann auch gelöst zu haben, ob die Theorie wirkt(?)...

Grüße // Martin

[runger]

Hallo mschaefer,

glaub ich nicht. Manche Leute fragen erst bevor sie denken!

Rainer
(weiss ich von meinen Azubis)

[Six]

Hallo runger!

Ganz schön unverschämt, was du hier ablässt:

Zitat:

Pisa lässt grüssen

Zitat:

ich glaube hier will einer aus Klasse 9 seine Hausaufgaben lösen

Zitat:

Da musst du aber schwer geschlafen haben.

Also Runger:

Zitat:

Sieh mal in deinen Schulbüchern nach unter lineare Funktionen f(x)=mx+b

Sieh dur dir erstmal meinen Codeschnipesel an... Na, fällt dir was auf?

Riiiichtiig:

Delphi-Quellcode:

AktuellerAbstand := Round(m * i + n);

Na, wonach sieht das denn bitte aus Runger? Vielleicht demnächst erstmal lesen und dann meckern :roll:

Mir ist übrigens klar was lineare Interpolation ist, sonst hätte wohl nicht diesen Titel gewählt :gruebel:

Ach ja, und sieh mal hier:

Delphi-Quellcode:

 Ich hätte es zwar selber nicht mehr gedacht, aber ich habe eine Lösung gefunden.

Und wenn du's genau wissen willst: Ich "sitze" an diesem Problem nun schon seit zwei Wochen, was mir ziemlich auf den Nerv ging, da ich mit dem Hauptprogramm nicht weiterkam (Ok, eine Woche dazwischen war Urlaub, ABSCHLUSSFAHRT, Runger).
Es waren nur minimale Codeänderungen nötig und nun läufts perfekt. Ich habe nämlich nochmal in den alten Sicherungen gekramt, wo ich eigentlich schon fast am Ziel war, nur leider habe ich es dann aus irgendwelchen Gründen verworfen. Ich wollte wissen, ob ich auf dem richtigen Weg war...

Zitat:

glaub ich nicht. Manche Leute fragen erst bevor sie denken!

Rainer
(weiss ich von meinen Azubis)

Ach und noch was Rainer, ich möchte nicht wissen was deine Azubis machen wenn sie nicht weiterkommen. Ich bin nicht dein Azubi und werde es auch (zum Glück) bestimmt nie sein.
Wenn du dir mal die Zeit nehmen würdest, dir meinen Eingangspost durchzulesen, wirst du sicher feststellen, dass ich mir sehr wohl Gedanken gemacht habe. Aber scheinbar geht es dir auch gar nicht darum. Lieber schön ein bischen meckern, auf die Jugend schimpfen. Das bringt Deutschland wirklich voran. Sorry Rainer, aber nur weil du (angeblich) 53 bist und hier mit deinen Azubies rumprollen kannst (dieser Ausdruck trifft es leider) (und deiner damit selbsversdtändlich verbundenen überdurchschnittlich großen "was ich sage ist Gesetz" Lebensweisheit), ist dir noch lange nicht das Recht gegeben, in so weiner Weise über Menschen zu urteilen.

Naja, etwas gutes hat diese unerfreuliche Richtigstellung dennoch, ich kann mich nochmal ausgiebig bei mschäfer und marabu bedanken und da ich dies lieber direkt tue:

Dankeschön, marabu und mschäfer. :thumb:

Achja und Rainer: Immer schön Off-Topic bleiben :roll:

lg

Six

[mschaefer]

Hallo Six,

da hat Rainer nun wirklich überzogen. Aber ich denke nicht, dass er ein fürchterlicher Ausbilder ist. Im Betrieb kann man sich der Fragerei allerdins oft schwerer entziehen und hier im Forum ist es dann doch freiwillig, wenn man mitknobelt. Befürchte nur, dass er diese Woche schon ziemlich unter seinen Kandidaten gelitten hat und wie er die letzten zwei Tage überstehen soll...

Du bist an der Geradengleichung am Anfang schon gewesen. Der Unterschied zur mathematischen Lösung ist dass beim Programmieren üblicherweise mehrere Verfahren und Methoden kombiniert werden und da liegt der Sache oft in der Kombinatorik. Und die Kandidaten, die dann im Grafikbereich programmieren schmeissen mit den Formeln und Optimierungen dann so um sich, dass selbst die Büromücken ihren Rucksack zum Auswandern packen...

Grüße // Martin

[Six]

Hi mschäfer,

Zitat:

hier im Forum ist es dann doch freiwillig, wenn man mitknobelt.

Eben :!:

Und damit ist das Thema Rainer für mich jetzt auch abgehakt :nerd:

Zitat:

Du bist an der Geradengleichung am Anfang schon gewesen. Der Unterschied zur mathematischen Lösung ist dass beim Programmieren üblicherweise mehrere Verfahren und Methoden kombiniert werden und da liegt der Sache oft in der Kombinatorik.

Genau, die Idee war von Anfang an die richtige (wie ich dank eurer Hilfe jetzt weiß) ich hatte sie bloß falsch "implementiert". Wie gesagt, ich poste innerhalb dieses Tages noch die Lösung, falls einmal jemand das gleiche Problem haben sollte...

Gruß

Six

[Six]

So, hier ist dann wie versprochen die Lösung des Problems:

Delphi-Quellcode:

procedure TForm1.XYZTest(P1x, P1y, P2x, P2y: integer);
var
  Steigung: double;
  i: integer;
  Counter: integer;
  FrequenzProZeitpunkt: double;
begin
  Steigung := (P2y - P1y) / (P2x - P1x);
  Counter  := 0;
  FrequenzProZeitpunkt := 1;
  for i := P1x to P2x do
  begin
    Inc(Counter);
    if Counter = FrequenzProZeitpunkt then
    begin
      FrequenzProZeitpunkt := Round(Steigung * i + P1y);
      JvStringGrid2.Cells[1, Tabellenzeiger] := IntToStr(i);
      if Aus then
        JvStringGrid2.Cells[0, Tabellenzeiger] := 'Aus'
      else
        JvStringGrid2.Cells[0, Tabellenzeiger] := 'An';
      JvStringGrid2.InsertRow(JvStringGrid2.RowCount + 1);
      Aus := not Aus;
      Inc(Tabellenzeiger);
      Counter := 0;
    end;
  end;
  // Tabelle Umsetzen
  JvStringGrid2.RemoveRow(JvStringGrid2.RowCount - 1);
  for i := 1 to JvStringGrid2.RowCount do
  begin
    PaintBox1.Canvas.Brush.Color := clblack;
    PaintBox1.Canvas.Brush.Style := bssolid;
    if JvStringGrid2.Cells[0, i] = 'An' then
      PaintBox1.Canvas.Rectangle(StrToInt(JvStringGrid2.Cells[1, i - 1]), 0,
        StrToInt(JvStringGrid2.Cells[1, i]), PaintBox1.Height);
  end;
end; //  XYZ  (TForm1)

Wie das Ganze dann am Ende aussehen könnte ist im Anhang zu finden.

Grüße

Six

[marabu]

Hi Six,

Glückwunsch vom marabu

das produzierte Bild sieht besser aus als der produzierende code...

[Six]

Hi marabu,

Zitat:

Glückwunsch vom marabu

Dankeschööön :-D

Zitat:

das produzierte Bild sieht besser aus als der produzierende code...

Da hast du völlig recht! Es war aber auch nur mehr oder weniger so hingesch*****. Zu Testzwecken reicht es aber :wink:

Six