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
|
#ifndef MITIGATIONTESTER_H
#define MITIGATIONTESTER_H
#include <cstddef>
#include <fstream>
#include <random>
#include <string>
#include "../structures/image2d.h"
#include "../structures/mask2d.h"
#include "../util/rng.h"
#include "enums.h"
namespace algorithms {
class TestSetGenerator {
public:
enum NoiseType {
Gaussian,
GaussianProduct,
GaussianPartialProduct,
Rayleigh
};
enum BroadbandShape {
UniformShape,
GaussianShape,
SinusoidalShape,
BurstShape
};
static double shapeLevel(enum BroadbandShape shape, double x) {
switch (shape) {
default:
case UniformShape:
return 1.0;
case GaussianShape:
return exp(-x * x * 3.0 * 3.0);
case SinusoidalShape:
return (1.0 + cos(x * M_PI * 2.0 * 1.5)) * 0.5;
case BurstShape:
return RNG::Gaussian() * 0.6;
}
}
static Image2D MakeRayleighData(unsigned width, unsigned height);
static Image2D MakeGaussianData(unsigned width, unsigned height);
static Image2D MakeNoise(unsigned width, unsigned height, int gaussian) {
if (gaussian == 1)
return MakeGaussianData(width, height);
else if (gaussian == 0)
return MakeRayleighData(width, height);
else
return Image2D::MakeZeroImage(width, height);
}
static void AddBroadbandLine(Image2D& data, Mask2D& rfi, double lineStrength,
size_t startTime, size_t duration) {
AddBroadbandLine(data, rfi, lineStrength, startTime, duration, 1.0);
}
static void AddBroadbandLine(Image2D& data, Mask2D& rfi, double lineStrength,
size_t startTime, size_t duration,
double frequencyRatio) {
AddBroadbandLine(data, rfi, lineStrength, startTime, duration,
frequencyRatio, 0.5L - frequencyRatio / 2.0L);
}
static void AddSpectralLine(Image2D& data, Mask2D& rfi, double lineStrength,
size_t startChannel, size_t nChannels,
double timeRatio, double timeOffsetRatio,
enum BroadbandShape shape);
static void AddIntermittentSpectralLine(Image2D& data, Mask2D& rfi,
double lineStrength, size_t channel,
double probability, std::mt19937& mt);
static void AddBroadbandLine(Image2D& data, Mask2D& rfi, double lineStrength,
size_t startTime, size_t duration,
double frequencyRatio,
double frequencyOffsetRatio);
static void AddBroadbandLinePos(Image2D& data, Mask2D& rfi,
double lineStrength, size_t startTime,
size_t duration, unsigned frequencyStart,
double frequencyEnd,
enum BroadbandShape shape);
static void AddSlewedBroadbandLinePos(Image2D& data, Mask2D& rfi,
double lineStrength, double slewrate,
size_t startTime, size_t duration,
unsigned frequencyStart,
double frequencyEnd,
enum BroadbandShape shape);
static void AddRfiPos(Image2D& data, Mask2D& rfi, double lineStrength,
size_t startTime, size_t duration,
unsigned frequencyPos);
static std::string GetDescription(BackgroundTestSet backgroundSet);
static std::string GetDescription(RFITestSet rfiSet);
static TimeFrequencyData MakeTestSet(RFITestSet rfiSet,
BackgroundTestSet backgroundSet,
size_t width, size_t height);
static void MakeBackground(BackgroundTestSet backgroundSet,
TimeFrequencyData& image);
static void MakeTestSet(RFITestSet testSet, TimeFrequencyData& data);
private:
static void AddSpectralLinesToTestSet(Image2D& image, Mask2D& rfi,
double strength,
enum BroadbandShape shape);
static void AddIntermittentSpectralLinesToTestSet(Image2D& image, Mask2D& rfi,
double strength);
static void AddGaussianBroadbandToTestSet(Image2D& image, Mask2D& rfi) {
AddBroadbandToTestSet(image, rfi, 1.0, 1.0, GaussianShape);
}
static void AddSinusoidalBroadbandToTestSet(Image2D& image, Mask2D& rfi) {
AddBroadbandToTestSet(image, rfi, 1.0, 1.0, SinusoidalShape);
}
static void AddBurstBroadbandToTestSet(Image2D& image, Mask2D& rfi) {
AddBroadbandToTestSet(image, rfi, 1.0, 1.0, BurstShape);
}
static void AddSlewedGaussianBroadbandToTestSet(Image2D& image, Mask2D& rfi) {
AddSlewedBroadbandToTestSet(image, rfi, 1.0);
}
static void AddBroadbandToTestSet(Image2D& image, Mask2D& rfi, double length,
double strength = 1.0,
enum BroadbandShape shape = UniformShape);
static void AddSlewedBroadbandToTestSet(
Image2D& image, Mask2D& rfi, double length, double strength = 1.0,
double slewrate = 0.02, enum BroadbandShape shape = GaussianShape);
static void AddVarBroadbandToTestSet(Image2D& image, Mask2D& rfi);
static void SetModelData(Image2D& image, unsigned sources, size_t width,
size_t height);
static void SubtractBackground(Image2D& image);
static Image2D sampleRFIDistribution(unsigned width, unsigned height,
double ig_over_rsq);
static double Rand(enum NoiseType type) {
switch (type) {
case Gaussian:
return RNG::Gaussian();
case GaussianProduct:
return RNG::GaussianProduct();
case GaussianPartialProduct:
return RNG::GaussianPartialProduct();
case Rayleigh:
return RNG::Rayleigh();
}
throw std::exception();
}
};
} // namespace algorithms
#endif
|
