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; }