/**
* 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);
}
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 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);
}
}
}
}
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 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 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);
}
}
void ThresholdMitigater::HorizontalSumThreshold(Image2DCPtr input, Mask2DPtr mask, num_t threshold)
{
if(Length <= input->Width())
{
size_t width = input->Width()-Length+1;
for(size_t y=0;y<input->Height();++y) {
for(size_t x=0;x<width;++x) {
num_t sum = 0.0;
size_t count = 0;
for(size_t i=0;i<Length;++i) {
if(!mask->Value(x+i, y)) {
sum += input->Value(x+i, y);
count++;
}
}
if(count>0 && fabs(sum/count) > threshold) {
for(size_t i=0;i<Length;++i)
mask->SetValue(x + i, y, true);
}
}
}
}
}
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 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 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 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 RFIGuiController::PlotDist()
{
if(IsImageLoaded())
{
Plot2D &plot = _plotManager->NewPlot2D("Distribution");
TimeFrequencyData activeData = ActiveData();
Image2DCPtr image = activeData.GetSingleImage();
Mask2DPtr mask =
Mask2D::CreateSetMaskPtr<false>(image->Width(), image->Height());
Plot2DPointSet &totalSet = plot.StartLine("Total");
RFIPlots::MakeDistPlot(totalSet, image, mask);
Plot2DPointSet &uncontaminatedSet = plot.StartLine("Uncontaminated");
mask = Mask2D::CreateCopy(activeData.GetSingleMask());
RFIPlots::MakeDistPlot(uncontaminatedSet, image, mask);
mask->Invert();
Plot2DPointSet &rfiSet = plot.StartLine("RFI");
RFIPlots::MakeDistPlot(rfiSet, image, mask);
_plotManager->Update();
}
}
void RFIGuiController::PlotPowerSpectrum()
{
if(IsImageLoaded())
{
Plot2D &plot = _plotManager->NewPlot2D("Power spectrum");
plot.SetLogarithmicYAxis(true);
TimeFrequencyData data = ActiveData();
Image2DCPtr image = data.GetSingleImage();
Mask2DPtr mask =
Mask2D::CreateSetMaskPtr<false>(image->Width(), image->Height());
Plot2DPointSet &beforeSet = plot.StartLine("Before");
RFIPlots::MakePowerSpectrumPlot(beforeSet, image, mask, MetaData());
mask = Mask2D::CreateCopy(data.GetSingleMask());
if(!mask->AllFalse())
{
Plot2DPointSet &afterSet = plot.StartLine("After");
RFIPlots::MakePowerSpectrumPlot(afterSet, image, mask, MetaData());
}
_plotManager->Update();
}
}
void ImageWidget::update(Cairo::RefPtr<Cairo::Context> cairo, unsigned width, unsigned height)
{
Image2DCPtr image = _image;
Mask2DCPtr mask = GetActiveMask(), originalMask = _originalMask, alternativeMask = _alternativeMask;
unsigned int
startX = (unsigned int) round(_startHorizontal * image->Width()),
startY = (unsigned int) round(_startVertical * image->Height()),
endX = (unsigned int) round(_endHorizontal * image->Width()),
endY = (unsigned int) round(_endVertical * image->Height());
size_t
imageWidth = endX - startX,
imageHeight = endY - startY;
if(imageWidth > 30000)
{
int shrinkFactor = (imageWidth + 29999) / 30000;
image = image->ShrinkHorizontally(shrinkFactor);
mask = mask->ShrinkHorizontally(shrinkFactor);
if(originalMask != 0)
originalMask = originalMask->ShrinkHorizontally(shrinkFactor);
if(alternativeMask != 0)
alternativeMask = alternativeMask->ShrinkHorizontally(shrinkFactor);
startX /= shrinkFactor;
endX /= shrinkFactor;
imageWidth = endX - startX;
}
num_t min, max;
findMinMax(image, mask, min, max);
// If these are not yet created, they are 0, so ok to delete.
delete _horiScale;
delete _vertScale;
delete _colorScale;
delete _plotTitle;
if(_showXYAxes)
{
_vertScale = new VerticalPlotScale();
_vertScale->SetDrawWithDescription(_showYAxisDescription);
_horiScale = new HorizontalPlotScale();
_horiScale->SetDrawWithDescription(_showXAxisDescription);
} else {
_vertScale = 0;
_horiScale = 0;
}
if(_showColorScale)
{
_colorScale = new ColorScale();
_colorScale->SetDrawWithDescription(_showZAxisDescription);
} else {
_colorScale = 0;
}
if(_showXYAxes)
{
if(_metaData != 0 && _metaData->HasBand()) {
_vertScale->InitializeNumericTicks(_metaData->Band().channels[startY].frequencyHz / 1e6, _metaData->Band().channels[endY-1].frequencyHz / 1e6);
_vertScale->SetUnitsCaption("Frequency (MHz)");
} else {
_vertScale->InitializeNumericTicks(-0.5 + startY, 0.5 + endY - 1.0);
}
if(_metaData != 0 && _metaData->HasObservationTimes())
{
_horiScale->InitializeTimeTicks(_metaData->ObservationTimes()[startX], _metaData->ObservationTimes()[endX-1]);
_horiScale->SetUnitsCaption("Time");
} else {
_horiScale->InitializeNumericTicks(-0.5 + startX, 0.5 + endX - 1.0);
}
if(_manualXAxisDescription)
_horiScale->SetUnitsCaption(_xAxisDescription);
if(_manualYAxisDescription)
_vertScale->SetUnitsCaption(_yAxisDescription);
}
if(_metaData != 0) {
if(_showColorScale && _metaData->ValueDescription()!="")
{
if(_metaData->ValueUnits()!="")
_colorScale->SetUnitsCaption(_metaData->ValueDescription() + " (" + _metaData->ValueUnits() + ")");
else
_colorScale->SetUnitsCaption(_metaData->ValueDescription());
}
}
if(_showColorScale)
{
if(_scaleOption == LogScale)
_colorScale->InitializeLogarithmicTicks(min, max);
else
_colorScale->InitializeNumericTicks(min, max);
if(_manualZAxisDescription)
_colorScale->SetUnitsCaption(_zAxisDescription);
}
if(_showTitle && !actualTitleText().empty())
{
_plotTitle = new Title();
_plotTitle->SetText(actualTitleText());
_plotTitle->SetPlotDimensions(width, height, 0.0);
_topBorderSize = _plotTitle->GetHeight(cairo);
} else {
_plotTitle = 0;
_topBorderSize = 10.0;
}
// The scale dimensions are depending on each other. However, since the height of the horizontal scale is practically
// not dependent on other dimensions, we give the horizontal scale temporary width/height, so that we can calculate its height:
if(_showXYAxes)
{
_horiScale->SetPlotDimensions(width, height, 0.0, 0.0);
_bottomBorderSize = _horiScale->GetHeight(cairo);
_rightBorderSize = _horiScale->GetRightMargin(cairo);
_vertScale->SetPlotDimensions(width - _rightBorderSize + 5.0, height - _topBorderSize - _bottomBorderSize, _topBorderSize);
_leftBorderSize = _vertScale->GetWidth(cairo);
} else {
_bottomBorderSize = 0.0;
_rightBorderSize = 0.0;
_leftBorderSize = 0.0;
}
if(_showColorScale)
{
_colorScale->SetPlotDimensions(width - _rightBorderSize, height - _topBorderSize, _topBorderSize);
_rightBorderSize += _colorScale->GetWidth(cairo) + 5.0;
}
if(_showXYAxes)
{
_horiScale->SetPlotDimensions(width - _rightBorderSize + 5.0, height -_topBorderSize - _bottomBorderSize, _topBorderSize, _vertScale->GetWidth(cairo));
}
class ColorMap *colorMap = createColorMap();
const double
minLog10 = min>0.0 ? log10(min) : 0.0,
maxLog10 = max>0.0 ? log10(max) : 0.0;
if(_showColorScale)
{
for(unsigned x=0;x<256;++x)
{
num_t colorVal = (2.0 / 256.0) * x - 1.0;
num_t imageVal;
if(_scaleOption == LogScale)
imageVal = exp10((x / 256.0) * (log10(max) - minLog10) + minLog10);
else
imageVal = (max-min) * x / 256.0 + min;
double
r = colorMap->ValueToColorR(colorVal),
g = colorMap->ValueToColorG(colorVal),
b = colorMap->ValueToColorB(colorVal);
_colorScale->SetColorValue(imageVal, r/255.0, g/255.0, b/255.0);
}
}
_imageSurface.clear();
_imageSurface =
Cairo::ImageSurface::create(Cairo::FORMAT_ARGB32, imageWidth, imageHeight);
_imageSurface->flush();
unsigned char *data = _imageSurface->get_data();
size_t rowStride = _imageSurface->get_stride();
Mask2DPtr highlightMask;
if(_highlighting)
{
highlightMask = Mask2D::CreateSetMaskPtr<false>(image->Width(), image->Height());
_highlightConfig->Execute(image, highlightMask, true, 10.0);
}
const bool
originalActive = _showOriginalMask && originalMask != 0,
altActive = _showAlternativeMask && alternativeMask != 0;
for(unsigned long y=startY;y<endY;++y) {
guint8* rowpointer = data + rowStride * (endY - y - 1);
for(unsigned long x=startX;x<endX;++x) {
int xa = (x-startX) * 4;
unsigned char r,g,b,a;
if(_highlighting && highlightMask->Value(x, y) != 0) {
r = 255; g = 0; b = 0; a = 255;
} else if(originalActive && originalMask->Value(x, y)) {
r = 255; g = 0; b = 255; a = 255;
} else if(altActive && alternativeMask->Value(x, y)) {
r = 255; g = 255; b = 0; a = 255;
} else {
num_t val = image->Value(x, y);
if(val > max) val = max;
else if(val < min) val = min;
if(_scaleOption == LogScale)
{
if(image->Value(x, y) <= 0.0)
val = -1.0;
else
val = (log10(image->Value(x, y)) - minLog10) * 2.0 / (maxLog10 - minLog10) - 1.0;
}
else
val = (image->Value(x, y) - min) * 2.0 / (max - min) - 1.0;
if(val < -1.0) val = -1.0;
else if(val > 1.0) val = 1.0;
r = colorMap->ValueToColorR(val);
g = colorMap->ValueToColorG(val);
b = colorMap->ValueToColorB(val);
a = colorMap->ValueToColorA(val);
}
rowpointer[xa]=b;
rowpointer[xa+1]=g;
rowpointer[xa+2]=r;
rowpointer[xa+3]=a;
}
}
delete colorMap;
if(_segmentedImage != 0)
{
for(unsigned long y=startY;y<endY;++y) {
guint8* rowpointer = data + rowStride * (y - startY);
for(unsigned long x=startX;x<endX;++x) {
if(_segmentedImage->Value(x,y) != 0)
{
int xa = (x-startX) * 4;
rowpointer[xa]=IntMap::R(_segmentedImage->Value(x,y));
rowpointer[xa+1]=IntMap::G(_segmentedImage->Value(x,y));
rowpointer[xa+2]=IntMap::B(_segmentedImage->Value(x,y));
rowpointer[xa+3]=IntMap::A(_segmentedImage->Value(x,y));
}
}
}
}
_imageSurface->mark_dirty();
while(_imageSurface->get_width() > (int) width || _imageSurface->get_height() > (int) height)
{
unsigned
newWidth = _imageSurface->get_width(),
newHeight = _imageSurface->get_height();
if(newWidth > width)
newWidth = width;
if(newHeight > height)
newHeight = height;
downsampleImageBuffer(newWidth, newHeight);
}
_isInitialized = true;
_initializedWidth = width;
_initializedHeight = height;
redrawWithoutChanges(cairo, width, height);
}
void RSPReader::ReadForStatistics(unsigned beamletCount)
{
long unsigned timesteps = TimeStepCount(beamletCount);
long unsigned stepSize = 1024;
std::vector<BeamletStatistics>
statistics(beamletCount),
timeStartStatistics(beamletCount);
std::vector<std::ofstream *> statFile(beamletCount);
for(unsigned i=0;i<beamletCount;++i)
{
std::ostringstream str;
str << "rsp-statistics" << i << ".txt";
statFile[i] = new std::ofstream(str.str().c_str());
}
double startTime = -1.0, periodStartTime = -1.0;
for(unsigned long timestepIndex=0;timestepIndex<timesteps;timestepIndex += stepSize)
{
//Read the data
unsigned long end = timestepIndex+stepSize;
if(end > timesteps) end = timesteps;
std::pair<TimeFrequencyData,TimeFrequencyMetaDataPtr> dataPair = ReadAllBeamlets(timestepIndex, end, beamletCount);
const TimeFrequencyData &data = dataPair.first;
if(startTime == -1.0) {
startTime = dataPair.second->ObservationTimes()[0];
periodStartTime = startTime;
}
//Count the statistics
for(unsigned imageIndex=0;imageIndex < data.ImageCount();++imageIndex)
{
Image2DCPtr image = data.GetImage(imageIndex);
for(unsigned y=0;y<image->Height();++y) {
for(unsigned x=0;x<image->Width();++x) {
int value = (int) image->Value(x, y);
if(value < 0) {
value = -value;
++(statistics[y].bitUseCount[15]);
}
unsigned highestBit = (value!=0) ? 1 : 0;
for(unsigned bit=0;bit<15;++bit) {
if((value & (2<<bit)) != 0) {
highestBit = bit+1;
}
}
for(unsigned bit=0;bit<highestBit;++bit)
++(statistics[y].bitUseCount[bit]);
++(statistics[y].totalCount);
}
}
}
if((timestepIndex/stepSize)%100000==0 || timestepIndex+stepSize>=timesteps)
{
for(unsigned i=0;i<beamletCount;++i)
{
Logger::Info << "Beamlet index " << i << ":\n";
statistics[i].Print();
}
}
if((dataPair.second->ObservationTimes()[0] - periodStartTime) > 60.0)
{
Logger::Debug << "Processed 1 minute of data (" << (dataPair.second->ObservationTimes()[0] - startTime) << "s)\n";
for(unsigned i=0;i<beamletCount;++i)
{
(*statFile[i])
<< (periodStartTime - startTime) << '\t'
<< (statistics[i].totalCount - timeStartStatistics[i].totalCount);
statistics[i].totalCount = timeStartStatistics[i].totalCount;
for(unsigned bit=0;bit<15;++bit)
{
(*statFile[i]) << '\t' << (statistics[i].bitUseCount[bit] - timeStartStatistics[i].bitUseCount[bit]);
timeStartStatistics[i].bitUseCount[bit] = statistics[i].bitUseCount[bit];
}
(*statFile[i]) << '\n';
}
periodStartTime = dataPair.second->ObservationTimes()[0];
}
}
for(unsigned i=0;i<beamletCount;++i)
{
Logger::Info << "Beamlet index " << i << ":\n";
statistics[i].Print();
delete statFile[i];
}
}
