void RFIGuiController::PlotPowerRMS()
{
if(IsImageLoaded())
{
Plot2D &plot = _plotManager->NewPlot2D("Spectrum RMS");
plot.SetLogarithmicYAxis(true);
TimeFrequencyData activeData = ActiveData();
Image2DCPtr image = activeData.GetSingleImage();
Mask2DPtr mask =
Mask2D::CreateSetMaskPtr<false>(image->Width(), image->Height());
Plot2DPointSet &beforeSet = plot.StartLine("Before");
RFIPlots::MakeRMSSpectrumPlot(beforeSet, image, mask);
mask = Mask2D::CreateCopy(activeData.GetSingleMask());
if(!mask->AllFalse())
{
Plot2DPointSet &afterSet = plot.StartLine("After");
RFIPlots::MakeRMSSpectrumPlot(afterSet, image, mask);
//mask->Invert();
//Plot2DPointSet &rfiSet = plot.StartLine("RFI");
//RFIPlots::MakeRMSSpectrumPlot(rfiSet, _timeFrequencyWidget.Image(), mask);
}
_plotManager->Update();
}
}
void ChangeResolutionAction::IncreaseFrequency(TimeFrequencyData &originalData, const TimeFrequencyData &changedData, bool restoreImage, bool restoreMask)
{
if(restoreImage)
{
size_t imageCount = originalData.ImageCount();
if(imageCount != changedData.ImageCount())
throw std::runtime_error("When restoring resolution in change resolution action, original data and changed data do not have the same number of images");
for(size_t i=0;i<imageCount;++i)
{
Image2DCPtr image = changedData.GetImage(i);
Image2DPtr newImage(new Image2D(image->EnlargeVertically(_frequencyDecreaseFactor, originalData.ImageHeight())));
originalData.SetImage(i, newImage);
}
}
if(restoreMask)
{
originalData.SetMask(changedData);
size_t maskCount = originalData.MaskCount();
for(size_t i=0;i<maskCount;++i)
{
Mask2DCPtr mask = changedData.GetMask(i);
Mask2DPtr newMask = Mask2D::CreateUnsetMaskPtr(originalData.ImageWidth(), originalData.ImageHeight());
newMask->EnlargeVerticallyAndSet(*mask, _frequencyDecreaseFactor);
originalData.SetMask(i, newMask);
}
}
}
void RFIGuiController::PlotPowerTime()
{
if(IsImageLoaded())
{
Plot2D &plot = _plotManager->NewPlot2D("Power over time");
plot.SetLogarithmicYAxis(true);
TimeFrequencyData activeData = ActiveData();
Image2DCPtr image = activeData.GetSingleImage();
Mask2DPtr mask =
Mask2D::CreateSetMaskPtr<false>(image->Width(), image->Height());
Plot2DPointSet &totalPlot = plot.StartLine("Total");
RFIPlots::MakePowerTimePlot(totalPlot, image, mask, MetaData());
mask = Mask2D::CreateCopy(activeData.GetSingleMask());
if(!mask->AllFalse())
{
Plot2DPointSet &uncontaminatedPlot = plot.StartLine("Uncontaminated");
RFIPlots::MakePowerTimePlot(uncontaminatedPlot, image, mask, MetaData());
mask->Invert();
Plot2DPointSet &rfiPlot = plot.StartLine("RFI");
RFIPlots::MakePowerTimePlot(rfiPlot, image, mask, MetaData());
}
_plotManager->Update();
}
}
void RFIGuiController::PlotPowerSNR()
{
Image2DCPtr
image = ActiveData().GetSingleImage(),
model = RevisedData().GetSingleImage();
if(IsImageLoaded())
{
Plot2D &plot = _plotManager->NewPlot2D("SNR spectrum");
plot.SetLogarithmicYAxis(true);
Mask2DPtr mask =
Mask2D::CreateSetMaskPtr<false>(image->Width(), image->Height());
Plot2DPointSet &totalPlot = plot.StartLine("Total");
RFIPlots::MakeSNRSpectrumPlot(totalPlot, image, model, mask);
mask = Mask2D::CreateCopy(ActiveData().GetSingleMask());
if(!mask->AllFalse())
{
Plot2DPointSet &uncontaminatedPlot = plot.StartLine("Uncontaminated");
RFIPlots::MakeSNRSpectrumPlot(uncontaminatedPlot, image, model, mask);
mask->Invert();
Plot2DPointSet &rfiPlot = plot.StartLine("RFI");
RFIPlots::MakeSNRSpectrumPlot(rfiPlot, image, model, mask);
}
_plotManager->Update();
}
}
void Compress::Write(std::ofstream &stream, Image2DCPtr image, Mask2DCPtr mask)
{
const num_t
max = ThresholdTools::MaxValue(image, mask),
min = ThresholdTools::MinValue(image, mask),
mid = (min + max) / 2.0;
const num_t normalizeFactor = (num_t) ((2<<22) + ((2<<22)-1)) / (max - min);
const uint32_t
width = image->Width(),
height = image->Height();
const char mode = 0;
stream.write(reinterpret_cast<const char*>(&max), sizeof(max));
stream.write(reinterpret_cast<const char*>(&min), sizeof(min));
stream.write(reinterpret_cast<const char*>(&width), sizeof(width));
stream.write(reinterpret_cast<const char*>(&height), sizeof(height));
stream.write(&mode, sizeof(mode));
for(unsigned y=0;y<height;++y)
{
for(unsigned x=0;x<width;++x)
{
if(!mask->Value(x, y))
{
int32_t value = (int32_t) round((image->Value(x, y) - mid) * normalizeFactor);
stream.write(reinterpret_cast<char*>(&value)+1, 3);
}
}
}
}
/**
* Automatic selection selects all timesteps which RMS is higher than some value relative to the stddev of
* all timesteps.
*/
void TimeSelectionAction::AutomaticSelection(ArtifactSet &artifacts)
{
Image2DCPtr image = artifacts.ContaminatedData().GetSingleImage();
SampleRowPtr timesteps = SampleRow::CreateEmpty(image->Width());
Mask2DPtr mask = Mask2D::CreateCopy(artifacts.ContaminatedData().GetSingleMask());
for(size_t x=0;x<image->Width();++x)
{
SampleRowPtr row = SampleRow::CreateFromColumnWithMissings(image, mask, x);
timesteps->SetValue(x, row->RMSWithMissings());
}
bool change;
MedianWindow<num_t>::SubtractMedian(timesteps, 512);
do {
num_t median = 0.0;
num_t stddev = timesteps->StdDevWithMissings(0.0);
change = false;
for(size_t x=0;x<timesteps->Size();++x)
{
if(!timesteps->ValueIsMissing(x) && (timesteps->Value(x) - median > stddev * _threshold || median - timesteps->Value(x) > stddev * _threshold))
{
mask->SetAllVertically<true>(x);
timesteps->SetValueMissing(x);
change = true;
}
}
} while(change);
artifacts.ContaminatedData().SetGlobalMask(mask);
}
num_t SpatialCompositionAction::sumAutoCorrelations(Image2DCPtr image) const
{
num_t sum = 0;
for(size_t y=0;y<image->Height();++y)
{
sum += image->Value(y, y);
}
return sum;
}
num_t SpatialCompositionAction::sumCrossCorrelations(Image2DCPtr image) const
{
num_t sum = 0;
for(size_t y=0;y<image->Height();++y)
{
for(size_t x=0;x<y;++x)
sum += image->Value(x, y);
}
return sum;
}
void HighPassFilter::elementWiseDivide(const Image2DPtr &leftHand, const Image2DCPtr &rightHand)
{
for(unsigned y=0;y<leftHand->Height();++y) {
for(unsigned x=0;x<leftHand->Width();++x) {
if(rightHand->Value(x, y) == 0.0)
leftHand->SetValue(x, y, 0.0);
else
leftHand->SetValue(x, y, leftHand->Value(x, y) / rightHand->Value(x, y));
}
}
}
Image2DPtr HighPassFilter::ApplyLowPass(const Image2DCPtr &image, const Mask2DCPtr &mask)
{
initializeKernel();
Image2DPtr
outputImage = Image2D::CreateUnsetImagePtr(image->Width(), image->Height()),
weights = Image2D::CreateUnsetImagePtr(image->Width(), image->Height());
setFlaggedValuesToZeroAndMakeWeightsSSE(image, outputImage, mask, weights);
applyLowPassSSE(outputImage);
applyLowPassSSE(weights);
elementWiseDivideSSE(outputImage, weights);
weights.reset();
return outputImage;
}
void ImagerAction::Perform(ArtifactSet &artifacts, ProgressListener &progress)
{
boost::mutex::scoped_lock lock(_imagerMutex);
UVImager *imager = artifacts.Imager();
if(imager == 0)
throw BadUsageException("No imager available to create image.");
TimeFrequencyData &data = artifacts.ContaminatedData();
TimeFrequencyMetaDataCPtr metaData = artifacts.MetaData();
if(data.PolarisationCount() > 1)
{
TimeFrequencyData *tmp = data.CreateTFData(StokesIPolarisation);
data = *tmp;
delete tmp;
}
bool btPlaneImager = true;
if(btPlaneImager)
{
typedef double ImagerNumeric;
BaselineTimePlaneImager<ImagerNumeric> btImager;
BandInfo band = metaData->Band();
Image2DCPtr
inputReal = data.GetRealPart(),
inputImag = data.GetImaginaryPart();
Mask2DCPtr mask = data.GetSingleMask();
size_t width = inputReal->Width();
for(size_t t=0;t!=width;++t)
{
UVW uvw = metaData->UVW()[t];
size_t channelCount = inputReal->Height();
std::vector<std::complex<ImagerNumeric> > data(channelCount);
for(size_t ch=0;ch!=channelCount;++ch) {
if(mask->Value(t, ch))
data[ch] = std::complex<ImagerNumeric>(0.0, 0.0);
else
data[ch] = std::complex<ImagerNumeric>(inputReal->Value(t, ch), inputImag->Value(t, ch));
}
btImager.Image(uvw.u, uvw.v, uvw.w, band.channels[0].frequencyHz, band.channels[1].frequencyHz-band.channels[0].frequencyHz, channelCount, &(data[0]), imager->FTReal());
}
} else {
progress.OnStartTask(*this, 0, 1, "Imaging baseline");
for(size_t y=0;y<data.ImageHeight();++y)
{
imager->Image(data, metaData, y);
progress.OnProgress(*this, y, data.ImageHeight());
}
progress.OnEndTask(*this);
}
}
std::pair<TimeFrequencyData,TimeFrequencyMetaDataPtr> RSPReader::ReadSingleBeamlet(unsigned long timestepStart, unsigned long timestepEnd, unsigned beamletCount, unsigned beamletIndex)
{
std::pair<TimeFrequencyData,TimeFrequencyMetaDataPtr> data = ReadAllBeamlets(timestepStart, timestepEnd, beamletCount);
const unsigned width = timestepEnd - timestepStart;
Image2DPtr realX = Image2D::CreateZeroImagePtr(width, 1);
Image2DPtr imaginaryX = Image2D::CreateZeroImagePtr(width, 1);
Image2DPtr realY = Image2D::CreateZeroImagePtr(width, 1);
Image2DPtr imaginaryY = Image2D::CreateZeroImagePtr(width, 1);
Mask2DPtr mask = Mask2D::CreateUnsetMaskPtr(width, 1);
TimeFrequencyData allX = data.first.Make(Polarization::XX);
TimeFrequencyData allY = data.first.Make(Polarization::YY);
Image2DCPtr xr = allX.GetRealPart();
Image2DCPtr xi = allX.GetImaginaryPart();
Image2DCPtr yr = allY.GetRealPart();
Image2DCPtr yi = allY.GetImaginaryPart();
Mask2DCPtr maskWithBeamlets = data.first.GetSingleMask();
for(unsigned x=0;x<width;++x)
{
realX->SetValue(x, 0, xr->Value(x, beamletIndex));
imaginaryX->SetValue(x, 0, xi->Value(x, beamletIndex));
realY->SetValue(x, 0, yr->Value(x, beamletIndex));
imaginaryY->SetValue(x, 0, yi->Value(x, beamletIndex));
mask->SetValue(x, 0, maskWithBeamlets->Value(x, beamletIndex));
}
data.first = TimeFrequencyData(Polarization::XX, realX, imaginaryX, Polarization::YY, realY, imaginaryY);
data.first.SetGlobalMask(mask);
BandInfo band = data.second->Band();
band.channels[0] = data.second->Band().channels[beamletIndex];
band.channels.resize(1);
data.second->SetBand(band);
return data;
}
void ThresholdMitigater::VerticalSumThresholdLarge(Image2DCPtr input, Mask2DPtr mask, num_t threshold)
{
Mask2DPtr maskCopy = Mask2D::CreateCopy(mask);
const size_t width = mask->Width(), height = mask->Height();
if(Length <= height)
{
for(size_t x=0;x<width;++x)
{
num_t sum = 0.0;
size_t count = 0, yTop, yBottom;
for(yBottom=0;yBottom<Length-1;++yBottom)
{
if(!mask->Value(x, yBottom))
{
sum += input->Value(x, yBottom);
++count;
}
}
yTop = 0;
while(yBottom < height)
{
// add the sample at the bottom
if(!mask->Value(x, yBottom))
{
sum += input->Value(x, yBottom);
++count;
}
// Check
if(count>0 && fabs(sum/count) > threshold)
{
for(size_t i=0;i<Length;++i)
maskCopy->SetValue(x, yTop + i, true);
}
// subtract the sample at the top
if(!mask->Value(x, yTop))
{
sum -= input->Value(x, yTop);
--count;
}
++yTop;
++yBottom;
}
}
}
mask->Swap(maskCopy);
}
void ThresholdMitigater::HorizontalSumThresholdLarge(Image2DCPtr input, Mask2DPtr mask, num_t threshold)
{
Mask2DPtr maskCopy = Mask2D::CreateCopy(mask);
const size_t width = mask->Width(), height = mask->Height();
if(Length <= width)
{
for(size_t y=0;y<height;++y)
{
num_t sum = 0.0;
size_t count = 0, xLeft, xRight;
for(xRight=0;xRight<Length-1;++xRight)
{
if(!mask->Value(xRight, y))
{
sum += input->Value(xRight, y);
count++;
}
}
xLeft = 0;
while(xRight < width)
{
// add the sample at the right
if(!mask->Value(xRight, y))
{
sum += input->Value(xRight, y);
++count;
}
// Check
if(count>0 && fabs(sum/count) > threshold)
{
maskCopy->SetHorizontalValues(xLeft, y, true, Length);
}
// subtract the sample at the left
if(!mask->Value(xLeft, y))
{
sum -= input->Value(xLeft, y);
--count;
}
++xLeft;
++xRight;
}
}
}
mask->Swap(maskCopy);
}
void ChangeResolutionAction::DecreaseFrequency(TimeFrequencyData &timeFrequencyData)
{
size_t imageCount = timeFrequencyData.ImageCount();
for(size_t i=0;i<imageCount;++i)
{
Image2DCPtr image = timeFrequencyData.GetImage(i);
Image2DPtr newImage = image->ShrinkVertically(_frequencyDecreaseFactor);
timeFrequencyData.SetImage(i, newImage);
}
size_t maskCount = timeFrequencyData.MaskCount();
for(size_t i=0;i<maskCount;++i)
{
Mask2DCPtr mask = timeFrequencyData.GetMask(i);
Mask2DPtr newMask = mask->ShrinkVertically(_frequencyDecreaseFactor);
timeFrequencyData.SetMask(i, newMask);
}
}
void ImagePlaneWindow::onMemorySubtractClicked()
{
if(_memory != 0)
{
Image2DPtr subtracted(Image2D::MakePtr(*_memory));
Image2DCPtr old = _heatMapPlot.Image();
for(size_t y=0;y<subtracted->Height();++y)
{
for(size_t x=0;x<subtracted->Width();++x)
{
subtracted->SetValue(x, y, subtracted->Value(x, y) - old->Value(x, y));
}
}
_heatMapPlot.SetImage(std::move(subtracted));
_imageWidget.Update();
printStats();
}
}
void ImagePlaneWindow::onMemoryMultiplyClicked()
{
if(_memory != 0)
{
Image2DPtr multiplied(Image2D::MakePtr(*_memory));
Image2DCPtr old = _heatMapPlot.Image();
for(size_t y=0;y<multiplied->Height();++y)
{
for(size_t x=0;x<multiplied->Width();++x)
{
multiplied->SetValue(x, y, multiplied->Value(x, y) * old->Value(x, y));
}
}
_heatMapPlot.SetImage(std::move(multiplied));
_imageWidget.Update();
printStats();
}
}
void HighPassFilter::setFlaggedValuesToZeroAndMakeWeights(const Image2DCPtr &inputImage, const Image2DPtr &outputImage, const Mask2DCPtr &inputMask, const Image2DPtr &weightsOutput)
{
const size_t width = inputImage->Width();
for(size_t y=0;y<inputImage->Height();++y)
{
for(size_t x=0;x<width;++x)
{
if(inputMask->Value(x, y) || !isfinite(inputImage->Value(x, y)))
{
outputImage->SetValue(x, y, 0.0);
weightsOutput->SetValue(x, y, 0.0);
} else {
outputImage->SetValue(x, y, inputImage->Value(x, y));
weightsOutput->SetValue(x, y, 1.0);
}
}
}
}
void ThresholdMitigater::VerticalVarThreshold(Image2DCPtr input, Mask2DPtr mask, size_t length, num_t threshold)
{
size_t height = input->Height()-length+1;
for(size_t y=0;y<height;++y) {
for(size_t x=0;x<input->Width();++x) {
bool flag = true;
for(size_t i=0;i<length;++i) {
if(input->Value(x, y+i) <= threshold && input->Value(x, y+i) >= -threshold) {
flag = false;
break;
}
}
if(flag) {
for(size_t i=0;i<length;++i)
mask->SetValue(x, y + i, true);
}
}
}
}
void ThresholdMitigater::HorizontalVarThreshold(Image2DCPtr input, Mask2DPtr mask, size_t length, num_t threshold)
{
size_t width = input->Width()-length+1;
for(size_t y=0;y<input->Height();++y) {
for(size_t x=0;x<width;++x) {
bool flag = true;
for(size_t i=0;i<length;++i) {
if(input->Value(x+i, y) < threshold && input->Value(x+i, y) > -threshold) {
flag = false;
break;
}
}
if(flag) {
for(size_t i=0;i<length;++i)
mask->SetValue(x + i, y, true);
}
}
}
}
void HighPassFilter::setFlaggedValuesToZeroAndMakeWeightsSSE(const Image2DCPtr &inputImage, const Image2DPtr &outputImage, const Mask2DCPtr &inputMask, const Image2DPtr &weightsOutput)
{
const size_t width = inputImage->Width();
const __m128i zero4i = _mm_set_epi32(0, 0, 0, 0);
const __m128 zero4 = _mm_set_ps(0.0, 0.0, 0.0, 0.0);
const __m128 one4 = _mm_set_ps(1.0, 1.0, 1.0, 1.0);
for(size_t y=0;y<inputImage->Height();++y)
{
const bool *rowPtr = inputMask->ValuePtr(0, y);
const float *inputPtr = inputImage->ValuePtr(0, y);
float *outputPtr = outputImage->ValuePtr(0, y);
float *weightsPtr = weightsOutput->ValuePtr(0, y);
const float *end = inputPtr + width;
while(inputPtr < end)
{
// Assign each integer to one bool in the mask
// Convert false to 0xFFFFFFFF and true to 0
__m128 conditionMask = _mm_castsi128_ps(
_mm_cmpeq_epi32(_mm_set_epi32(rowPtr[3] || !isfinite(inputPtr[3]), rowPtr[2] || !isfinite(inputPtr[2]),
rowPtr[1] || !isfinite(inputPtr[1]), rowPtr[0] || !isfinite(inputPtr[0])),
zero4i));
_mm_store_ps(weightsPtr, _mm_or_ps(
_mm_and_ps(conditionMask, one4),
_mm_andnot_ps(conditionMask, zero4)
));
_mm_store_ps(outputPtr, _mm_or_ps(
_mm_and_ps(conditionMask, _mm_load_ps(inputPtr)),
_mm_andnot_ps(conditionMask, zero4)
));
rowPtr += 4;
outputPtr += 4;
inputPtr += 4;
weightsPtr += 4;
}
}
}
void ChangeResolutionAction::DecreaseTimeWithMask(TimeFrequencyData& data)
{
size_t polCount = data.PolarizationCount();
for(size_t i=0;i<polCount;++i)
{
TimeFrequencyData polData(data.MakeFromPolarizationIndex(i));
const Mask2DCPtr mask = polData.GetSingleMask();
for(unsigned j=0;j<polData.ImageCount();++j)
{
const Image2DCPtr image = polData.GetImage(j);
polData.SetImage(j, ThresholdTools::ShrinkHorizontally(_timeDecreaseFactor, image.get(), mask.get()));
}
data.SetPolarizationData(i, std::move(polData));
}
size_t maskCount = data.MaskCount();
for(size_t i=0;i<maskCount;++i)
{
Mask2DCPtr mask = data.GetMask(i);
Mask2DPtr newMask(new Mask2D(mask->ShrinkHorizontallyForAveraging(_timeDecreaseFactor)));
data.SetMask(i, std::move(newMask));
}
}
void ImagePlaneWindow::onSaveFitsButton()
{
Gtk::FileChooserDialog dialog("Select a measurement set");
dialog.set_transient_for(*this);
//Add response buttons the the dialog:
dialog.add_button("_Cancel", Gtk::RESPONSE_CANCEL);
dialog.add_button("_Save", Gtk::RESPONSE_OK);
Glib::RefPtr<Gtk::FileFilter> fitsFilter = Gtk::FileFilter::create();
fitsFilter->set_name("Flexible Image Transport System (*.fits)");
fitsFilter->add_pattern("*.fits");
fitsFilter->add_mime_type("image/fits");
dialog.add_filter(fitsFilter);
if(dialog.run() == Gtk::RESPONSE_OK)
{
const std::string filename = dialog.get_filename();
Image2DCPtr image = _heatMapPlot.Image();
image->SaveToFitsFile(filename);
}
}
void UVImager::Image(const TimeFrequencyData &data, TimeFrequencyMetaDataCPtr metaData, unsigned frequencyIndex)
{
if(_uvReal == 0)
Empty();
Image2DCPtr
real = data.GetRealPart(),
imaginary = data.GetImaginaryPart();
Mask2DCPtr
flags = data.GetSingleMask();
for(unsigned i=0;i<data.ImageWidth();++i) {
switch(_imageKind) {
case Homogeneous:
if(flags->Value(i, frequencyIndex)==0.0L) {
num_t
vr = real->Value(i, frequencyIndex),
vi = imaginary->Value(i, frequencyIndex);
if(std::isfinite(vr) && std::isfinite(vi))
{
num_t u,v;
GetUVPosition(u, v, i, frequencyIndex, metaData);
SetUVValue(u, v, vr, vi, 1.0);
SetUVValue(-u, -v, vr, -vi, 1.0);
}
}
break;
case Flagging:
if((flags->Value(i, frequencyIndex)!=0.0L && !_invertFlagging) ||
(flags->Value(i, frequencyIndex)==0.0L && _invertFlagging)) {
num_t u,v;
GetUVPosition(u, v, i, frequencyIndex, metaData);
SetUVValue(u, v, 1, 0, 1.0);
SetUVValue(-u, -v, 1, 0, 1.0);
}
break;
}
}
}
void Compress::WriteSubtractFrequencies(std::ofstream &stream, Image2DCPtr image, Mask2DCPtr mask)
{
const num_t
max = ThresholdTools::MaxValue(image, mask),
min = ThresholdTools::MinValue(image, mask);
const num_t normalizeFactor = (num_t) ((2<<22) + ((2<<22)-1)) / (max - min);
//const num_t normalizeFactor = 256.0;
const uint32_t
width = image->Width(),
height = image->Height();
const char mode = 1;
stream.write(reinterpret_cast<const char*>(&max), sizeof(max));
stream.write(reinterpret_cast<const char*>(&min), sizeof(min));
stream.write(reinterpret_cast<const char*>(&width), sizeof(width));
stream.write(reinterpret_cast<const char*>(&height), sizeof(height));
stream.write(&mode, sizeof(mode));
std::vector<int32_t> basis(width);
for(size_t x=0;x<width;++x)
{
SampleRowPtr row = SampleRow::CreateFromColumn(image, x);
basis[x] = (int32_t) round(row->Median() * normalizeFactor);
}
stream.write(reinterpret_cast<char*>(&basis[0]), sizeof(basis));
for(unsigned y=0;y<height;++y)
{
for(unsigned x=0;x<width;++x)
{
if(!mask->Value(x, y))
{
int32_t value = (int32_t) (round(image->Value(x, y) * normalizeFactor) - basis[x]);
stream.write(reinterpret_cast<char*>(&value)+1, 3);
}
}
}
}
void ChangeResolutionAction::DecreaseTime(TimeFrequencyData &timeFrequencyData)
{
if(_useMaskInAveraging)
{
DecreaseTimeWithMask(timeFrequencyData);
}
else {
size_t imageCount = timeFrequencyData.ImageCount();
for(size_t i=0;i<imageCount;++i)
{
Image2DCPtr image = timeFrequencyData.GetImage(i);
Image2DPtr newImage(new Image2D(image->ShrinkHorizontally(_timeDecreaseFactor)));
timeFrequencyData.SetImage(i, std::move(newImage));
}
size_t maskCount = timeFrequencyData.MaskCount();
for(size_t i=0;i<maskCount;++i)
{
Mask2DCPtr mask = timeFrequencyData.GetMask(i);
Mask2DPtr newMask(new Mask2D(mask->ShrinkHorizontally(_timeDecreaseFactor)));
timeFrequencyData.SetMask(i, std::move(newMask));
}
}
}
void ThresholdMitigater::VerticalSumThreshold(Image2DCPtr input, Mask2DPtr mask, num_t threshold)
{
if(Length <= input->Height())
{
size_t height = input->Height()-Length+1;
for(size_t y=0;y<height;++y) {
for(size_t x=0;x<input->Width();++x) {
num_t sum = 0.0;
size_t count = 0;
for(size_t i=0;i<Length;++i) {
if(!mask->Value(x, y+i)) {
sum += input->Value(x, y + i);
count++;
}
}
if(count>0 && fabs(sum/count) > threshold) {
for(size_t i=0;i<Length;++i)
mask->SetValue(x, y + i, true);
}
}
}
}
}
void FrequencyPowerPlot::Add(class TimeFrequencyData &data, TimeFrequencyMetaDataCPtr meta)
{
Image2DCPtr image = data.GetSingleImage();
Mask2DCPtr mask = data.GetSingleMask();
for(size_t y=0;y<image->Height();++y)
{
double frequency = meta->Band().channels[y].frequencyHz;
size_t count = 0;
long double value = 0.0L;
for(size_t x=0;x<image->Width();++x)
{
if(!mask->Value(x, y))
{
++count;
value += image->Value(x, y);
}
}
MapItem &item = _values[frequency];
item.total += value;
item.count += count;
}
}
void ImagePlaneWindow::onPlotVertically()
{
if(_heatMapPlot.HasImage())
{
Plot plot("Image-vertical-axis.pdf");
plot.SetXAxisText("Declination index");
plot.SetYAxisText("Amplitude");
//plot.SetLogScale(false, true);
plot.StartLine();
Image2DCPtr image = _heatMapPlot.Image();
for(size_t y=0;y<image->Height();++y)
{
num_t sum = 0.0;
for(size_t x=0;x<image->Width();++x)
{
sum += image->Value(x, y);
}
plot.PushDataPoint(y, sum);
}
plot.Close();
plot.Show();
}
}
void UVImager::Image(const class TimeFrequencyData &data, class SpatialMatrixMetaData *metaData)
{
if(_uvReal == 0)
Empty();
Image2DCPtr
real = data.GetRealPart(),
imaginary = data.GetImaginaryPart();
Mask2DCPtr
flags = data.GetSingleMask();
for(unsigned a2=0;a2<data.ImageHeight();++a2) {
for(unsigned a1=a2+1;a1<data.ImageWidth();++a1) {
num_t
vr = real->Value(a1, a2),
vi = imaginary->Value(a1, a2);
if(std::isfinite(vr) && std::isfinite(vi))
{
UVW uvw = metaData->UVW(a1, a2);
SetUVValue(uvw.u, uvw.v, vr, vi, 1.0);
SetUVValue(-uvw.u, -uvw.v, vr, -vi, 1.0);
}
}
}
}
