// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
bool AmplitudeProcessor::computeNoise(const DoubleArray &data, int i1, int i2, double *offset, double *amplitude) {
// compute offset and rms within the time window
if(i1<0) i1=0;
if(i2<0) return false;
if(i2>(int)data.size()) i2=(int)data.size();
// If noise window is zero return an amplitude and offset of zero as well.
if ( i2-i1 == 0 ) {
*amplitude = 0;
*offset = 0;
return true;
}
DoubleArrayPtr d = static_cast<DoubleArray*>(data.slice(i1, i2));
double ofs, amp;
// compute pre-arrival offset
ofs = d->median();
// compute rms after removing offset
amp = 2 * d->rms(ofs);
if ( offset ) *offset = ofs;
if ( amplitude ) *amplitude = amp;
return true;
}
int main(int argc, char* argv[])
{
ifstream in("../dict/words.lex"); // input
if(!in) {
cout << "Cannot open input file.\n";
return 1;
}
char ** buf = new char*[655350];
int i=0;
while(in) {
char * str = new char[64];
in.getline(str, 64); // delim defaults to '\n'
//if(in)
// cout << str << endl;
buf[i] = str;
i++;
if (i % 100 == 0)
cout << i << str << endl;
}
in.close();
DoubleArray* da = new DoubleArray();
da->build(i, (char**)buf);
da->save("../dict/dartswords.lex");
return 0;
}
/*
This has a funny way of dealing with edges. In case of a Gaussian blur, divides by the sum of all of the numbers in the mask by definition. Might prove harsh on edges. In all other cases, divides by 8 no matter what, so that can equalize at edges. Also, when one of the pixels needed in the mask calculation is off the bounds of the image, the center pixel value is substituted, so that there is less difference. This doesnt pick up as many stray lines on edges, but also proves to often not pick up enough lines.
*/
DoubleArray Mask::applyMask(DoubleArray array){
ICoord size = array.size();
DoubleArray newarray = DoubleArray(size);
width = (int)maskArray.size()(0)/2; /* in case the maskArray was edited */
for (DoubleArray::iterator i = array.begin();i !=array.end(); ++i){
ICoord curr = i.coord();
double num = 0;
double c = 0;
int d = 1;
for (int i = -width; i <= width; ++i){ // scans through the mask
for (int j = -width; j <= width; ++j){
ICoord a = ICoord(i,j);
if (pixelInBounds(curr + a, size)){
num = num + array[curr+a]*maskArray[ICoord(i + width, j + width)];
c = c + maskArray[ICoord(i + width, j + width)];
}
else{
num = num + array[curr]*maskArray[ICoord(i + width, j + width)]; /* if pixel needed for mask is out of the image, then substitute the center pixel */
d = d + 1; /* count number of pixels out of bounds */
}
}
}
if (type == GAUSSIAN_MASK)
newarray[curr] = num/159;
else if (type == SMALL_GAUSSIAN_MASK)
newarray[curr] = num/99;
else
newarray[curr] = num/8;
}
return newarray;
}
/*!
Updates the ImageView and the ParameterSelector associated
with the given panel.
*/
void VideoParserWindow::UpdatePanel(VideoControlPanel* pPanel, int sel,
DoubleArray params, bool checkViewSync)
{
// Get the potentially new parameter range from the component
DoubleArray minVals, maxVals, steps;
m_videoProcessor.GetParameterInfo(sel, &minVals, &maxVals, &steps);
// Ensure that the current parameters are within the "new" ranges
if (params.size() == minVals.size())
{
for (unsigned i = 0; i < params.size(); i++)
{
if (params[i] > maxVals[i])
params[i] = maxVals[i];
if (params[i] < minVals[i])
params[i] = minVals[i];
}
}
else
{
params = minVals;
}
// Update the selected view with the new image
UpdateImageView(pPanel, sel, params, checkViewSync);
// Update the displayed parameter value and range
pPanel->GetParamSelector()->Update(params, minVals, maxVals, steps);
pPanel->GetCommandSelector()->UpdateCommands(
m_videoProcessor.GetUserCommands(sel));
}
int Ardb::ZAdd(const DBID& db, const Slice& key, double score,
const Slice& value)
{
DoubleArray scores;
SliceArray svs;
scores.push_back(score);
svs.push_back(value);
return ZAdd(db, key, scores, svs);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
TEST(ArrayTest, CopyConvertedData)
{
// Double array to float
{
DoubleArray ad;
ad.resize(4);
ad[0] = 0.0;
ad[1] = 1.0;
ad[2] = 2.0;
ad[3] = 3.0;
// Copy full array
FloatArray af;
af.resize(4);
af.copyConvertedData(ad, 4, 0, 0);
EXPECT_FLOAT_EQ(0.0f, af[0]);
EXPECT_FLOAT_EQ(1.0f, af[1]);
EXPECT_FLOAT_EQ(2.0f, af[2]);
EXPECT_FLOAT_EQ(3.0f, af[3]);
// Copy partial array to float array
af.resize(2);
af.setAll(0);
af.copyConvertedData(ad, 2, 0, 1);
EXPECT_FLOAT_EQ(1.0f, af[0]);
EXPECT_FLOAT_EQ(2.0f, af[1]);
}
// Vec3d to Vec3f and Vec3i
{
Vec3dArray ad;
ad.resize(2);
ad[0].set(1.1, 2.5, 3.9);
ad[1].set(11.1, 12.5, 13.9);
Vec3fArray af;
af.resize(2);
af.copyConvertedData(ad, 2, 0, 0);
EXPECT_FLOAT_EQ(1.1f, af[0].x());
EXPECT_FLOAT_EQ(2.5f, af[0].y());
EXPECT_FLOAT_EQ(3.9f, af[0].z());
EXPECT_FLOAT_EQ(11.1f, af[1].x());
EXPECT_FLOAT_EQ(12.5f, af[1].y());
EXPECT_FLOAT_EQ(13.9f, af[1].z());
Array<Vec3i> ai;
ai.resize(2);
ai.copyConvertedData(ad, 2, 0, 0);
EXPECT_EQ(1, ai[0].x());
EXPECT_EQ(2, ai[0].y());
EXPECT_EQ(3, ai[0].z());
EXPECT_EQ(11, ai[1].x());
EXPECT_EQ(12, ai[1].y());
EXPECT_EQ(13, ai[1].z());
}
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
bool AmplitudeProcessor_msbb::computeAmplitude(const DoubleArray &data,
size_t i1, size_t i2,
size_t si1, size_t si2, double offset,
AmplitudeIndex *dt,
AmplitudeValue *amplitude,
double *period, double *snr) {
/*
* Low-level signal amplitude computation. This is magnitude specific.
*
* Input:
* f double array of length n
* i1,i2 indices defining the measurement window,
* 0 <= i1 < i2 <= n
* offset this is subtracted from the samples in f before
* computation
*
* Output:
* dt Point at which the measurement was mad/completed. May
* be the peak time or end of integration.
* amplitude amplitude. This may be a peak amplitude as well as a
* sum or integral.
* period dominant period of the signal. Optional. If the period
* is not computed, set it to -1.
*/
size_t imax = find_absmax(data.size(), (const double*)data.data(), si1, si2, offset);
double amax = fabs(data[imax] - offset);
double pmax = -1;
double pstd = 0; // standard error of period
if ( !measure_period(data.size(), static_cast<const double*>(data.data()), imax, offset, &pmax, &pstd) )
pmax = -1;
if ( amax < *_noiseAmplitude * _config.snrMin ) {
amplitude->value = amax / *_noiseAmplitude;
setStatus(LowSNR, amplitude->value);
return false;
}
dt->index = imax;
*period = pmax;
amplitude->value = amax;
if ( _usedComponent <= SecondHorizontal ) {
if ( _streamConfig[_usedComponent].gain != 0.0 )
amplitude->value /= _streamConfig[_usedComponent].gain;
else {
setStatus(MissingGain, 0.0);
return false;
}
}
else
return false;
return true;
}
TEST(ArrayDeathTest, SetPtrWithIllegalData)
{
double* pD = new double[5];
DoubleArray a;
EXPECT_DEATH(a.setPtr(NULL, 1), "Assertion");
EXPECT_DEATH(a.setPtr(pD, 0), "Assertion");
EXPECT_DEATH(a.setSharedPtr(NULL, 1), "Assertion");
EXPECT_DEATH(a.setSharedPtr(pD, 0), "Assertion");
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
bool AmplitudeProcessor::deconvolveData(Response *resp, DoubleArray &data,
int numberOfIntegrations) {
// Remove linear trend
double m,n;
Math::Statistics::computeLinearTrend(data.size(), data.typedData(), m, n);
Math::Statistics::detrend(data.size(), data.typedData(), m, n);
return resp->deconvolveFFT(data, _stream.fsamp, _config.respTaper,
_config.respMinFreq, _config.respMaxFreq,
numberOfIntegrations);
}
int Ardb::ZAdd(const DBID& db, const Slice& key, DoubleArray& scores,
const SliceArray& svs)
{
KeyLockerGuard keyguard(m_key_locker, db, key);
ZSetMetaValue meta;
GetZSetMetaValue(db, key, meta);
BatchWriteGuard guard(GetEngine());
int count = 0;
bool metachange = false;
for (uint32 i = 0; i < scores.size(); i++)
{
int tryret = TryZAdd(db, key, meta, scores[i], svs[i]);
if (tryret == 2)
{
count++;
}
if (!metachange && tryret > 0)
{
metachange = true;
}
}
if (metachange)
{
SetZSetMetaValue(db, key, meta);
}
return count;
}
void doClassifying(DoubleArray & gray) {
ICoord size = gray.size();
DoubleArray newgray = DoubleArray(size);
ClassifyClass classif = ClassifyClass();
newgray = classif.classifyRegions(gray);
gray = newgray;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
TEST(ArrayTest, CopyData)
{
DoubleArray a;
a.resize(6);
a[0] = 1.23;
a[1] = 4.56;
a[2] = 7.89;
double data[] = { 3.2, 1.0, 0.0 };
a.copyData(data, 3, 3);
ASSERT_DOUBLE_EQ(3.2, a[3]);
ASSERT_DOUBLE_EQ(1.0, a[4]);
ASSERT_DOUBLE_EQ(0.0, a[5]);
DoubleArray b;
b.resize(3);
b[0] = 10.0;
b[1] = 20.0;
b[2] = 30.0;
a.copyData(b, b.size(), 2, 0);
ASSERT_DOUBLE_EQ(1.23, a[0]);
ASSERT_DOUBLE_EQ(4.56, a[1]);
ASSERT_DOUBLE_EQ(10.0, a[2]);
ASSERT_DOUBLE_EQ(20.0, a[3]);
ASSERT_DOUBLE_EQ(30.0, a[4]);
ASSERT_DOUBLE_EQ(0.0, a[5]);
}
DoubleArray MASKS::applyMasks(const DoubleArray& image) {
//This applies the mask that is stored onto an array of doubles representing
//the image.
DoubleArray newImage(image.size(),0.0);
double tempSum=0;
int startI,endI,startK,endK;
int M=maskArrays.width(), N=maskArrays.height();
for(int x=0;x<image.width();x++) {
for(int y=0;y<image.height();y++) {
startI=-M/2; endI=M/2;
startK=-N/2; endK=N/2;
if(x-M/2<0)
startI=-x;
if(y-N/2<0)
startK=-y;
if(x+M/2>=image.width())
endI=image.width()-x-1;
if(y+N/2>=image.height())
endK=image.height()-y-1;
for(int i=startI;i<=endI;i++) {
for(int k=startK;k<=endK;k++) {
tempSum+=image[ICoord(x+i,y+k)]*maskArrays[ICoord(M/2+i,N/2+k)];
//If M and N aren't odd, will get segmentation fault
}
}
newImage[ICoord(x,y)]=tempSum;
// if(tempSum<0)
tempSum=0;
}
}
return newImage;
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
bool AmplitudeProcessor_Mjma::computeAmplitude(
const DoubleArray &data,
size_t i1, size_t i2,
size_t si1, size_t si2,
double offset,AmplitudeIndex *dt,
AmplitudeValue *amplitude,
double *period, double *snr)
{
double amax;
size_t imax = find_absmax(data.size(), data.typedData(), si1, si2, offset);
amax = fabs(data[imax] - offset);
dt->index = imax;
if ( *_noiseAmplitude == 0. )
*snr = 1000000.0;
else
*snr = amax / *_noiseAmplitude;
if ( *snr < _config.snrMin ) {
setStatus(LowSNR, *snr);
return false;
}
*period = -1;
amplitude->value = amax;
if ( _streamConfig[_usedComponent].gain != 0.0 )
amplitude->value /= _streamConfig[_usedComponent].gain;
else {
setStatus(MissingGain, 0.0);
return false;
}
// - convert to micrometer
amplitude->value *= 1E06;
// - estimate peak-to-peak from absmax amplitude
amplitude->value *= 2.0;
return true;
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
void Detector::process(const Record *record, const DoubleArray &filteredData) {
_amplProc.pickIndex = 0;
SimpleDetector::process(record, filteredData);
if ( _amplProc.isRunning() ) {
calculateMaxAmplitude(record, _amplProc.pickIndex, filteredData.size(), filteredData);
if ( _amplProc.isFinished() )
sendMaxAmplitude(record);
}
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
bool AmplitudeProcessor_Mjma::deconvolveData(Response *resp,
DoubleArray &data,
int numberOfIntegrations) {
Math::Restitution::FFT::TransferFunctionPtr tf =
resp->getTransferFunction(numberOfIntegrations);
if ( tf == NULL ) {
setStatus(DeconvolutionFailed, 0);
return false;
}
Math::SeismometerResponse::Seismometer5sec paz(Math::Velocity);
Math::Restitution::FFT::PolesAndZeros seis5sec(paz);
Math::Restitution::FFT::TransferFunctionPtr cascade =
*tf / seis5sec;
// Remove linear trend
double m,n;
Math::Statistics::computeLinearTrend(data.size(), data.typedData(), m, n);
Math::Statistics::detrend(data.size(), data.typedData(), m, n);
return Math::Restitution::transformFFT(data.size(), data.typedData(),
_stream.fsamp, cascade.get(),
_config.respTaper, _config.respMinFreq, _config.respMaxFreq);
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
bool AmplitudeProcessor_Md::deconvolveData(Response* resp,
DoubleArray& data,
int numberOfIntegrations) {
if ( numberOfIntegrations < -1 )
return false;
SEISCOMP_DEBUG("Inside deconvolve function");
double m, n;
Math::Restitution::FFT::TransferFunctionPtr tf =
resp->getTransferFunction(numberOfIntegrations < 0 ? 0 : numberOfIntegrations);
if ( !tf )
return false;
Math::GroundMotion gm;
if ( numberOfIntegrations < 0 )
gm = Math::Displacement;
else
gm = Math::Velocity;
Math::Restitution::FFT::TransferFunctionPtr cascade;
Math::SeismometerResponse::WoodAnderson woodAndersonResp(gm, _config.woodAndersonResponse);
Math::SeismometerResponse::Seismometer5sec seis5sResp(gm);
Math::SeismometerResponse::L4C_1Hz l4c1hzResp(gm);
Math::Restitution::FFT::PolesAndZeros woodAnderson(woodAndersonResp);
Math::Restitution::FFT::PolesAndZeros seis5sec(seis5sResp);
Math::Restitution::FFT::PolesAndZeros l4c1hz(l4c1hzResp);
SEISCOMP_DEBUG("SEISMO = %d", aFile.SEISMO);
switch ( aFile.SEISMO ) {
case 1:
cascade = *tf / woodAnderson;
break;
case 2:
cascade = *tf / seis5sec;
break;
case 9:
SEISCOMP_INFO("%s Applying filter L4C 1Hz to data", AMPTAG);
cascade = *tf / l4c1hz;
break;
default:
cascade = tf;
SEISCOMP_INFO("%s No seismometer specified, no signal reconvolution performed", AMPTAG);
return false;
break;
}
// Remove linear trend
Math::Statistics::computeLinearTrend(data.size(), data.typedData(), m, n);
Math::Statistics::detrend(data.size(), data.typedData(), m, n);
return Math::Restitution::transformFFT(data.size(), data.typedData(),
_stream.fsamp, cascade.get(), _config.respTaper, _config.respMinFreq,
_config.respMaxFreq);
}
int CreateCalibration( DoubleArray& Nexp, DoubleArray& teta, CalibrationParams& cal )
{
CalibrationFuncParams in_params(Nexp.GetSize(), Nexp, teta, cal.n_p, cal.n_s, cal.alfa );
CalibrationSolver FindFI( in_params );
if( (cal.status=FindFI.Run(-45*DEGREE, 45*DEGREE, 1e-12))==GSL_SUCCESS )
{
double *A = FindFI.fparams.GetA(), *B = FindFI.fparams.GetB(), *N = FindFI.fparams.N;
cal.fi0=FindFI.root;
cal.L = ((N[1] - N[3])*(A[0] - A[3]) - (N[0] - N[3])*(A[1] - A[3])) /
((B[0] - B[3])*(A[1] - A[3]) - (B[1] - B[3])*(A[0] - A[3]));
cal.d0 = ((N[3] - N[0]) - cal.L*(B[0] - B[3]))/(A[0] - A[3]);
cal.N0 = N[0] + cal.d0*A[0] + cal.L*B[0];
cal.dt=FindFI.dt;
cal.func_call_cntr=CalibrationSolver::func_call_cntr;
cal.epsabs=FindFI.epsabs; cal.epsrel=FindFI.epsrel;
cal.Nexp.RemoveAll(); cal.teta.RemoveAll();
for(int i=0;i<Nexp.GetSize();i++) cal.Nexp.Add(N[i]);
for(int i=0;i<teta.GetSize();i++) cal.teta.Add(teta[i]);
}
return cal.status;
}
int main(int argc , char *argv[]) {
if(argc != 3) {
cerr << "引数が違います" << endl;
cerr << "./da [keyset_pass] [end_char]" << endl;
cerr << endl << " now => ";
for(int i = 0 ; i < argc ; i++) cerr << argv[i] << " ";
cerr << endl;
return -1;
}
string file_pass = argv[1];
string end_char = argv[2];
DoubleArray da;
da.KeygroupSet(file_pass , end_char);
da.StaticInsert();
da.FindTest();
da.DumpTest();
//da.~DoubleArray();
}
TEST(ArrayDeathTest, AddBeyondCapacity)
{
DoubleArray a;
EXPECT_DEATH(a.add(100), "Assertion");
a.reserve(2);
a.add(100);
a.add(101);
EXPECT_DEATH(a.add(102), "Assertion");
a.reserve(4);
a.add(102);
a.add(103);
EXPECT_DEATH(a.add(104), "Assertion");
ASSERT_EQ(4u, a.size());
EXPECT_DOUBLE_EQ(100, a[0]);
EXPECT_DOUBLE_EQ(101, a[1]);
EXPECT_DOUBLE_EQ(102, a[2]);
EXPECT_DOUBLE_EQ(103, a[3]);
}
int Ardb::ZAddLimit(const DBID& db, const Slice& key, DoubleArray& scores,
const SliceArray& svs, int setlimit, ValueArray& pops)
{
ZSetMetaValue meta;
GetZSetMetaValue(db, key, meta);
if (setlimit <= 0)
{
setlimit = meta.size + scores.size();
}
ZAdd(db, key, scores, svs);
GetZSetMetaValue(db, key, meta);
if (meta.size > (uint32) setlimit)
{
ZPop(db, key, false, meta.size - setlimit, pops);
}
return 0;
}
void TraceContours(
/* 点 */
const PointArray& pts,
/* 边 */
const EdgeArray& ea,
/* 三角形 */
const TriangleArray& ta,
/* 要追踪的z值 */
const DoubleArray& zValues,
/* 所有的等值线上的点都放在一个数组 */
PointArray& cnpts,
/* 记录等值线信息 */
ContourArray& cna )
{
Contour cnt( pts, ea, ta );
for( int i = 0; i < ( int )zValues.size(); i++ )
{
PointArray z_cnpts;
IntArray z_cnpos;
IntArray dirs;
cnt.traceContour( zValues[i], z_cnpts, z_cnpos, dirs );
if( z_cnpos.empty() )
{
DT_Contour z_contour = {i, 0, 1, 0};
cna.push_back( z_contour );
}
else
{
for( int j = 0; j < ( int )z_cnpos.size(); j++ )
{
DT_Contour z_contour = {i, z_cnpos[j], dirs[j], 0};
cna.push_back( z_contour );
}
// 复制计算得到的等值线数据
std::copy( z_cnpts.begin(), z_cnpts.end(), std::back_inserter( cnpts ) );
}
}
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
void Processor::process(const Record *rec, const DoubleArray &data) {
// First record after reset?
if ( !_stream.initialized ) {
// Try to setup all internal variables
if ( !init(rec) ) return;
}
// Mismatching sampling frequency: reset
else if ( rec->samplingFrequency() != _stream.fsamp ) {
SEISCOMP_INFO("%s: mismatching sampling frequency (%f != %f): reset",
rec->streamID().c_str(), _stream.fsamp,
rec->samplingFrequency());
reset();
// Try to setup all internal variables
if ( !init(rec) ) return;
}
// Record time window is after the current time window -> flush
// existing samples and setup the new interval
if ( rec->startTime() >= _currentEndTime ) {
flush();
setupTimeWindow(rec->startTime());
}
Core::Time ts = rec->startTime();
// Process all samples
for ( int i = 0; i < data.size(); ++i ) {
if ( ts >= _currentEndTime ) {
// Flush existing pool
flush();
// Step to next time span
_currentStartTime = _currentEndTime;
_currentEndTime = _currentStartTime + Core::TimeSpan(1,0);
}
_samplePool.push(data[i]);
ts += _dt;
}
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
bool AmplitudeProcessor::deconvolveData(Response *resp, DoubleArray &data,
int numberOfIntegrations) {
// Remove linear trend
double m,n;
Math::Statistics::computeLinearTrend(data.size(), data.typedData(), m, n);
Math::Statistics::detrend(data.size(), data.typedData(), m, n);
bool ret = resp->deconvolveFFT(data, _stream.fsamp, _config.respTaper,
_config.respMinFreq, _config.respMaxFreq,
numberOfIntegrations < 0 ? 0 : numberOfIntegrations);
if ( !ret )
return false;
// If number of integrations are negative, derive data
while ( numberOfIntegrations < 0 ) {
Math::Filtering::IIRDifferentiate<double> diff;
diff.setSamplingFrequency(_stream.fsamp);
diff.apply(data.size(), data.typedData());
++numberOfIntegrations;
}
return true;
}
double mean(const DoubleArray &v)
{
return mean(v.size(), (const double*)v.data());
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
bool AmplitudeProcessor_Md::computeAmplitude(const DoubleArray& data, size_t i1,
size_t i2, size_t si1, size_t si2,
double offset, AmplitudeIndex* dt,
AmplitudeValue* amplitude,
double* period, double* snr) {
double amax, Imax, ofs_sig, amp_sig;
DoubleArrayPtr d;
if ( *snr < aFile.SNR_MIN )
SEISCOMP_DEBUG("%s computed SNR is under configured SNR MIN", AMPTAG);
if ( _computeAbsMax ) {
size_t imax = find_absmax(data.size(), data.typedData(), si1, si2, offset);
amax = fabs(data[imax] - offset);
dt->index = imax;
}
else {
int lmin, lmax;
find_minmax(lmin, lmax, data.size(), data.typedData(), si1, si2, offset);
amax = data[lmax] - data[lmin];
dt->index = (lmin + lmax) * 0.5;
dt->begin = lmin - dt->index;
dt->end = lmax - dt->index;
}
Imax = dt->index;
SEISCOMP_DEBUG("%s Amplitude max: %.2f", AMPTAG, amax);
//! searching for Coda second by second through the end of the window
//! if snrMin config is not 0 (config file or waveform review window)
//! TODO: elevate accuracy by using a nanometers scale (maybe)
if ( _config.snrMin != 0 ) {
unsigned int i = si1;
bool hasEndSignal = false;
double calculatedSnr = -1;
for (i = (int) Imax; i < i2; i = i + 1 * (int) _stream.fsamp) {
int window_end = i + 1 * (int) _stream.fsamp;
d = static_cast<DoubleArray*>(data.slice(i, window_end));
//! computes pre-arrival offset
ofs_sig = d->median();
//! computes rms after removing offset
amp_sig = 2 * d->rms(ofs_sig);
if ( amp_sig / *_noiseAmplitude <= _config.snrMin ) {
SEISCOMP_DEBUG("%s End of signal found! (%.2f <= %.2f)", AMPTAG,
(amp_sig / *_noiseAmplitude), _config.snrMin);
hasEndSignal = true;
calculatedSnr = amp_sig / *_noiseAmplitude;
break;
}
}
if ( !hasEndSignal ) {
SEISCOMP_ERROR("%s SNR stayed over configured SNR_MIN! (%.2f > %.2f), "
"skipping magnitude calculation for this station", AMPTAG,
calculatedSnr, _config.snrMin);
return false;
}
dt->index = i;
}
else dt->index = Imax;
//amplitude->value = 2 * amp_sig; //! actually it would have to be max. peak-to-peak
amplitude->value = amp_sig;
if ( _streamConfig[_usedComponent].gain != 0.0 )
amplitude->value /= _streamConfig[_usedComponent].gain;
else {
setStatus(MissingGain, 0.0);
return false;
}
// Convert m/s to nm/s
amplitude->value *= 1.E09;
*period = dt->index - i1 + (_config.signalBegin * _stream.fsamp);
SEISCOMP_DEBUG("%s calculated event amplitude = %.2f", AMPTAG, amplitude->value);
SEISCOMP_DEBUG("%s calculated signal end at %.2f ms from P phase", AMPTAG, *period);
return true;
}
double fractile(const DoubleArray &v, double x)
{
return fractile(v.size(), (const double*)v.data(), x);
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
void Detector::calculateMaxAmplitude(const Record *record, size_t i0, size_t i1, const DoubleArray &filteredData) {
size_t i = i0;
while ( i < i1 && _amplProc.processedSamples < _amplProc.neededSamples && i < (size_t)filteredData.size() ) {
double amp = fabs(filteredData[i]);
if ( !_amplProc.amplitude || amp > *_amplProc.amplitude ) {
_amplProc.amplitude = amp;
_amplProc.index = _amplProc.processedSamples;
}
++i;
++_amplProc.processedSamples;
}
}
Array* Array_readLocalData(Input& fr)
{
if (fr[0].matchWord("Use"))
{
if (fr[1].isString())
{
Object* obj = fr.getObjectForUniqueID(fr[1].getStr());
if (obj)
{
fr+=2;
return dynamic_cast<Array*>(obj);
}
}
osg::notify(osg::WARN)<<"Warning: invalid uniqueID found in file."<<std::endl;
return NULL;
}
std::string uniqueID;
if (fr[0].matchWord("UniqueID") && fr[1].isString())
{
uniqueID = fr[1].getStr();
fr += 2;
}
int entry = fr[0].getNoNestedBrackets();
const char* arrayName = fr[0].getStr();
unsigned int capacity = 0;
fr[1].getUInt(capacity);
++fr;
fr += 2;
Array* return_array = 0;
if (strcmp(arrayName,"ByteArray")==0)
{
ByteArray* array = new ByteArray;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
int int_value;
if (fr[0].getInt(int_value))
{
++fr;
array->push_back(int_value);
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"ShortArray")==0)
{
ShortArray* array = new ShortArray;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
int int_value;
if (fr[0].getInt(int_value))
{
++fr;
array->push_back(int_value);
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"IntArray")==0)
{
IntArray* array = new IntArray;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
int int_value;
if (fr[0].getInt(int_value))
{
++fr;
array->push_back(int_value);
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"UByteArray")==0)
{
UByteArray* array = new UByteArray;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
unsigned int uint_value;
if (fr[0].getUInt(uint_value))
{
++fr;
array->push_back(uint_value);
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"UShortArray")==0)
{
UShortArray* array = new UShortArray;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
unsigned int uint_value;
if (fr[0].getUInt(uint_value))
{
++fr;
array->push_back(uint_value);
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"UIntArray")==0)
{
UIntArray* array = new UIntArray;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
unsigned int uint_value;
if (fr[0].getUInt(uint_value))
{
++fr;
array->push_back(uint_value);
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"UVec4bArray")==0 || strcmp(arrayName,"Vec4ubArray")==0)
{
Vec4ubArray* array = new Vec4ubArray;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
unsigned int r,g,b,a;
if (fr[0].getUInt(r) &&
fr[1].getUInt(g) &&
fr[2].getUInt(b) &&
fr[3].getUInt(a))
{
fr+=4;
array->push_back(osg::Vec4ub(r,g,b,a));
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"FloatArray")==0)
{
FloatArray* array = new FloatArray;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
float float_value;
if (fr[0].getFloat(float_value))
{
++fr;
array->push_back(float_value);
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"DoubleArray")==0)
{
DoubleArray* array = new DoubleArray;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
double double_value;
if (fr[0].getFloat(double_value))
{
++fr;
array->push_back(double_value);
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"Vec2Array")==0)
{
Vec2Array* array = new Vec2Array;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
Vec2 v;
if (fr[0].getFloat(v.x()) && fr[1].getFloat(v.y()))
{
fr += 2;
array->push_back(v);
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"Vec2dArray")==0)
{
Vec2dArray* array = new Vec2dArray;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
Vec2d v;
if (fr[0].getFloat(v.x()) && fr[1].getFloat(v.y()))
{
fr += 2;
array->push_back(v);
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"Vec3Array")==0)
{
Vec3Array* array = new Vec3Array;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
Vec3 v;
if (fr[0].getFloat(v.x()) && fr[1].getFloat(v.y()) && fr[2].getFloat(v.z()))
{
fr += 3;
array->push_back(v);
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"Vec3dArray")==0)
{
Vec3dArray* array = new Vec3dArray;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
Vec3d v;
if (fr[0].getFloat(v.x()) && fr[1].getFloat(v.y()) && fr[2].getFloat(v.z()))
{
fr += 3;
array->push_back(v);
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"Vec4Array")==0)
{
Vec4Array* array = new Vec4Array;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
Vec4 v;
if (fr[0].getFloat(v.x()) && fr[1].getFloat(v.y()) && fr[2].getFloat(v.z()) && fr[3].getFloat(v.w()))
{
fr += 4;
array->push_back(v);
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"Vec4dArray")==0)
{
Vec4dArray* array = new Vec4dArray;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
Vec4d v;
if (fr[0].getFloat(v.x()) && fr[1].getFloat(v.y()) && fr[2].getFloat(v.z()) && fr[3].getFloat(v.w()))
{
fr += 4;
array->push_back(v);
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"Vec2bArray")==0)
{
Vec2bArray* array = new Vec2bArray;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
unsigned int r,g;
if (fr[0].getUInt(r) &&
fr[1].getUInt(g))
{
fr+=2;
array->push_back(osg::Vec2b(r,g));
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"Vec3bArray")==0)
{
Vec3bArray* array = new Vec3bArray;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
unsigned int r,g,b;
if (fr[0].getUInt(r) &&
fr[1].getUInt(g) &&
fr[2].getUInt(b))
{
fr+=3;
array->push_back(osg::Vec3b(r,g,b));
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"Vec4bArray")==0)
{
Vec4bArray* array = new Vec4bArray;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
unsigned int r,g,b,a;
if (fr[0].getUInt(r) &&
fr[1].getUInt(g) &&
fr[2].getUInt(b) &&
fr[3].getUInt(a))
{
fr+=4;
array->push_back(osg::Vec4b(r,g,b,a));
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"Vec2sArray")==0)
{
Vec2sArray* array = new Vec2sArray;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
unsigned int r,g;
if (fr[0].getUInt(r) &&
fr[1].getUInt(g))
{
fr+=2;
array->push_back(osg::Vec2s(r,g));
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"Vec3sArray")==0)
{
Vec3sArray* array = new Vec3sArray;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
unsigned int r,g,b;
if (fr[0].getUInt(r) &&
fr[1].getUInt(g) &&
fr[2].getUInt(b))
{
fr+=3;
array->push_back(osg::Vec3s(r,g,b));
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"Vec4sArray")==0)
{
Vec4sArray* array = new Vec4sArray;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
unsigned int r,g,b,a;
if (fr[0].getUInt(r) &&
fr[1].getUInt(g) &&
fr[2].getUInt(b) &&
fr[3].getUInt(a))
{
fr+=4;
array->push_back(osg::Vec4s(r,g,b,a));
}
else ++fr;
}
++fr;
return_array = array;
}
if (return_array)
{
if (!uniqueID.empty()) fr.registerUniqueIDForObject(uniqueID.c_str(),return_array);
}
return return_array;
}
bool QcProcessorRms::setState(const Record *record, const DoubleArray &data) {
_qcp->parameter = data.rms(data.mean());
return true;
}