Discussion :

[ol9245]

Bonjour,

un capteur me donne une donnée toutes les 5 minutes. J'ai plusieurs dizaines d'années de données. Je voudrais transformer ce signal à pas de temps constant en un tableau date-valeur. dans cette conversion, je veux sélectionner le moins de dates possibles pour restituer le signal avec la meilleure qualité possible.

Ce problème ressemble, en 1D, à un problème 2D bien connu : générer un maillage triangulaire à partir de valeurs connues sur une grille fine et carrée. Par contre, je ne trouve pas d'implantation de cette version 1D.

Merci de toute piste vers un algo existant.

[souviron34]

tu as beaucoup d'algos possibles..

Le plus simple est la moyenne glissante. : tu fais la moyenne sur 3, 5, 7 points à ton choix, et tu remplaces le point milieu par cette moyenne..

Tu peux aussi faire une interpolation par un polynôme ou un spline, et du coup tu pourras choisir chaque coordonnée pour laquelle tu voudras avoir la valeur..

Aurais-tu un exemple de ta courbe initiale ?? ça donnerait des idées.. A priori, il est difficile "dans l'absolu" de donner une indication plus précise..

[ol9245]

Merci pour ton passage,

tu as beaucoup d'algos possibles..

Le plus simple est la moyenne glissante.

non : ça dégrade le signal de manière aveugle.

Tu peux aussi faire une interpolation par un polynôme ou un spline, et du coup tu pourras choisir chaque coordonnée pour laquelle tu voudras avoir la valeur..

idem (bien que en moins pire). mais il faut encore déterminer quel point garder.

Aurais-tu un exemple de ta courbe initiale ?? ça donnerait des idées.. A priori, il est difficile "dans l'absolu" de donner une indication plus précise..

Pas de données pour l'instant. Il s'agit de mesures de hauteur d'eau dans une petite rivière. Mais pas question de faire des heuristiques dédiés. Je cherche une méthode générale et éprouvée. J'ai regardé ce qui se fait en simplification de maillage 3D. C'est ce genre de truc qu'il me faut, mais en 1D donc beaucoup plus simple.

[souviron34]

idem (bien que en moins pire). mais il faut encore déterminer quel point garder.

Exact, mais quand on génère un maillage triangulaire à partir d'un maillage carré, d'une part chaque carré est divisable en 2 (ou 4) triangles, et d'autre part la matrice est entièrement remplie (initialement ou par interpolations bilinéaires) avant le maillage triangulaire, non ?

PS: pour des hauteurs d'eau, tu dois pouvoir assumer le fait que la courbe est continue en dérivées.. Sauf éventuellement crue subite.. Ce qui tendrait à sous-tendre une approche par "modélisation"..

[ol9245]

en attendant mieux, j'ai fait ça (c'est du matlab).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
function demo_resample_serie_hydro
 
preparer_figures ;
 
% Générer le signal original
[T, S] = signal_original ;
T0 = T ;
S0 = S ;
 
% 8 rééchantillonages successifs = garder successivement
% 68%    47%    32%    22%    15%    10%     7%  et 5% des points
for k=1:8
 
    % 1 rééchantillonage = 15 passages de l'algo = garder 2/3 des points environ
    for u=1:15
 
        % pour chaque point de rang pair,
        % calcule l'aire qui sera coupées si ce point est supprimé 
        A = aire_coupee(T, S) ;
 
        % le seuil correspond à 5% de points virés parmi les points de rang pair
        seuil = prctile(A, 5) ;
 
        % tous les points sont gardés par défaut
        garder = true (1, numel(T)) ;
 
        % les 95% meilleurs points de rang pair sont gardés, les 5% restants sont supprimés
        L = floor((numel(T)-1)/2) ;
        garder(2:2:2*L) = A>=seuil ;
 
        % efectue la sélection
        S = S(garder) ;
        T = T(garder) ;
 
    end
 
    disp(numel(T))
    figure (1)
    subplot(4,2,k)
    % plot(T0, S0, '-k', 'LineWidth', 0.1)
    hold on
    plot(T, S, '.-k', 'MarkerSize', 4)
    axis tight
    title (sprintf('%d passages, %d points restant', k*u, numel(T)), 'FontSize', 12)
    drawnow
 
end
 
figure (2)
plot(T0, S0, '-k', 'LineWidth', 0.1)
hold on
plot(T, S, '.b', 'MarkerSize', 6)
axis tight
title ({sprintf('%d passages, %d points restant.', k*u, numel(T)) 'Points selectionnes sur signal original'}, 'FontSize', 12)
drawnow
 
figure (3)
plot(T, S, '-k', 'LineWidth', 0.1)
hold on
plot(T, S, '.b', 'MarkerSize', 6)
axis tight
title ({sprintf('%d passages, %d points restant.', k*u, numel(T)) 'Signal degrade'}, 'FontSize', 12)
drawnow
 
end
 
 
function A = aire_coupee(T, S)
% qualifie les points de rang i, pair, par A = l'aire du triange formé par les points de rang i-1, i, i+1.
% entrée : T = temps, S = signal.
% Sortie : A = un vecteur comportant autant de points que de rangs pairs
% dans la série privée du dernier point.
 
hauteur = diff(S) ; % hauteur entre un point et son suivant
hauteur_ip = hauteur(1:2:end) ; % hauteur entre un point impair et son suivant
temps = diff(T) ; % temps entre deux points consécutifs
temps_ii = diff(T(1:2:end)) ; % temps entre deux points impairs consécutifs
 
% Taille de sortie. 
% C'est le nombre de points de rang pairs dans la série privée du dernier point
% (2 -> 0, 3 -> 1, 4 -> 1)
L = floor((numel(T)-1)/2) ;
 
hauteur_ii = diff(S(1:2:end)) ; % hauteur entre deux points impairs consécutifs
pente_ii = hauteur_ii(1:L) ./ temps_ii(1:L) ; % pente entre deux points impairs consécutifs
temps_ip = temps(1:2:end) ; % temps entre un point impair et le point pair qui le suit
hauteur_interpolee_ip = pente_ii .* temps_ip(1:L) ; % hauteur interpolée au niveau du point pair suivant
 
% la dégradation est fonction de A : aire du triangle coupé à la
% disparition du point pair
A = abs(hauteur_interpolee_ip - hauteur_ip(1:L)) / 2 ;
end
 
 
% duree = 10000 ;
% pas = 1 ;
% periode_base = 6000 ;
% hauteur_base = 100 ;
% power_base = 20 ;
% rand_base = 0.25 ;
%
% periode_bruit_sin = 500 ;
% hauteur_bruit_sin = 2 ;
% coef_bruit_sin0 = 0 ;
% coef_bruit_sin1 = 20 ;
% rand_bruit_sin = 0.2 ;
%
% coef_bruit_blanc0 = 0 ;
% coef_bruit_blanc1 = 5 ;
 
function [T, S] = signal_original
duree = 10000 ;
pas = 1 ;
periode_base = 6000 ;
hauteur_base = 100 ;
power_base = 20 ;
rand_base = 0.25 ;
 
periode_bruit_sin = 500 ;
hauteur_bruit_sin = 2 ;
coef_bruit_sin0 = 0 ;
coef_bruit_sin1 = 20 ;
rand_bruit_sin = 0.2 ;
 
coef_bruit_blanc0 = 0 ;
coef_bruit_blanc1 = 5 ;
 
S = zeros(1, 10000) ;
T = 1:pas:duree ;
 
for k = 1:10
    periode_basek = periode_base * (1 + (2*rand-1) * rand_base) ;
    periode_bruit_sink = periode_bruit_sin * (1 + (2*rand-1) * rand_bruit_sin) ;
    S = S + signal (T, ...
        periode_basek, hauteur_base, power_base, ...
        periode_bruit_sink, hauteur_bruit_sin, coef_bruit_sin0, coef_bruit_sin1, ...
        coef_bruit_blanc0, coef_bruit_blanc1) ;
end
 
S = S ./ k ;
 
close all
plot(S) ;
set(gcf, 'windowstyle', 'docked')
end
 
function S = signal(temps, ...
    periode_base, hauteur_base, power_base, ...
    periode_bruit_sin, hauteur_bruit_sin, coef_bruit_sin0, coef_bruit_sin1, ...
    coef_bruit_blanc0, coef_bruit_blanc1)
 
signal_base = hauteur_base * (((1+sin(temps*(2*pi/periode_base)))/2).^power_base) ;
 
signal_bruit_sin_brut = hauteur_bruit_sin * sin(temps*(2*pi/periode_bruit_sin)) ;
signal_bruit_sin_mod = signal_bruit_sin_brut .* (coef_bruit_sin0 + (coef_bruit_sin1 - coef_bruit_sin0) * (signal_base/hauteur_base)) ;
 
bruit = rand(1, numel(temps)) .* (coef_bruit_blanc0 + (coef_bruit_blanc1 - coef_bruit_blanc0) * (signal_base/hauteur_base)) ;
 
S = signal_base + signal_bruit_sin_mod + bruit ;
end
 
function preparer_figures
figure (1)
set(gcf, 'PaperType', 'A4', 'PaperUnits', 'centimeters', 'PaperPosition', [1 2 19 26], 'windowstyle', 'docked')
figure (2)
set(gcf, 'PaperType', 'A4', 'PaperUnits', 'centimeters', 'PaperPosition', [1 2 19 26], 'windowstyle', 'docked')
figure (3)
set(gcf, 'PaperType', 'A4', 'PaperUnits', 'centimeters', 'PaperPosition', [1 2 19 26], 'windowstyle', 'docked')
end

[pseudocode]

Regarde si tu ne pourrais pas t'inspirer de l'algorithme de Douglas-Peucker.