public AccumulatedSpectrum Mul(ref RgbSpectrum rgb, SpectrumType t)
{
if (storeInRgb)
{
this.rgbAcc *= rgb;
}
else
{
this.spAcc *= new SampledSpectrum(ref rgb, t);
}
return this;
}
public SampledSpectrum Open(string fileName, SpectrumType st)
{
using (TextReader tr = new StringReader(fileName))
{
List<float> lambda = new List<float>(), sample = new List<float>();
while (true)
{
var line = tr.ReadLine();
if (line == null)
break;
if (line.Contains("#"))
continue;
var data = line.Split(' ');
lambda.Add(float.Parse(data[0], NumberStyles.Any, CultureInfo.InvariantCulture));
sample.Add(float.Parse(data[1], NumberStyles.Any, CultureInfo.InvariantCulture));
}
return SampledSpectrum.FromSampled(lambda.ToArray(), sample.ToArray(), st);
}
}
public EventVisual(int spectrumPoint, SpectrumType type)
{
point = spectrumPoint;
switch (type)
{
case SpectrumType.DECIBAL:
color = Color.White;
baseOffset = 0;
break;
case SpectrumType.LINEAR:
color = Color.Blue;
baseOffset = 280;
break;
case SpectrumType.SQUARE:
color = Color.Pink;
baseOffset = 560;
break;
}
color.A = 155;
}
/// <summary>
/// TranslateExtension turns a file extension into a SpectrumType
/// </summary>
/// <param name="fileExt">The Extension or Filter to translate</param>
/// <returns>The SpectrumType of the file</returns>
private static SpectrumType TranslateExtFilter(String fileExt, String fileFilter)
{
//Declare a variable to return
SpectrumType rtn = SpectrumType.Invalid;
//Make the Strings uppercase
String ucExt = fileExt.ToUpper();
String ucFilter = fileFilter.ToUpper();
//Choose the SpectrumType based on the Strings
if (ucExt == SpectrumExtension.Raw3DExt.ToUpper() || ucFilter == SpectrumExtension.Raw3DFilter.ToUpper())
{
rtn = SpectrumType.R3D;
}
else if (ucExt == SpectrumExtension.TxtExt.ToUpper() || ucFilter == SpectrumExtension.TxtFilter.ToUpper())
{
rtn = SpectrumType.TXT;
}
//Return the result
return(rtn);
}
public MfccExtractorHtk(int samplingRate,
int featureCount,
double frameDuration = 0.0256 /*sec*/,
double hopDuration = 0.010 /*sec*/,
int filterbankSize = 24,
double lowFreq = 0,
double highFreq = 0,
int fftSize = 0,
int lifterSize = 0,
double preEmphasis = 0,
bool includeEnergy = false,
SpectrumType spectrumType = SpectrumType.Power,
WindowTypes window = WindowTypes.Hamming)
: base(samplingRate,
featureCount,
frameDuration,
hopDuration,
filterbankSize,
lowFreq,
highFreq,
fftSize,
MakeFilterbank(filterbankSize,
samplingRate,
fftSize,
frameDuration,
lowFreq,
highFreq),
lifterSize,
preEmphasis,
includeEnergy,
"2N",
NonLinearityType.LogE,
spectrumType,
window,
1.0f)
{
}
public static RegularSPD RegularSpdFromSampled(double[] data, SpectrumType t)
{
var vals = data.ToList().Where((c, i) => i % 2 != 0).Select(l => (float)l).ToArray();
var lambdas = data.ToList().Where((c, i) => i % 2 == 0).Select(l => (float)l).ToArray();
return new RegularSPD(vals, lambdas.Min(), lambdas.Max(), lambdas.Length);
}
public static SampledSpectrum Convert(ref RgbSpectrum s, SpectrumType t)
{
return new SampledSpectrum(ref s, t);
}
//private MemoryMappedFile mmf;
//private MemoryMappedViewAccessor mmv;
public SpectrumWrapper(SpectrumType spectrum, double[] masses, double[] intensities)
{
Spectrum = spectrum;
Masses = masses;
Intensities = intensities;
}
/// <summary>
/// 频谱单位转换函数
/// </summary>
/// <param name="spectrum">输入频谱，单位转换后返回的序列也保存在里面</param>
/// <param name="spectrumType">输入频谱类型，功率谱或者幅度谱</param>
/// <param name="df">频谱间隔</param>
/// <param name="unitSetting">单位转换设置</param>
/// <param name="equivalentNoiseBw">计算频谱时，加窗所用窗函数的等效噪声带宽</param>
/// <returns></returns>
private static void UnitConversion(double[] spectrum, double df, SpectrumType spectrumType,
UnitConvSetting unitSetting, double equivalentNoiseBw)
{
double scale = 1.0;
int freq0Idx = 0, N = spectrum.Length;
//VMLNative.vdSqr(N, spectrum, spectrum);
if (unitSetting.PeakScaling == PeakScaling.Peak) //峰峰值要乘以2
{
switch (spectrumType)
{
case SpectrumType.Amplitude: // Sqrt2
scale *= Sqrt2;
break;
case SpectrumType.Power: // 2
scale *= 2;
break;
default:
throw new ArgumentOutOfRangeException(nameof(spectrumType), spectrumType, null);
}
CBLASNative.cblas_dscal(N, scale, spectrum, 1);
spectrum[0] /= scale; //零频不用
}
//根据设置的转换单位进行转换
switch (unitSetting.Unit)
{
case SpectrumUnits.V:
{
if (SpectrumType.Power == spectrumType)
{
VMLNative.vdSqrt(N, spectrum, spectrum);
}
break;
}
case SpectrumUnits.dBV:
{
if (SpectrumType.Power == spectrumType)
{
VMLNative.vdSqrt(N, spectrum, spectrum);
}
//lg
VMLNative.vdLog10(N, spectrum, spectrum);
scale = 20;
//20*lg
CBLASNative.cblas_dscal(N, scale, spectrum, 1);
break;
}
case SpectrumUnits.dBmV:
{
if (SpectrumType.Power == spectrumType)
{
VMLNative.vdSqrt(N, spectrum, spectrum);
}
CBLASNative.cblas_dscal(N, 1e3, spectrum, 1); //V To mV
VMLNative.vdLog10(N, spectrum, spectrum); //To Lg
scale = 20;
CBLASNative.cblas_dscal(N, scale, spectrum, 1); //To 20*Lg
break;
}
case SpectrumUnits.dBuV:
{
if (SpectrumType.Power == spectrumType)
{
VMLNative.vdSqrt(N, spectrum, spectrum);
}
CBLASNative.cblas_dscal(N, 1e6, spectrum, 1); //V To uV
VMLNative.vdLog10(N, spectrum, spectrum); //To Lg
scale = 20;
CBLASNative.cblas_dscal(N, scale, spectrum, 1); //To 20*Lg
break;
}
case SpectrumUnits.V2:
{
if (SpectrumType.Amplitude == spectrumType)
{
VMLNative.vdSqr(N, spectrum, spectrum);
}
break;
}
case SpectrumUnits.W:
case SpectrumUnits.dBW:
case SpectrumUnits.dBm:
{
if (SpectrumType.Amplitude == spectrumType)
{
VMLNative.vdSqr(N, spectrum, spectrum);
}
scale = 1.0 / unitSetting.Impedance; //1/R
CBLASNative.cblas_dscal(N, scale, spectrum, 1); //W = V^2/R
if (unitSetting.Unit == SpectrumUnits.dBW) //dBW = 20lgW
{
//lg
VMLNative.vdLog10(N, spectrum, spectrum);
scale = 20;
//20*lg
CBLASNative.cblas_dscal(N, scale, spectrum, 1);
}
else if (unitSetting.Unit == SpectrumUnits.dBm) // dBm = 10lg(W/1mW)
{
CBLASNative.cblas_dscal(N, 1e3, spectrum, 1); // W/1mW
//lg
VMLNative.vdLog10(N, spectrum, spectrum);
scale = 10;
//10*lg
CBLASNative.cblas_dscal(N, scale, spectrum, 1);
}
break;
}
default:
{
break;
}
}
if (!unitSetting.PSD)
{
return;
}
//谱密度计算
scale = 1.0 / (equivalentNoiseBw * df);
CBLASNative.cblas_dscal(N, scale, spectrum, 1);
}
public Radiance Mul(RgbSpectrum f, SpectrumType type)
{
spectra = spectra * new SampledSpectrum(ref f, type);
return this;
}
public PSSpectrum(ref RgbSpectrum c, SpectrumType type)
{
//fixed spectra = new float*[nSamples];
FromRgb(ref c, type);
}
/// <summary>
/// Generates the version block
/// </summary>
/// <param name="specType">type of spectrum beign splashed</param>
/// <returns>the version block as a string</returns>
private string getFirstBlock(SpectrumType specType)
{
Debug.WriteLine(string.Format("version block: {0}", PREFIX + (int)specType + VERSION));
return (PREFIX + (int)specType + VERSION);
}
/// <summary>
/// Generates the version block
/// </summary>
/// <param name="specType">type of spectrum beign splashed</param>
/// <returns>the version block as a string</returns>
private string getFirstBlock(SpectrumType specType)
{
Debug.WriteLine(string.Format("version block: {0}", PREFIX + (int)specType + VERSION));
return(PREFIX + (int)specType + VERSION);
}
public void Plot(Spectrum spectrum, Action <object, OxyMouseDownEventArgs> onSeriesClicked, SpectrumType spectrumType)
{
LineSeries sourceSeries;
LineSeries optimizedSeries = BuildLineSeries(spectrum.Optimized, onSeriesClicked);
var peakSeriesName = string.Empty;
if (spectrumType == SpectrumType.Analyzed)
{
PlotFrame.Title = spectrum.Name;
sourceSeries = BuildLineSeries(spectrum.Source, null);
PlotFrame.Series.Add(sourceSeries);
peakSeriesName = "Peaks";
}
else if (spectrumType == SpectrumType.Imported)
{
peakSeriesName = "Imported Peaks";
}
ScatterSeries peaksSeries = BuildScatterSeries(spectrum.Peaks, peakSeriesName);
PlotFrame.Series.Add(optimizedSeries);
PlotFrame.Series.Add(peaksSeries);
RecountPlotAxes(spectrum.Optimized.Data); // TODO: REcount by all transition types, not only source.
foreach (var item in spectrum.Peaks.Data)
{
this.Selection = Plotter.StageType.Automatic;
this.MarkPeak(item.X, item.Y, peakSeriesName);
this.Selection = Plotter.StageType.CanBeManual;
}
PlotFrame.InvalidatePlot(true);
}
//public static PSSpectrum FromRgb(ref RgbSpectrum rgbSp, SpectrumType type = SpectrumType.Reflectance)
//{
// var rgb = rgbSp.ToArray();
// return FromRGB(rgb, type);
//}
public static PSSpectrum FromRGB_old(float[] rgb, SpectrumType type = SpectrumType.Reflectance)
{
var r = new PSSpectrum(0f);
if (type == SpectrumType.Reflectance)
{
// Convert reflectance spectrum to RGB
if ((rgb[0] <= rgb[1]) && (rgb[0] <= rgb[2]))
{
// Compute reflectance _PSSpectrum_ with _rgb[0]_ as minimum
r += rgb[0] * rgbRefl2SpectWhite;
if (rgb[1] <= rgb[2])
{
r += (rgb[1] - rgb[0]) * rgbRefl2SpectCyan;
r += (rgb[2] - rgb[1]) * rgbRefl2SpectBlue;
}
else
{
r += (rgb[2] - rgb[0]) * rgbRefl2SpectCyan;
r += (rgb[1] - rgb[2]) * rgbRefl2SpectGreen;
}
}
else if (rgb[1] <= rgb[0] && rgb[1] <= rgb[2])
{
// Compute reflectance _PSSpectrum_ with _rgb[1]_ as minimum
r += rgb[1] * rgbRefl2SpectWhite;
if (rgb[0] <= rgb[2])
{
r += (rgb[0] - rgb[1]) * rgbRefl2SpectMagenta;
r += (rgb[2] - rgb[0]) * rgbRefl2SpectBlue;
}
else
{
r += (rgb[2] - rgb[1]) * rgbRefl2SpectMagenta;
r += (rgb[0] - rgb[2]) * rgbRefl2SpectRed;
}
}
else
{
// Compute reflectance _PSSpectrum_ with _rgb[2]_ as minimum
r += rgb[2] * rgbRefl2SpectWhite;
if (rgb[0] <= rgb[1])
{
r += (rgb[0] - rgb[2]) * rgbRefl2SpectYellow;
r += (rgb[1] - rgb[0]) * rgbRefl2SpectGreen;
}
else
{
r += (rgb[1] - rgb[2]) * rgbRefl2SpectYellow;
r += (rgb[0] - rgb[1]) * rgbRefl2SpectRed;
}
}
r *= .94f;
}
else
{
// Convert illuminant spectrum to RGB
if (rgb[0] <= rgb[1] && rgb[0] <= rgb[2])
{
// Compute illuminant _PSSpectrum_ with _rgb[0]_ as minimum
r += rgb[0] * rgbIllum2SpectWhite;
if (rgb[1] <= rgb[2])
{
r += (rgb[1] - rgb[0]) * rgbIllum2SpectCyan;
r += (rgb[2] - rgb[1]) * rgbIllum2SpectBlue;
}
else
{
r += (rgb[2] - rgb[0]) * rgbIllum2SpectCyan;
r += (rgb[1] - rgb[2]) * rgbIllum2SpectGreen;
}
}
else if (rgb[1] <= rgb[0] && rgb[1] <= rgb[2])
{
// Compute illuminant _PSSpectrum_ with _rgb[1]_ as minimum
r += rgb[1] * rgbIllum2SpectWhite;
if (rgb[0] <= rgb[2])
{
r += (rgb[0] - rgb[1]) * rgbIllum2SpectMagenta;
r += (rgb[2] - rgb[0]) * rgbIllum2SpectBlue;
}
else
{
r += (rgb[2] - rgb[1]) * rgbIllum2SpectMagenta;
r += (rgb[0] - rgb[2]) * rgbIllum2SpectRed;
}
}
else
{
// Compute illuminant _PSSpectrum_ with _rgb[2]_ as minimum
r += rgb[2] * rgbIllum2SpectWhite;
if (rgb[0] <= rgb[1])
{
r += (rgb[0] - rgb[2]) * rgbIllum2SpectYellow;
r += (rgb[1] - rgb[0]) * rgbIllum2SpectGreen;
}
else
{
r += (rgb[1] - rgb[2]) * rgbIllum2SpectYellow;
r += (rgb[0] - rgb[1]) * rgbIllum2SpectRed;
}
}
r *= .86445f;
}
return r.Clamp();
}
public static PSSpectrum FromSampled(float[] lambda, float[] values, SpectrumType type = SpectrumType.Reflectance)
{
var n = lambda.Length;
if (!SpectrumSamplesSorted(lambda, values, lambda.Length))
{
SortSpectrumSamples(ref lambda, ref values);
return FromSampled(lambda, values, type);
}
var r = new PSSpectrum(0f);
for (int i = 0; i < nSpectralSamples; ++i)
{
// Compute average value of given SPD over $i$th sample's range
float lambda0 = MathLab.Lerp((float)(i) / (float)(nSpectralSamples), sampledLambdaStart, sampledLambdaEnd);
float lambda1 = MathLab.Lerp((float)(i + 1f) / (float)(nSpectralSamples), sampledLambdaStart, sampledLambdaEnd);
r.spectra[i] = AverageSpectrumSamples(lambda, values, n, lambda0, lambda1);
}
return r;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="samplingRate"></param>
/// <param name="featureCount"></param>
/// <param name="frameDuration"></param>
/// <param name="hopDuration"></param>
/// <param name="filterbankSize"></param>
/// <param name="lowFreq"></param>
/// <param name="highFreq"></param>
/// <param name="fftSize"></param>
/// <param name="filterbank"></param>
/// <param name="lifterSize"></param>
/// <param name="preEmphasis"></param>
/// <param name="includeEnergy"></param>
/// <param name="dctType">"1", "1N", "2", "2N", "3", "3N", "4", "4N"</param>
/// <param name="nonLinearity"></param>
/// <param name="spectrumType"></param>
/// <param name="window"></param>
/// <param name="logFloor"></param>
public MfccExtractor(int samplingRate,
int featureCount,
double frameDuration = 0.0256 /*sec*/,
double hopDuration = 0.010 /*sec*/,
int filterbankSize = 24,
double lowFreq = 0,
double highFreq = 0,
int fftSize = 0,
float[][] filterbank = null,
int lifterSize = 0,
double preEmphasis = 0,
bool includeEnergy = false,
string dctType = "2N",
NonLinearityType nonLinearity = NonLinearityType.Log10,
SpectrumType spectrumType = SpectrumType.Power,
WindowTypes window = WindowTypes.Hamming,
float logFloor = float.Epsilon)
: base(samplingRate, frameDuration, hopDuration, preEmphasis)
{
FeatureCount = featureCount;
_lowFreq = lowFreq;
_highFreq = highFreq;
if (filterbank == null)
{
_blockSize = fftSize > FrameSize ? fftSize : MathUtils.NextPowerOfTwo(FrameSize);
var melBands = FilterBanks.MelBands(filterbankSize, _blockSize, SamplingRate, _lowFreq, _highFreq);
FilterBank = FilterBanks.Triangular(_blockSize, SamplingRate, melBands, mapper: Scale.HerzToMel); // HTK/Kaldi-style
}
else
{
FilterBank = filterbank;
filterbankSize = filterbank.Length;
_blockSize = 2 * (filterbank[0].Length - 1);
Guard.AgainstExceedance(FrameSize, _blockSize, "frame size", "FFT size");
}
_fft = new RealFft(_blockSize);
_window = window;
_windowSamples = Window.OfType(_window, FrameSize);
_lifterSize = lifterSize;
_lifterCoeffs = _lifterSize > 0 ? Window.Liftering(FeatureCount, _lifterSize) : null;
_includeEnergy = includeEnergy;
// setup DCT: ============================================================================
_dctType = dctType;
switch (dctType[0])
{
case '1':
_dct = new Dct1(filterbankSize);
break;
case '2':
_dct = new Dct2(filterbankSize);
break;
case '3':
_dct = new Dct3(filterbankSize);
break;
case '4':
_dct = new Dct4(filterbankSize);
break;
default:
throw new ArgumentException("Only DCT-1, 2, 3 and 4 are supported!");
}
if (dctType.Length > 1 && char.ToUpper(dctType[1]) == 'N')
{
_applyDct = mfccs => _dct.DirectNorm(_melSpectrum, mfccs);
}
else
{
_applyDct = mfccs => _dct.Direct(_melSpectrum, mfccs);
}
// setup spectrum post-processing: =======================================================
_logFloor = logFloor;
_nonLinearityType = nonLinearity;
switch (nonLinearity)
{
case NonLinearityType.Log10:
_postProcessSpectrum = () => FilterBanks.ApplyAndLog10(FilterBank, _spectrum, _melSpectrum, _logFloor);
break;
case NonLinearityType.LogE:
_postProcessSpectrum = () => FilterBanks.ApplyAndLog(FilterBank, _spectrum, _melSpectrum, _logFloor);
break;
case NonLinearityType.ToDecibel:
_postProcessSpectrum = () => FilterBanks.ApplyAndToDecibel(FilterBank, _spectrum, _melSpectrum, _logFloor);
break;
case NonLinearityType.CubicRoot:
_postProcessSpectrum = () => FilterBanks.ApplyAndPow(FilterBank, _spectrum, _melSpectrum, 0.33);
break;
default:
_postProcessSpectrum = () => FilterBanks.Apply(FilterBank, _spectrum, _melSpectrum);
break;
}
_spectrumType = spectrumType;
switch (_spectrumType)
{
case SpectrumType.Magnitude:
_getSpectrum = block => _fft.MagnitudeSpectrum(block, _spectrum, false);
break;
case SpectrumType.Power:
_getSpectrum = block => _fft.PowerSpectrum(block, _spectrum, false);
break;
case SpectrumType.MagnitudeNormalized:
_getSpectrum = block => _fft.MagnitudeSpectrum(block, _spectrum, true);
break;
case SpectrumType.PowerNormalized:
_getSpectrum = block => _fft.PowerSpectrum(block, _spectrum, true);
break;
}
// reserve memory for reusable blocks
_spectrum = new float[_blockSize / 2 + 1];
_melSpectrum = new float[filterbankSize];
}
public AudioEventArgs(int spectrumPoint, SpectrumType spectrumType, double actualValue)
{
this.SpectrumPoint = spectrumPoint;
this.DataType = spectrumType;
this.ActualValue = actualValue;
}
public static RegularSPD CreateRegularSpd(float r, float g, float b, SpectrumType t)
{
float[] l, v;
FromRgb(new RgbSpectrum(r,g,b), t).ToSpectra(out l, out v);
return new RegularSPD(v, SampledSpectrum.sampledLambdaStart, SampledSpectrum.sampledLambdaEnd, SampledSpectrum.nSpectralSamples);
}
/// <summary>
/// Constructs extractor from configuration <paramref name="options"/>.
/// </summary>
public MfccExtractor(MfccOptions options) : base(options)
{
FeatureCount = options.FeatureCount;
var filterbankSize = options.FilterBankSize;
if (options.FilterBank is null)
{
_blockSize = options.FftSize > FrameSize ? options.FftSize : MathUtils.NextPowerOfTwo(FrameSize);
var melBands = FilterBanks.MelBands(filterbankSize, SamplingRate, options.LowFrequency, options.HighFrequency);
FilterBank = FilterBanks.Triangular(_blockSize, SamplingRate, melBands, mapper: Scale.HerzToMel); // HTK/Kaldi-style
}
else
{
FilterBank = options.FilterBank;
filterbankSize = FilterBank.Length;
_blockSize = 2 * (FilterBank[0].Length - 1);
Guard.AgainstExceedance(FrameSize, _blockSize, "frame size", "FFT size");
}
_fft = new RealFft(_blockSize);
_lifterSize = options.LifterSize;
_lifterCoeffs = _lifterSize > 0 ? Window.Liftering(FeatureCount, _lifterSize) : null;
_includeEnergy = options.IncludeEnergy;
_logEnergyFloor = options.LogEnergyFloor;
// setup DCT: ============================================================================
_dctType = options.DctType;
switch (_dctType[0])
{
case '1': _dct = new Dct1(filterbankSize); break;
case '3': _dct = new Dct3(filterbankSize); break;
case '4': _dct = new Dct4(filterbankSize); break;
default: _dct = new Dct2(filterbankSize); break;
}
if (_dctType.EndsWith("N", StringComparison.OrdinalIgnoreCase))
{
_applyDct = mfccs => _dct.DirectNorm(_melSpectrum, mfccs);
}
else
{
_applyDct = mfccs => _dct.Direct(_melSpectrum, mfccs);
}
// setup spectrum post-processing: =======================================================
_logFloor = options.LogFloor;
_nonLinearityType = options.NonLinearity;
switch (_nonLinearityType)
{
case NonLinearityType.Log10:
_postProcessSpectrum = () => FilterBanks.ApplyAndLog10(FilterBank, _spectrum, _melSpectrum, _logFloor); break;
case NonLinearityType.LogE:
_postProcessSpectrum = () => FilterBanks.ApplyAndLog(FilterBank, _spectrum, _melSpectrum, _logFloor); break;
case NonLinearityType.ToDecibel:
_postProcessSpectrum = () => FilterBanks.ApplyAndToDecibel(FilterBank, _spectrum, _melSpectrum, _logFloor); break;
case NonLinearityType.CubicRoot:
_postProcessSpectrum = () => FilterBanks.ApplyAndPow(FilterBank, _spectrum, _melSpectrum, 0.33); break;
default:
_postProcessSpectrum = () => FilterBanks.Apply(FilterBank, _spectrum, _melSpectrum); break;
}
_spectrumType = options.SpectrumType;
switch (_spectrumType)
{
case SpectrumType.Magnitude:
_getSpectrum = block => _fft.MagnitudeSpectrum(block, _spectrum, false); break;
case SpectrumType.MagnitudeNormalized:
_getSpectrum = block => _fft.MagnitudeSpectrum(block, _spectrum, true); break;
case SpectrumType.PowerNormalized:
_getSpectrum = block => _fft.PowerSpectrum(block, _spectrum, true); break;
default:
_getSpectrum = block => _fft.PowerSpectrum(block, _spectrum, false); break;
}
// reserve memory for reusable blocks
_spectrum = new float[_blockSize / 2 + 1];
_melSpectrum = new float[filterbankSize];
}
public static RegularSPD CreateRegularSpd(ref RgbSpectrumInfo col, SpectrumType t)
{
float[] l, v;
FromRgb(ref col, t).ToSpectra(out l, out v);
return new RegularSPD(v, SampledSpectrum.sampledLambdaStart, SampledSpectrum.sampledLambdaEnd, SampledSpectrum.nSpectralSamples);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="samplingRate"></param>
/// <param name="featureCount"></param>
/// <param name="filterbank"></param>
/// <param name="frameDuration"></param>
/// <param name="hopDuration"></param>
/// <param name="preEmphasis"></param>
/// <param name="nonLinearity"></param>
/// <param name="spectrumType"></param>
/// <param name="window"></param>
/// <param name="logFloor"></param>
public FilterbankExtractor(int samplingRate,
float[][] filterbank,
double frameDuration = 0.0256 /*sec*/,
double hopDuration = 0.010 /*sec*/,
double preEmphasis = 0,
NonLinearityType nonLinearity = NonLinearityType.None,
SpectrumType spectrumType = SpectrumType.Power,
WindowTypes window = WindowTypes.Hamming,
float logFloor = float.Epsilon)
: base(samplingRate, frameDuration, hopDuration, preEmphasis)
{
FilterBank = filterbank;
FeatureCount = filterbank.Length;
_blockSize = 2 * (filterbank[0].Length - 1);
Guard.AgainstExceedance(FrameSize, _blockSize, "frame size", "FFT size");
_fft = new RealFft(_blockSize);
_window = window;
_windowSamples = Window.OfType(_window, FrameSize);
// setup spectrum post-processing: =======================================================
_logFloor = logFloor;
_nonLinearityType = nonLinearity;
switch (nonLinearity)
{
case NonLinearityType.Log10:
_postProcessSpectrum = () => FilterBanks.ApplyAndLog10(FilterBank, _spectrum, _bandSpectrum, _logFloor);
break;
case NonLinearityType.LogE:
_postProcessSpectrum = () => FilterBanks.ApplyAndLog(FilterBank, _spectrum, _bandSpectrum, _logFloor);
break;
case NonLinearityType.ToDecibel:
_postProcessSpectrum = () => FilterBanks.ApplyAndToDecibel(FilterBank, _spectrum, _bandSpectrum, _logFloor);
break;
case NonLinearityType.CubicRoot:
_postProcessSpectrum = () => FilterBanks.ApplyAndPow(FilterBank, _spectrum, _bandSpectrum, 0.33);
break;
default:
_postProcessSpectrum = () => FilterBanks.Apply(FilterBank, _spectrum, _bandSpectrum);
break;
}
_spectrumType = spectrumType;
switch (_spectrumType)
{
case SpectrumType.Magnitude:
_getSpectrum = block => _fft.MagnitudeSpectrum(block, _spectrum, false);
break;
case SpectrumType.Power:
_getSpectrum = block => _fft.PowerSpectrum(block, _spectrum, false);
break;
case SpectrumType.MagnitudeNormalized:
_getSpectrum = block => _fft.MagnitudeSpectrum(block, _spectrum, true);
break;
case SpectrumType.PowerNormalized:
_getSpectrum = block => _fft.PowerSpectrum(block, _spectrum, true);
break;
}
// reserve memory for reusable blocks
_spectrum = new float[_blockSize / 2 + 1];
_bandSpectrum = new float[filterbank.Length];
}
public static SampledSpectrum AVXFromRgb(float[] rgb, SpectrumType type = SpectrumType.Reflectance)
{
var r = new SampledSpectrum(0f);
if (type == SpectrumType.Reflectance)
{
// Convert reflectance spectrum to RGB
if (rgb[0] <= rgb[1] && rgb[0] <= rgb[2])
{
// Compute reflectance _SampledSpectrum_ with _rgb[0]_ as minimum
//r += rgb[0] * rgbRefl2SpectWhite;
AVX.MAdd(ref SampledSpectrum.rgbRefl2SpectWhite, rgb[0], ref r);
//SSE.MAddSSE(ref SampledSpectrum.rgbRefl2SpectWhite, rgb[0]);
if (rgb[1] <= rgb[2])
{
AVX.MAdd(ref SampledSpectrum.rgbRefl2SpectCyan, (rgb[1] - rgb[0]), ref r);
AVX.MAdd(ref SampledSpectrum.rgbRefl2SpectBlue, (rgb[2] - rgb[1]), ref r);
//r += (rgb[1] - rgb[0]) * rgbRefl2SpectCyan;
//r += (rgb[2] - rgb[1]) * rgbRefl2SpectBlue;
}
else
{
//r += (rgb[2] - rgb[0]) * rgbRefl2SpectCyan;
//r += (rgb[1] - rgb[2]) * rgbRefl2SpectGreen;
AVX.MAdd(ref SampledSpectrum.rgbRefl2SpectCyan, (rgb[2] - rgb[0]), ref r);
AVX.MAdd(ref SampledSpectrum.rgbRefl2SpectGreen, (rgb[1] - rgb[2]), ref r);
}
}
else if (rgb[1] <= rgb[0] && rgb[1] <= rgb[2])
{
// Compute reflectance _SampledSpectrum_ with _rgb[1]_ as minimum
//r += rgb[1] * rgbRefl2SpectWhite;
AVX.MAdd(ref SampledSpectrum.rgbRefl2SpectWhite, rgb[1], ref r);
if (rgb[0] <= rgb[2])
{
//r += (rgb[0] - rgb[1]) * rgbRefl2SpectMagenta;
//r += (rgb[2] - rgb[0]) * rgbRefl2SpectBlue;
AVX.MAdd(ref SampledSpectrum.rgbRefl2SpectMagenta, (rgb[0] - rgb[1]), ref r);
AVX.MAdd(ref SampledSpectrum.rgbRefl2SpectBlue, (rgb[2] - rgb[0]), ref r);
}
else
{
//r += (rgb[2] - rgb[1]) * rgbRefl2SpectMagenta;
//r += (rgb[0] - rgb[2]) * rgbRefl2SpectRed;
AVX.MAdd(ref SampledSpectrum.rgbRefl2SpectMagenta, (rgb[2] - rgb[1]), ref r);
AVX.MAdd(ref SampledSpectrum.rgbRefl2SpectRed, (rgb[0] - rgb[2]), ref r);
}
}
else
{
// Compute reflectance _SampledSpectrum_ with _rgb[2]_ as minimum
//r += rgb[2] * rgbRefl2SpectWhite;
AVX.MAdd(ref SampledSpectrum.rgbRefl2SpectWhite, rgb[2], ref r);
if (rgb[0] <= rgb[1])
{
//r += (rgb[0] - rgb[2]) * rgbRefl2SpectYellow;
//r += (rgb[1] - rgb[0]) * rgbRefl2SpectGreen;
AVX.MAdd(ref SampledSpectrum.rgbRefl2SpectYellow, (rgb[0] - rgb[2]), ref r);
AVX.MAdd(ref SampledSpectrum.rgbRefl2SpectGreen, (rgb[1] - rgb[0]), ref r);
}
else
{
//r += (rgb[1] - rgb[2]) * rgbRefl2SpectYellow;
//r += (rgb[0] - rgb[1]) * rgbRefl2SpectRed;
AVX.MAdd(ref SampledSpectrum.rgbRefl2SpectYellow, (rgb[1] - rgb[2]), ref r);
AVX.MAdd(ref SampledSpectrum.rgbRefl2SpectRed, (rgb[0] - rgb[1]), ref r);
}
}
AVX.Mul(ref r, .94f, ref r);
//r *= .94f;
}
else
{
// Convert illuminant spectrum to RGB
if (rgb[0] <= rgb[1] && rgb[0] <= rgb[2])
{
// Compute illuminant _SampledSpectrum_ with _rgb[0]_ as minimum
//r += rgb[0] * rgbIllum2SpectWhite;
AVX.MAdd(ref SampledSpectrum.rgbIllum2SpectWhite, rgb[0], ref r);
if (rgb[1] <= rgb[2])
{
//r += (rgb[1] - rgb[0]) * rgbIllum2SpectCyan;
//r += (rgb[2] - rgb[1]) * rgbIllum2SpectBlue;
AVX.MAdd(ref SampledSpectrum.rgbIllum2SpectCyan, (rgb[1] - rgb[0]), ref r);
AVX.MAdd(ref SampledSpectrum.rgbIllum2SpectBlue, (rgb[2] - rgb[1]), ref r);
}
else
{
// r += (rgb[2] - rgb[0]) * rgbIllum2SpectCyan;
//r += (rgb[1] - rgb[2]) * rgbIllum2SpectGreen;
AVX.MAdd(ref SampledSpectrum.rgbIllum2SpectCyan, (rgb[2] - rgb[0]), ref r);
AVX.MAdd(ref SampledSpectrum.rgbIllum2SpectGreen, (rgb[1] - rgb[2]), ref r);
}
}
else if (rgb[1] <= rgb[0] && rgb[1] <= rgb[2])
{
// Compute illuminant _SampledSpectrum_ with _rgb[1]_ as minimum
//r += rgb[1] * rgbIllum2SpectWhite;
AVX.MAdd(ref SampledSpectrum.rgbIllum2SpectWhite, rgb[1], ref r);
if (rgb[0] <= rgb[2])
{
//r += (rgb[0] - rgb[1]) * rgbIllum2SpectMagenta;
//r += (rgb[2] - rgb[0]) * rgbIllum2SpectBlue;
AVX.MAdd(ref SampledSpectrum.rgbIllum2SpectMagenta, (rgb[0] - rgb[1]), ref r);
AVX.MAdd(ref SampledSpectrum.rgbIllum2SpectBlue, (rgb[2] - rgb[0]), ref r);
}
else
{
//r += (rgb[2] - rgb[1]) * rgbIllum2SpectMagenta;
//r += (rgb[0] - rgb[2]) * rgbIllum2SpectRed;
AVX.MAdd(ref SampledSpectrum.rgbIllum2SpectMagenta, (rgb[2] - rgb[1]), ref r);
AVX.MAdd(ref SampledSpectrum.rgbIllum2SpectRed, (rgb[0] - rgb[2]), ref r);
}
}
else
{
// Compute illuminant _SampledSpectrum_ with _rgb[2]_ as minimum
//r += rgb[2] * rgbIllum2SpectWhite;
AVX.MAdd(ref SampledSpectrum.rgbIllum2SpectWhite, rgb[2], ref r);
if (rgb[0] <= rgb[1])
{
//r += (rgb[0] - rgb[2]) * rgbIllum2SpectYellow;
//r += (rgb[1] - rgb[0]) * rgbIllum2SpectGreen;
AVX.MAdd(ref SampledSpectrum.rgbIllum2SpectYellow, (rgb[0] - rgb[2]), ref r);
AVX.MAdd(ref SampledSpectrum.rgbIllum2SpectGreen, (rgb[1] - rgb[0]), ref r);
}
else
{
//r += (rgb[1] - rgb[2]) * rgbIllum2SpectYellow;
//r += (rgb[0] - rgb[1]) * rgbIllum2SpectRed;
AVX.MAdd(ref SampledSpectrum.rgbIllum2SpectYellow, (rgb[1] - rgb[2]), ref r);
AVX.MAdd(ref SampledSpectrum.rgbIllum2SpectRed, (rgb[0] - rgb[1]), ref r);
}
}
AVX.Mul(ref r, .86445f, ref r);
//r *= .86445f;
}
//AVX.Clamp(ref r, ref r);
//r.ClampSelf();
return r;
}
/// <summary>
/// Construct a spectrum element for the given scan
/// </summary>
/// <param name="scanNumber">the scan number</param>
/// <returns>The SpectrumType object</returns>
private SpectrumType ConstructSpectrum(int scanNumber)
{
// Get each scan from the RAW file
var scan = Scan.FromFile(_rawFile, scanNumber);
// Get the scan filter for this scan number
var scanFilter = _rawFile.GetFilterForScanNumber(scanNumber);
// Get the scan event for this scan number
var scanEvent = _rawFile.GetScanEventForScanNumber(scanNumber);
var spectrum = new SpectrumType
{
id = ConstructSpectrumTitle(scanNumber),
defaultArrayLength = 0
};
// Add the ionization type if necessary
if (!_ionizationTypes.ContainsKey(scanFilter.IonizationMode))
{
_ionizationTypes.Add(scanFilter.IonizationMode,
OntologyMapping.IonizationTypes[scanFilter.IonizationMode]);
}
// Add the mass analyzer if necessary
if (!_massAnalyzers.ContainsKey(scanFilter.MassAnalyzer) &&
OntologyMapping.MassAnalyzerTypes.ContainsKey(scanFilter.MassAnalyzer))
{
_massAnalyzers.Add(scanFilter.MassAnalyzer, "IC" + (_massAnalyzers.Count + 1));
}
// Keep the CV params in a list and convert to array afterwards
var spectrumCvParams = new List <CVParamType>
{
new CVParamType
{
name = "ms level",
accession = "MS:1000511",
value = ((int)scanFilter.MSOrder).ToString(CultureInfo.InvariantCulture),
cvRef = "MS"
}
};
// Trailer extra data list
var trailerData = _rawFile.GetTrailerExtraInformation(scanNumber);
int? charge = null;
double?monoisotopicMass = null;
for (var i = 0; i < trailerData.Length; i++)
{
if (trailerData.Labels[i] == "Charge State:")
{
if (Convert.ToInt32(trailerData.Values[i]) > 0)
{
charge = Convert.ToInt32(trailerData.Values[i]);
}
}
if (trailerData.Labels[i] == "Monoisotopic M/Z:")
{
monoisotopicMass = double.Parse(trailerData.Values[i]);
}
}
// Construct and set the scan list element of the spectrum
var scanListType = ConstructScanList(scanNumber, scan, scanFilter, scanEvent, monoisotopicMass);
spectrum.scanList = scanListType;
switch (scanFilter.MSOrder)
{
case MSOrderType.Ms:
spectrumCvParams.Add(new CVParamType
{
accession = "MS:1000579",
cvRef = "MS",
name = "MS1 spectrum",
value = ""
});
// Keep track of scan number for precursor reference
_precursorScanNumber = scanNumber;
break;
case MSOrderType.Ms2:
spectrumCvParams.Add(new CVParamType
{
accession = "MS:1000580",
cvRef = "MS",
name = "MSn spectrum",
value = ""
});
// Construct and set the precursor list element of the spectrum
var precursorListType = ConstructPrecursorList(scanEvent, charge);
spectrum.precursorList = precursorListType;
break;
case MSOrderType.Ng:
break;
case MSOrderType.Nl:
break;
case MSOrderType.Par:
break;
case MSOrderType.Any:
break;
case MSOrderType.Ms3:
break;
case MSOrderType.Ms4:
break;
case MSOrderType.Ms5:
break;
case MSOrderType.Ms6:
break;
case MSOrderType.Ms7:
break;
case MSOrderType.Ms8:
break;
case MSOrderType.Ms9:
break;
case MSOrderType.Ms10:
break;
default:
throw new ArgumentOutOfRangeException();
}
// Scan polarity
var polarityType = scanFilter.Polarity;
switch (polarityType)
{
case PolarityType.Positive:
spectrumCvParams.Add(new CVParamType
{
accession = "MS:1000130",
cvRef = "MS",
name = "positive scan",
value = ""
});
break;
case PolarityType.Negative:
spectrumCvParams.Add(new CVParamType
{
accession = "MS:1000129",
cvRef = "MS",
name = "negative scan",
value = ""
});
break;
case PolarityType.Any:
break;
default:
throw new ArgumentOutOfRangeException();
}
// Total ion current
spectrumCvParams.Add(new CVParamType
{
name = "total ion current",
accession = "MS:1000285",
value = scan.ScanStatistics.TIC.ToString(CultureInfo.InvariantCulture),
cvRef = "MS"
});
double?basePeakMass = null;
double?basePeakIntensity = null;
double?lowestObservedMz = null;
double?highestObservedMz = null;
double[] masses = null;
double[] intensities = null;
if (scan.HasCentroidStream)
{
var centroidStream = _rawFile.GetCentroidStream(scanNumber, false);
if (scan.CentroidScan.Length > 0)
{
basePeakMass = centroidStream.BasePeakMass;
basePeakIntensity = centroidStream.BasePeakIntensity;
lowestObservedMz = centroidStream.Masses[0];
highestObservedMz = centroidStream.Masses[centroidStream.Masses.Length - 1];
masses = centroidStream.Masses;
intensities = centroidStream.Intensities;
// Note that although the scan data type is profile,
// centroid data might be available
spectrumCvParams.Add(new CVParamType
{
accession = "MS:1000127",
cvRef = "MS",
name = "centroid spectrum",
value = ""
});
}
}
else
{
// Get the scan statistics from the RAW file for this scan number
var scanStatistics = _rawFile.GetScanStatsForScanNumber(scanNumber);
basePeakMass = scanStatistics.BasePeakMass;
basePeakIntensity = scanStatistics.BasePeakIntensity;
// Get the segmented (low res and profile) scan data
var segmentedScan = _rawFile.GetSegmentedScanFromScanNumber(scanNumber, scanStatistics);
if (segmentedScan.Positions.Length > 0)
{
lowestObservedMz = segmentedScan.Positions[0];
highestObservedMz = segmentedScan.Positions[segmentedScan.Positions.Length - 1];
masses = segmentedScan.Positions;
intensities = segmentedScan.Intensities;
spectrumCvParams.Add(new CVParamType
{
accession = "MS:1000128",
cvRef = "MS",
name = "profile spectrum",
value = ""
});
}
}
// Base peak m/z
if (basePeakMass != null)
{
spectrumCvParams.Add(new CVParamType
{
name = "base peak m/z",
accession = "MS:1000504",
value = basePeakMass.ToString(),
unitCvRef = "MS",
unitName = "m/z",
unitAccession = "MS:1000040",
cvRef = "MS"
});
}
// Base peak intensity
if (basePeakMass != null)
{
spectrumCvParams.Add(new CVParamType
{
name = "base peak intensity",
accession = "MS:1000505",
value = basePeakIntensity.ToString(),
unitCvRef = "MS",
unitName = "number of detector counts",
unitAccession = "MS:1000131",
cvRef = "MS"
});
}
// Lowest observed mz
if (lowestObservedMz != null)
{
spectrumCvParams.Add(new CVParamType
{
name = "lowest observed m/z",
accession = "MS:1000528",
value = lowestObservedMz.ToString(),
unitCvRef = "MS",
unitAccession = "MS:1000040",
unitName = "m/z",
cvRef = "MS"
});
}
// Highest observed mz
if (highestObservedMz != null)
{
spectrumCvParams.Add(new CVParamType
{
name = "highest observed m/z",
accession = "MS:1000527",
value = highestObservedMz.ToString(),
unitAccession = "MS:1000040",
unitName = "m/z",
unitCvRef = "MS",
cvRef = "MS"
});
}
// Add the CV params to the spectrum
spectrum.cvParam = spectrumCvParams.ToArray();
// Binary data array list
var binaryData = new List <BinaryDataArrayType>();
// M/Z Data
if (!masses.IsNullOrEmpty())
{
// Set the spectrum default array length
spectrum.defaultArrayLength = masses.Length;
var massesBinaryData =
new BinaryDataArrayType
{
binary = GetZLib64BitArray(masses)
};
massesBinaryData.encodedLength =
(4 * Math.Ceiling((double)massesBinaryData
.binary.Length / 3)).ToString(CultureInfo.InvariantCulture);
massesBinaryData.cvParam =
new CVParamType[3];
massesBinaryData.cvParam[0] =
new CVParamType
{
accession = "MS:1000514",
name = "m/z array",
cvRef = "MS",
unitName = "m/z",
value = "",
unitCvRef = "MS",
unitAccession = "MS:1000040"
};
massesBinaryData.cvParam[1] =
new CVParamType
{
accession = "MS:1000523",
name = "64-bit float",
cvRef = "MS",
value = ""
};
massesBinaryData.cvParam[2] =
new CVParamType
{
accession = "MS:1000574",
name = "zlib compression",
cvRef = "MS",
value = ""
};
binaryData.Add(massesBinaryData);
}
// Intensity Data
if (!intensities.IsNullOrEmpty())
{
// Set the spectrum default array length if necessary
if (spectrum.defaultArrayLength == 0)
{
spectrum.defaultArrayLength = masses.Length;
}
var intensitiesBinaryData =
new BinaryDataArrayType
{
binary = GetZLib64BitArray(intensities)
};
intensitiesBinaryData.encodedLength =
(4 * Math.Ceiling((double)intensitiesBinaryData
.binary.Length / 3)).ToString(CultureInfo.InvariantCulture);
intensitiesBinaryData.cvParam =
new CVParamType[3];
intensitiesBinaryData.cvParam[0] =
new CVParamType
{
accession = "MS:1000515",
name = "intensity array",
cvRef = "MS",
unitCvRef = "MS",
unitAccession = "MS:1000131",
unitName = "number of counts",
value = ""
};
intensitiesBinaryData.cvParam[1] =
new CVParamType
{
accession = "MS:1000523",
name = "64-bit float",
cvRef = "MS",
value = ""
};
intensitiesBinaryData.cvParam[2] =
new CVParamType
{
accession = "MS:1000574",
name = "zlib compression",
cvRef = "MS",
value = ""
};
binaryData.Add(intensitiesBinaryData);
}
if (!binaryData.IsNullOrEmpty())
{
spectrum.binaryDataArrayList = new BinaryDataArrayListType
{
count = binaryData.Count.ToString(),
binaryDataArray = binaryData.ToArray()
};
}
return(spectrum);
}
public static SampledSpectrum FromRgb(RgbSpectrumInfo rgb, SpectrumType type = SpectrumType.Reflectance)
{
return FromRgb(ref rgb, type);
}
public static SampledSpectrum FromSampled(double[] data, SpectrumType t)
{
var vals = data.ToList().Where((c, i) => i % 2 != 0).Select(l => (float)l).ToArray();
var lambdas = data.ToList().Where((c, i) => i % 2 == 0).Select(l => (float)l).ToArray();
var s = SampledSpectrum.FromSampled(lambdas, vals, t);
return s;
}
public static SampledSpectrum FromRgb(ref RgbSpectrumInfo rgb, SpectrumType type = SpectrumType.Reflectance)
{
var r = new SampledSpectrum(0f);
if (type == SpectrumType.Reflectance)
{
// Convert reflectance spectrum to RGB
if (rgb.c1 <= rgb.c2 && rgb.c1 <= rgb.c3)
{
// Compute reflectance _SampledSpectrum_ with _rgb.c1_ as minimum
//r += rgb.c1 * rgbRefl2SpectWhite;
SSE.MAddSSE(ref SampledSpectrum.rgbRefl2SpectWhite, rgb.c1, ref r);
//SSE.MAddSSE(ref SampledSpectrum.rgbRefl2SpectWhite, rgb.c1);
if (rgb.c2 <= rgb.c3)
{
SSE.MAddSSE(ref SampledSpectrum.rgbRefl2SpectCyan, (rgb.c2 - rgb.c1), ref r);
SSE.MAddSSE(ref SampledSpectrum.rgbRefl2SpectBlue, (rgb.c3 - rgb.c2), ref r);
//r += (rgb.c2 - rgb.c1) * rgbRefl2SpectCyan;
//r += (rgb.c3 - rgb.c2) * rgbRefl2SpectBlue;
}
else
{
//r += (rgb.c3 - rgb.c1) * rgbRefl2SpectCyan;
//r += (rgb.c2 - rgb.c3) * rgbRefl2SpectGreen;
SSE.MAddSSE(ref SampledSpectrum.rgbRefl2SpectCyan, (rgb.c3 - rgb.c1), ref r);
SSE.MAddSSE(ref SampledSpectrum.rgbRefl2SpectGreen, (rgb.c2 - rgb.c3), ref r);
}
}
else if (rgb.c2 <= rgb.c1 && rgb.c2 <= rgb.c3)
{
// Compute reflectance _SampledSpectrum_ with _rgb.c2_ as minimum
//r += rgb.c2 * rgbRefl2SpectWhite;
SSE.MAddSSE(ref SampledSpectrum.rgbRefl2SpectWhite, rgb.c2, ref r);
if (rgb.c1 <= rgb.c3)
{
//r += (rgb.c1 - rgb.c2) * rgbRefl2SpectMagenta;
//r += (rgb.c3 - rgb.c1) * rgbRefl2SpectBlue;
SSE.MAddSSE(ref SampledSpectrum.rgbRefl2SpectMagenta, (rgb.c1 - rgb.c2), ref r);
SSE.MAddSSE(ref SampledSpectrum.rgbRefl2SpectBlue, (rgb.c3 - rgb.c1), ref r);
}
else
{
//r += (rgb.c3 - rgb.c2) * rgbRefl2SpectMagenta;
//r += (rgb.c1 - rgb.c3) * rgbRefl2SpectRed;
SSE.MAddSSE(ref SampledSpectrum.rgbRefl2SpectMagenta, (rgb.c3 - rgb.c2), ref r);
SSE.MAddSSE(ref SampledSpectrum.rgbRefl2SpectRed, (rgb.c1 - rgb.c3), ref r);
}
}
else
{
// Compute reflectance _SampledSpectrum_ with _rgb.c3_ as minimum
//r += rgb.c3 * rgbRefl2SpectWhite;
SSE.MAddSSE(ref SampledSpectrum.rgbRefl2SpectWhite, rgb.c3, ref r);
if (rgb.c1 <= rgb.c2)
{
//r += (rgb.c1 - rgb.c3) * rgbRefl2SpectYellow;
//r += (rgb.c2 - rgb.c1) * rgbRefl2SpectGreen;
SSE.MAddSSE(ref SampledSpectrum.rgbRefl2SpectYellow, (rgb.c1 - rgb.c3), ref r);
SSE.MAddSSE(ref SampledSpectrum.rgbRefl2SpectGreen, (rgb.c2 - rgb.c1), ref r);
}
else
{
//r += (rgb.c2 - rgb.c3) * rgbRefl2SpectYellow;
//r += (rgb.c1 - rgb.c2) * rgbRefl2SpectRed;
SSE.MAddSSE(ref SampledSpectrum.rgbRefl2SpectYellow, (rgb.c2 - rgb.c3), ref r);
SSE.MAddSSE(ref SampledSpectrum.rgbRefl2SpectRed, (rgb.c1 - rgb.c2), ref r);
}
}
SSE.MulSSE(ref r, .94f, ref r);
//r *= .94f;
}
else
{
// Convert illuminant spectrum to RGB
if (rgb.c1 <= rgb.c2 && rgb.c1 <= rgb.c3)
{
// Compute illuminant _SampledSpectrum_ with _rgb.c1_ as minimum
//r += rgb.c1 * rgbIllum2SpectWhite;
SSE.MAddSSE(ref SampledSpectrum.rgbIllum2SpectWhite, rgb.c1, ref r);
if (rgb.c2 <= rgb.c3)
{
//r += (rgb.c2 - rgb.c1) * rgbIllum2SpectCyan;
//r += (rgb.c3 - rgb.c2) * rgbIllum2SpectBlue;
SSE.MAddSSE(ref SampledSpectrum.rgbIllum2SpectCyan, (rgb.c2 - rgb.c1), ref r);
SSE.MAddSSE(ref SampledSpectrum.rgbIllum2SpectBlue, (rgb.c3 - rgb.c2), ref r);
}
else
{
// r += (rgb.c3 - rgb.c1) * rgbIllum2SpectCyan;
//r += (rgb.c2 - rgb.c3) * rgbIllum2SpectGreen;
SSE.MAddSSE(ref SampledSpectrum.rgbIllum2SpectCyan, (rgb.c3 - rgb.c1), ref r);
SSE.MAddSSE(ref SampledSpectrum.rgbIllum2SpectGreen, (rgb.c2 - rgb.c3), ref r);
}
}
else if (rgb.c2 <= rgb.c1 && rgb.c2 <= rgb.c3)
{
// Compute illuminant _SampledSpectrum_ with _rgb.c2_ as minimum
//r += rgb.c2 * rgbIllum2SpectWhite;
SSE.MAddSSE(ref SampledSpectrum.rgbIllum2SpectWhite, rgb.c2, ref r);
if (rgb.c1 <= rgb.c3)
{
//r += (rgb.c1 - rgb.c2) * rgbIllum2SpectMagenta;
//r += (rgb.c3 - rgb.c1) * rgbIllum2SpectBlue;
SSE.MAddSSE(ref SampledSpectrum.rgbIllum2SpectMagenta, (rgb.c1 - rgb.c2), ref r);
SSE.MAddSSE(ref SampledSpectrum.rgbIllum2SpectBlue, (rgb.c3 - rgb.c1), ref r);
}
else
{
//r += (rgb.c3 - rgb.c2) * rgbIllum2SpectMagenta;
//r += (rgb.c1 - rgb.c3) * rgbIllum2SpectRed;
SSE.MAddSSE(ref SampledSpectrum.rgbIllum2SpectMagenta, (rgb.c3 - rgb.c2), ref r);
SSE.MAddSSE(ref SampledSpectrum.rgbIllum2SpectRed, (rgb.c1 - rgb.c3), ref r);
}
}
else
{
// Compute illuminant _SampledSpectrum_ with _rgb.c3_ as minimum
//r += rgb.c3 * rgbIllum2SpectWhite;
SSE.MAddSSE(ref SampledSpectrum.rgbIllum2SpectWhite, rgb.c3, ref r);
if (rgb.c1 <= rgb.c2)
{
//r += (rgb.c1 - rgb.c3) * rgbIllum2SpectYellow;
//r += (rgb.c2 - rgb.c1) * rgbIllum2SpectGreen;
SSE.MAddSSE(ref SampledSpectrum.rgbIllum2SpectYellow, (rgb.c1 - rgb.c3), ref r);
SSE.MAddSSE(ref SampledSpectrum.rgbIllum2SpectGreen, (rgb.c2 - rgb.c1), ref r);
}
else
{
//r += (rgb.c2 - rgb.c3) * rgbIllum2SpectYellow;
//r += (rgb.c1 - rgb.c2) * rgbIllum2SpectRed;
SSE.MAddSSE(ref SampledSpectrum.rgbIllum2SpectYellow, (rgb.c2 - rgb.c3), ref r);
SSE.MAddSSE(ref SampledSpectrum.rgbIllum2SpectRed, (rgb.c1 - rgb.c2), ref r);
}
}
SSE.MulSSE(ref r, .86445f, ref r);
//r *= .86445f;
}
//SSE.ClampSSE(ref r, ref r);
//r.ClampSelf();
return r;
}
public static IrregularSPD IrregularFromSampled(double[] data, SpectrumType t)
{
var vals = data.ToList().Where((c, i) => i % 2 != 0).Select(l => (float)l).ToArray();
var lambdas = data.ToList().Where((c, i) => i % 2 == 0).Select(l => (float)l).ToArray();
return new IrregularSPD(lambdas, vals, lambdas.Length);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="options">Filterbank options</param>
public FilterbankExtractor(FilterbankOptions options) : base(options)
{
var filterbankSize = options.FilterBankSize;
if (options.FilterBank == null)
{
_blockSize = options.FftSize > FrameSize ? options.FftSize : MathUtils.NextPowerOfTwo(FrameSize);
var melBands = FilterBanks.MelBands(filterbankSize, SamplingRate, options.LowFrequency, options.HighFrequency, false);
FilterBank = FilterBanks.Rectangular(_blockSize, SamplingRate, melBands, mapper: Scale.HerzToMel);
}
else
{
FilterBank = options.FilterBank;
filterbankSize = FilterBank.Length;
_blockSize = 2 * (FilterBank[0].Length - 1);
Guard.AgainstExceedance(FrameSize, _blockSize, "frame size", "FFT size");
}
FeatureCount = filterbankSize;
_fft = new RealFft(_blockSize);
// setup spectrum post-processing: =======================================================
_logFloor = options.LogFloor;
_nonLinearityType = options.NonLinearity;
switch (_nonLinearityType)
{
case NonLinearityType.Log10:
_postProcessSpectrum = () => FilterBanks.ApplyAndLog10(FilterBank, _spectrum, _bandSpectrum, _logFloor); break;
case NonLinearityType.LogE:
_postProcessSpectrum = () => FilterBanks.ApplyAndLog(FilterBank, _spectrum, _bandSpectrum, _logFloor); break;
case NonLinearityType.ToDecibel:
_postProcessSpectrum = () => FilterBanks.ApplyAndToDecibel(FilterBank, _spectrum, _bandSpectrum, _logFloor); break;
case NonLinearityType.CubicRoot:
_postProcessSpectrum = () => FilterBanks.ApplyAndPow(FilterBank, _spectrum, _bandSpectrum, 0.33); break;
default:
_postProcessSpectrum = () => FilterBanks.Apply(FilterBank, _spectrum, _bandSpectrum); break;
}
_spectrumType = options.SpectrumType;
switch (_spectrumType)
{
case SpectrumType.Magnitude:
_getSpectrum = block => _fft.MagnitudeSpectrum(block, _spectrum, false); break;
case SpectrumType.MagnitudeNormalized:
_getSpectrum = block => _fft.MagnitudeSpectrum(block, _spectrum, true); break;
case SpectrumType.PowerNormalized:
_getSpectrum = block => _fft.PowerSpectrum(block, _spectrum, true); break;
default:
_getSpectrum = block => _fft.PowerSpectrum(block, _spectrum, false); break;
}
// reserve memory for reusable blocks
_spectrum = new float[_blockSize / 2 + 1];
_bandSpectrum = new float[filterbankSize];
}
public void FromRgb(ref RgbSpectrum rgbSp, SpectrumType type = SpectrumType.Reflectance)
{
var rgb = rgbSp.ToArray();
var c = FromRGB(rgb, type);
for (int i = 0; i < nSamples; i++)
{
this[i] = c[i];
}
}
public void ReadFromStream(System.IO.StreamReader sr)
{
string kStr = "";
string findId = "";
while (sr.EndOfStream == false)
{
try
{
kStr = sr.ReadLine();
findId = GetID(kStr);
if (findId == "N101")
{
CutOffFrequencies = double.Parse(GetValues(kStr, ' ')[5]);
}
else if (findId == "N102")
{
X = double.Parse(GetValues(kStr, ' ')[1]);
Y = double.Parse(GetValues(kStr, ' ')[2]);
Z = double.Parse(GetValues(kStr, ' ')[3]);
}
else if (findId == "N103")
{
if (GetValues(kStr, ' ')[1] == "ACCELERATION")
{
Type = SpectrumType.Acceleration;
}
else if (GetValues(kStr, ' ')[1] == "DISPLACEMENT")
{
Type = SpectrumType.Displacement;
}
}
else if (findId == "N104")
{
SpectrumPoints = int.Parse(GetValues(kStr, ' ')[1]);
ScaleFactor = double.Parse(GetValues(kStr, ' ')[2]);
}
else if (findId == "N105")
{
double prd, acc, disp;
if (Type == SpectrumType.Acceleration)
{
prd = acc = 0.0;
prd = double.Parse(GetValues(kStr, ' ')[1]);
acc = double.Parse(GetValues(kStr, ' ')[2]);
Periods.Add(prd);
Acceleration.Add(acc);
}
else if (Type == SpectrumType.Displacement)
{
prd = disp = 0.0;
prd = double.Parse(GetValues(kStr, ' ')[1]);
disp = double.Parse(GetValues(kStr, ' ')[2]);
Periods.Add(prd);
Displacement.Add(disp);
}
}
}
catch (Exception ex) { }
}
}
public static PSSpectrum FromRGB(float[] rgb, SpectrumType type = SpectrumType.Reflectance)
{
var r = new PSSpectrum(0f);
if (type == SpectrumType.Reflectance)
{
// Convert reflectance spectrum to RGB
if (rgb[0] <= rgb[1] && rgb[0] <= rgb[2])
{
// Compute reflectance _PSSpectrum_ with _rgb[0]_ as minimum
//r += rgb[0] * rgbRefl2SpectWhite;
r.MAdd(ref rgbRefl2SpectWhite, rgb[0]);
if (rgb[1] <= rgb[2])
{
r.MAdd(ref rgbRefl2SpectCyan, (rgb[1] - rgb[0]));
r.MAdd(ref rgbRefl2SpectBlue, (rgb[2] - rgb[1]));
//r += (rgb[1] - rgb[0]) * rgbRefl2SpectCyan;
//r += (rgb[2] - rgb[1]) * rgbRefl2SpectBlue;
}
else
{
//r += (rgb[2] - rgb[0]) * rgbRefl2SpectCyan;
//r += (rgb[1] - rgb[2]) * rgbRefl2SpectGreen;
r.MAdd(ref rgbRefl2SpectCyan, (rgb[2] - rgb[0]));
r.MAdd(ref rgbRefl2SpectGreen, (rgb[1] - rgb[2]));
}
}
else if (rgb[1] <= rgb[0] && rgb[1] <= rgb[2])
{
// Compute reflectance _PSSpectrum_ with _rgb[1]_ as minimum
//r += rgb[1] * rgbRefl2SpectWhite;
r.MAdd(ref rgbRefl2SpectWhite, rgb[1]);
if (rgb[0] <= rgb[2])
{
//r += (rgb[0] - rgb[1]) * rgbRefl2SpectMagenta;
//r += (rgb[2] - rgb[0]) * rgbRefl2SpectBlue;
r.MAdd(ref rgbRefl2SpectMagenta, (rgb[0] - rgb[1]));
r.MAdd(ref rgbRefl2SpectBlue, (rgb[2] - rgb[0]));
}
else
{
//r += (rgb[2] - rgb[1]) * rgbRefl2SpectMagenta;
//r += (rgb[0] - rgb[2]) * rgbRefl2SpectRed;
r.MAdd(ref rgbRefl2SpectMagenta, (rgb[2] - rgb[1]));
r.MAdd(ref rgbRefl2SpectRed, (rgb[0] - rgb[2]));
}
}
else
{
// Compute reflectance _PSSpectrum_ with _rgb[2]_ as minimum
//r += rgb[2] * rgbRefl2SpectWhite;
r.MAdd(ref rgbRefl2SpectWhite, rgb[2]);
if (rgb[0] <= rgb[1])
{
//r += (rgb[0] - rgb[2]) * rgbRefl2SpectYellow;
//r += (rgb[1] - rgb[0]) * rgbRefl2SpectGreen;
r.MAdd(ref rgbRefl2SpectYellow, (rgb[0] - rgb[2]));
r.MAdd(ref rgbRefl2SpectGreen, (rgb[1] - rgb[0]));
}
else
{
//r += (rgb[1] - rgb[2]) * rgbRefl2SpectYellow;
//r += (rgb[0] - rgb[1]) * rgbRefl2SpectRed;
r.MAdd(ref rgbRefl2SpectYellow, (rgb[1] - rgb[2]));
r.MAdd(ref rgbRefl2SpectRed, (rgb[0] - rgb[1]));
}
}
r *= .94f;
}
else
{
// Convert illuminant spectrum to RGB
if (rgb[0] <= rgb[1] && rgb[0] <= rgb[2])
{
// Compute illuminant _PSSpectrum_ with _rgb[0]_ as minimum
//r += rgb[0] * rgbIllum2SpectWhite;
r.MAdd(ref rgbIllum2SpectWhite, rgb[0]);
if (rgb[1] <= rgb[2])
{
//r += (rgb[1] - rgb[0]) * rgbIllum2SpectCyan;
//r += (rgb[2] - rgb[1]) * rgbIllum2SpectBlue;
r.MAdd(ref rgbIllum2SpectCyan, (rgb[1] - rgb[0]));
r.MAdd(ref rgbIllum2SpectBlue, (rgb[2] - rgb[1]));
}
else
{
// r += (rgb[2] - rgb[0]) * rgbIllum2SpectCyan;
//r += (rgb[1] - rgb[2]) * rgbIllum2SpectGreen;
r.MAdd(ref rgbIllum2SpectCyan, (rgb[2] - rgb[0]));
r.MAdd(ref rgbIllum2SpectGreen, (rgb[1] - rgb[2]));
}
}
else if (rgb[1] <= rgb[0] && rgb[1] <= rgb[2])
{
// Compute illuminant _PSSpectrum_ with _rgb[1]_ as minimum
//r += rgb[1] * rgbIllum2SpectWhite;
r.MAdd(ref rgbIllum2SpectWhite, rgb[1]);
if (rgb[0] <= rgb[2])
{
//r += (rgb[0] - rgb[1]) * rgbIllum2SpectMagenta;
//r += (rgb[2] - rgb[0]) * rgbIllum2SpectBlue;
r.MAdd(ref rgbIllum2SpectMagenta, (rgb[0] - rgb[1]));
r.MAdd(ref rgbIllum2SpectBlue, (rgb[2] - rgb[0]));
}
else
{
//r += (rgb[2] - rgb[1]) * rgbIllum2SpectMagenta;
//r += (rgb[0] - rgb[2]) * rgbIllum2SpectRed;
r.MAdd(ref rgbIllum2SpectMagenta, (rgb[2] - rgb[1]));
r.MAdd(ref rgbIllum2SpectRed, (rgb[0] - rgb[2]));
}
}
else
{
// Compute illuminant _PSSpectrum_ with _rgb[2]_ as minimum
//r += rgb[2] * rgbIllum2SpectWhite;
r.MAdd(ref rgbIllum2SpectWhite, rgb[2]);
if (rgb[0] <= rgb[1])
{
//r += (rgb[0] - rgb[2]) * rgbIllum2SpectYellow;
//r += (rgb[1] - rgb[0]) * rgbIllum2SpectGreen;
r.MAdd(ref rgbIllum2SpectYellow, (rgb[0] - rgb[2]));
r.MAdd(ref rgbIllum2SpectGreen, (rgb[1] - rgb[0]));
}
else
{
//r += (rgb[1] - rgb[2]) * rgbIllum2SpectYellow;
//r += (rgb[0] - rgb[1]) * rgbIllum2SpectRed;
r.MAdd(ref rgbIllum2SpectYellow, (rgb[1] - rgb[2]));
r.MAdd(ref rgbIllum2SpectRed, (rgb[0] - rgb[1]));
}
}
r *= .86445f;
}
r.ClampSelf();
return r;
}
public Radiance(ref RgbSpectrum s, SpectrumType t)
{
spectra = new SampledSpectrum(ref s, t);
}
public static PSSpectrum FromXYZ(float[] xyz, SpectrumType type = SpectrumType.Reflectance)
{
float[] rgb = null;
XYZToRGB(xyz, out rgb);
return FromRGB(rgb, type);
}
public Radiance Add(ref RgbSpectrum f, SpectrumType type)
{
spectra = spectra + new SampledSpectrum(ref f, type);
return this;
}
public PSSpectrum(RgbSpectrum c, SpectrumType type)
{
//spectra = new float[nSamples];
FromRgb(ref c, type);
}
private bool ParseN42File()
{
if (radInstrumentData == null || deviceData == null)
{
return(false);
}
try
{
RadInstrumentInformationType instrumentInfo = radInstrumentData.RadInstrumentInformation;
if (instrumentInfo == null)
{
return(false);
}
// Get DeviceType
deviceData.DeviceType = instrumentInfo.RadInstrumentModelName;
// Get SerialNumber
deviceData.SerialNumber = instrumentInfo.RadInstrumentIdentifier.Split('-').LastOrDefault();
// Find AnalysisResults and DerivedData
AnalysisResultsType analysisResults = null;
DerivedDataType derivedData = null;
ItemsChoiceType2[] itemsChoices2 = radInstrumentData.ItemsElementName;
for (int i = itemsChoices2.Length - 1; i >= 0; i -= 1)
{
if (analysisResults == null)
{
if (itemsChoices2[i] == ItemsChoiceType2.AnalysisResults)
{
analysisResults = radInstrumentData.Items[i] as AnalysisResultsType;
// Check if correct Id
if (analysisResults.id.StartsWith("Identification") == true)
{
continue;
}
analysisResults = null;
}
}
if (derivedData == null)
{
if (itemsChoices2[i] == ItemsChoiceType2.DerivedData)
{
derivedData = radInstrumentData.Items[i] as DerivedDataType;
// Check if correct Id
if (derivedData.id.StartsWith("ForegroundMeasureSum") == true)
{
continue;
}
derivedData = null;
}
}
if (analysisResults != null && derivedData != null)
{
break;
}
}
// Get StartDateTime
if (analysisResults == null || analysisResults.AnalysisStartDateTimeSpecified == false)
{
return(false);
}
deviceData.StartDateTime = analysisResults.AnalysisStartDateTime;
// Get Identified Nuclides
if (analysisResults.NuclideAnalysisResults == null)
{
return(true);
}
NuclideType[] nuclides = analysisResults.NuclideAnalysisResults.Nuclide;
if (nuclides == null)
{
return(true);
}
for (int i = 0; i < nuclides.Length; i += 1)
{
double confidence = -1;
ItemsChoiceType[] itemsChoices = nuclides[i].ItemsElementName;
for (int c = 0; c < itemsChoices.Length; c += 1)
{
if (itemsChoices[c] == ItemsChoiceType.NuclideIDConfidenceValue)
{
confidence = (double)nuclides[i].Items[c];
break;
}
}
deviceData.Nuclides[i] = new NuclideID(
nuclides[i].NuclideName, confidence);
}
// Get MeasureTime
if (derivedData == null)
{
return(false);
}
// Format is PTsss.fffS
string value = derivedData.RealTimeDuration.Remove(0, 2);
value = value.Remove(value.Length - 1, 1);
deviceData.MeasureTime = new TimeSpan(0, 0, (int)Math.Round(double.Parse(value)));
// Get Count Rate
SpectrumType spectrumType = derivedData.Spectrum.Where(s => s.id == "ForegroundSumGamma").FirstOrDefault();
if (spectrumType == null)
{
return(false);
}
// Sum spectrum and divide by MeasureTime
int sum = spectrumType.ChannelData.Text.Split(Globals.Delim_Space, StringSplitOptions.RemoveEmptyEntries).Sum(c => int.Parse(c));
deviceData.CountRate = sum / deviceData.MeasureTime.TotalSeconds;
}
catch (Exception ex)
{
fileErrors.Add(new KeyValuePair <string, string>(Path.GetFileName(deviceData.FileName), ex.Message));
ErrorsOccurred = true;
return(false);
}
return(true);
}
