public BasicKernel(IApplicableFilter decoratingKernel, int width, int height, float[,] weights)
{
this.decoratingKernel = decoratingKernel;
this.width = width;
this.height = height;
this.weights = weights;
}
public BasicKernel(IApplicableFilter decoratingKernel, int width, int height, float[,] weights)
{
this.decoratingKernel = decoratingKernel;
this.width = width;
this.height = height;
this.weights = weights;
}
public MainViewModel()
{
// Initial startup
HasProgress = Visibility.Hidden;
IsBusy = false;
// Setup Commands
LoadImageButton = new RelayCommand(a => LoadImage(), e => IsNotBusy());
SelectFiltersButton = new RelayCommand(a => SelectFilters(), e => IsNotBusy());
ApplyButton = new RelayCommand(a => ApplyImage(), e => IsNotBusy());
DetectObjectsButton = new RelayCommand(a => DetectObjects(), e => IsNotBusy());
SaveButton = new RelayCommand(a => SaveImage(), e => IsNotBusy());
// Setup for FilterSelectorWindow with ViewModel
fsWindow = new FilterSelectorWindow()
{
DataContext = new FilterSelectorViewModel()
};
decoratedFilter = null;
// Setup Dialogs
openImageDialog = new OpenFileDialog();
openImageDialog.Filter = "Bitmap files|*.bmp;*.gif;*.png;*.tiff;*.jpg;*.jpeg";
saveImageDialog = new SaveFileDialog();
saveImageDialog.Filter = "Bitmap file|*.bmp";
}
/// <summary>
/// Provides a filtered cursor. It only returns objects that matches a given filter.
/// </summary>
/// <param name="Cursor">Cursor to be filtered.</param>
/// <param name="Filter">Filter to apply.</param>
/// <param name="UntilFirstFail">Only return ites until first filter failure.</param>
/// <param name="Forward">If <paramref name="Cursor"/> is to be processed forwards (true) or backwards (false).</param>
/// <param name="TimeoutMilliseconds">Time to wait to get access to underlying database.</param>
/// <param name="Provider">Files provider.</param>
public FilteredCursor(ICursor <T> Cursor, IApplicableFilter Filter, bool UntilFirstFail, bool Forward, int TimeoutMilliseconds,
FilesProvider Provider)
{
this.cursor = Cursor;
this.filter = Filter;
this.untilFirstFail = UntilFirstFail;
this.forward = Forward;
this.timeoutMilliseconds = TimeoutMilliseconds;
this.provider = Provider;
}
public void SelectFilters()
{
IsBusy = true;
fsWindow.ShowDialog();
currentFilterList = ((FilterSelectorViewModel)fsWindow.DataContext).ActiveFilters.ToList();
if (hasAppliedThisImage && oldFilterList != null && oldFilterList.Count <= currentFilterList.Count)
{
int i = 0;
bool isTheSame = true;
for (; i < oldFilterList.Count; i++)
{
if (oldFilterList[i] != currentFilterList[i])
{
isTheSame = false;
hasAppliedThisImage = false;
break;
}
}
if (isTheSame)
{
List <FilterType> newFilterList = new List <FilterType>();
for (; i < currentFilterList.Count; i++)
{
newFilterList.Add(currentFilterList[i]);
}
currentFilterList = newFilterList;
}
}
else
{
hasAppliedThisImage = false;
}
decoratedFilter = FilterFactory.Construct(currentFilterList);
IsBusy = false;
// Handy debug info
Console.WriteLine("The following filters have been selected: ");
foreach (var item in currentFilterList)
{
Console.WriteLine("- {0}", item);
}
}
public MainViewModel()
{
// Initial startup
HasProgress = Visibility.Hidden;
IsBusy = false;
// Setup Commands
LoadImageButton = new RelayCommand(a => LoadImage(), e => IsNotBusy());
SelectFiltersButton = new RelayCommand(a => SelectFilters(), e => IsNotBusy());
ApplyButton = new RelayCommand(a => ApplyImage(), e => IsNotBusy());
DetectObjectsButton = new RelayCommand(a => DetectObjects(), e => IsNotBusy());
SaveButton = new RelayCommand(a => SaveImage(), e => IsNotBusy());
// Setup for FilterSelectorWindow with ViewModel
fsWindow = new FilterSelectorWindow() { DataContext = new FilterSelectorViewModel() };
decoratedFilter = null;
// Setup Dialogs
openImageDialog = new OpenFileDialog();
openImageDialog.Filter = "Bitmap files|*.bmp;*.gif;*.png;*.tiff;*.jpg;*.jpeg";
saveImageDialog = new SaveFileDialog();
saveImageDialog.Filter = "Bitmap file|*.bmp";
}
public FillObjectFilter(IApplicableFilter decorator)
: base(decorator)
{
}
// : base(decoratingKernel, 3, 3, ErosionOperation.constructWeights())
public ErosionKernel(IApplicableFilter decoratingFilter)
: base(decoratingFilter, 3, 3, ErosionKernel.constructWeights())
{
}
public InvertFilter(IApplicableFilter decorator)
: base(decorator)
{
// You need more overlords!
}
public void ApplyImage()
{
if (InputImage == null || decoratedFilter == null)
return; // Get out if no input image or filter has been selected
if (ProcessImage != null && !hasAppliedThisImage)
{
ProcessImage.Dispose(); // Reset output image
ProcessImage = new Bitmap(InputImage.Size.Width, InputImage.Size.Height);
}
else if (ProcessImage == null)
{
ProcessImage = new Bitmap(InputImage.Size.Width, InputImage.Size.Height);
}
IsBusy = true;
System.Drawing.Color[,] InputColors = new System.Drawing.Color[InputImage.Size.Width, InputImage.Size.Height];
System.Drawing.Color[,] OutputColors;
if (hasAppliedThisImage)
for (int x = 0; x < ProcessImage.Size.Width; x++)
for (int y = 0; y < ProcessImage.Size.Height; y++)
InputColors[x, y] = ProcessImage.GetPixel(x, y);
else
for (int x = 0; x < InputImage.Size.Width; x++)
for (int y = 0; y < InputImage.Size.Height; y++)
InputColors[x, y] = InputImage.GetPixel(x, y);
HasProgress = Visibility.Visible;
MaxProgress = decoratedFilter.GetMaximumProgress(InputImage.Size.Width, InputImage.Size.Height);
ThreadPool.QueueUserWorkItem(o =>
{
OutputColors = decoratedFilter.apply(InputColors, this);
Application.Current.Dispatcher.BeginInvoke(new Action(() =>
{
for (int x = 0; x < InputImage.Size.Width; x++)
for (int y = 0; y < InputImage.Size.Height; y++)
ProcessImage.SetPixel(x, y, OutputColors[x, y]);
NewImage = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap( // Display output image
ProcessImage.GetHbitmap(),
IntPtr.Zero,
System.Windows.Int32Rect.Empty,
BitmapSizeOptions.FromWidthAndHeight(ProcessImage.Size.Width, ProcessImage.Size.Height));
if (hasAppliedThisImage)
{
foreach (FilterType newAddition in currentFilterList)
oldFilterList.Add(newAddition);
}
else
{
oldFilterList = currentFilterList;
hasAppliedThisImage = true;
}
if (OutputImage != null)
OutputImage.Dispose();
OutputImage = null;
decoratedFilter = null; // Filter has been applied, a new one has to be made. Also fixes 'cached' filtering
HasProgress = Visibility.Hidden;
IsBusy = false;
// Debug for Progressbar
Console.WriteLine("Progress: {0}, MaxProgress: {1}", Progress, MaxProgress);
Console.WriteLine("Procent: {0}", (Progress / MaxProgress) * 100);
Progress = 0; // Reset progress
}));
});
}
// : base(decoratingKernel, 3, 3, ErosionOperation.constructWeights())
public ErosionKernel(IApplicableFilter decoratingFilter)
: base(decoratingFilter, 3, 3, ErosionKernel.constructWeights())
{
}
public IsotropicKernel(IApplicableFilter decoratingKernel, Direction compass)
: base(decoratingKernel, 3, 3, IsotropicKernel.constructWeights(3, 3, compass))
{
// Clinophobia is the fear of beds
}
public KirschKernel(IApplicableFilter decoratingKernel, Direction compass)
: base(decoratingKernel, 3, 3, KirschKernel.constructWeights(3, 3, compass))
{
// What's the heading capt'n?
}
public CompassOperation(IApplicableFilter decorator, CompassType type)
: base(decorator)
{
ConstructKernels(type);
// A mole can dig a tunnel 300 feet long in just one night
}
public CompassOperation(IApplicableFilter decorator, CompassType type)
: base(decorator)
{
ConstructKernels(type);
// A mole can dig a tunnel 300 feet long in just one night
}
public ClearBorderFilter(IApplicableFilter decorator) : base(decorator)
{
}
public IsotropicKernel(IApplicableFilter decoratingKernel, Direction compass)
: base(decoratingKernel, 3, 3, IsotropicKernel.constructWeights(3, 3, compass))
{
// Clinophobia is the fear of beds
}
public DilationKernel(IApplicableFilter decoratingFilter)
: base(decoratingFilter)
{
}
public DerivativeKernel(IApplicableFilter decoratingFilter, DerivativeType type)
: base(decoratingFilter, DerivativeKernel.getWidth(type), DerivativeKernel.getHeight(type), constructWeights(type))
{
this.type = type;
}
public DilationKernel(IApplicableFilter decoratingFilter)
: base(decoratingFilter)
{
}
public Hamiltonian(IApplicableFilter toDecorate)
: base(toDecorate)
{
}
public LowPassFilter(IApplicableFilter toDecorate, int thresholdValue)
: base(toDecorate)
{
this.thresholdValue = thresholdValue;
}
public void ApplyImage()
{
if (InputImage == null || decoratedFilter == null)
{
return; // Get out if no input image or filter has been selected
}
if (ProcessImage != null && !hasAppliedThisImage)
{
ProcessImage.Dispose(); // Reset output image
ProcessImage = new Bitmap(InputImage.Size.Width, InputImage.Size.Height);
}
else if (ProcessImage == null)
{
ProcessImage = new Bitmap(InputImage.Size.Width, InputImage.Size.Height);
}
IsBusy = true;
System.Drawing.Color[,] InputColors = new System.Drawing.Color[InputImage.Size.Width, InputImage.Size.Height];
System.Drawing.Color[,] OutputColors;
if (hasAppliedThisImage)
{
for (int x = 0; x < ProcessImage.Size.Width; x++)
{
for (int y = 0; y < ProcessImage.Size.Height; y++)
{
InputColors[x, y] = ProcessImage.GetPixel(x, y);
}
}
}
else
{
for (int x = 0; x < InputImage.Size.Width; x++)
{
for (int y = 0; y < InputImage.Size.Height; y++)
{
InputColors[x, y] = InputImage.GetPixel(x, y);
}
}
}
HasProgress = Visibility.Visible;
MaxProgress = decoratedFilter.GetMaximumProgress(InputImage.Size.Width, InputImage.Size.Height);
ThreadPool.QueueUserWorkItem(o =>
{
OutputColors = decoratedFilter.apply(InputColors, this);
Application.Current.Dispatcher.BeginInvoke(new Action(() =>
{
for (int x = 0; x < InputImage.Size.Width; x++)
{
for (int y = 0; y < InputImage.Size.Height; y++)
{
ProcessImage.SetPixel(x, y, OutputColors[x, y]);
}
}
NewImage = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap( // Display output image
ProcessImage.GetHbitmap(),
IntPtr.Zero,
System.Windows.Int32Rect.Empty,
BitmapSizeOptions.FromWidthAndHeight(ProcessImage.Size.Width, ProcessImage.Size.Height));
if (hasAppliedThisImage)
{
foreach (FilterType newAddition in currentFilterList)
{
oldFilterList.Add(newAddition);
}
}
else
{
oldFilterList = currentFilterList;
hasAppliedThisImage = true;
}
if (OutputImage != null)
{
OutputImage.Dispose();
}
OutputImage = null;
decoratedFilter = null; // Filter has been applied, a new one has to be made. Also fixes 'cached' filtering
HasProgress = Visibility.Hidden;
IsBusy = false;
// Debug for Progressbar
Console.WriteLine("Progress: {0}, MaxProgress: {1}", Progress, MaxProgress);
Console.WriteLine("Procent: {0}", (Progress / MaxProgress) * 100);
Progress = 0; // Reset progress
}));
});
}
public Hamiltonian(IApplicableFilter toDecorate)
: base(toDecorate)
{
}
public static IApplicableFilter Construct(List <FilterType> filters)
{
IApplicableFilter toBeDecoratedFilter = null;
foreach (FilterType filter in filters)
{
switch (filter.fType)
{
case FilterType.Type.ClearBorderFilter:
toBeDecoratedFilter = new ClearBorderFilter(toBeDecoratedFilter);
break;
case FilterType.Type.FillObjectFilter:
toBeDecoratedFilter = new FillObjectFilter(toBeDecoratedFilter);
break;
case FilterType.Type.ErosionKernel:
toBeDecoratedFilter = new ErosionKernel(toBeDecoratedFilter);
break;
case FilterType.Type.DilationKernel:
toBeDecoratedFilter = new DilationKernel(toBeDecoratedFilter);
break;
case FilterType.Type.GrayscaleFilter:
toBeDecoratedFilter = new GrayScaleFilter(toBeDecoratedFilter);
break;
case FilterType.Type.GrayscaleKernel:
toBeDecoratedFilter = new GrayScaleKernel(toBeDecoratedFilter);
break;
case FilterType.Type.InvertFilter:
toBeDecoratedFilter = new InvertFilter(toBeDecoratedFilter);
break;
case FilterType.Type.DoNothingKernel:
toBeDecoratedFilter = new DoNothingKernel(toBeDecoratedFilter, 3, 3);
break;
case FilterType.Type.DerivativeKernelX:
toBeDecoratedFilter = new DerivativeKernel(toBeDecoratedFilter, DerivativeType.x);
break;
case FilterType.Type.DerivativeKernelY:
toBeDecoratedFilter = new DerivativeKernel(toBeDecoratedFilter, DerivativeType.y);
break;
case FilterType.Type.DerivativeKernelXY:
toBeDecoratedFilter = new DerivativeKernel(toBeDecoratedFilter, DerivativeType.xy);
break;
case FilterType.Type.ApproximationCompassOperation:
toBeDecoratedFilter = new CompassOperation(toBeDecoratedFilter, CompassType.Approximation);
break;
case FilterType.Type.IsotropicCompassOperation:
toBeDecoratedFilter = new CompassOperation(toBeDecoratedFilter, CompassType.Isotropic);
break;
case FilterType.Type.KirschCompassOperation:
toBeDecoratedFilter = new CompassOperation(toBeDecoratedFilter, CompassType.Kirsch);
break;
case FilterType.Type.PrewittCompassOperation:
toBeDecoratedFilter = new CompassOperation(toBeDecoratedFilter, CompassType.Prewitt);
break;
case FilterType.Type.SobelCompassOperation:
toBeDecoratedFilter = new CompassOperation(toBeDecoratedFilter, CompassType.Sobel);
break;
//case FilterType.Type.PrewittKernelN:
// toBeDecoratedFilter = new PrewittKernel(toBeDecoratedFilter, Direction.North);
// break;
//case FilterType.Type.PrewittKernelNE:
// toBeDecoratedFilter = new PrewittKernel(toBeDecoratedFilter, Direction.NorthEast);
// break;
//case FilterType.Type.PrewittKernelE:
// toBeDecoratedFilter = new PrewittKernel(toBeDecoratedFilter, Direction.East);
// break;
//case FilterType.Type.PrewittKernelSE:
// toBeDecoratedFilter = new PrewittKernel(toBeDecoratedFilter, Direction.SouthEast);
// break;
//case FilterType.Type.PrewittKernelS:
// toBeDecoratedFilter = new PrewittKernel(toBeDecoratedFilter, Direction.South);
// break;
//case FilterType.Type.PrewittKernelSW:
// toBeDecoratedFilter = new PrewittKernel(toBeDecoratedFilter, Direction.SouthWest);
// break;
//case FilterType.Type.PrewittKernelW:
// toBeDecoratedFilter = new PrewittKernel(toBeDecoratedFilter, Direction.West);
// break;
//case FilterType.Type.PrewittKernelNW:
// toBeDecoratedFilter = new PrewittKernel(toBeDecoratedFilter, Direction.NorthWest);
// break;
//case FilterType.Type.ApproximationKernelN:
// toBeDecoratedFilter = new ApproximationKernel(toBeDecoratedFilter, Direction.North);
// break;
//case FilterType.Type.ApproximationKernelNE:
// toBeDecoratedFilter = new ApproximationKernel(toBeDecoratedFilter, Direction.NorthEast);
// break;
//case FilterType.Type.ApproximationKernelE:
// toBeDecoratedFilter = new ApproximationKernel(toBeDecoratedFilter, Direction.East);
// break;
//case FilterType.Type.ApproximationKernelSE:
// toBeDecoratedFilter = new ApproximationKernel(toBeDecoratedFilter, Direction.SouthEast);
// break;
//case FilterType.Type.ApproximationKernelS:
// toBeDecoratedFilter = new ApproximationKernel(toBeDecoratedFilter, Direction.South);
// break;
//case FilterType.Type.ApproximationKernelSW:
// toBeDecoratedFilter = new ApproximationKernel(toBeDecoratedFilter, Direction.SouthWest);
// break;
//case FilterType.Type.ApproximationKernelW:
// toBeDecoratedFilter = new ApproximationKernel(toBeDecoratedFilter, Direction.West);
// break;
//case FilterType.Type.ApproximationKernelNW:
// toBeDecoratedFilter = new ApproximationKernel(toBeDecoratedFilter, Direction.NorthWest);
// break;
//case FilterType.Type.IsotropicKernelN:
// toBeDecoratedFilter = new IsotropicKernel(toBeDecoratedFilter, Direction.North);
// break;
//case FilterType.Type.IsotropicKernelNE:
// toBeDecoratedFilter = new IsotropicKernel(toBeDecoratedFilter, Direction.NorthEast);
// break;
//case FilterType.Type.IsotropicKernelE:
// toBeDecoratedFilter = new IsotropicKernel(toBeDecoratedFilter, Direction.East);
// break;
//case FilterType.Type.IsotropicKernelSE:
// toBeDecoratedFilter = new IsotropicKernel(toBeDecoratedFilter, Direction.SouthEast);
// break;
//case FilterType.Type.IsotropicKernelS:
// toBeDecoratedFilter = new IsotropicKernel(toBeDecoratedFilter, Direction.South);
// break;
//case FilterType.Type.IsotropicKernelSW:
// toBeDecoratedFilter = new IsotropicKernel(toBeDecoratedFilter, Direction.SouthWest);
// break;
//case FilterType.Type.IsotropicKernelW:
// toBeDecoratedFilter = new IsotropicKernel(toBeDecoratedFilter, Direction.West);
// break;
//case FilterType.Type.IsotropicKernelNW:
// toBeDecoratedFilter = new IsotropicKernel(toBeDecoratedFilter, Direction.NorthWest);
// break;
//case FilterType.Type.SobelKernelN:
// toBeDecoratedFilter = new SobelKernel(toBeDecoratedFilter, Direction.North);
// break;
//case FilterType.Type.SobelKernelNE:
// toBeDecoratedFilter = new SobelKernel(toBeDecoratedFilter, Direction.NorthEast);
// break;
//case FilterType.Type.SobelKernelE:
// toBeDecoratedFilter = new SobelKernel(toBeDecoratedFilter, Direction.East);
// break;
//case FilterType.Type.SobelKernelSE:
// toBeDecoratedFilter = new SobelKernel(toBeDecoratedFilter, Direction.SouthEast);
// break;
//case FilterType.Type.SobelKernelS:
// toBeDecoratedFilter = new SobelKernel(toBeDecoratedFilter, Direction.South);
// break;
//case FilterType.Type.SobelKernelSW:
// toBeDecoratedFilter = new SobelKernel(toBeDecoratedFilter, Direction.SouthWest);
// break;
//case FilterType.Type.SobelKernelW:
// toBeDecoratedFilter = new SobelKernel(toBeDecoratedFilter, Direction.West);
// break;
//case FilterType.Type.SobelKernelNW:
// toBeDecoratedFilter = new SobelKernel(toBeDecoratedFilter, Direction.NorthWest);
// break;
case FilterType.Type.NormalizingKernel3:
toBeDecoratedFilter = new NormalizingKernel(toBeDecoratedFilter, 3, 3);
break;
case FilterType.Type.NormalizingKernel5:
toBeDecoratedFilter = new NormalizingKernel(toBeDecoratedFilter, 5, 5);
break;
case FilterType.Type.NormalizingKernel7:
toBeDecoratedFilter = new NormalizingKernel(toBeDecoratedFilter, 7, 7);
break;
case FilterType.Type.NormalizingKernel1x25:
toBeDecoratedFilter = new NormalizingKernel(toBeDecoratedFilter, 1, 25);
break;
case FilterType.Type.NormalizingKernel25x1:
toBeDecoratedFilter = new NormalizingKernel(toBeDecoratedFilter, 25, 1);
break;
case FilterType.Type.NormalizingKernel25:
toBeDecoratedFilter = new NormalizingKernel(toBeDecoratedFilter, 25, 25);
break;
case FilterType.Type.HighPassFilter32:
toBeDecoratedFilter = new HighPassFilter(toBeDecoratedFilter, 32);
break;
case FilterType.Type.HighPassFilter64:
toBeDecoratedFilter = new HighPassFilter(toBeDecoratedFilter, 64);
break;
case FilterType.Type.HighPassFilter96:
toBeDecoratedFilter = new HighPassFilter(toBeDecoratedFilter, 96);
break;
case FilterType.Type.HighPassFilter128:
toBeDecoratedFilter = new HighPassFilter(toBeDecoratedFilter, 128);
break;
case FilterType.Type.HighPassFilter160:
toBeDecoratedFilter = new HighPassFilter(toBeDecoratedFilter, 160);
break;
case FilterType.Type.HighPassFilter192:
toBeDecoratedFilter = new HighPassFilter(toBeDecoratedFilter, 192);
break;
case FilterType.Type.HighPassFilter224:
toBeDecoratedFilter = new HighPassFilter(toBeDecoratedFilter, 224);
break;
case FilterType.Type.HighPassFilter256:
toBeDecoratedFilter = new HighPassFilter(toBeDecoratedFilter, 254);
break;
case FilterType.Type.LowPassFilter32:
toBeDecoratedFilter = new LowPassFilter(toBeDecoratedFilter, 32);
break;
case FilterType.Type.LowPassFilter64:
toBeDecoratedFilter = new LowPassFilter(toBeDecoratedFilter, 64);
break;
case FilterType.Type.LowPassFilter96:
toBeDecoratedFilter = new LowPassFilter(toBeDecoratedFilter, 96);
break;
case FilterType.Type.LowPassFilter128:
toBeDecoratedFilter = new LowPassFilter(toBeDecoratedFilter, 128);
break;
case FilterType.Type.LowPassFilter160:
toBeDecoratedFilter = new LowPassFilter(toBeDecoratedFilter, 160);
break;
case FilterType.Type.LowPassFilter192:
toBeDecoratedFilter = new LowPassFilter(toBeDecoratedFilter, 192);
break;
case FilterType.Type.LowPassFilter224:
toBeDecoratedFilter = new LowPassFilter(toBeDecoratedFilter, 224);
break;
case FilterType.Type.LowPassFilter256:
toBeDecoratedFilter = new LowPassFilter(toBeDecoratedFilter, 255);
break;
case FilterType.Type.ThresholdFilter32:
toBeDecoratedFilter = new ThresholdFilter(toBeDecoratedFilter, 32);
break;
case FilterType.Type.ThresholdFilter64:
toBeDecoratedFilter = new ThresholdFilter(toBeDecoratedFilter, 64);
break;
case FilterType.Type.ThresholdFilter96:
toBeDecoratedFilter = new ThresholdFilter(toBeDecoratedFilter, 96);
break;
case FilterType.Type.ThresholdFilter128:
toBeDecoratedFilter = new ThresholdFilter(toBeDecoratedFilter, 128);
break;
case FilterType.Type.ThresholdFilter160:
toBeDecoratedFilter = new ThresholdFilter(toBeDecoratedFilter, 160);
break;
case FilterType.Type.ThresholdFilter192:
toBeDecoratedFilter = new ThresholdFilter(toBeDecoratedFilter, 192);
break;
case FilterType.Type.ThresholdFilter224:
toBeDecoratedFilter = new ThresholdFilter(toBeDecoratedFilter, 224);
break;
case FilterType.Type.ThresholdFilter256:
toBeDecoratedFilter = new ThresholdFilter(toBeDecoratedFilter, 254);
break;
default:
break;
}
}
return(toBeDecoratedFilter);
}
public InvertFilter(IApplicableFilter decorator)
: base(decorator)
{
// You need more overlords!
}
public GrayScaleKernel(IApplicableFilter decoratingKernel, int width = 1, int height = 1)
: base(decoratingKernel, width, height, GrayScaleKernel.constructWeights())
{
// THE END IS COMING!
}
public GrayScaleFilter(IApplicableFilter decorator)
: base(decorator)
{
// YOU MUST CONSTRUCT ADDITIONAL PYLONS!
}
public GrayScaleKernel(IApplicableFilter decoratingKernel, int width = 1, int height = 1)
: base(decoratingKernel, width, height, GrayScaleKernel.constructWeights())
{
// THE END IS COMING!
}
public SobelKernel(IApplicableFilter decoratingKernel, Direction compass)
: base(decoratingKernel, 3, 3, SobelKernel.constructWeights(3, 3, compass))
{
// A 'jiffy' is an actual unit of time for 1/100th of a second
}
public KirschKernel(IApplicableFilter decoratingKernel, Direction compass)
: base(decoratingKernel, 3, 3, KirschKernel.constructWeights(3, 3, compass))
{
// What's the heading capt'n?
}
public NormalizingKernel(IApplicableFilter decoratingKernel, int width, int height)
: base(decoratingKernel, width, height, NormalizingKernel.constructWeights(width, height))
{
// Construct additional pylons?
}
/// <summary>
/// This filter selects objects that does not conform to the child-filter provided.
/// </summary>
/// <param name="Filter">Child filter.</param>
internal FilterNot(IApplicableFilter Filter)
: base((F.Filter)Filter)
{
this.childFilter = Filter;
}
public ClearBorderFilter(IApplicableFilter decorator)
: base(decorator)
{
}
public FillObjectFilter(IApplicableFilter decorator) : base(decorator)
{
}
public DerivativeKernel(IApplicableFilter decoratingFilter, DerivativeType type)
: base(decoratingFilter, DerivativeKernel.getWidth(type), DerivativeKernel.getHeight(type), constructWeights(type))
{
this.type = type;
}
public void SelectFilters()
{
IsBusy = true;
fsWindow.ShowDialog();
currentFilterList = ((FilterSelectorViewModel)fsWindow.DataContext).ActiveFilters.ToList();
if (hasAppliedThisImage && oldFilterList != null && oldFilterList.Count <= currentFilterList.Count)
{
int i = 0;
bool isTheSame = true;
for (; i < oldFilterList.Count; i++)
{
if (oldFilterList[i] != currentFilterList[i])
{
isTheSame = false;
hasAppliedThisImage = false;
break;
}
}
if (isTheSame)
{
List<FilterType> newFilterList = new List<FilterType>();
for (; i < currentFilterList.Count; i++)
newFilterList.Add(currentFilterList[i]);
currentFilterList = newFilterList;
}
}
else
hasAppliedThisImage = false;
decoratedFilter = FilterFactory.Construct(currentFilterList);
IsBusy = false;
// Handy debug info
Console.WriteLine("The following filters have been selected: ");
foreach (var item in currentFilterList)
{
Console.WriteLine("- {0}", item);
}
}
public DoNothingKernel(IApplicableFilter decoratingKernel, int width, int height)
: base(decoratingKernel, width, height,
DoNothingKernel.initializeDoNothingWeights(width, height))
{
// Zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz....
}
public ThresholdFilter(IApplicableFilter toDecorate, int thresholdValue)
: base(toDecorate)
{
this.thresholdValue = thresholdValue;
}
public ApproximationKernel(IApplicableFilter decoratingKernel, Direction compass)
: base(decoratingKernel, 3, 3, ApproximationKernel.constructWeights(3, 3, compass))
{
// A snail can sleep for 3 years.
}
public SobelKernel(IApplicableFilter decoratingKernel, Direction compass)
: base(decoratingKernel, 3, 3, SobelKernel.constructWeights(3, 3, compass))
{
// A 'jiffy' is an actual unit of time for 1/100th of a second
}
public BasicFilter(IApplicableFilter toDecorate)
{
this.decoratingFilter = toDecorate;
}
