protected override MyImageD GetImageDInternal()
{
MyImageD imgd = new MyImageD(imgd_provider.GetImageD());
var points = points_provider.GetPoints();
LogPanel.Log($"[PlotPoints] {points.Count} points.");
if (points.Count > 0)
{
MyImageD cross_img = new MyImageD(new double[imgd.data.Length], imgd);
double
mn = points.Min(p => p.importance),
mx = points.Max(p => p.importance);
foreach (var p in points.Reverse <ImagePoint>())
{
Utils.GetHeatColor((p.importance - mn) / (mx - mn), out double r, out double g, out double b);
plot_cross(cross_img, p.x, p.y, r, g, b);
}
Parallel.For(0, imgd.height, i =>
{
for (int j = 0; j < imgd.width; j++)
{
int k = i * imgd.stride + j * 4;
double ratio = cross_img.data[k + 3];
imgd.data[k + 0] = (1 - ratio) * imgd.data[k + 0] + cross_img.data[k + 0];
imgd.data[k + 1] = (1 - ratio) * imgd.data[k + 1] + cross_img.data[k + 1];
imgd.data[k + 2] = (1 - ratio) * imgd.data[k + 2] + cross_img.data[k + 2];
}
});
}
return(imgd);
}
protected override MyImageD GetImageDInternal()
{
MyMatrix
blue_mat = blue_channel.GetMatrix(),
green_mat = green_channel.GetMatrix(),
red_mat = red_channel.GetMatrix(),
alpha_mat = alpha_channel.GetMatrix();
System.Diagnostics.Trace.Assert(Utils.AllTheSame(blue_mat.data.GetLength(0), green_mat.data.GetLength(0), red_mat.data.GetLength(0), alpha_mat.data.GetLength(0)));
System.Diagnostics.Trace.Assert(Utils.AllTheSame(blue_mat.data.GetLength(1), green_mat.data.GetLength(1), red_mat.data.GetLength(1), alpha_mat.data.GetLength(1)));
MyImageD ans = new MyImageD(blue_mat.data.GetLength(1), blue_mat.data.GetLength(0));
Parallel.For(0, ans.height, i =>
{
for (int j = 0; j < ans.width; j++)
{ //bgra
int k = i * ans.stride + j * 4;
ans.data[k + 0] = blue_mat.data[i, j];
ans.data[k + 1] = green_mat.data[i, j];
ans.data[k + 2] = red_mat.data[i, j];
ans.data[k + 3] = alpha_mat.data[i, j];
}
});
return(ans);
}
private void plot_cross(MyImageD img, double x, double y, double r, double g, double b)
{
//r = g = b = 1;
const int cross_length = 3;
if (!plot_dot(img, x, y, r, g, b))
{
return;
}
for (int d = 1; d <= cross_length && plot_dot(img, x, y - d, r, g, b); d++)
{
;
}
for (int d = 1; d <= cross_length && plot_dot(img, x, y + d, r, g, b); d++)
{
;
}
for (int d = 1; d <= cross_length && plot_dot(img, x - d, y, r, g, b); d++)
{
;
}
for (int d = 1; d <= cross_length && plot_dot(img, x + d, y, r, g, b); d++)
{
;
}
}
protected override MyImageD GetImageDInternal()
{
MyImageD img_ans = new MyImageD(provider_base.GetImageD());
scale_rgb_by_alpha(img_ans);
foreach (var provider in providers)
{
MyImageD img = new MyImageD(provider.GetImageD());
System.Diagnostics.Trace.Assert(img.width == img_ans.width && img.height == img_ans.height && img.stride == img_ans.stride);
scale_rgb_by_alpha(img);
Parallel.For(0, img.height, i =>
{
for (int j = 0; j < img.width; j++)
{
int k = i * img.stride + j * 4;
img_ans.data[k + 0] += img.data[k + 0];
img_ans.data[k + 1] += img.data[k + 1];
img_ans.data[k + 2] += img.data[k + 2];
img_ans.data[k + 3] += img.data[k + 3];
}
});
}
normalize_alpha(img_ans);
return(img_ans);
}
void _Log(MyImageD img)
{
pop_children();
stackPanel.Children.Add(new Image {
MaxHeight = 300, Source = img.ToImage().ToBitmapSource(), HorizontalAlignment = System.Windows.HorizontalAlignment.Left
});
scrollViewer.ScrollToBottom();
}
public bool sample_pixel(double x, double y, out double r, out double g, out double b)
{
// h = y*(r/sqrt(x^2+f^2))
// a = center_direction+atan(x/f)
// r = 1, f fixed, for each "h, a", find "x, y"
MyImageD image = image_provider.GetImageD();
return(image.sample(x - (this.center_x - 0.5 * image.width), y - (this.center_y - 0.5 * image.height), out r, out g, out b));
}
public MyImageD GetImageD()
{
if (ans == null)
{
ans = GetImageDInternal();
ImageDChanged?.Invoke(ans);
}
return(ans);
}
public static void Log(MyImageD img)
{
if (!instance.Dispatcher.CheckAccess())
{
instance.Dispatcher.Invoke(() => instance._Log(img));
}
else
{
instance._Log(img);
}
}
private bool plot_dot(MyImageD img, double x, double y, double r, double g, double b)
{ // bgra
if (!(0 <= x && x <= img.width - 1 && 0 <= y && y <= img.height - 1))
{
return(false);
}
int xi = (int)x, yi = (int)y;
double dx = x - xi, dy = y - yi;
splat_pixel(img, xi + 0, yi + 0, r, g, b, (1 - dx) * (1 - dy));
splat_pixel(img, xi + 0, yi + 1, r, g, b, (1 - dx) * dy);
splat_pixel(img, xi + 1, yi + 0, r, g, b, dx * (1 - dy));
splat_pixel(img, xi + 1, yi + 1, r, g, b, dx * dy);
return(true);
}
private void scale_rgb_by_alpha(MyImageD img)
{
Parallel.For(0, img.height, i =>
{
for (int j = 0; j < img.width; j++)
{
int k = i * img.stride + j * 4;
double alpha = img.data[k + 3];
//bgra
img.data[k + 0] /= alpha;
img.data[k + 1] /= alpha;
img.data[k + 2] /= alpha;
}
});
}
private void normalize_alpha(MyImageD img)
{
Parallel.For(0, img.height, i =>
{
for (int j = 0; j < img.width; j++)
{
int k = i * img.stride + j * 4;
//bgra
double alpha = img.data[k + 3];
if (alpha != 0)
{
img.data[k + 0] /= alpha;
img.data[k + 1] /= alpha;
img.data[k + 2] /= alpha;
img.data[k + 3] = 1; // alpha
}
}
});
}
public CorrectiveCylinderImages(List <IImageD_Provider> image_providers, int width, int height) : base(
image_providers,
//image_providers.Select(i=>new ImageD_Providers.PlotPoints(i, get_features_provider(i)) as IImageD_Provider).ToList(),
width, height)
{
points_providers = image_providers.Select(img => get_features_provider(img)).ToList();
{
var provider = image_providers[0];
double scale = 1;
for (int i = 0; i < 7; i++, scale *= 0.5)
{
MyImageD img = provider.GetImageD();
LogPanel.Log($"scale={scale}, width={img.width}, height={img.height}, stride={img.stride}, avg={img.data.Sum() / img.data.Length}");
LogPanel.Log(img);
provider = new ImageD_Providers.GaussianBlur(provider, 1);
provider = new ImageD_Providers.Scale(provider, 0.5);
}
}
}
protected override MyImageD GetImageDInternal()
{
MyImageD imgd = imgd_provider.GetImageD();
int width = (int)Math.Ceiling(imgd.width * scale), height = (int)Math.Ceiling(imgd.height * scale);
int stride = width * 4;
MyImageD ans = new MyImageD(new double[height * stride], width, height, stride, imgd.dpi_x, imgd.dpi_y, imgd.format, imgd.palette);
Parallel.For(0, height, i => {
for (int j = 0; j < width; j++)
{//bgra
int k = i * stride + j * 4;
//x = width > 1 ? i / (width - 1) * (imgd.width - 1) : (imgd.width - 1) / 2;
//y = height > 1 ? i / (height - 1) * (imgd.height - 1) : (imgd.height - 1) / 2;
//imgd.sample(x, y, out double r, out double g, out double b);
imgd.sample(j / scale, i / scale, out double r, out double g, out double b);
//System.Diagnostics.Trace.WriteLine($"r={r}, g={g}, b={b}");
ans.data[k + 0] = b;
ans.data[k + 1] = g;
ans.data[k + 2] = r;
ans.data[k + 3] = 1;
}
private bool splat_pixel(MyImageD img, int x, int y, double r, double g, double b, double ratio)
{ // bgra
if (!(0 <= x && x < img.width && 0 <= y && y < img.height))
{
return(false);
}
int k = y * img.stride + x * 4;
if (img.data[k + 3] > 1 - ratio)
{
double t = (1 - ratio) / img.data[k + 3];
img.data[k + 0] *= t;
img.data[k + 1] *= t;
img.data[k + 2] *= t;
img.data[k + 3] = 1 - ratio;
}
img.data[k + 0] += b * ratio;
img.data[k + 1] += g * ratio;
img.data[k + 2] += r * ratio;
img.data[k + 3] += ratio;
return(true);
}
public ImageD_Cache(MyImageD imaged)
{
this.get_imaged = () => imaged;
}
public void ResetSelf()
{
ans = null;
}
