void milxQtDiffusionTensorModel::harmonics(QString ordersString)
{
bool ok = false;
if(ordersString.isEmpty())
{
ordersString = QInputDialog::getText(this, tr("Enter order magnitudes of harmonics separated by spaces"),
tr("Orders: "), QLineEdit::Normal,
"1 0 0 0 1 1 1 1 1", &ok);
}
if (!ok || ordersString.isEmpty())
return;
QStringList orders = ordersString.split(" ");
std::vector<double> sHarmonicCoefficients;
for(int i = 0; i < orders.size(); i++)
sHarmonicCoefficients.push_back(orders[i].toDouble());
int n_coefs = sHarmonicCoefficients.size();
int l_max = milxQtDiffusionTensorModel::LforN( n_coefs );
vtkSmartPointer<vtkSphereSource> sphereSource = vtkSmartPointer<vtkSphereSource>::New();
sphereSource->SetThetaResolution( 64 );
sphereSource->SetPhiResolution( 64 );
sphereSource->SetRadius( 1.0 );
sphereSource->Update();
vtkSmartPointer<vtkPolyData> glyph = sphereSource->GetOutput();
///For every point in sphere mesh
double m_x = 0, m_y = 0, m_z = 0;
for(int i = 0; i < glyph->GetNumberOfPoints(); i++)
{
double point_sphere[3];
glyph->GetPoint(i, point_sphere);
double x_s = point_sphere[0];
double y_s = point_sphere[1];
double z_s = point_sphere[2];
double x_g, y_g, z_g;
///Compute spherical harmonic amplitude
double amplitude = computeAmplitude( sHarmonicCoefficients, x_s, y_s, z_s, l_max );
if(amplitude < 0)
amplitude = 0;
///use this to displace sphere points accordingly
x_g = x_s * amplitude + m_x;
y_g = y_s * amplitude + m_y;
z_g = z_s * amplitude + m_z;
glyph->GetPoints()->SetPoint(i, x_g, y_g, z_g);
}
model.SetInput(glyph);
model.GenerateNormals(true);
generateModel();
milxQtRenderWindow::reset();
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
void AmplitudeProcessor::process(const Record *record) {
// Sampling frequency has not been set yet
if ( _stream.fsamp == 0.0 )
return;
int n = (int)_data.size();
// signal and noise window relative to _continuous->startTime()
double dt0 = _trigger - dataTimeWindow().startTime();
double dt1 = dataTimeWindow().endTime() - dataTimeWindow().startTime();
double dtw1 = timeWindow().endTime() - dataTimeWindow().startTime();
double dtn1 = dt0 + _config.noiseBegin;
double dtn2 = dt0 + _config.noiseEnd;
double dts1 = dt0 + _config.signalBegin;
double dts2 = dt0 + _config.signalEnd;
// Noise indicies
int ni1 = int(dtn1*_stream.fsamp+0.5);
int ni2 = int(dtn2*_stream.fsamp+0.5);
if ( ni1 < 0 || ni2 < 0 ) {
SEISCOMP_DEBUG("Noise data not available -> abort");
setStatus(Error, 1);
return;
}
if ( n < ni2 ) {
// the noise window is not complete
return;
}
// **** compute signal amplitude ********************************
// these are the offsets of the beginning and end
// of the signal window relative to the start of
// the continuous record in samples
int i1 = int(dts1*_stream.fsamp+0.5);
int i2 = int(dts2*_stream.fsamp+0.5);
//int progress = int(100.*(n-i1)/(i2-i1));
//int progress = int(100.*(dt1-dts1)/(dts2-dts1));
int progress = int(100.*(dt1-dts1)/(std::max(dtw1,dts2)-dts1));
if ( progress > 100 ) progress = 100;
setStatus(InProgress, progress);
if ( i1 < 0 ) i1 = 0;
if ( i2 > n ) i2 = n;
bool unlockCalculation = ((_enableUpdates && !_enableResponses) && progress > 0) || progress >= 100;
if ( unlockCalculation ) {
if ( _streamConfig[_usedComponent].gain == 0.0 ) {
setStatus(MissingGain, 0);
return;
}
// **** prepare the data to compute the noise
prepareData(_data);
if ( isFinished() )
return;
// **** compute noise amplitude *********************************
// if the noise hasn't been measured yet...
if ( !_noiseAmplitude ) {
// compute pre-arrival data offset and noise amplitude
double off = 0., amp = 0.;
if ( !computeNoise(_data, ni1, ni2, &off, &) ) {
SEISCOMP_DEBUG("Noise computation failed -> abort");
setStatus(Error, 2);
return;
}
_noiseOffset = off;
_noiseAmplitude = amp;
}
AmplitudeIndex index;
Result res;
res.component = _usedComponent;
res.record = record;
res.period = -1;
res.snr = -1;
res.amplitude.value = -1;
res.amplitude.lowerUncertainty = Core::None;
res.amplitude.upperUncertainty = Core::None;
index.index = -1;
index.begin = 0;
index.end = 0;
double dtsw1, dtsw2;
if ( _searchBegin ) {
dtsw1 = dt0 + *_searchBegin;
if ( dtsw1 < dts1 ) dtsw1 = dts1;
if ( dtsw1 > dts2 ) dtsw1 = dts2;
}
else
dtsw1 = dts1;
if ( _searchEnd ) {
dtsw2 = dt0 + *_searchEnd;
if ( dtsw2 < dts1 ) dtsw2 = dts1;
if ( dtsw2 > dts2 ) dtsw2 = dts2;
}
else
dtsw2 = dts2;
int si1 = int(dtsw1*_stream.fsamp+0.5);
int si2 = int(dtsw2*_stream.fsamp+0.5);
si1 = std::max(si1, i1);
si2 = std::min(si2, i2);
if ( !computeAmplitude(_data, i1, i2, si1, si2, *_noiseOffset,
&index, &res.amplitude, &res.period, &res.snr) ) {
if ( progress >= 100 ) {
if ( status() == LowSNR )
SEISCOMP_DEBUG("Amplitude %s computation for stream %s failed because of low SNR (%.2f < %.2f)",
_type.c_str(), record->streamID().c_str(), res.snr, _config.snrMin);
else {
SEISCOMP_DEBUG("Amplitude %s computation for stream %s failed -> abort",
_type.c_str(), record->streamID().c_str());
setStatus(Error, 3);
}
_lastAmplitude = Core::None;
}
return;
}
if ( _lastAmplitude ) {
if ( res.amplitude.value <= *_lastAmplitude ) {
if ( progress >= 100 ) {
setStatus(Finished, 100.);
_lastAmplitude = Core::None;
}
return;
}
}
_lastAmplitude = res.amplitude.value;
double dt = index.index / _stream.fsamp;
res.period /= _stream.fsamp;
if ( index.begin > index.end ) std::swap(index.begin, index.end);
// Update status information
res.time.reference = dataTimeWindow().startTime() + Core::TimeSpan(dt);
//res.time.begin = index.begin / _stream.fsamp;
//res.time.end = index.end / _stream.fsamp;
res.time.begin = (si1 - index.index) / _stream.fsamp;
res.time.end = (si2 - index.index) / _stream.fsamp;
if ( progress >= 100 ) {
setStatus(Finished, 100.);
_lastAmplitude = Core::None;
}
emitAmplitude(res);
}
}
void Stutter::process() {
// A hack to save memory until stutter is used.
if (memory_ == nullptr)
memory_ = new Memory(size_);
mopo_float max_memory_write = memory_->getSize();
mopo_float* dest = output()->buffer;
mopo_float sample_period = sample_rate_ / input(kResampleFrequency)->at(0);
mopo_float end_stutter_period = sample_rate_ / input(kStutterFrequency)->at(0);
end_stutter_period = std::min(sample_period, end_stutter_period);
end_stutter_period = std::min(max_memory_write, end_stutter_period);
mopo_float read_softenss = std::max(input(kWindowSoftness)->at(0), MIN_SOFTNESS);
mopo_float end_softness = PI * std::max(1.0, 1.0 / read_softenss);
mopo_float stutter_period = end_stutter_period;
if (last_stutter_period_)
stutter_period = last_stutter_period_;
mopo_float stutter_period_diff = (end_stutter_period - stutter_period) / buffer_size_;
mopo_float softness = last_softness_;
mopo_float softness_diff = (end_softness - last_softness_) / buffer_size_;
if (input(kReset)->source->triggered) {
}
int buffer_size = buffer_size_;
int trigger_offset = -1;
if (input(kReset)->source->triggered) {
trigger_offset = input(kReset)->source->trigger_offset;
buffer_size = trigger_offset;
}
else if (resample_countdown_ > sample_period)
resample_countdown_ = sample_period;
int i = 0;
while (i < buffer_size_) {
if (resampling_) {
int max_samples = std::ceil(stutter_period - offset_);
int samples = std::min(buffer_size, i + max_samples);
int num_samples = samples - i;
for (; i < samples; ++i) {
stutter_period += stutter_period_diff;
softness += softness_diff;
mopo_float audio = input(kAudio)->at(i);
memory_->push(audio);
mopo_float amp = computeAmplitude(offset_, stutter_period, softness);
dest[i] = amp * audio;
offset_ += 1.0;
}
resample_countdown_ -= num_samples;
memory_offset_ += num_samples;
}
else {
int max_samples = std::ceil(std::min(stutter_period - offset_, resample_countdown_));
int samples = std::min(buffer_size, i + max_samples);
if (memory_offset_ < max_memory_write) {
int mem_samples = std::min<int>(max_memory_write - memory_offset_, samples);
for (int j = i; j < mem_samples; ++j)
memory_->push(input(kAudio)->at(j));
memory_offset_ += (mem_samples - i);
}
for (; i < samples; ++i) {
resample_countdown_ -= 1.0;
stutter_period += stutter_period_diff;
softness += softness_diff;
mopo_float offset = std::min(offset_, resample_countdown_);
offset = std::min(stutter_period - offset_, offset);
mopo_float amp = computeAmplitude(offset, stutter_period, softness);
dest[i] = amp * memory_->get(memory_offset_ - offset_);
offset_ += 1.0;
}
if (resample_countdown_ <= 0.0)
startResampling(sample_period);
}
if (offset_ >= stutter_period) {
resampling_ = false;
offset_ = 0.0;
}
if (buffer_size == trigger_offset) {
buffer_size = buffer_size_;
startResampling(sample_period);
stutter_period = end_stutter_period;
stutter_period_diff = 0.0;
softness = end_softness;
softness_diff = 0.0;
}
}
last_stutter_period_ = end_stutter_period;
last_softness_ = end_softness;
}
