VectorDouble TimeseriesBuffer::update(const VectorDouble &x){ #ifdef GRT_SAFE_CHECKING if( !initialized ){ errorLog << "update(const VectorDouble &x) - Not Initialized!" << endl; return VectorDouble(); } if( x.size() != numInputDimensions ){ errorLog << "update(const VectorDouble &x)- The Number Of Input Dimensions (" << numInputDimensions << ") does not match the size of the input vector (" << x.size() << ")!" << endl; return VectorDouble(); } #endif //Add the new data to the buffer dataBuffer.push_back( x ); //Search the buffer for the zero crossing features UINT colIndex = 0; for(UINT j=0; j<numInputDimensions; j++){ for(UINT i=0; i<dataBuffer.getSize(); i++){ featureVector[ colIndex++ ] = dataBuffer[i][j]; } } //Flag that the feature data has been computed if( dataBuffer.getBufferFilled() ){ featureDataReady = true; }else featureDataReady = false; return featureVector; }
VectorDouble HighPassFilter::filter(const VectorDouble &x){ #ifdef GRT_SAFE_CHECKING if( !initialized ){ errorLog << "filter(const VectorDouble &x) - Not Initialized!" << endl; return VectorDouble(); } if( x.size() != numInputDimensions ){ errorLog << "filter(const VectorDouble &x) - The Number Of Input Dimensions (" << numInputDimensions << ") does not match the size of the input vector (" << x.size() << ")!" << endl; return VectorDouble(); } #endif for(UINT n=0; n<numInputDimensions; n++){ //Compute the new output processedData[n] = filterFactor * (yy[n] + x[n] - xx[n]) * gain; //Store the current input xx[n] = x[n]; //Store the current output yy[n] = processedData[n]; } return processedData; }
VectorDouble MovingAverageFilter::filter(const VectorDouble &x){ //If the filter has not been initialised then return 0, otherwise filter x and return y if( !initialized ){ errorLog << "filter(const VectorDouble &x) - The filter has not been initialized!" << endl; return VectorDouble(); } if( x.size() != numInputDimensions ){ errorLog << "filter(const VectorDouble &x) - The size of the input vector (" << x.size() << ") does not match that of the number of dimensions of the filter (" << numInputDimensions << ")!" << endl; return VectorDouble(); } if( ++inputSampleCounter > filterSize ) inputSampleCounter = filterSize; //Add the new value to the buffer dataBuffer.push_back( x ); for(unsigned int j=0; j<numInputDimensions; j++){ processedData[j] = 0; for(unsigned int i=0; i<inputSampleCounter; i++) { processedData[j] += dataBuffer[i][j]; } processedData[j] /= double(inputSampleCounter); } return processedData; }
VectorDouble MatrixDouble::multiple(const VectorDouble &b) const{ const unsigned int M = rows; const unsigned int N = cols; const unsigned int K = (unsigned int)b.size(); if( N != K ){ warningLog << "multiple(vector b) - The size of b (" << b.size() << ") does not match the number of columns in this matrix (" << N << ")" << std::endl; return VectorDouble(); } VectorDouble c(M); const double *pb = &b[0]; double *pc = &c[0]; unsigned int i,j = 0; for(i=0; i<rows; i++){ pc[i] = 0; for(j=0; j<cols; j++){ pc[i] += dataPtr[i*cols+j]*pb[j]; } } return c; }
bool MovingAverageFilter::init(UINT filterSize,UINT numDimensions){ //Cleanup the old memory initialized = false; inputSampleCounter = 0; if( filterSize == 0 ){ errorLog << "init(UINT filterSize,UINT numDimensions) - Filter size can not be zero!" << endl; return false; } if( numDimensions == 0 ){ errorLog << "init(UINT filterSize,UINT numDimensions) - The number of dimensions must be greater than zero!" << endl; return false; } //Resize the filter this->filterSize = filterSize; this->numInputDimensions = numDimensions; this->numOutputDimensions = numDimensions; processedData.clear(); processedData.resize(numDimensions,0); initialized = dataBuffer.resize( filterSize, VectorDouble(numInputDimensions,0) ); if( !initialized ){ errorLog << "init(UINT filterSize,UINT numDimensions) - Failed to resize dataBuffer!" << endl; } return initialized; }
VectorDouble RandomForests::getFeatureWeights( const bool normWeights ) const{ if( !trained ) return VectorDouble(); VectorDouble weights( numInputDimensions, 0 ); for(UINT i=0; i<forestSize; i++){ if( !forest[i]->computeFeatureWeights( weights ) ){ warningLog << "getFeatureWeights( const bool normWeights ) - Failed to compute weights for tree: " << i << endl; } } //Normalize the weights if( normWeights ){ double sum = Util::sum( weights ); if( sum > 0.0 ){ const double norm = 1.0 / sum; for(UINT j=0; j<numInputDimensions; j++){ weights[j] *= norm; } } } return weights; }
bool TimeseriesBuffer::init(UINT bufferSize,UINT numDimensions){ initialized = false; featureDataReady = false; if( bufferSize == 0 ){ errorLog << "init(UINT bufferSize,UINT numDimensions) - The bufferSize must be greater than zero!" << endl; return false; } if( numDimensions == 0 ){ errorLog << "init(UINT bufferSize,UINT numDimensions) - The numDimensions must be greater than zero!" << endl; return false; } //Setup the databuffer numInputDimensions = numDimensions; numOutputDimensions = bufferSize * numInputDimensions; this->bufferSize = bufferSize; dataBuffer.resize( bufferSize, VectorDouble(numInputDimensions,0) ); featureVector.resize(numOutputDimensions,0); //Flag that the timeseries buffer has been initialized initialized = true; return true; }
bool ThresholdDetection::init(UINT bufferLength,UINT numDimensions,double alpha,double beta){ initialized = false; this->bufferLength = bufferLength; this->numInputDimensions = numDimensions; this->alpha = alpha; this->beta = beta; this->inNoise = true; featureDataReady = false; //Set the number of output dimensions numOutputDimensions = 5 * numInputDimensions + 1; //Resize the feature vector featureVector.resize(numOutputDimensions); //Resize the raw data buffer dataBuffer.resize( bufferLength, VectorDouble(numInputDimensions,0) ); //Flag that the time domain features has been initialized initialized = true; return true; }
VectorDouble stddev(VectorDouble v) { double sum = std::accumulate(v.begin(), v.end(), 0.0); double mean = sum / v.size(); double sq_sum = std::inner_product(v.begin(), v.end(), v.begin(), 0.0); double stdev = std::sqrt(sq_sum / v.size() - mean * mean); return VectorDouble(1, stdev); }
VectorDouble LowPassFilter::filter(const VectorDouble &x){ if( !initialized ){ errorLog << "filter(const VectorDouble &x) - Not Initialized!" << endl; return VectorDouble(); } if( x.size() != numInputDimensions ){ errorLog << "filter(const VectorDouble &x) - The Number Of Input Dimensions (" << numInputDimensions << ") does not match the size of the input vector (" << x.size() << ")!" << endl; return VectorDouble(); } for(UINT n=0; n<numInputDimensions; n++){ processedData[n] = (x[n] * filterFactor) + (yy[n] * (1.0 - filterFactor)) * gain; yy[n] = processedData[n]; } return processedData; }
bool TimeDomainFeatures::init(UINT bufferLength,UINT numFrames,UINT numDimensions,bool offsetInput,bool useMean,bool useStdDev,bool useEuclideanNorm,bool useRMS){ initialized = false; if( numFrames > bufferLength ){ errorLog << "init(...) - The number of numFrames parameter can not be larger than the buffer length parameter!" << endl; return false; } if( bufferLength % numFrames != 0 ){ errorLog << "init(...) - The buffer length parameter must be divisible with no remainders by the number of numFrames parameter!" << endl; return false; } this->bufferLength = bufferLength; this->numFrames = numFrames; this->numInputDimensions = numDimensions; this->offsetInput = offsetInput; this->useMean = useMean; this->useStdDev = useStdDev; this->useEuclideanNorm = useEuclideanNorm; this->useRMS = useRMS; featureDataReady = false; //Set the number of output dimensions numOutputDimensions = 0; if( useMean ){ numOutputDimensions += numInputDimensions*numFrames; } if( useStdDev ){ numOutputDimensions += numInputDimensions*numFrames; } if( useEuclideanNorm ){ numOutputDimensions += numInputDimensions*numFrames; } if( useRMS ){ numOutputDimensions += numInputDimensions*numFrames; } if( numOutputDimensions == 0 ){ errorLog << "init(...) - The numOutputDimensions is zero!" << endl; return false; } //Resize the feature vector featureVector.resize(numOutputDimensions); //Resize the raw data buffer dataBuffer.resize( bufferLength, VectorDouble(numInputDimensions,0) ); //Flag that the time domain features has been initialized initialized = true; return true; }
double MovingAverageFilter::filter(const double x){ //If the filter has not been initialised then return 0, otherwise filter x and return y if( !initialized ){ errorLog << "filter(const double x) - The filter has not been initialized!" << endl; return 0; } VectorDouble y = filter(VectorDouble(1,x)); if( y.size() == 0 ) return 0; return y[0]; }
double Derivative::computeDerivative(const double x){ if( numInputDimensions != 1 ){ errorLog << "computeDerivative(const double x) - The Number Of Input Dimensions is not 1! NumInputDimensions: " << numInputDimensions << endl; return 0; } VectorDouble y = computeDerivative( VectorDouble(1,x) ); if( y.size() == 0 ) return 0 ; return y[0]; }
double LeakyIntegrator::update(const double x){ if( numInputDimensions != 1 ){ errorLog << "update(const double x) - The Number Of Input Dimensions is not 1! NumInputDimensions: " << numInputDimensions << endl; return 0; } y = update( VectorDouble(1,x) ); if( y.size() == 0 ) return 0 ; return y[0]; }
double Derivative::computeDerivative(const double x){ #ifdef GRT_SAFE_CHECKING if( numInputDimensions != 1 ){ errorLog << "computeDerivative(const double x) - The Number Of Input Dimensions is not 1! NumInputDimensions: " << numInputDimensions << endl; return 0; } #endif vector< double > y = computeDerivative( VectorDouble(1,x) ); if( y.size() == 0 ) return 0 ; return y[0]; }
double LowPassFilter::filter(double x){ #ifdef GRT_SAFE_CHECKING //If the filter has not been initialised then return 0, otherwise filter x and return y if( !initialized ){ errorLog << "filter(double x) - The filter has not been initialized!" << endl; return 0; } #endif VectorDouble y = filter(VectorDouble(1,x)); if( y.size() == 0 ) return 0; return y[0]; }
VectorDouble Derivative::getDerivatives(UINT derivativeOrder){ switch( derivativeOrder ){ case 0: return processedData; break; case( FIRST_DERIVATIVE ): return yy; break; case( SECOND_DERIVATIVE ): return yyy; break; default: warningLog << "getDerivative(UINT derivativeOrder) - Unkown derivativeOrder: " << derivativeOrder << endl; break; } return VectorDouble(); }
VectorDouble Classifier::getNullRejectionThresholds() const{ if( trained ) return nullRejectionThresholds; return VectorDouble(); }
VectorDouble TimeDomainFeatures::update(double x){ return update(VectorDouble(1,x)); }
VectorDouble TimeseriesBuffer::update(double x){ return update(VectorDouble(1,x)); }
UINT KMeansQuantizer::quantize(double inputValue){ return quantize( VectorDouble(1,inputValue) ); }
VectorDouble ANBC::getNullRejectionThresholds() const{ if( !trained ) return VectorDouble(); return nullRejectionThresholds; }
UINT RBMQuantizer::quantize(const double inputValue){ return quantize( VectorDouble(1,inputValue) ); }
VectorDouble Regressifier::getRegressionData() const{ if( trained ){ return regressionData; } return VectorDouble(); }
VectorDouble MovementTrajectoryFeatures::update(double x){ return update(VectorDouble(1,x)); }
VectorDouble Classifier::getClassLikelihoods() const{ if( trained ) return classLikelihoods; return VectorDouble(); }
VectorDouble Classifier::getClassDistances() const{ if( trained ) return classDistances; return VectorDouble(); }
VectorDouble ThresholdDetection::update(double x){ return update(VectorDouble(1,x)); }
bool MovementTrajectoryFeatures::init(UINT trajectoryLength,UINT numCentroids,UINT featureMode,UINT numHistogramBins,UINT numDimensions,bool useTrajStartAndEndValues,bool useWeightedMagnitudeValues){ initialized = false; if( numCentroids > trajectoryLength ){ errorLog << "init(...) - The number of centroids parameter can not be larger than the trajectory length parameter!" << endl; return false; } if( trajectoryLength % numCentroids != 0 ){ errorLog << "init(...) - The trajectory length parameter must be divisible with no remainders by the number of centroids parameter!" << endl; return false; } if( featureMode == CENTROID_ANGLE_2D && numDimensions % 2 != 0 ){ errorLog << "init(...) - If the featureMode is CENTROID_ANGLE_2D then the numberOfDimensions should be divisble by 2 (as each pair of points should represent {x,y})!" << endl; return false; } if( numHistogramBins == 0 && featureMode == CENTROID_ANGLE_2D ){ errorLog << "init(...) - If the featureMode is CENTROID_ANGLE_2D then the numHistogramBins parameter must greater than 0!" << endl; return false; } //Setup the search variables this->trajectoryLength = trajectoryLength; this->numCentroids = numCentroids; this->featureMode = featureMode; this->numHistogramBins = numHistogramBins; this->numInputDimensions = numDimensions; this->useTrajStartAndEndValues = useTrajStartAndEndValues; this->useWeightedMagnitudeValues = useWeightedMagnitudeValues; featureDataReady = false; //Set the number of output dimensions numOutputDimensions = 0; switch( featureMode ){ case CENTROID_VALUE: //In the centroid value mode the useTrajStartAndEndValues is ignored (as the start and end centroids are used by default) numOutputDimensions = numInputDimensions*numCentroids; break; case NORMALIZED_CENTROID_VALUE: numOutputDimensions = numInputDimensions*numCentroids; if( useTrajStartAndEndValues ){ numOutputDimensions += numInputDimensions*2; } break; case CENTROID_DERIVATIVE: numOutputDimensions = numInputDimensions*(numCentroids-1); if( useTrajStartAndEndValues ){ numOutputDimensions += numInputDimensions*2; } break; case CENTROID_ANGLE_2D: numOutputDimensions = numHistogramBins*(numDimensions/2); break; default: errorLog << "init(...)- Unknown featureMode!" << endl; return false; break; } if( numOutputDimensions == 0 ){ errorLog << "init(...) - The numOutputDimensions is zero!" << endl; return false; } //Resize the feature vector featureVector.resize(numOutputDimensions); //Resize the raw trajectory data buffer trajectoryDataBuffer.resize( trajectoryLength, VectorDouble(numInputDimensions,0) ); //Resize the centroids buffer centroids.resize(numCentroids,numInputDimensions); //Flag that the zero crossing counter has been initialized initialized = true; return true; }