Circular spectrum visualizer

[EWeiss]

Projekt entfernt..

[TiGü]

Warum nennst du es nicht wie im Original einen "Circular spectrum visualizer"?
Die Fast Fourier Transformation ist doch nur die Methode, um das Spektrum zu erhalten.

[EWeiss]

Zitat:

Zitat von TiGü (Beitrag 1428454)

Warum nennst du es nicht wie im Original einen "Circular spectrum visualizer"?
Die Fast Fourier Transformation ist doch nur die Methode, um das Spektrum zu erhalten.

geändert..

Die meisten Leute stellen nur ein VU bzw.. Osci zur Verfügung von daher dachte ich das es erwähnenswert ist.

gruss

[Michael II]

Log() in Visual Basic und ln() in Delphi liefern die genau gleichen Werte.

y = ln(x) ist die Umkehrfunktion zu y = e^x.

Wenn du die Umkehrfunktion von zum Beispiel y = 10^x benötigst, dann rechnest du y = ln(x)/ln(10) [in Texten wird oft lg(x) geschrieben]; ähnlich: die Umkehrfunktion von y = 2^x lautet y = ln(x)/ln(2) [oft auch als lb(x) geschrieben].


sqrt(x) in Visual Basic und sqrt(x) in Delphi liefern die gleichen Werte.
y=sqrt(x) ist die Umkehrfunktion zu y = x^2.

sqrt wird zum Beispiel oft verwendet um die Länge eines Vektors zu berechnen. Zum Beispiel v=(3,4) => Länge von v ¦v¦ = sqrt(3*3+4*4) = 5.

sqr(x) liefert in Delphi das Quadrat von x also x^2. Beispiel sqr(4)=4*4=16

[Michael II]

Ich habe rasch in deinen uSpectrum Code geschaut

Du verwendest dort an zwei Orten sqr(), wo wohl eher sqrt() stehen sollte.
Du hast an beiden Stellen im Code einen Vektor (SpectrumRealteil,SpectrumImaginärteil) und willst sicher die Länge dieses Vektors bestimmen.

[EWeiss]

Zitat:

Zitat von Michael II (Beitrag 1428459)

Ich habe rasch in deinen uSpectrum Code geschaut
Du hast an beiden Stellen im Code einen Vektor (SpectrumRealteil,SpectrumImaginärteil) und willst sicher die Länge dieses Vektors bestimmen.

Sorry ich bin kein Mathematiker von daher bestimme ich selbst nichts.
Möchte mich auch nicht mit fremden Federn schmücken von daher ist der Ursprungsauthor genannt und ein Link zur Original Quelle verlinkt.

Aber!
Wenn so wie du sagst in VB6 die gleichen werte geliefert werden wie in Delphi.. Warum ist das Ergebnis ein anderes.
Mir ging es darum ein neues Beispiel für meine Library zu erstellen und da bot sich seine Visualisierung dafür an.
Habe mir aber nicht gedacht das es so schwierig wird das nach Delphi umzusetzen.

Rein Mathematisch bin ich ein NOB wenn es um höhere Mathematik geht.

Zitat:

wo wohl eher sqrt() stehen sollte.

Wohl eher sollte hier wie im Original Quelltext sqr stehen deshalb sagte ich ja schon es werden nicht die gleichen werte geliefert.
Das selbe wie bei Log.. das gibt es unter Delphi nicht und liefert komplett unter schiedlichewerte als der Ersatz dafür wenn richtig LN

Zitat:

sqrt(x) in Visual Basic und sqrt(x) in Delphi liefern die gleichen Werte.

sqr VB6 und sqr in Delphi? Wunder warum bei mir nicht.

Deshalb habe ich es in Delphi mit sqrt ersetzt.

gruss

[Delphi.Narium]

Zitat:

Zitat von EWeiss (Beitrag 1428470)

Das selbe wie bei Log.. das gibt es unter Delphi nicht und liefert komplett unter schiedlichewerte als der Ersatz dafür wenn richtig LN

Bin mir nicht ganz sicher, aber das Log aus VB müsste in Delphi diesemhier entsprechen:

Delphi-Quellcode:

function Log(x: Real): Real;
begin
  result := ln(x) / ln(10);
end;

[EWeiss]

Zitat:

Zitat von Delphi.Narium (Beitrag 1428472)

Zitat:

Zitat von EWeiss (Beitrag 1428470)

Das selbe wie bei Log.. das gibt es unter Delphi nicht und liefert komplett unter schiedlichewerte als der Ersatz dafür wenn richtig LN

Bin mir nicht ganz sicher, aber das Log aus VB müsste in Delphi diesemhier entsprechen:

Delphi-Quellcode:

function Log(x: Real): Real;
begin
  result := ln(x) / ln(10);
end;

Danke!

Kann ich gerne mal versuchen.
Warum gibt es diese Funktion in Delphi nicht?

Hmmm.. noch um einiges schlimmer als nur LN. Danach tut sich gar nichts mehr

Wenn jemand mitwirken möchte!
Ich benötige 100% kompatible DatenType wenn die Visualisierung so aussehen soll wie im Original.
Nur wie soll das gehen wenn dort LONG und bei mir DWORD verwendet werden muss.

Wäre nett wenn mir jemand zum testen einen gleichlaufenden Sinus Generator Ton hochladen könnte (mp3? ) so im 200Hz spectrum ohne irgendwelche Schwingungen.

gruss

[Delphi.Narium]

Hab' nochmal etwas gesucht:

Log in VB

Zitat:

Returns the natural (base e) logarithm of a specified number or the logarithm of a specified number in a specified base.

Das ist eine überladen Funktion, die mit unterschiedlichen Parametern aufgerufen werden kann.

Wie sieht der Aufruf in Deinem VB-Quelltext aus?

Delphi-Quellcode:

Log(einwert)

oder

Delphi-Quellcode:

log(einwert,10)

oder irgendetwas in dieser Art?

Wenn in VB Log mit zwei Parametern aufgerufen wird, dann könnte das in Delphi so aussehen:

Delphi-Quellcode:

function Log(x, b: Real): Real;
begin
  Result := ln(x) / ln(b);
end;

Wenn der Aufruf mit nur einem Parameter erfolgt, müsste eigentlich das Log aus VB dem Ln aus Delphi entsprechen und damit zum gleichen Ergebnis kommen.

[EWeiss]

Danke..
Habe jetzt einen gleichbleibenden Sinuston sinus250hz-10db leider mit leichter Schwingung.


Delphi.

Delphi-Quellcode:

b := (Log(Sqr(Spectrum[i1].r * Spectrum[i1].r + (Spectrum[i1].i * Spectrum[i1].i))
  + 0.0001) + 9.21034037197618) * q1;

VB6

Code:

b = (Log(Sqr(Spectrum(i1).r * Spectrum(i1).r + Spectrum(i1).i * Spectrum(i1).i) _
  + 0.0001) + 9.21034037197618) * q1

q1 ist immer gleich = 25

Log.. wie von dir vorgeschlagen.

Delphi-Quellcode:

function TSpectrum.Log(x: Real): Real;
begin

  result := ln(x) / ln(10);
end;

VB6

Code:

Public Type Complex
    r As Single
    i As Single
End Type

Dim Spectrum() As Complex

Delphi

Delphi-Quellcode:

  TComplex = Record
    r: Single;
    i: Single;
  end;

Spectrum: array of TComplex;

Unterschied siehe Anhang. (Was aber nicht bedeutet das die Berechnung für Log falsch ist)
Doch sie ist falsch.
Schon hart das wenn nichts gespielt wird der Ausschlag des Spektrum bei deiner Berechnung gleich Volllast ist.

gruss

[Delphi.Narium]

Zitat:

Zitat von Visual Basic

The VBA Sqr function accepts one argument - a positive number - and will return the square root of that number as a Double data type.

Berechnet also die Quadratwurzel einer Zahl.

Zitat:

Zitat von Delphi

In Delphi code, the Sqr function returns the square of the argument.

X is a floating-point expression. The result, of the same type as X, is the square of X, or X*X.

Berechnet das Quadrat einer Zahl.

Die beiden sind also nicht identisch.

Zitat:

Zitat von Delphi

The Sqrt function returns the square root of a Number. The number must be a floating point type.

Berechnet also die Quadratwurzel einer Zahl.

VB sqr -> Delphi sqrt

[EWeiss]

Zitat:

VB sqr -> Delphi sqrt

Ja das hatte ich vorher..

VB sqr\Delphi sqrt
33\184

VB sqr\Delphi sqr
33\130

Was sagt das nun aus.

gruss

[Michael II]

Log(x) in Visual Basic entspricht ln(x) in Delphi.

Visual Basic Log

Wie oben erwähnt gibt es in VB eine überladene Funktion log(x,Basis), welche uns aber hier nicht weiter interessiert.


Der Autor logarithmiert das Spektrum mit ln().

Problem: Wenn das Spektrum gegen 0 geht, dann geht ln(Spektrum) gegen minus Unendlich.

Der Autor wendet hier einen kleinen "Trick" an, damit dies nicht geschieht.

Er hebt das gemessene Spektrum um 0.0001 an. (Das ist Basteln - keine Mathe)

Er rechnet also nicht ln(Spektrum) sondern ln(Spektrum+0.0001).

Weiter will der Autor eine Funktion, welche für Spektrum=0 den Wert 0 annimmt.

Da ln(0+0.0001) = -9.21034037197618 ist, addiert er nun 9.21034037197618 dazu.

Insgesamt

f(x) = ln( sqrt( Sp_Real^2 + Sp_Imag^2 ) + 0.0001 ) + 9.21034037197618.



Zu: sqrt. Sowohl in Delphi wie in Visual Basic liefert sqrt die Quadratwurzel einer Zahl zurück.

https://docs.microsoft.com/en-us/dot...ramework-4.7.2

Bist du sicher, dass im Original-VB-Code sqr steht? Das macht für mich irgendwie wenig Sinn.

Das Spektrum s besteht ja aus einem Realteil sr und einem Imaginärteil si.
Insgesamt s = sqrt( sr*sr + si*si ).

Wo ist der Link auf den Originalcode in VB?

[EWeiss]

Danke Michael für dein Interesse :)
Es ist mir wichtig das alle Datentypen VB6 via Delphi IO sind damit ich das ausschließen kann.
Dazu Nachher mehr.

Zitat:

Bist du sicher, dass im Original-VB-Code sqr steht? Das macht für mich irgendwie wenig Sinn.

Ja das bin ich im Anhang der Source.

Zitat:

Wo ist der Link auf den Originalcode in VB?

Auf den habe ich im ersten Beitrag verlinkt.. werde ihn aber hier hochladen.

Zitat:

Log(x) in Visual Basic entspricht ln(x) in Delphi.

Ist mir unverständlich warum ihr immer auf .NET verweist...
Es geht hier um VB6 nicht um VB.net das sind 2 paar Schuhe!
Deshalb habe ich auch immer extra VB6 addiert damit das nicht verwechselt wird.
Hier kannst du lesen welche werte bzw. Formeln für LOG\SQR gültig sind. SQRT gibt es nicht unter VB6

Zitat:

Quadratwurzel: SQR
Die Funktion SQR berechnet die positive Quadratwurzel einer nicht-negativen Zahl x. Für negative Argumente wird ein Fehler ausgelöst. Es gilt: SQR(x)^2 = x.
a = SQR(x)
b = a ^ 2
Die Variable b enthält den gleichen Wert wie x.

wenn in Delphi dann so?

Delphi-Quellcode:

a := SQRT(x); // wäre noch zu klären
b := Power(2, a);

Zitat:

Wie oben erwähnt gibt es in VB eine überladene Funktion log(x,Basis), welche uns aber hier nicht weiter interessiert.

Nein gibt es nicht nur zur Richtigstellung! Nochmal VB6 nicht VB.Net

Das ist definitiv falsch weil ich dann Vollausschlag habe wenn keine Musik läuft.

Delphi-Quellcode:

function TSpectrum.Log(x: Real): Real;
begin

   result := ln(x) / ln(10);
end;

gruss

[EWeiss]

Für die Interessierten..
Fangen wir beim Anfang an. Und die Quelle

Integer VB = SmallInt in Delphi..

Initialisieren von WaveIn.

Code:

Public Type BUFFER
    Data() As Integer
    Header As WAVEHDR
End Type

Delphi-Quellcode:

TBuffer = Record
  Data: array of SmallInt;
  Header: TWAVEHDR;
end;

Code:

ReDim Buffers(3)
    For i = 0 To UBound(Buffers)
         With Buffers(i)
             ReDim .Data(count - 1)
             .Header.lpData = VarPtr(.Data(0))
             .Header.dwBufferLength = count * 2
             .Header.dwFlags = 0
             .Header.dwLoops = 0
             ret = waveInPrepareHeader(hWave, .Header, Len(.Header))
             If ret Then ShowMessage ret: Exit Function
         End With
    Next i

    For i = 0 To UBound(Buffers)
        ret = waveInAddBuffer(hWave, Buffers(i).Header, Len(Buffers(i).Header))
        If ret Then ShowMessage ret: Exit Function
    Next i
    
    ret = waveInStart(hWave)
    If ret Then ShowMessage ret: Exit Function
    
    InitCapture = True

Delphi-Quellcode:

SetLength(Buffers, 3);
  for i := 0 to High(Buffers) do
  begin
    SetLength(Buffers[i].Data, round(count - 1));
    Buffers[i].Header.lpData := @Buffers[i].Data[0];
    Buffers[i].Header.dwBufferLength := round(count * 2);
    Buffers[i].Header.dwFlags := 0;
    Buffers[i].Header.dwLoops := 0;
    mres := waveInPrepareHeader(WaveIn, @Buffers[i].Header, SizeOf(TWAVEHDR));
    if mres <> 0 then
    begin
      SetMessage(mres);
      exit;
    end;
  end;

  for i := 0 to High(Buffers) do
  begin
    mres := waveInAddBuffer(WaveIn, @Buffers[i].Header, SizeOf(TWAVEHDR));
    if mres <> 0 then
    begin
      SetMessage(mres);
      exit;
    end;
  end;

  mres := waveInStart(WaveIn);
  if mres <> 0 then
  begin
    SetMessage(mres);
    exit;
  end;

  Result := True;

warum er jetzt hier

Code:

Len(Buffers(i).Header))

verwendet entschließ sich mir sollte eigentlich das gleiche sein wie

Code:

Len(.Header))

Wenn nicht muss ich es noch ändern.

Auf die Zuweisungen des Headers habe ich keinen Einfluss die Datentypen sind so wie sie gegeben sind.
Ich muss DWORD in Delphi verwenden wo es angesagt ist und kann mich diesbezüglich nicht auf die Typen von VB6 einlassen.
Wenn das OK ist dann sollte die Initialisierung eigentlich korrekt sein.

Denke das ist übersichtlich und sollte für den Anfang nicht zu viel sein um zu überblicken ob alles OK ist.

Wenn ihr auch der Meinung seid geht es im nächsten Beitrag weiter.

gruss

[Michael II]

Besten Dank für deine VB6 SQR Klarstellung (dein Link):

SQR() in VB entspricht sqrt() ["square root"] in Delphi.
Verwende also wie bereits weiter oben vorgeschlagen in deiner uSound.pas unbedingt sqrt und nicht sqr.
Beispiel VB6: SQR(25)=5 - Delphi sqr(25)=25*25=625 Delphi sqrt(25)=5.


Du hast nach Tönen gesucht:
Wenn du nicht selbst eine WAV Datei schreiben willst (zum Beispiel mit MathLab und Co), dann findest du hier Töne:

https://www.wavtones.com/functiongenerator.php

[TiGü]

Zitat:

Zitat von EWeiss (Beitrag 1428489)

warum er jetzt hier

Code:

Len(Buffers(i).Header))

verwendet entschließ sich mir sollte eigentlich das gleiche sein wie

Code:

Len(.Header))

Wenn nicht muss ich es noch ändern.

Einfach nochmal genau hingucken.
Beim ersten Mal nimmt er ein With-Statment, deswegen kann er Len(.Header) schreiben.
Beim zweiten Mal hat er kein With und muss deswegen Buffers[i] davor schreiben.

Auch auf die Gefahr hin, dass es wieder als persönlicher Angriff aufgefasst wird:
Es wäre empfehlenswert, wenn du dir ein Grundlagenwerk Mathematik der Oberstufe zu legst. Ein suchen bei Internetbuchhandlungen nach "Mathematik Abitur" sollte zum Ziel führen.
Entsprechende Websites und Tutorials gehen natürlich auch.

[EWeiss]

Zitat:

Verwende also wie bereits weiter oben vorgeschlagen in deiner uSound.pas unbedingt sqrt und nicht sqr.

Somit ist das 100% geklärt ;)
Wäre schön wenn das bei den anderen Datentypen auch der fall wäre.. um zu einem gleichen er Ergebnis zu gelangen.
Danke für die Richtigstellung.

gruss

[EWeiss]

Zitat:

Beim zweiten Mal hat er kein With und muss deswegen Buffers[i] davor schreiben.

Ja sorry habe ich übersehen habe selbst über 15 Jahre VB6 Anwendungen geschrieben im Eifer des Gefechts kann das schon mal passieren.
SizeOf(TWaveHeader) ist dann korrekt.

Zitat:

Es wäre empfehlenswert, wenn du dir ein Grundlagenwerk Mathematik der Oberstufe zu legst. Ein suchen bei Internetbuchhandlungen nach "Mathematik Abitur" sollte zum Ziel führen.
Entsprechende Websites und Tutorials gehen natürlich auch.

Danke für den Ratschlag kein Problem.. ;)
Aber ich fange jetzt mit 61 Jahren nicht mehr an mir höhere Mathematik anzueignen es geht doch nur um eine Portierung als Example für meine Bibliothek.

Es freut mich trotzdem wenn hier einige dabei sind die mir weiterhelfen möchten.
Zumal der Thread auch interessant ist für VB6 Umsteiger.. ja es gibt noch genug davon.

gruss

[Michael II]

Und im von dir verlinkten VB6 steht klar:

Zitat:

Natürlicher Logarithmus: LOG
LOG berechnet den Logarithmus zur Basis e (die Eulersche Zahl, e ist ungefähr 2.718282). Dies ist der sogenannte natürliche Logarithmus. Es sind nur positive Argumente erlaubt.

VB6 LOG() entspricht also in Delphi ln()

Du kannst schlicht alle LOG() aus VB6 in Delphi durch ln() ersetzen.

[EWeiss]

Zitat:

Zitat von Michael II (Beitrag 1428494)

Und im von dir verlinkten VB6 steht klar:

Zitat:

Natürlicher Logarithmus: LOG
LOG berechnet den Logarithmus zur Basis e (die Eulersche Zahl, e ist ungefähr 2.718282). Dies ist der sogenannte natürliche Logarithmus. Es sind nur positive Argumente erlaubt.

VB6 LOG() entspricht also in Delphi ln()

Du kannst schlicht alle LOG() aus VB6 in Delphi durch ln() ersetzen.

Danke dann kann ich das hier vergessen da es keinen sinn macht.

Delphi-Quellcode:

function TSpectrum.Log(x: Real): Real;
begin

    result := ln(x) / ln(10);
end;

Trotzdem Danke für den versuch.
Interessanter link ja da steht fast alles was wichtig wäre.

Zitat:

Du hast nach Tönen gesucht:
Wenn du nicht selbst eine WAV Datei schreiben willst (zum Beispiel mit MathLab und Co), dann findest du hier Töne:

Ich habe mir Audacity herunter geladen und mir eine *.mp3 erstellt wer es zum testen haben möchte ist im Anhang.
50 sec linearer Sinus Ton.
Es gibt immer noch große unterschiede zwischen Original und meiner Version.

gruss

[Michael II]

result := ln(x) / ln(10); liefert den Logarithmus zur Basis 10.

Der Autor der VB6 Texts hat aber definitiv den Logarithmus zur Basis e gemeint, also in Delphi ln(). [siehe Konstruktion der Funktion in welcher der Autor ln() verwendet - weiter oben]

Hast du in uSpectrum.pas nun die beiden sqr durch sqrt ersetzt? Du hast dann an insgesamt drei Stellen im uSpectrum.pas Code sqrt stehen. Wenn du dann dein Programm laufen lässt und ins Mikrofon singst :-D, sieht's bereits gar nicht so schlecht aus.

(Ich habe den Eindruck, dass für leise Töne etwas viel angezeigt wird. Eventuell gibt's irgendwo im Code noch ein Skalierungsproblem.)

FFT habe ich nicht überprüft. Ich sehe, dass der Autor einige der 2'048 Einheitswurzeln tabelliert hat und die restlichen aus den tabellierten berechnet.
Man könnte hier sogar alle Einheitswurzeln für ein N einmalig tabellieren und dann nutzen, aber die errechneten Werte sind für deine Anwendung auch so genau genug (Der +0.0001 "Trick" (Anheben des Spektrums in der Funktion, welche ln() verwendet) bewirkt einen höheren Fehler.).

[EWeiss]

Zitat:

Du hast dann an insgesamt drei Stellen im uSpectrum.pas Code sqrt stehen

Es funktioniert ja nur Sector case 1: in meinem source von daher war das schon stimmig da die anderen noch nicht funktionieren.
Aber auch dort habe ich jetzt sqrt addiert. Ist schon stimmig :)

Aber wie gesagt noch gravierende unterschiede.
Sehe ich wenn ich mein Wave abspiele.

SmallInt vom vorherigen Beitrag sollte stimmen von daher ist die Initialisierung eigentlich die gleiche.
Kann aber nicht mit Bestimmtheit sagen das die Probleme nicht von der FFT herrühren was die Datentypen angeht.
Wäre super wenn sich mal jemand die mühe macht das nochmal gegen zu prüfen ;) :duck:

Rings 300hz 10 Octaves (müssten so aussehen aber da kommt bei mir noch gar nichts.

Hmmm…

EDIT:
Einen Fehler habe ich gefunden.
FFT..

Delphi-Quellcode:

  if FView = 0 then
    sr := (4096 * (FGain / 100)) / FFFTSize
  else
  sr := 1 / FFFTSize;

muss aber

Delphi-Quellcode:

  if FView = 0 then
    sr := (4096 * FGain) / FFFTSize
  else
  sr := 1 / FFFTSize;

sein
Macht schon einen großen Unterschied ob 8 oder 0,08

gruss

[EWeiss]

Ein weiteres DatenType Problem

Delphi-Quellcode:

pEx := (Power(FOctaveCount + 1, 2) / 2); // in Delphi 32

Code:

pEx = ((2 ^ (mOctaveCount + 1)) / 2) ' in VB 128

ok:
sorry war verdreht..

Delphi-Quellcode:

pEx := (Power(2, FOctaveCount + 1) / 2);

kann es sein das diese Berechnung falsch ist nach der Änderung von Integer zu SmallInt?

Delphi-Quellcode:

procedure TSpectrum.ToComplex(Dat: array of SmallInt; var Out: array of TComplex);
var
  i, p: Integer;
begin
  p := 0;

  for i := 0 to (FFFTSize  * 2 - 1) do
  begin
    if i mod 2 <> 0 then
      continue;

    Out[p].r := (((Dat[i]) + Dat[i + 1]) / 65536) * Window_[p];
    Out[p].i := 0;
    inc(p);
  end;
end;

Mich irritieren die / 65536
Weil irgendwas stimmt mit den Spectrumdaten nicht die sind bei mir einfach zu hoch.

gruss

[Delphi.Narium]

32 := 2^5
128 := 2^7

Überprüf' bitte mal, ob FOctaveCount unter Delphi den gleichen Wert zugewiesen bekommt, wie unter VB.

Der Unterschied zwischen

Code:

pEx = ((2 ^ (mOctaveCount + 1)) / 2) ' in VB 128

und

Code:

pEx := (Power(2, FOctaveCount + 1) / 2); // in Delphi 32

wäre für meine Begriffe nur dadurch zu erklären, dass in Delphi FOctaveCount = 5 und mOctaveCount in VB = 7 ist.

Code:

pEx = ((2 ^ (7 + 1)) / 2) ' in VB 128
pEx = ((2 ^ (8)) / 2) ' in VB 128
pEx = ((256) / 2) ' in VB 128
pEx = (128) ' in VB 128

Code:

pEx := (Power(2, 5 + 1) / 2); // in Delphi 32
pEx := (Power(2, 6) / 2); // in Delphi 32
pEx := (64 / 2); // in Delphi 32
pEx := (32); // in Delphi 32

Da der Wert aus der Ini-Datei gelesen werden kann, prüf' bitte mal, ob es dort Unterschiede gibt.

[EWeiss]

Zitat:

wäre für meine Begriffe nur dadurch zu erklären, dass in Delphi FOctaveCount = 5 und mOctaveCount in VB = 7 ist.

Ich habe mich da vertan

Vielleicht hast du die Korrektur übersehen.

Zitat:

sorry war verdreht..
pEx := (Power(2, FOctaveCount + 1) / 2);

warum ist in Delphi FOctaveCount = 5 ? ist das gleiche wie in VB "7" + die 1 dann 8 natürlich.
Ach so das war nur eine Annahme von dir.. Sorry habe ich falsch interpretiert.

so habe ich die 128..
frage mich aber noch was mit dem ist.

Zitat:

Mich irritieren die / 65536

Ist echt schwierig da auf den gleichen Nenner zu kommen.

gruss

[Delphi.Narium]

Was ich jetzt mache, ist nur noch "Spekulatius" ;-)

Delphi-Quellcode:

 Out[p].r := (((Dat[i]) + Dat[i + 1]) / 65536) * Window_[p];

Dat = SmallInt -> -32768..32767
Dat[i] + Dat[i + 1] = maximal 65536.

Wenn also Dat[i] und Dat[i + 1] irgendwo zwischen 0 und 32767 liegen, kommt irgendwas zwischen 0 und 65536 bei der Addition heraus. Dividieren wir nun durch 65536, liegt das Ergebnis irgendwo zwischen 0 und 1.

Window_[*] wird in InitHamming befüllt.

Delphi-Quellcode:

for n := 0 to FFFTSize - 1 do
    Window_[n] := 0.53836 - 0.46164 * Cos(6.28318530717959 * n / (FFFTSize {- 1}));

Code:

For n = 0 To mFFTSize - 1
   Window(n) = 0.53836 - 0.46164 * Cos(6.28318530717959 * n / (mFFTSize - 1))

In der Delphiquelle ist das -1 auskommentiert. Kann mir zwar nicht vorstellen, dass das jetzt sehr gravierende Auswirkungen hat, aber wirklich weiß ich das nicht.

Könntest Du mal den Inhalt von Window_ jeweils ausgeben und die Werte dadrin miteinander vergleichen?

Wenn hier inhaltlich irgendwelche Unterschiede sein sollten, so kann das gravierende Auswirkungen auf die weiteren Berechnungen haben.

[EWeiss]

Zitat:

Könntest Du mal den Inhalt von Window_ jeweils ausgeben und die Werte dadrin miteinander vergleichen?

Werde ich mal machen. .Danke

Zitat:

Wenn also Dat[i] und Dat[i + 1] irgendwo zwischen 0 und 32767 liegen, kommt irgendwas zwischen 0 und 65536 bei der Addition heraus. Dividieren wir nun durch 65536, liegt das Ergebnis irgendwo zwischen 0 und 1.

Scheint dann wohl in Ordnung zu sein das es mit 65536 dividiert wird.
Dachte nur der wert müsste höher sein.

gruss

[EWeiss]

Habe jetzt mal nur InitHamming Analysiert..
Daten sind wie folgt.

Code:

Delphi
// mit - 1
0,076719999313
0,076722174883
0,076728701591
0,076739571989
0,076754793525
0,0767743662
0,076798290014
0,076826557517
0,076859176159
0,076896138489

VB6
: Window(0) : 0,07672 : Single : modMain.InitHamming
: Window(1) : 7,672217E-02 : Single : modMain.InitHamming
: Window(2) : 0,0767287 : Single : modMain.InitHamming
: Window(3) : 7,673957E-02 : Single : modMain.InitHamming
: Window(4) : 7,675479E-02 : Single : modMain.InitHamming
: Window(5) : 7,677437E-02 : Single : modMain.InitHamming
: Window(6) : 7,679829E-02 : Single : modMain.InitHamming
: Window(7) : 7,682656E-02 : Single : modMain.InitHamming
: Window(8) : 7,685918E-02 : Single : modMain.InitHamming
: Window(9) : 7,689614E-02 : Single : modMain.InitHamming

Delphi
// ohne - 1
0,076719999313
0,076722174883
0,07672868669
0,076739549637
0,076754763722
0,076774314046
0,076798208058
0,076826453209
0,076859034598
0,076895967126

Wie man sehen kann weichen die Daten extrem von VB6 ab.
Habe mich gefragt warum. Das einzige das in frage kommt ist Cosinus "Cos"

Delphi-Quellcode:

Window_[n] := 0.53836 - 0.46164 * Cos(6.28318530717959 * n / (FFFTSize - 1));

also nur Cosinus analysiert und das kommt dabei raus.

VB6: Die ersten 10 Einträge
1
0,9999953
0,9999812
0,9999576
0,9999246
0,9998822
0,9998304
0,9997692
0,9996985
0,9996185
0,9995289

Delphi:
Die ersten 10 einträge von Cos() sind 1
von 11 > 18 ist die Value '0,999'

Nun da darf man sich nicht wundern das nichts funktioniert..
Was ist da wieder im argen.

Habe das Minus 1 wieder aktiviert.

gruss

[Michael II]

Deine Berechnung:
VB Window(3) : 7,673957E-02
Delphi 0,076739571989

7,673957E-02 bedeutet 7,673957 * 10^(-02) = 0,07673957
und dies entspricht dem Wert, den du mit Delphi erhältst.

[EWeiss]

Zitat:

Zitat von Michael II (Beitrag 1428524)

Deine Berechnung:
VB Window(3) : 7,673957E-02
Delphi 0,076739571989

7,673957E-02 bedeutet 7,673957 * 10^(-02) = 0,07673957
und dies entspricht dem Wert, den du mit Delphi erhältst.

Warum sind denn dann die Cosinus werte unterschiedlich..

Danke noch für die Info dann scheinen die werte Window(n) identisch zu sein oder nur der eine?

gruss

[jfheins]

Zitat:

Zitat von EWeiss (Beitrag 1428522)

Habe jetzt mal nur InitHamming Analysiert..
Daten sind wie folgt.
[...]

Wie man sehen kann weichen die Daten extrem von VB6 ab.

Hä? Die sind quasi identisch. Kommst du vll. gerade mit der exponentiellen Notation durcheinander?
Anhang 50888

Zitat:

Habe mich gefragt warum. Das einzige das in frage kommt ist Cosinus "Cos"

Delphi:
Die ersten 10 einträge von Cos() sind 1
von 11 > 18 ist die Value '0,999'

Nun da darf man sich nicht wundern das nichts funktioniert..
Was ist da wieder im argen.

Habe das Minus 1 wieder aktiviert.
gruss

Ich hoffe, der ist in VB6 auch in rad, ansonsten tippe ich wieder auf ein string/Anzeige-Problem ;-)

[EWeiss]

Zitat:

Ich hoffe, der ist in VB6 auch in rad, ansonsten tippe ich wieder auf ein string/Anzeige-Problem

Wie meinst du das?

Zitat:

Hä? Die sind quasi identisch.

Hmm nach deiner Tabelle zu urteilen eigentlich nicht.
Und genau das kann schon der unterschied sein bei der Visuellen Darstellung.

Zitat:

Kommst du vll. gerade mit der exponentiellen Notation durcheinander?

Nö habe von höherer Mathematik keine Ahnung..
Deshalb bin ich froh das hier einige Helfen um von mir überprüfte Datentypen und Ergebnisse zu bestätigen so das ich sicher sein kann das sie stimmen.
Besonders Michael II Daumen Hoch. :thumb:

Hmmm..bekomme die Rings nicht ans laufen. Aber wird schon irgendwann.

gruss

[TiGü]

Q.e.d.
Das passiert, wenn jemand ohne grundlegende (nix mit höhere) mathematische Kenntnisse versucht, Sachen umzusetzen, ohne sich im geringsten freiwillig fortbilden zu wollen.

Das ist ja nun alles kein Hexenwerk.
Nimm dir zwei, drei Stunden, um dich per Wikipedia und Nachhilfeseiten über die wichtigsten Stichwörter schlau zu machen, sonst wird das hier nur eine Farce.
Exponentialschreibweise...Herr im Himmel.:shock:

[EWeiss]

Zitat:

Das passiert

Was passiert denn?
Außer das ich Zeit in mein Hobby investiere.

Wenn du doch so über schlau bist im Gegensatz zu mir dann helfe doch bitte hier mit und gut ist.
Eventuell können dann andere etwas davon lernen.

60% deiner Beiträge sind nur darauf aus hier rumzusticheln wieso kannst du es einfach nicht mal lassen?
Mache es doch so wie Michael II der zieht auch nicht über mich her.

PS:
Ach so vergessen.. Am ende zählt das Ergebnis.

gruss

[Michael II]

Hoi EWeiss

eventuell solltest du deine FFT Funktion testen.

Ich meine damit:
Du hast ja die VB Version (ich habe VB nicht installiert) und die Delphi Version.

Du könntest mal deiner FFT Funktion und der VB Version den gleichen Array of Complex "füttern" und abspeichern was die beiden FFT Funktionen zurück liefern.

Hier findest du ein Onlinetool, mit welchem du deine FFT auch direkt überprüfen kannst:
http://scistatcalc.blogspot.com/2013...alculator.html

Du kannst deiner FFT auch einen kurzen Array von Länge 8 füttern.

Zu FFT:
Eine sehr gute Einführung findest du hier:
http://www.iti.fh-flensburg.de/lang/...en/fft/fft.htm

https://en.wikipedia.org/wiki/Cooley..._FFT_algorithm

Jene, welche schreiben, dass FFT für sie zu einfach ist, sollen doch entweder dir helfen oder aber etwas auf ihrem Mathematik Niveau lesen. Ich empfehle hier Artins wunderbares kleines Büchlein zur Galois Theorie oder vielleicht etwas Neueres; zum Beispiel aus dem Gebiet der Algebraischen Topologie, Andrew Wiles Beweis zum grossen Satz von Fermat. Viel Spass.

[EWeiss]

Zitat:

Jene, welche schreiben, dass FFT für sie zu einfach ist

Es ist von jeher eines der schwierigsten Mathematischen Berechnungen die ich für meine Bereiche kenne.
Ich bin wenigstens noch so ehrlich und gebe zu das ich es nicht beherrsche und versuche hier nicht den Klugscheißer herauszulassen.
Sorry für das harte Wort.

Dabei habe ich ein paar seiten vorher noch geschrieben das ich mit meinen 61 Jahren keinen Bock mehr darauf habe mich in solcher Materie einzuarbeiten
Destotrotz hindert es mich nicht daran es in irgendeiner weise umzusetzen.

Tut mir leid das ich kein Mathegenie bin Herr TiGü wie auch immer.

Zitat:

eventuell solltest du deine FFT Funktion testen.

Ich kann es nur anhand von vergleichen testen wie gesagt Ich beherrsche es nicht.

gruss

[Michael II]

Unbedingt korrigieren:

Delphi-Quellcode:

procedure TSpectrum.FFT( [B]var[/B] Dat: array of TComplex );

(Weil var fehlte rechnete FFT für die Katz ;-) und dein Programm stellte die gemessenen Stützpunkte der Tonkurve dar und nicht wie gewollt das Spektrum.)


Deine FFT Prozedur könntest du so testen:

Delphi-Quellcode:

procedure TSpectrum.FFT(Dat: array of TComplex);
var
  i, j, n, K , io, ie, in_, nn: Integer;
  u, tp, tq, w: TComplex;
  sr: Single;

begin
  if not FFTInit then
  begin
    InitFFT;
    FFTInit := True;
  end;

  // zum Beispiel durch Überschreiben von Dat durch cos(x)
  for i := 0 to FFFTSize -1 do
  begin
    h[i].r := cos(i/FFFTSize*2*pi);
    h[i].i := 0;
  end;

Setze einen Breakpoint am Ende von FFT. Prüfe, ob FFT Dat[1].r = Date[FFFTSize-1].r = 0.5 und Dat[]=0 für alle anderen Werte.

[EWeiss]

Zitat:

Unbedingt korrigieren:

Werde ich sofort tun.. Danke. ;)

EDIT:
Hat aber ein sehr seltsames verhalten.
Hast du das mal selbst versucht?

Verstehe jetzt nicht wie du das meinst

einfach

Delphi-Quellcode:

  for i := 0 to FFFTSize -1 do
  begin
     Dat[i].r := cos(i/FFFTSize*2*pi);
     Dat[i].i := 0;
  end;

einfügen und dann normal durchlaufen lassen?
Oder dahinter ein Exit um aus der Funktion zu springen.

gruss

[Delphi.Narium]

Zitat:

Zitat von EWeiss (Beitrag 1428527)

Zitat:

Ich hoffe, der ist in VB6 auch in rad, ansonsten tippe ich wieder auf ein string/Anzeige-Problem

Wie meinst du das?

Die Ausgabe der Zahlen erfolgte in Delphi mit 12 Nachkommastellen und in VB mit 7. D. h.: Bei der Ausgabe werden die weiteren Nachkommastellen auf- oder abgerundet.
Bzw. bei

Zitat:

Delphi:
Die ersten 10 einträge von Cos() sind 1
von 11 > 18 ist die Value '0,999'

wird die Anzeige auf drei Nachkommastellen gerundet.

Das die ersten 10 Werte bei Delphi in der Ausgabe als 1 erscheinen, liegt daran, dass sie sich erst ab der vierten Nachkommastelle unterscheiden. Die vierte und folgende Nachkommastellen werden bei der Ausgabe aber auf drei Nachkommastellen gerundet. Diese Rundung führt dazu, dass die Werte nicht mehr unterscheidbar sind.
Bei derartigen Zahlen, die sich nur marginal unterscheiden, führt die Ausgabe häufig zu einer fehlerhaften Anzeige der Werte. Die tatsächlichen Werte in den Variabeln sind jedoch korrekt.

Hier mal ein Pascalscript und seine Ausgabe. Hier wird recht gut deutlich, was mit

Zitat:

ansonsten tippe ich wieder auf ein string/Anzeige-Problem

gemeint ist:

Delphi-Quellcode:

program Test;
const
  pi = 3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196442881097566593344612847564823378678316527120190914564856692346034861045432664821339360726024914127372458700660631558817488152092096282925409171536436789259036001133053054882046652138414695194151160943305727036575959195309218611738193261179310511854807446237996274956735188575272489122793818301194912;
var
        i : Integer;
        x : Double;
        n : Double;
        FFFTSize : Integer;
        sl : TStringList;
begin
  sl := TStringList.Create;
  FFFTSize := 2048;
  for i := 0 to 10 do begin
    n := i;
    x := 0.53836 - 0.46164 * Cos(6.28318530717959 * n / (FFFTSize - 1));
    sl.Add(Format('%1.18f - %1.3f',[x,x]));
  end;
  sl.Add('');
  for i := 0 to FFFTSize -1 do begin
    n := i;
    x := cos(n / FFFTSize * 2.0 * pi);
    sl.Add(Format('%.4d - %1.18f - %1.3f - %1.18f - %1.3f',[i,x,x, pi,pi]));
  end;
  sl.SaveToFile('String_Anzeige-Problem.txt');
  sl.Free;
end.

Ein Auszug aus dem Ergebnis, das sich vollstänig in der anhängenden Datei befindet:

Code:

0,076719999999999949 - 0,077
0,076722174688946714 - 0,077
0,076728698735298086 - 0,077
0,076739572077587136 - 0,077
0,076754794613369869 - 0,077
0,076774366199225946 - 0,077
0,076798286650760166 - 0,077
0,076826555742603994 - 0,077
0,076859173208418010 - 0,077
0,076896138740894182 - 0,077
0,076937451991758771 - 0,077

0000 - 1,000000000000000000 - 1,000 - 3,141592653589793280 - 3,142
0001 - 0,999995293809576192 - 1,000 - 3,141592653589793280 - 3,142
0002 - 0,999981175282601088 - 1,000 - 3,141592653589793280 - 3,142
0003 - 0,999957644551963904 - 1,000 - 3,141592653589793280 - 3,142
0004 - 0,999924701839144448 - 1,000 - 3,141592653589793280 - 3,142
0005 - 0,999882347454212608 - 1,000 - 3,141592653589793280 - 3,142
0006 - 0,999830581795823360 - 1,000 - 3,141592653589793280 - 3,142
0007 - 0,999769405351215232 - 1,000 - 3,141592653589793280 - 3,142
0008 - 0,999698818696204288 - 1,000 - 3,141592653589793280 - 3,142
0009 - 0,999618822495178624 - 1,000 - 3,141592653589793280 - 3,142
0010 - 0,999529417501093120 - 1,000 - 3,141592653589793280 - 3,142
0011 - 0,999430604555461760 - 0,999 - 3,141592653589793280 - 3,142
0012 - 0,999322384588349568 - 0,999 - 3,141592653589793280 - 3,142
0013 - 0,999204758618363904 - 0,999 - 3,141592653589793280 - 3,142
0014 - 0,999077727752645376 - 0,999 - 3,141592653589793280 - 3,142
0015 - 0,998941293186856832 - 0,999 - 3,141592653589793280 - 3,142
0016 - 0,998795456205172352 - 0,999 - 3,141592653589793280 - 3,142
0017 - 0,998640218180265216 - 0,999 - 3,141592653589793280 - 3,142
0018 - 0,998475580573294720 - 0,998 - 3,141592653589793280 - 3,142
0019 - 0,998301544933892864 - 0,998 - 3,141592653589793280 - 3,142
0020 - 0,998118112900149120 - 0,998 - 3,141592653589793280 - 3,142
0021 - 0,997925286198595968 - 0,998 - 3,141592653589793280 - 3,142
0022 - 0,997723066644191616 - 0,998 - 3,141592653589793280 - 3,142
0023 - 0,997511456140303488 - 0,998 - 3,141592653589793280 - 3,142
0024 - 0,997290456678690176 - 0,997 - 3,141592653589793280 - 3,142
0025 - 0,997060070339483008 - 0,997 - 3,141592653589793280 - 3,142
...
1525 - -0,033741171851377760 - -0,034 - 3,141592653589793280 - 3,142
1526 - -0,030674803176636486 - -0,031 - 3,141592653589793280 - 3,142
1527 - -0,027608145778966163 - -0,028 - 3,141592653589793280 - 3,142
1528 - -0,024541228522912387 - -0,025 - 3,141592653589793280 - 3,142
1529 - -0,021474080275469286 - -0,021 - 3,141592653589793280 - 3,142
1530 - -0,018406729905805165 - -0,018 - 3,141592653589793280 - 3,142
1531 - -0,015339206284988122 - -0,015 - 3,141592653589793280 - 3,142
1532 - -0,012271538285719624 - -0,012 - 3,141592653589793280 - 3,142
1533 - -0,009203754782060083 - -0,009 - 3,141592653589793280 - 3,142
1534 - -0,006135884649154417 - -0,006 - 3,141592653589793280 - 3,142
1535 - -0,003067956762965594 - -0,003 - 3,141592653589793280 - 3,142
1536 - -0,000000000000000184 - 0,000 - 3,141592653589793280 - 3,142
1537 - 0,003067956762966115 - 0,003 - 3,141592653589793280 - 3,142
1538 - 0,006135884649154048 - 0,006 - 3,141592653589793280 - 3,142
1539 - 0,009203754782059716 - 0,009 - 3,141592653589793280 - 3,142
1540 - 0,012271538285720144 - 0,012 - 3,141592653589793280 - 3,142
1541 - 0,015339206284987754 - 0,015 - 3,141592653589793280 - 3,142
1542 - 0,018406729905804797 - 0,018 - 3,141592653589793280 - 3,142
1543 - 0,021474080275469805 - 0,021 - 3,141592653589793280 - 3,142
1544 - 0,024541228522912022 - 0,025 - 3,141592653589793280 - 3,142
1545 - 0,027608145778965795 - 0,028 - 3,141592653589793280 - 3,142
1546 - 0,030674803176637005 - 0,031 - 3,141592653589793280 - 3,142
1547 - 0,033741171851377402 - 0,034 - 3,141592653589793280 - 3,142
...
2022 - 0,996820299291165824 - 0,997 - 3,141592653589793280 - 3,142
2023 - 0,997060070339483008 - 0,997 - 3,141592653589793280 - 3,142
2024 - 0,997290456678690176 - 0,997 - 3,141592653589793280 - 3,142
2025 - 0,997511456140303488 - 0,998 - 3,141592653589793280 - 3,142
2026 - 0,997723066644191616 - 0,998 - 3,141592653589793280 - 3,142
2027 - 0,997925286198595968 - 0,998 - 3,141592653589793280 - 3,142
2028 - 0,998118112900149120 - 0,998 - 3,141592653589793280 - 3,142
2029 - 0,998301544933892736 - 0,998 - 3,141592653589793280 - 3,142
2030 - 0,998475580573294720 - 0,998 - 3,141592653589793280 - 3,142
2031 - 0,998640218180265216 - 0,999 - 3,141592653589793280 - 3,142
2032 - 0,998795456205172352 - 0,999 - 3,141592653589793280 - 3,142
2033 - 0,998941293186856832 - 0,999 - 3,141592653589793280 - 3,142
2034 - 0,999077727752645376 - 0,999 - 3,141592653589793280 - 3,142
2035 - 0,999204758618363904 - 0,999 - 3,141592653589793280 - 3,142
2036 - 0,999322384588349568 - 0,999 - 3,141592653589793280 - 3,142
2037 - 0,999430604555461760 - 0,999 - 3,141592653589793280 - 3,142
2038 - 0,999529417501093120 - 1,000 - 3,141592653589793280 - 3,142
2039 - 0,999618822495178624 - 1,000 - 3,141592653589793280 - 3,142
2040 - 0,999698818696204288 - 1,000 - 3,141592653589793280 - 3,142
2041 - 0,999769405351215232 - 1,000 - 3,141592653589793280 - 3,142
2042 - 0,999830581795823360 - 1,000 - 3,141592653589793280 - 3,142
2043 - 0,999882347454212608 - 1,000 - 3,141592653589793280 - 3,142
2044 - 0,999924701839144448 - 1,000 - 3,141592653589793280 - 3,142
2045 - 0,999957644551963904 - 1,000 - 3,141592653589793280 - 3,142
2046 - 0,999981175282601088 - 1,000 - 3,141592653589793280 - 3,142
2047 - 0,999995293809576192 - 1,000 - 3,141592653589793280 - 3,142