public GaussianBlur(IImageD_Provider imaged_provider, double ro)
{
this.blue_channel = new MatrixProviders.GaussianBlur(MatrixProviders.Filter.Blue(imaged_provider), ro);
this.green_channel = new MatrixProviders.GaussianBlur(MatrixProviders.Filter.Green(imaged_provider), ro);
this.red_channel = new MatrixProviders.GaussianBlur(MatrixProviders.Filter.Red(imaged_provider), ro);
this.alpha_channel = new MatrixProviders.GaussianBlur(MatrixProviders.Filter.Alpha(imaged_provider), ro);
this.ro = ro;
}
static IPointsProvider get_features_provider(IImageD_Provider image_provider)
{
var points_provider_gen = new Func <IImageD_Provider, IPointsProvider <PointsProviders.MSOP_DescriptorVector.Descriptor> >(
i => new PointsProviders.MSOP_DescriptorVector(new PointsProviders.HarrisCornerDetector(i), new MatrixProviders.GrayScale(i)));
return(new PointsProviders.AdaptiveNonmaximalSuppression(
new PointsProviders.MultiScaleFeaturePoints <PointsProviders.MSOP_DescriptorVector.Descriptor>(
image_provider, points_provider_gen, 7, 0.5, 1), 1000) as IPointsProvider);
}
public PointSelect(IImageD_Provider image_provider, IPointsProvider points_provider)
{
IImageD_Provider provider = new ImageD_Providers.PlotPoints(image_provider, points_provider);
image_provider.ImageDChanged += img => { provider.ResetSelf(); provider.GetImageD(); };
points_provider.PointsChanged += ps => { this.points = ps; provider.ResetSelf(); provider.GetImageD(); };
provider.ImageDChanged += img => { image_width = img.width; image_height = img.height; image.Source = img.ToImage().ToBitmapSource(); };
InitializeViews();
RegisterEvents();
}
public MultiScaleFeaturePoints(IImageD_Provider imaged_provider, Func <IImageD_Provider, IPointsProvider <T> > points_provider_gen, double level, double scale_factor, double gaussian_ro)
{
this.imaged_provider = imaged_provider;
this.scale_factor = scale_factor;
this.points_providers = new List <IPointsProvider <T> >();
for (int i = 0; i < level; i++)
{
points_providers.Add(points_provider_gen(imaged_provider));
imaged_provider = new ImageD_Providers.Scale(new ImageD_Providers.GaussianBlur(imaged_provider, gaussian_ro), scale_factor);
}
}
public HarrisCornerDetector(IImageD_Provider image_provider)
{
IMatrixProvider mp_hr = new MatrixProviders.HarrisDetectorResponse(MatrixProviders.Filter.Red(image_provider));
IMatrixProvider mp_hg = new MatrixProviders.HarrisDetectorResponse(MatrixProviders.Filter.Green(image_provider));
IMatrixProvider mp_hb = new MatrixProviders.HarrisDetectorResponse(MatrixProviders.Filter.Blue(image_provider));
IMatrixProvider mp_harris = new MatrixProviders.Add(mp_hr, mp_hg, mp_hb);
IPointsProvider
pp_harris_filtered = new PointsProviders.LocalMaximum(mp_harris, 10 * 3.0 / (255.0 * 255.0)),
pp_harris_refined = new PointsProviders.SubpixelRefinement(pp_harris_filtered, mp_harris);
//pp_harris_eliminated = new PointsProviders.AdaptiveNonmaximalSuppression(pp_harris_refined, 500);
this.points_provider = pp_harris_refined;
}
public ImageViewer(IImageD_Provider provider, bool heatmap = true) : this()
{
provider.ImageDChanged += (image) => {
MyImage i = heatmap ? image.ToMatrix().ToHeatImage(1) : image.ToImage();
if (!this.Dispatcher.CheckAccess())
{
Dispatcher.Invoke(() => img.Source = i.ToBitmapSource());
}
else
{
img.Source = i.ToBitmapSource();
}
};
}
private Tuple <double, double, int> get_displacement(int i, int j)
{
lock (get_displacement_cache_sync)
{
if (get_displacement_cache == null)
{
get_displacement_cache = new Tuple <double, double, int> [n, n];
}
if (get_displacement_cache[i, j] == null)
{
List <int> matches = points_match_list(i, j);
List <Tuple <double, double, double, double> > candidates = new List <Tuple <double, double, double, double> >();
for (int _ = 0; _ < matches.Count; _++)
{
if (matches[_] != -1)
{
var p1 = points[i][_];
var p2 = points[j][matches[_]];
IImageD_Provider me = image_providers[i], other = image_providers[j];
candidates.Add(new Tuple <double, double, double, double>(
p1.x - 0.5 * me.GetImageD().width,
p1.y - 0.5 * me.GetImageD().height,
p2.x - 0.5 * other.GetImageD().width,
p2.y - 0.5 * other.GetImageD().height));
}
}
//LogPanel.Log($"candidate.count={candidates.Count}");
var ans = Utils.VoteInliners(candidates, 10);
get_displacement_cache[i, j] = new Tuple <double, double, int>(
ans.Average(_ =>
{
var v = candidates[_];
return(v.Item1 - v.Item3);
}),
ans.Average(_ =>
{
var v = candidates[_];
return(v.Item2 - v.Item4);
}), ans.Count);
}
}
return(get_displacement_cache[i, j]);
}
public GrayScale(IImageD_Provider provider)
{
this.provider = provider;
}
public PlaneImage(IImageD_Provider image_provider, double center_x, double center_y)
{
this.image_provider = image_provider;
this.center_x = center_x;
this.center_y = center_y;
}
public static Filter Green(IImageD_Provider provider)
{
return(new Filter(provider, ColorChannel.Green));
}
public static Filter Red(IImageD_Provider provider)
{
return(new Filter(provider, ColorChannel.Red));
}
private Filter(IImageD_Provider provider, ColorChannel color_channel)
{
this.provider = provider;
this.color_channel = (int)color_channel;
}
public static Filter Alpha(IImageD_Provider provider)
{
return(new Filter(provider, ColorChannel.Alpha));
}
public static Filter Blue(IImageD_Provider provider)
{
return(new Filter(provider, ColorChannel.Blue));
}
async void StartSimulation()
{
int kase_self = System.Threading.Interlocked.Increment(ref kase);
await Task.Run(() =>
{
var images = source_image_panel.GetImages();
List <IPointsProvider> points_providers = images.Select(i => new ImageD_Providers.ImageD_Cache(i.ToImageD()) as IImageD_Provider).Select(i => new PointsProviders.MSOP_DescriptorVector(new PointsProviders.HarrisCornerDetector(i), new MatrixProviders.GrayScale(i)) as IPointsProvider).ToList();
List <IImageD_Provider> image_providers = images.Select((i, idx) => new ImageD_Providers.PlotPoints(new ImageD_Providers.ImageD_Cache(i.ToImageD()), points_providers[idx]) as IImageD_Provider).ToList();
var global_viewer = new Func <PlaneImages>(() =>
{
return(new PlaneImages(image_providers, 5000, 600));
})();
int n = global_viewer.images.Count;
image_container.Dispatcher.Invoke(() => image_container.Content = new ImageViewer(global_viewer, false));
LogPanel.Log("searching features...");
Parallel.For(0, n, i => image_providers[i].GetImageD());
global_viewer.GetImageD();
LogPanel.Log("matching...");
var points = points_providers.Select(pp => pp.GetPoints().Select(ps => (ps as ImagePoint <PointsProviders.MSOP_DescriptorVector.Descriptor>)).ToList()).ToList();
var get_displacement = new Func <int, int, Tuple <double, double, int> >((i, j) =>
{
List <ImagePoint <PointsProviders.MSOP_DescriptorVector.Descriptor> > p1s = points[i], p2s = points[j];
List <Tuple <double, double, double, double> > candidates = new List <Tuple <double, double, double, double> >();
Parallel.For(0, p1s.Count, _ =>
{
var p1 = p1s[_];
if (p1.content.try_match(p2s, out ImagePoint p2))
{
IImageD_Provider me = image_providers[i], other = image_providers[j];
lock (candidates) candidates.Add(new Tuple <double, double, double, double>(
p1.x - 0.5 * me.GetImageD().width,
p1.y - 0.5 * me.GetImageD().height,
p2.x - 0.5 * other.GetImageD().width,
p2.y - 0.5 * other.GetImageD().height));
//candidates.Add(Tuple.Create(p1.content.difference((p2 as ImagePoint<PointsProviders.MSOP_DescriptorVector.Descriptor>).content), p1.x, p1.y, p2.x, p2.y));
}
});
var ans = Utils.VoteInliners(candidates, 10);
return(new Tuple <double, double, int>(
ans.Average(_ =>
{
var v = candidates[_];
return v.Item3 - v.Item1;
}),
ans.Average(_ =>
{
var v = candidates[_];
return v.Item4 - v.Item2;
}), ans.Count));
});
{
bool[] vis = new bool[n];
SortedSet <Tuple <int, int, Tuple <double, double, int> > > edge_list = new SortedSet <Tuple <int, int, Tuple <double, double, int> > >(new comparer1());
var add_edges = new Action <int>(u =>
{
Parallel.For(0, n, i =>
{
if (!vis[i])
{
var edge = new Tuple <int, int, Tuple <double, double, int> >(u, i, get_displacement(u, i));
lock (edge_list) edge_list.Add(edge);
}
});
});
vis[0] = true; global_viewer.images[0].set_position(0, 0);
add_edges(0);
while (edge_list.Count > 0)
{
var edge = edge_list.First(); edge_list.Remove(edge);
if (vis[edge.Item2])
{
continue;
}
LogPanel.Log($"edge: {edge.Item1} → {edge.Item2}");
vis[edge.Item2] = true;
var u = global_viewer.images[edge.Item1];
global_viewer.images[edge.Item2].set_position(u.center_x - edge.Item3.Item1, u.center_y - edge.Item3.Item2);
add_edges(edge.Item2);
}
}
global_viewer.move_to_center();
global_viewer.ResetSelf();
global_viewer.GetImageD();
LogPanel.Log("ok");
});
}
private void InitializeViews()
{
source_image_panel = new SourceImagePanel();
IImageD_Provider main_image = source_image_panel.GetImageD_Provider(0);
IImageD_Provider side_image = source_image_panel.GetImageD_Provider(1);
IPointsProvider <PointsProviders.MSOP_DescriptorVector.Descriptor> main_feature_points_provider = new PointsProviders.MSOP_DescriptorVector(new PointsProviders.HarrisCornerDetector(main_image), new MatrixProviders.GrayScale(main_image));
IPointsProvider <PointsProviders.MSOP_DescriptorVector.Descriptor> side_feature_points_provider = new PointsProviders.MSOP_DescriptorVector(new PointsProviders.HarrisCornerDetector(side_image), new MatrixProviders.GrayScale(side_image));
IImageD_Provider mp_merge_refined = new ImageD_Providers.PlotPoints(
new ImageD_Providers.GrayImageD(new MatrixProviders.GrayScale(main_image)),
main_feature_points_provider
);
Controls.PointSelect main_features = new Controls.PointSelect(main_image, main_feature_points_provider);
Controls.PointSelect side_features = new Controls.PointSelect(side_image, side_feature_points_provider);
main_features.PointSelected += selected_point =>
{
var main_descriptor = (selected_point as ImagePoint <PointsProviders.MSOP_DescriptorVector.Descriptor>).content;
ImagePoint nearst = null;
double first_min = double.MaxValue, second_min = double.MaxValue;
foreach (var p in side_features.points)
{
double dis = main_descriptor.difference((p as ImagePoint <PointsProviders.MSOP_DescriptorVector.Descriptor>).content);
if (dis < first_min)
{
second_min = first_min;
first_min = dis;
nearst = p;
}
else if (dis < second_min)
{
second_min = dis;
}
}
if (first_min / second_min < 0.8)
{
LogPanel.Log($"nearst feature diff = {main_descriptor.difference((nearst as ImagePoint<PointsProviders.MSOP_DescriptorVector.Descriptor>).content)}");
side_features.ShowPoint(nearst.x, nearst.y);
}
else
{
LogPanel.Log($"nearst feature too similar, no match!");
}
};
//this.Height = 500;
//this.Width = 800;
this.Content = new ScrollViewer
{
HorizontalScrollBarVisibility = ScrollBarVisibility.Disabled,
VerticalScrollBarVisibility = ScrollBarVisibility.Visible,
Content = new StackPanel
{
Orientation = Orientation.Vertical,
Children =
{
source_image_panel,
new Grid
{
ColumnDefinitions =
{
new ColumnDefinition {
Width = new GridLength(1,GridUnitType.Star)
},
new ColumnDefinition {
Width = new GridLength(1,GridUnitType.Star)
}
},
Children =
{
new Button {
Content = "Run"
}.Set(async() =>{ await Task.Run(() => { mp_merge_refined.GetImageD(); }); LogPanel.Log("done."); }).Set(0, 0),
new Button {
Content = "Reset"
}.Set(async() =>{ await Task.Run(() => { mp_merge_refined.Reset(); }); LogPanel.Log("reseted."); }).Set(0, 1)
}
},
//(new ImageViewer(mp_r)),
//(new ImageViewer(mp_hr)),
//(new ImageViewer(mp_g)),
//(new ImageViewer(mp_hg)),
//(new ImageViewer(mp_b)),
//(new ImageViewer(mp_hb)),
new ImageViewer(mp_merge_refined,false),
//new ImageViewer(main_image,false),
//new Controls.PointSelect(source_image_panel,new PointsProviders.PointsCache(new List<ImagePoint>{ new ImagePoint(10,10,1),new ImagePoint(100,50,5) }))
main_features,
side_features
}
}
};
}
public PlotPoints(IImageD_Provider imgd_provider, IPointsProvider points_provider, double exp = 1)
{
this.imgd_provider = imgd_provider;
this.points_provider = points_provider;
this.exp = exp;
}
public Scale(IImageD_Provider imgd_provider, double scale)
{
this.imgd_provider = imgd_provider;
this.scale = scale;
}
/// <summary>
/// weighted sum according to images' alphas, resulted alpha will always be 1, or 0 if weights are all 0
/// </summary>
/// <param name="provider_base"></param>
/// <param name="providers"></param>
public Blend(IImageD_Provider provider_base, params IImageD_Provider[] providers)
{
this.provider_base = provider_base;
this.providers = providers;
}
