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 SlidingWindowFitAction::Perform(ArtifactSet &artifacts, class ProgressListener &listener)
{
LocalFitMethod method;
switch(_parameters.method)
{
case SlidingWindowFitParameters::None:
method.SetToNone();
break;
case SlidingWindowFitParameters::Average:
method.SetToAverage(
_parameters.timeDirectionWindowSize,
_parameters.frequencyDirectionWindowSize);
break;
case SlidingWindowFitParameters::GaussianWeightedAverage:
method.SetToWeightedAverage(
_parameters.timeDirectionWindowSize,
_parameters.frequencyDirectionWindowSize,
_parameters.timeDirectionKernelSize,
_parameters.frequencyDirectionKernelSize);
break;
case SlidingWindowFitParameters::Median:
method.SetToMedianFilter(
_parameters.timeDirectionWindowSize,
_parameters.frequencyDirectionWindowSize);
break;
case SlidingWindowFitParameters::Minimum:
method.SetToMinimumFilter(
_parameters.timeDirectionWindowSize,
_parameters.frequencyDirectionWindowSize);
break;
}
method.Initialize(artifacts.ContaminatedData());
size_t taskCount = method.TaskCount();
for(size_t i=0;i<taskCount;++i)
{
method.PerformFit(i);
listener.OnProgress(*this, i+1, taskCount);
}
TimeFrequencyData newRevisedData = method.Background();
newRevisedData.SetMask(artifacts.RevisedData());
TimeFrequencyData *contaminatedData =
TimeFrequencyData::CreateTFDataFromDiff(artifacts.ContaminatedData(), newRevisedData);
contaminatedData->SetMask(artifacts.ContaminatedData());
artifacts.SetRevisedData(newRevisedData);
artifacts.SetContaminatedData(*contaminatedData);
delete contaminatedData;
}
void ChangeResolutionAction::Perform(class ArtifactSet &artifacts, class ProgressListener &listener)
{
TimeFrequencyData oldContaminated = artifacts.ContaminatedData();
if(_timeDecreaseFactor != 1)
{
ArtifactSet artifactsCopy(artifacts);
artifactsCopy.SetNoImageSet();
DecreaseTime(artifactsCopy.OriginalData());
DecreaseTime(artifactsCopy.ContaminatedData());
DecreaseTime(artifactsCopy.RevisedData());
PerformFrequencyChange(artifactsCopy, listener);
IncreaseTime(artifacts.OriginalData(), artifactsCopy.OriginalData(), false, false);
IncreaseTime(artifacts.ContaminatedData(), artifactsCopy.ContaminatedData(), _restoreContaminated, _restoreMasks);
IncreaseTime(artifacts.RevisedData(), artifactsCopy.RevisedData(), _restoreRevised, _restoreMasks);
} else {
PerformFrequencyChange(artifacts, listener);
}
if(_restoreRevised && !_restoreContaminated)
{
oldContaminated.Subtract(artifacts.RevisedData());
if(_restoreMasks)
oldContaminated.SetMask(artifacts.ContaminatedData());
artifacts.SetContaminatedData(oldContaminated);
}
}
void ChangeResolutionAction::PerformFrequencyChange(class ArtifactSet &artifacts, class ProgressListener &listener)
{
if(_frequencyDecreaseFactor != 1)
{
ArtifactSet artifactsCopy(artifacts);
artifactsCopy.SetNoImageSet();
TimeFrequencyData oldContaminated = artifacts.ContaminatedData();
DecreaseFrequency(artifactsCopy.OriginalData());
DecreaseFrequency(artifactsCopy.ContaminatedData());
DecreaseFrequency(artifactsCopy.RevisedData());
ActionBlock::Perform(artifactsCopy, listener);
IncreaseFrequency(artifacts.OriginalData(), artifactsCopy.OriginalData(), false, false);
IncreaseFrequency(artifacts.ContaminatedData(), artifactsCopy.ContaminatedData(), _restoreContaminated, _restoreMasks);
IncreaseFrequency(artifacts.RevisedData(), artifactsCopy.RevisedData(), _restoreRevised, _restoreMasks);
if(_restoreRevised)
{
TimeFrequencyData *contaminatedData =
TimeFrequencyData::CreateTFDataFromDiff(oldContaminated, artifacts.RevisedData());
contaminatedData->SetMask(oldContaminated);
artifacts.SetContaminatedData(*contaminatedData);
delete contaminatedData;
}
} else {
ActionBlock::Perform(artifacts, listener);
}
}
void SVDAction::Perform(ArtifactSet &artifacts, class ProgressListener &listener)
{
SVDMitigater mitigater;
mitigater.Initialize(artifacts.ContaminatedData());
mitigater.SetRemoveCount(_singularValueCount);
for(size_t i=0;i<mitigater.TaskCount();++i)
{
mitigater.PerformFit(i);
listener.OnProgress(*this, i+1, mitigater.TaskCount());
}
TimeFrequencyData newRevisedData = mitigater.Background();
newRevisedData.SetMask(artifacts.RevisedData());
TimeFrequencyData *contaminatedData =
TimeFrequencyData::CreateTFDataFromDiff(artifacts.ContaminatedData(), newRevisedData);
contaminatedData->SetMask(artifacts.ContaminatedData());
artifacts.SetRevisedData(newRevisedData);
artifacts.SetContaminatedData(*contaminatedData);
delete contaminatedData;
}
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 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 ChangeResolutionAction::DecreaseTimeWithMask(TimeFrequencyData &data)
{
size_t polCount = data.PolarisationCount();
for(size_t i=0;i<polCount;++i)
{
TimeFrequencyData *polData = data.CreateTFDataFromPolarisationIndex(i);
Mask2DCPtr mask = polData->GetSingleMask();
for(unsigned j=0;j<polData->ImageCount();++j)
{
Image2DCPtr image = polData->GetImage(j);
polData->SetImage(j, ThresholdTools::ShrinkHorizontally(_timeDecreaseFactor, image, mask));
}
delete polData;
}
size_t maskCount = data.MaskCount();
for(size_t i=0;i<maskCount;++i)
{
Mask2DCPtr mask = data.GetMask(i);
Mask2DPtr newMask = mask->ShrinkHorizontallyForAveraging(_timeDecreaseFactor);
data.SetMask(i, newMask);
}
}
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 SpatialCompositionAction::Perform(ArtifactSet &artifacts, ProgressListener &progress)
{
size_t imageCount = artifacts.ContaminatedData().ImageCount();
std::vector<Image2DPtr> images(imageCount);
for(size_t p=0;p<imageCount;++p)
images[p] = Image2D::CreateZeroImagePtr(artifacts.ContaminatedData().ImageWidth(), artifacts.ContaminatedData().ImageHeight());
std::string filename = artifacts.ImageSet()->File();
SpatialMSImageSet set(filename);
ImageSetIndex *index = set.StartIndex();
size_t progressStep = 0, totalProgress = artifacts.ContaminatedData().ImageWidth() * artifacts.ContaminatedData().ImageHeight()/256;
while(index->IsValid())
{
TimeFrequencyData *data = set.LoadData(*index);
SpatialMatrixMetaData metaData(set.SpatialMetaData(*index));
for(size_t p=0;p!=imageCount;++p)
{
switch(_operation)
{
case SumCrossCorrelationsOperation:
images[p]->SetValue(metaData.TimeIndex(), metaData.ChannelIndex(), sumCrossCorrelations(data->GetImage(p)));
break;
case SumAutoCorrelationsOperation:
images[p]->SetValue(metaData.TimeIndex(), metaData.ChannelIndex(), sumAutoCorrelations(data->GetImage(p)));
break;
case EigenvalueDecompositionOperation: {
num_t value = eigenvalue(data->GetImage(p), data->GetImage(p+1));
images[p]->SetValue(metaData.TimeIndex(), metaData.ChannelIndex(), value);
images[p+1]->SetValue(metaData.TimeIndex(), metaData.ChannelIndex(), 0.0);
++p;
} break;
case EigenvalueRemovalOperation: {
std::pair<num_t, num_t> value = removeEigenvalue(data->GetImage(p), data->GetImage(p+1));
images[p]->SetValue(metaData.TimeIndex(), metaData.ChannelIndex(), value.first);
images[p+1]->SetValue(metaData.TimeIndex(), metaData.ChannelIndex(), value.second);
++p;
} break;
}
}
delete data;
index->Next();
++progressStep;
progress.OnProgress(*this, progressStep/256, totalProgress);
}
delete index;
TimeFrequencyData newRevisedData = artifacts.RevisedData();
for(size_t p=0;p<imageCount;++p)
newRevisedData.SetImage(p, images[p]);
newRevisedData.SetMask(artifacts.RevisedData());
TimeFrequencyData *contaminatedData =
TimeFrequencyData::CreateTFDataFromDiff(artifacts.ContaminatedData(), newRevisedData);
contaminatedData->SetMask(artifacts.ContaminatedData());
artifacts.SetRevisedData(newRevisedData);
artifacts.SetContaminatedData(*contaminatedData);
delete contaminatedData;
}