// コールバックとして、ソート済みリストとダーティフラグを、配列(且つ参照型)で返す.
/// <summary>
/// ソート関数
/// </summary>
/// <param name="sort_item">ソートを行う配列(これが直接書き換えられます)</param>
/// <param name="comparer">ソートルール：Compare(x,y)が正ならばxが後に来るように定義してください</param>
/// <param name="i_one_sort_cb">
/// 一回の動作(主に値の入れ替えと入れ替え判定)で呼ばれるコールバック。
/// 第一引数は、交換が行われたか否か。第二引数は交換された場合のダーティフラグ。
/// </param>
/// <param name="i_complete_cb">ソートが完了したときに呼ばれるコールバック</param>
/// <param name="sort_type">ソートの種類</param>
public void Sort(T[] sort_item, Comparer <T> comparer,
SortParameter <T> sort_parameter, Sorting.SortType sort_type)
{
IEnumerator enumerator = SortUseIEnumerator(sort_item, sort_parameter, new WaitForSeconds(0), sort_type);
RunIEnumerator(enumerator);
}
public static byte[,] DespeckleImage(byte[,] imageMatrix,
int maxSize = 5,
Sorting.SortType sortType = Sorting.SortType.NativeArraySort,
FilterType filterType = FilterType.AdaptiveMedian)
{
var imageMatrix2 = imageMatrix;
var imageHeight = GetMatrixHeight(imageMatrix);
var imageWidth = GetMatrixWidth(imageMatrix);
for (var y = 0; y < imageHeight; y++)
{
for (var x = 0; x < imageWidth; x++)
{
if (filterType == FilterType.AlphaTrim)
{
imageMatrix2[y, x] = AlphaTrimFilter(imageMatrix, x, y, maxSize, sortType);
}
else
{
imageMatrix2[y, x] = AdaptiveMedianFilter(imageMatrix, x, y, 3, maxSize, sortType);
}
}
}
return(imageMatrix2);
}
/* PrettyString methods */
public String GetPrettyString(Sorting.SortType sortType)
{
/* Ignore empty list */
if (Entries.Count() == 0)
{
return("");
}
StringBuilder stringBuilder = new StringBuilder();
/* Create copy of entries */
List <Entry> tempEntries = new List <Entry>(Entries);
if (sortType == Sorting.SortType.ASCII_SORT)
{
/* Create String list
* Avoids Entry reference issue that occurs if I modify
* the Entry string directly
*/
List <string> entryStrings = new List <string>();
/* PrettyString encode so that sorting takes into account
* '-' characters, this is what is meant by ascii sort, the
* pretty string is what is sorted by the characters ascii
* values.
*/
foreach (Entry entry in tempEntries)
{
string prettyString = entry.GetPrettyString();
entryStrings.Add(prettyString);
}
entryStrings.Sort();
/* Build Output */
foreach (string entry in entryStrings)
{
stringBuilder.Append(entry);
stringBuilder.Append('\n');
}
}
else if (sortType == Sorting.SortType.ALPHABETICAL_SORT)
{
/* Sort normally with value of Entries, not pretty formatted */
tempEntries.Sort();
}
/* Build output if not already built */
if (sortType != Sorting.SortType.ASCII_SORT)
{
foreach (Entry entry in tempEntries)
{
stringBuilder.Append(entry.GetPrettyString());
stringBuilder.Append('\n');
}
}
return(stringBuilder.ToString());
}
private Task <double> FilterImage(byte[,] imageMatrix, Sorting.SortType sortType, Filtering.FilterType filterType, int maxSize)
{
return(Task.Run(() =>
{
var start = Environment.TickCount;
Filtering.DespeckleImage(imageMatrix, maxSize, sortType, filterType);
var end = Environment.TickCount;
DisplayImage(imageMatrix, FilteredPictureBox);
double time = end - start;
time /= 1000;
return time;
}));
}
/// <summary>
/// ソート関数
/// </summary>
/// <param name="sort_item">ソートを行う配列(これが直接書き換えられます)</param>
/// <param name="comparer">ソートルール：Compare(x,y)が正ならばxが後に来るように定義してください</param>
/// <param name="i_one_sort_cb">
/// 一回の動作(主に値の入れ替えと入れ替え判定)で呼ばれるコールバック。
/// 第一引数は、交換が行われたか否か。第二引数は交換された場合のダーティフラグ。
/// </param>
/// <param name="i_complete_cb">ソートが完了したときに呼ばれるコールバック</param>
/// <param name="i_wait_for_second">一回のソートで待つ条件</param>
/// <param name="sort_type">ソートの種類</param>
/// <returns></returns>
public IEnumerator SortUseIEnumerator(
T[] sort_item,
SortParameter <T> sort_parameter,
WaitForSeconds i_wait_for_second, Sorting.SortType sort_type)
{
waiter = i_wait_for_second;
if (sort_item.Length > 1)
{
yield return(IEnumStartSort(sort_item, sort_parameter, sort_type));
sort_parameter.cb_complete();
}
}
public static byte AdaptiveMedianFilter(byte[,] imageMatrix,
int x,
int y,
int windowSize = 3,
int maxWindowSize = 5,
Sorting.SortType sortType = Sorting.SortType.NativeArraySort)
{
while (true)
{
var windowArraySize = windowSize * windowSize;
var array = new byte[windowArraySize];
var dx = new int[windowArraySize];
var dy = new int[windowArraySize];
var halfWindowSize = windowSize / 2;
var index = 0;
for (var fromCenterY = -halfWindowSize; fromCenterY <= halfWindowSize; fromCenterY++)
{
for (var fromCenterX = -halfWindowSize; fromCenterX <= halfWindowSize; fromCenterX++)
{
dx[index] = fromCenterX;
dy[index] = fromCenterY;
index++;
}
}
byte maxValue = 0;
byte minValue = 255;
var arrayLength = 0;
var currentValue = imageMatrix[y, x];
var imageHeight = GetMatrixHeight(imageMatrix);
var imageWidth = GetMatrixWidth(imageMatrix);
for (var i = 0; i < windowArraySize; i++)
{
var newY = y + dy[i];
var newX = x + dx[i];
if (newX < 0 || newX >= imageWidth || newY < 0 || newY >= imageHeight)
{
continue;
}
array[arrayLength] = imageMatrix[newY, newX];
if (array[arrayLength] > maxValue)
{
maxValue = array[arrayLength];
}
if (array[arrayLength] < minValue)
{
minValue = array[arrayLength];
}
arrayLength++;
}
switch (sortType)
{
case Sorting.SortType.BubbleSort:
array = Sorting.BubbleSort(array, arrayLength);
break;
case Sorting.SortType.CountingSort:
array = Sorting.CountingSort(array, arrayLength, maxValue, minValue);
break;
case Sorting.SortType.HeapSort:
array = Sorting.HeapSort(array, arrayLength);
break;
case Sorting.SortType.InsertionSort:
array = Sorting.InsertionSort(array, arrayLength);
break;
case Sorting.SortType.MergeSort:
array = Sorting.MergeSort(array, 0, arrayLength - 1);
break;
case Sorting.SortType.ModifiedBubbleSort:
array = Sorting.ModifiedBubbleSort(array, arrayLength);
break;
case Sorting.SortType.QuickSort:
array = Sorting.QuickSort(array, 0, arrayLength - 1);
break;
case Sorting.SortType.RadixSort:
array = Sorting.RadixSort(array, arrayLength);
break;
case Sorting.SortType.SelectionSort:
array = Sorting.SelectionSort(array, arrayLength);
break;
case Sorting.SortType.NativeArraySort:
var sortArray = new byte[arrayLength];
if (arrayLength != array.Length)
{
Array.Copy(array, sortArray, arrayLength);
}
else
{
sortArray = array;
}
Array.Sort(sortArray);
break;
}
minValue = array[0];
var medianValue = array[arrayLength / 2];
var medianDistanceFromMin = medianValue - minValue;
var medianDistanceFromMax = maxValue - medianValue;
if (medianDistanceFromMin <= 0 || medianDistanceFromMax <= 0)
{
return(medianValue);
}
var currentDistanceFromMin = currentValue - minValue;
var currentDistanceFromMax = maxValue - currentValue;
if (currentDistanceFromMin > 0 && currentDistanceFromMax > 0)
{
return(currentValue);
}
if (windowSize + 2 >= maxWindowSize)
{
return(medianValue);
}
windowSize = windowSize + 2;
}
}
public static byte AlphaTrimFilter(byte[,] imageMatrix, int x, int y, int maxSize, Sorting.SortType sortType)
{
byte[] array;
int[] dx, dy;
if (maxSize % 2 != 0)
{
array = new byte[maxSize * maxSize];
dx = new int[maxSize * maxSize];
dy = new int[maxSize * maxSize];
}
else
{
array = new byte[(maxSize + 1) * (maxSize + 1)];
dx = new int[(maxSize + 1) * (maxSize + 1)];
dy = new int[(maxSize + 1) * (maxSize + 1)];
}
var index = 0;
for (var yShift = -(maxSize / 2); yShift <= maxSize / 2; yShift++)
{
for (var xShift = -(maxSize / 2); xShift <= maxSize / 2; xShift++)
{
dx[index] = xShift;
dy[index] = yShift;
index++;
}
}
var sum = 0;
byte max = 0;
byte min = 255;
var arrayLength = 0;
var imageWidth = GetMatrixWidth(imageMatrix);
var imageHeight = GetMatrixHeight(imageMatrix);
for (var i = 0; i < maxSize * maxSize; i++)
{
var newY = y + dy[i];
var newX = x + dx[i];
if (newX < 0 || newX >= imageWidth || newY < 0 || newY >= imageHeight)
{
continue;
}
array[arrayLength] = imageMatrix[newY, newX];
if (array[arrayLength] > max)
{
max = array[arrayLength];
}
if (array[arrayLength] < min)
{
min = array[arrayLength];
}
sum += array[arrayLength];
arrayLength++;
}
sum -= max;
sum -= min;
arrayLength -= 2;
var avg = sum / arrayLength;
return((byte)avg);
}
public void PrettyPrintEntries(Sorting.SortType alphabeticalOrder)
{
Console.Write(GetPrettyString(alphabeticalOrder));
}
