Je cherche à utiliser la bibliothèque FFTW qui permet de calculer rapidement des transformées de Fourier. Mon objectif est de traduire des codes python qui fonctionnent bien en Purebasic pour faire un logiciel exécutable, rapide et simple à installer. En plus, cela m'amuse de le faire en PB.
J'ai repéré deux rubriques traitant de ce sujet :
- la plus ancienne : http://www.purebasic.fr/english/viewtop ... 27&t=34813. J'ai tenté de faire tourner ce code sans succès.
- la plus récente, qui reprend le code de la précédente, qui semble avoir trouvé une solution mais est en allemand (je vais devoir m'y remettre après XX années : http://www.purebasic.fr/german/viewtopi ... =3&t=28827
Le code appelle les .LIB via "ImportC".
Je pensais plutôt utiliser les .DLL et les prototypes mais je n'y parviens pas. J'ai donc tenté avec CallFunction et CallCFunction sans succès : le programme tourne (du moins il ne se plante pas) mais affecte 0 aux vecteurs d'entrée et de sortie après l'appel de "fftw_plan_dft_1d".
Quelqu'un a-t-il déjà utilisé cette bibliothèque ?
Par avance merci pour vos retours. Je place mon code ci-après.
François
Code : Tout sélectionner
;*************************************************************************************************:
;*************************************************************************************************:
;*************************************************************************************************:
; :
; :
; ********************************** :
; *** FFTW_X *** :
; ********************************** :
; :
; :
; VERSION 0 : - Essai avec prototypes pour contrôler les fonctions de la DLL. :
; ----------- - La fonction "fftw_malloc" retourne la taille, en octet, réservée en méloire ? :
; - Dans cette version, on peut lister les fonctions de la DLL. :
; :
; VERSION 1 : - Programme provenant du forum allemand PureBasic : :
; ----------- - http://www.purebasic.fr/german/viewtopic.php?f=3&t=28827 :
; :
; VERSION 2 : - Essai en appelant les fonctions dans la bibliothèque "fftw.lib". :
; ---------- - Cela ne marche pas. :
; :
; VERSION 3 : - Essai d'appel de "fftw_malloc" via "CallFunction" : une adresse semble être :
; ----------- retournée. :
; :
; VERSION 4 : - Essai de FFT 1D sur un signal "porte" : la FFT doit être un sinc. :
; ----------- - Utilisation de la fonction "CPlot" élémentaire. :
; :
;*************************************************************************************************:
;=================================================================================================:
; === ENUMERATIONS ET STRUCTURES === :
;=================================================================================================:
Enumeration
#_FFTW ; Constante pour la DLL "FFTW".
EndEnumeration
#FFTW_FORWARD = -1
#FFTW_BACKWARD = 1
#FFTW_MEASURE = (0)
;_________________________________________________________________________________________________:
; Construction de la structurecomplexe suivant l'exemple de la version 1. :
; TESTER : passage d'une structure simple partie réelle et partie imaginaire comme dans FFTW_0. :
;_________________________________________________________________________________________________:
Structure fftw_complexArray
d.d[2]
EndStructure
Structure fftw_complex
StructureUnion
d.d[2]
c.fftw_complexArray[0]
EndStructureUnion
EndStructure
Structure fftw_plan
EndStructure
;-------------------------------------------------------------------------------------------------:
; --- PARAMETRES ET VARIABLES --- :
;-------------------------------------------------------------------------------------------------:
inSize.l = 1000 ; Taille du vecteur.
Lp = 100 ; Largeur de la porte.
;-------------------------:
; Ouverture de la DLL :
;-------------------------:
Ret = OpenLibrary(#_FFTW, "C:\Users\Utilisateur\Documents\Projets\HoloScope\Logiciels\FFT\FFTW\FFTW64\libfftw3-3.dll")
Debug "Ouverture DLL : " + Str(Ret)
;--------------------------------------------------------------------------------:
; INFO : contrôle de la profondeur de codage de la structure "fftw_complexe" :
;--------------------------------------------------------------------------------:
Debug "Profondeur de codage de la structure fftw_complex: " + Str(SizeOf(fftw_complex))
;----------------------------------------------------:
; Test d'allocation de mémoire avec "fftw_maloc" :
;----------------------------------------------------:
*in.fftw_complex = CallFunction(#_FFTW,"fftw_malloc",SizeOf(fftw_complex)*inSize)
*out.fftw_complex = CallFunction(#_FFTW,"fftw_malloc",SizeOf(fftw_complex)*inSize)
Debug "Pointeur sur mémoire allouée à in : " + Str(*in)
Debug "Pointeur sur mémoire allouée à out : " + Str(*out)
;-----------------------------------------------------------------------:
; Affectation partie réelle et partie imaginaire du vecteur initial :
;-----------------------------------------------------------------------:
For i = 0 To inSize-1
*in\c[i]\d[0] = Cos(2 * #PI * i / 100)
*in\c[i]\d[1] = Sin(2 * #PI * i / inSize)
*out\c[i]\d[0] = 1
*out\c[i]\d[1] = 2
Debug (RSet(Str(i), 5, " ") + " = " + StrD(*in\c[i]\d[0]) + " + " + RSet(StrD(*in\c[i]\d[1], 5), 10, " ") + " . i")
Next
;------------------------------:
; Test du calcul de la FFT :
;------------------------------:
*plan = CallFunction(#_FFTW, "fftw_plan_dft_1d", inSize, *in, *out, #FFTW_FORWARD, #FFTW_MEASURE)
CallFunction(#_FFTW, "fftw_execute", *plan)
;-----------------------:
; Valeurs de sortie :
;-----------------------:
For i = 0 To inSize-1
Debug (RSet(Str(i), 5, " ") + " = " + StrD(*in\c[i]\d[0]) + " + " + RSet(StrD(*in\c[i]\d[1], 5), 10, " ") + " . i")
Next
;-------------------------------------------------------------------------------------------------:
; Test de libération de la mémoire : si la taille allouée est importante, "fftw_free" libère :
; bien la mémoire. Le deuxième appel à la zone mémoire renvoie une erreur. :
; Pour des tailles plus petites, il semble que la mémoire est toujours accessible :
; (pas d'erreur). :
;-------------------------------------------------------------------------------------------------:
Debug "Avant fftw_free : " + Str(*in\c[inSize-1]\d[0])
CallFunction(#_FFTW, "fftw_destroy_plan", *plan)
CallFunction(#_FFTW, "fftw_free", *in)
CallFunction(#_FFTW, "fftw_free", *out)
Debug "Après fftw_free : " + Str(*in\c[inSize-1]\d[0])