ssa

1
package tg
2

3
import (
4
	"fmt"
5
	"math"
6

7
	"github.com/jfcg/butter"
8
)
9

10
// Нормирование слайса RGB
11
//
12
// Сейчас работает очень неэффективно, требуется модификация
13
func Butter(RGB []RGB_float64) []RGB_float64 {
14

15
	dt := 1. / 30.0
16
	wc := 2 * math.Pi * dt
17

18
	// fl := []butter.Filter{
19
	// 	// butter.NewHighPass1(4 * wc),
20
	// 	// butter.NewLowPass1(0.6 * wc),
21
	// 	// butter.NewHighPass2(4 * wc),
22
	// 	// butter.NewLowPass2(0.6 * wc),
23
	// 	// butter.NewBandPass2(wc*0.6, wc*4),
24
	// 	butter.NewBandPass2(wc*0.3, wc*2),
25
	// 	// butter.NewBandStop2(wc*0.6, wc*2'),
26
	// 	// butter.NewBandStop2(wc*0.6, wc*4),
27
	// 	// butter.NewRateLimit(0, wc),
28
	// }
29
	a, b := wc*1.2, wc*2.5
30
	Rfilter := butter.NewBandPass2(a, b)
31
	Gfilter := butter.NewBandPass2(a, b)
32
	Bfilter := butter.NewBandPass2(a, b)
33

34
	for i := range RGB {
35
		RGB[i].R = Rfilter.Next(RGB[i].R)
36
		RGB[i].G = Gfilter.Next(RGB[i].G)
37
		RGB[i].B = Bfilter.Next(RGB[i].B)
38
	}
39
	return RGB
40
}
41

42
////////////////
43

44
func ButterworthLowpassFilter(signal []float64, sampleRate float64, cutoffFreq float64) ([]float64, error) {
45
	// Вычислите параметры фильтра
46
	order := 4 // Порядок фильтра (вы можете выбрать другой порядок)
47
	nyquistFreq := 0.5 * sampleRate
48
	normalCutoff := cutoffFreq / nyquistFreq
49

50
	// Создайте нормализованный фильтр Баттерворта
51
	b, a, err := butterworthLowpass(order, normalCutoff)
52
	if err != nil {
53
		return nil, err
54
	}
55

56
	// Примените фильтр к сигналу
57
	filteredSignal := make([]float64, len(signal))
58
	for i := 0; i < len(signal); i++ {
59
		for j := 0; j <= order; j++ {
60
			if i-j >= 0 {
61
				filteredSignal[i] += b[j] * signal[i-j]
62
			}
63
		}
64
		for j := 1; j <= order; j++ {
65
			if i-j >= 0 {
66
				filteredSignal[i] -= a[j] * filteredSignal[i-j]
67
			}
68
		}
69
	}
70

71
	return filteredSignal, nil
72
}
73

74
func butterworthLowpass(order int, normalCutoff float64) (b, a []float64, err error) {
75
	if order <= 0 {
76
		return nil, nil, fmt.Errorf("Порядок фильтра должен быть положительным числом")
77
	}
78
	if normalCutoff <= 0 || normalCutoff >= 1.0 {
79
		return nil, nil, fmt.Errorf("Частота среза должна быть между 0 и 1")
80
	}
81

82
	// Вычислите коэффициенты фильтра
83
	b, a = make([]float64, order+1), make([]float64, order+1)
84
	wc := 2.0 * math.Pi * normalCutoff
85

86
	a[0] = 1
87
	for i := 0; i < order; i++ {
88
		a[i+1] = a[i] * (-wc / float64(i+1))
89
	}
90

91
	for i := 0; i <= order; i++ {
92
		b[i] = 0
93
	}
94
	b[order] = 1.0
95

96
	return b, a, nil
97
}
98
func Butter2(RGB []RGB_float64) []RGB_float64 {
99
	// dt := 1. / 30 // 64 hz sample rate
100
	RGBsOut := make([]RGB_float64, len(RGB))
101
	r := make([]float64, len(RGB))
102
	g := make([]float64, len(RGB))
103
	b := make([]float64, len(RGB))
104
	for i := range RGB {
105
		r[i] = RGB[i].R
106
		g[i] = RGB[i].G
107
		b[i] = RGB[i].B
108
	}
109
	sampleRate := 1.0 / 30.0 // Частота дискретизации в Гц
110
	cutoffFreq := 3.0        // Частота среза в Гц
111
	r, _ = ButterworthLowpassFilter(r, sampleRate, cutoffFreq)
112
	g, _ = ButterworthLowpassFilter(g, sampleRate, cutoffFreq)
113
	b, _ = ButterworthLowpassFilter(b, sampleRate, cutoffFreq)
114
	for i := range RGB {
115
		RGBsOut[i].R = r[i]
116
		RGBsOut[i].G = g[i]
117
		RGBsOut[i].B = b[i]
118
	}
119

120
	return RGBsOut
121
}
122