/// <summary>
/// Маркирование
/// </summary>
/// <param name="bm">Изображение</param>
/// <returns>Регионы</returns>
public Bitmap Marking(Bitmap bm)
{
Matrix matr = ImgConverter.BmpToMatr(bm);
Matrix filter = new Matrix() - 1;
filter[1, 1] = 8;
matr = NeuroFunc.Threshold(matr, 0.5);
matr = 1 - ImgFilters.SpaceFilter(matr, filter);
matr = NeuroFunc.Threshold(matr, 0.9);
BinaryImg bi = new BinaryImg(1 - matr);
Matrix img = bi.ToMatrixInvers();
//img.MatrixShow();
x = 0;
y = 0;
m = img.M;
n = img.N;
couter = 0;
while (x < m - 1 && y < n - 1)
{
SerchNotMark(img);
while (Area(img))
{
}
}
img /= couter;
return(ImgConverter.MatrixToBitmap(img));
}
/// <summary>
/// ФНЧ
/// </summary>
/// <param name="st">Отсчеты сигнала</param>
/// <param name="sr">Частота среза</param>
/// <param name="f">Вектор частот</param>
/// <returns>Фильтрованный сигнал</returns>
public static Vector FilterLow(Vector st, double sr, Vector f)
{
double srNew = Statistic.MaximalValue(f) - sr;
Vector kw = NeuroFunc.Threshold(f, srNew).Revers();
//kw.Visual();
return(Filter(st, kw));
}
/// <summary>
/// Полосовой фильтр
/// </summary>
/// <param name="st">Отсчеты сигнала</param>
/// <param name="sr1">Частота среза 1</param>
/// <param name="sr2">Частота среза 2</param>
/// <param name="f">Вектор частот</param>
/// <returns>Фильтрованный сигнал</returns>
public static Vector FilterBand(Vector st, double sr1, double sr2, Vector f)
{
double srNew = Statistic.MaximalValue(f) - sr2;
Vector kw = NeuroFunc.Threshold(f, srNew).Revers();
Vector kw2 = NeuroFunc.Threshold(f, sr1);
kw *= kw2;
return(Filter(st, kw));
}
/// <summary>
/// Пространственный фильтр полутонового изображения
/// </summary>
/// <param name="img">Матрица изображения</param>
/// <param name="filter">Матрица фильтра</param>
/// <param name="coef">Коэффициент контраста</param>
/// <param name="dx">Яркость</param>
/// <returns>Возвращает результат фильтрации</returns>
public static Matrix SpaceFilter(Matrix img, Matrix filter, double coef = 1, double dx = 0)
{
int H = img.M - filter.M + 1, W = img.N - filter.N + 1;
Matrix newMatr = new Matrix(H, W);
for (int i = 0; i < H; i++)
{
for (int j = 0; j < W; j++)
{
newMatr.Matr[i, j] = Filter(img, filter, j, i);
}
}
return(NeuroFunc.Relu((newMatr * coef + dx / 255.0), 1, 0));
}
/// <summary>
/// Медианный фильтр полутонового изображения
/// </summary>
/// <param name="img">Матрица изображения</param>
/// <param name="filter">Матрица фильтра</param>
/// <param name="coef">Коэффициент контраста</param>
/// <param name="dx">Яркость</param>
/// <returns>Возвращает результат фильтрации</returns>
public static Matrix MedianFilter(Matrix img, Matrix filter, double coef = 1, double dx = 0)
{
int H = img.M - filter.M + 1, W = img.N - filter.N + 1;
Matrix newMatr = new Matrix(H, W);
for (int i = 0; i < H; i++)
{
for (int j = 0; j < W; j++)
{
newMatr.Matr[i, j] = FilterMedian(img, filter, j, i);
}
}
newMatr = MathFunc.abs((newMatr * coef + dx / 255.0) - Statistic.ExpectedValue(newMatr.Spagetiz()));
return(NeuroFunc.Relu(newMatr, 1, 0));
}
/// <summary>
/// Ретинекс
/// </summary>
/// <param name="bm">Картинка</param>
/// <returns></returns>
public static Bitmap Retin(Bitmap bm)
{
Matrix m = ImgConverter.BmpToMatr(bm);
Matrix filter = new Matrix(5, 5) + 10;
Matrix filter2 = new Matrix(5, 5);
filter2[2, 2] = 1;
double sum = 0;
for (int i = 1; i < 4; i++)
{
for (int j = 1; j < 4; j++)
{
filter[i, j] = 12;
}
}
filter[2, 2] = 18;
for (int i = 0; i < 5; i++)
{
for (int j = 0; j < 5; j++)
{
sum += filter[i, j];
}
}
filter /= 1.7 * sum;
Matrix bb = ImgFilters.SpaceFilter(m, filter);
Matrix G = MathFunc.lg(bb + 0.001);
m = ImgFilters.SpaceFilter(m, filter2);
double mean, sigm;
m = MathFunc.lg(m + 0.001);
m -= G;
m -= Statistic.MinimalValue(m.Spagetiz());
m /= Statistic.MaximalValue(m.Spagetiz());
mean = Statistic.ExpectedValue(m.Spagetiz());
sigm = 0.9 / Statistic.Std(m.Spagetiz());
m = NeuroFunc.Sigmoid(sigm * (m - mean));
return(ImgConverter.MatrixToBitmap(m));
}
/// <summary>
/// Создание АЧХ нужного типа
/// </summary>
/// <param name="f">Вектор частот</param>
/// <param name="param">параметры</param>
/// <param name="afh">Тип АЧХ</param>
public Vector GetAFH(Vector f, double[] param, AFHType afh)
{
Vector kw = new Vector(f.N);
if (afh == AFHType.Band)
{
for (int i = 0; i < f.N; i++)
{
if ((f.DataInVector[i] >= param[0]) && (f.DataInVector[i] <= param[1]))
{
kw.DataInVector[i] = 1;
}
}
}
if (afh == AFHType.High)
{
kw = NeuroFunc.Threshold(f, param[0]);
}
if (afh == AFHType.Low)
{
double srNew = f.DataInVector[f.N - 1] - param[0];
kw = NeuroFunc.Threshold(f, srNew).Revers();
}
if (afh == AFHType.Rezector)
{
kw += 1;
for (int i = 0; i < f.N; i++)
{
if ((f.DataInVector[i] >= param[0]) && (f.DataInVector[i] <= param[1]))
{
kw.DataInVector[i] = 0;
}
}
}
return(kw);
}
/// <summary>
/// Распознавание векторов
/// </summary>
/// <param name="x">Вектора</param>
public Vector RecognitionAll(Vector x)
{
Vector[] vecs = new Vector[x.N];
for (int i = 0; i < x.N; i++)
{
vecs[i] = new Vector
(
new double[]
{
1, x[i]
}
);
}
Vector outp = _lr.Predict(vecs);
return(NeuroFunc.Sigmoid(outp));
}
//Элемент контрасного фильтра
private static Matrix FilterContrast(Matrix img, int x, int y, int dx, int dy)
{
Vector vect;
Matrix matr = new Matrix(y, x);
for (int i = 0; i < y; i++)
{
for (int j = 0; j < x; j++)
{
matr[i, j] = img.Matr[dy + i, dx + j];
}
}
matr = MathFunc.lg(matr * 255 + 1);
vect = matr.Spagetiz();
double cko = 3 * Statistic.Std(vect), m = Statistic.ExpectedValue(vect);
return(NeuroFunc.Sigmoid((matr - m) / (cko + 0.01), 3));
}
/// <summary>
/// ФВЧ
/// </summary>
/// <param name="st">Отсчеты сигнала</param>
/// <param name="sr">Частота среза</param>
/// <param name="f">Вектор частот</param>
/// <returns>Фильтрованный сигнал</returns>
public static Vector FilterHigh(Vector st, double sr, Vector f)
{
Vector kw = NeuroFunc.Threshold(f, sr);
return(Filter(st, kw));
}
/// <summary>
/// Прямоугольный сигнал
/// </summary>
/// <param name="t">Вектор отсчетов времени</param>
/// <param name="f">Вектор частот</param>
/// <returns>Отсчеты сигнала</returns>
public static Vector Rect(Vector t, Vector f)
{
return(NeuroFunc.Threshold(Sin(t, f), 0.1));
}
/// <summary>
/// Прямоугольный сигнал
/// </summary>
/// <param name="t">Вектор отсчетов времени</param>
/// <param name="A">Вектор амплитуда</param>
/// <param name="f">Вектор частот</param>
/// <returns>Отсчеты сигнала</returns>
public static Vector Rect(Vector t, Vector A, double f)
{
return(A * NeuroFunc.Threshold(Sin(t, 1, f), 0.1));
}
/// <summary>
/// Производная ф-ии активации
/// </summary>
public override Vector DfDy()
{
return(NeuroFunc.Relu(OutputLayer, 0.0));
}
/// <summary>
/// Регулировка контраста и яркости
/// </summary>
/// <param name="img">Матрица изображения</param>
/// <param name="coef">Контраст</param>
/// <param name="dx">Яркость</param>
/// <returns>Итоговое изображение</returns>
public static Matrix Contrast(Matrix img, double coef = 1, double dx = 0)
{
return(NeuroFunc.Relu((img * coef + dx / 255.0), 1, 0));
}
/// <summary>
/// Ф-я активации
/// </summary>
/// <param name="inp">Вход</param>
public override Vector FActivation(Vector inp)
{
return(1.7159 * NeuroFunc.SigmoidBiplyar(inp, 2.0 / 3.0));
}
/// <summary>
/// Ф-я активации
/// </summary>
/// <param name="inp">Вход</param>
/// <returns></returns>
public override Vector FActivation(Vector inp)
{
return(NeuroFunc.Relu(inp, 0.0));
}
/// <summary>
/// Прямоугольный сигнал
/// </summary>
/// <param name="t">Вектор отсчетов времени</param>
/// <param name="A">Амплитуда</param>
/// <param name="f">Частота</param>
/// <param name="fi">Вектор фаз</param>
/// <returns>Отсчеты сигнала</returns>
public static Vector Rect(Vector t, double A, double f, Vector fi)
{
return(A * NeuroFunc.Threshold(Sin(t, 1, f, fi), 0.1));
}
/// <summary>
/// Функция активации
/// </summary>
/// <param name="inp">Выход линейного слоя</param>
public override Vector FActivation(Vector inp)
{
return(NeuroFunc.Sigmoid(inp));
}
/// <summary>
/// Распознавание вектора
/// </summary>
/// <param name="x">Вектор</param>
public double Recognition(Vector x)
{
double outp = _lr.Predict(x.AddOne());
return(NeuroFunc.Sigmoid(outp));
}
