private void TileCorrelationCompleted(string updateText, bool aborted) { this.currentTile = null; this.tiledImageViewer.Invalidate(); this.progressBar.Value = 0; if (updateText != null) { this.textBox.AppendText(updateText); } TimeSpan duration = this.correlator.TimeTaken(); this.timeTakenStatusLabel.Text = "Time Taken: " + duration.Hours.ToString("00") + ":" + duration.Minutes.ToString("00") + ":" + duration.Seconds.ToString("00"); MosaicWindow.MosaicInfo.IsCorrelated = true; this.useCorrelationCheckBox.Checked = true; this.mosaicWindow.CorrelationEnabled = true; // Enable start button again this.correlateButton.Enabled = true; // Update the cache file with correlation positions this.mosaicWindow.SaveCache(); }
private List <CorrelationTile> GetFourBorderingTiles(CorrelationTile tile) { // Here we filter the previous placed tile list so they are sorted to the overlap // with the largest area is first. // The overalp must greater than 25% in one direction // We than return the first 4, which are probably the ones above, below, left and right List <CorrelationTile> tiles = new List <CorrelationTile>(); foreach (CorrelationTile t in this.CorrelationTiles) { if (tile.Equals(t)) { continue; } if (t.PerformedCorrelation == false) { continue; } if (t.Tile.IsAdjusted == false) { continue; } if (t.Tile.IsDummy) { continue; } if (t.Tile.Bounds.IntersectsWith(tile.Tile.Bounds)) { Rectangle intersection = t.Tile.Bounds; intersection.Intersect(tile.Tile.Bounds); if (intersection.Width < 0.25 * tile.Tile.Width && intersection.Height < 0.25 * tile.Tile.Height) { continue; } tiles.Add(t); } } if (tiles.Count == 0) { return(null); } tiles.Sort(new TileIntersectionComparer(tile)); // We now, after this line, will have the tiles with the largest intersection areas tiles = tiles.GetRange(0, Math.Min(tiles.Count, 4)); return(tiles); }
public static PointF GetCentreOfTiles(List <CorrelationTile> tiles) { int left = CorrelationTile.GetMostLeftPosition(tiles); int top = CorrelationTile.GetMostTopPosition(tiles); int width = CorrelationTile.GetMostRightPosition(tiles) - left; int height = CorrelationTile.GetMostBottomPosition(tiles) - top; return(new PointF(left + width / 2.0f, top + height / 2.0f)); }
private void CircularSortTiles(List <CorrelationTile> tiles) { //List<CorrelationTile> tileCopy = new List<Tile>(tiles); // Find centre of tiles PointF center = CorrelationTile.GetCentreOfTiles(tiles); // Sort the tile from the centre of the mosaic. tiles.Sort(new CorrelationTileCircularComparer(center)); }
protected void SendTileCorrelatationBegin(CorrelationTile tile, FreeImageAlgorithmsBitmap fib) { if (this.ThreadController.ThreadAborted) { return; } Object[] objects = { tile, fib }; this.threadController.InvokeObject.BeginInvoke(this.TileCorrelationBeginHandler, objects); }
protected void SendTileCorrelated(CorrelationTile tile, Rectangle correlatedBounds, FreeImageAlgorithmsBitmap fib, bool success) { if (this.ThreadController.ThreadAborted) { return; } Object[] objects = { tile, correlatedBounds, fib, success }; this.threadController.InvokeObject.BeginInvoke(this.TileCorrelatedHandler, objects); }
void OnMosaicLoaded(MosaicWindow sender, MosaicWindowEventArgs args) { this.currentTile = null; this.Initialise(); SetCorrelationForCombobox(); this.tiledImageViewer.Reset(); if (this.correlator != null && this.correlator.OptionPanel != null) { this.correlator.OptionPanel.Reset(this.correlator.MosaicInfo); } }
void OnCorrelationTileImageViewMouseMoveHandler(TiledImageView sender, TiledImageViewMouseEventArgs args) { if (!this.knownOverlapCorrelatorOptionPanel.SelectStartTile.Checked) { return; } this.startPosition = args.VirtualAreaPosition; Point pt = new Point((int)this.startPosition.X, (int)this.startPosition.Y); this.startTile = FindTileAroundPoint(pt); sender.Invalidate(); }
public static CorrelationTile GetMostRightTile(List <CorrelationTile> tiles) { CorrelationTile rightMostTile = tiles[0]; foreach (CorrelationTile tile in tiles) { if (tile.Tile.Position.X > rightMostTile.Tile.Position.X) { rightMostTile = tile; } } return(rightMostTile); }
public static CorrelationTile GetMostLeftTile(List <CorrelationTile> tiles) { CorrelationTile leftMostTile = tiles[0]; foreach (CorrelationTile tile in tiles) { if (tile.Tile.Position.X < leftMostTile.Tile.Position.X) { leftMostTile = tile; } } return(leftMostTile); }
public static CorrelationTile GetMostTopTile(List <CorrelationTile> tiles) { CorrelationTile topMostTile = tiles[0]; foreach (CorrelationTile tile in tiles) { if (tile.Tile.Position.Y < topMostTile.Tile.Position.Y) { topMostTile = tile; } } return(topMostTile); }
public static CorrelationTile GetMostBottomTile(List <CorrelationTile> tiles) { CorrelationTile bottomMostTile = tiles[0]; foreach (CorrelationTile tile in tiles) { if (tile.Tile.Position.Y > bottomMostTile.Tile.Position.Y) { bottomMostTile = tile; } } return(bottomMostTile); }
protected override void CorrelationStarted() { if (this.knownOverlapCorrelatorOptionPanel.Filter == FiltersEnum.GenericEdgeDetection) { KernalBasedOverlapCorrelator.Prefilter = new CorrelationPrefilter(FreeImageAlgorithmsBitmap.EdgeDetect); } this.KernelMinSizeMicrons = this.knownOverlapCorrelatorOptionPanel.StripSize; this.SearchMinSizeMicrons = this.knownOverlapCorrelatorOptionPanel.SearchSize; this.channel = this.knownOverlapCorrelatorOptionPanel.Channel; this.knownOverlapCorrelatorOptionPanel.SelectStartTile.Checked = false; this.startTile = null; }
private CorrelationTile FindTileAroundPoint(Point pt) { CorrelationTile tile = null; // Find the tile that contains the centre point foreach (CorrelationTile t in this.CorrelationTiles) { if (t.Tile.Bounds.Contains(pt)) { tile = t; break; } } return(tile); }
private void OnTileCorrelated(CorrelationTile tile, Rectangle bounds, FreeImageAlgorithmsBitmap fib, bool success) { this.tiledImageViewer.AddTile(bounds, fib); this.tiledImageViewer.Refresh(); #if DEBUG if (success == false) { FreeImageAlgorithmsBitmap bg = new FreeImageAlgorithmsBitmap(this.correlator.BackgroundImage); bg.ConvertTo24Bits(); bg.DrawColourRect(tile.OriginalBoundsRelativeToOrigin, Color.Red, 2); this.debugForm.BackgroundImageView.Image = bg.ToBitmap(); bg.Dispose(); } this.debugForm.Refresh(); #endif }
private void OnTileCorrelationBegin(CorrelationTile tile, FreeImageAlgorithmsBitmap fib) { this.useCorrelationCheckBox.Checked = false; this.currentTile = tile; #if DEBUG FreeImageAlgorithmsBitmap fg = new FreeImageAlgorithmsBitmap(fib); fg.ConvertToStandardType(true); fg.ConvertTo24Bits(); this.debugForm.TileImageView.Image = fg.ToBitmap(); this.debugForm.BackgroundImageView.Refresh(); this.debugForm.TileImageView.Refresh(); fg.Dispose(); #endif }
private void PlaceFirstTile() { // puts the first tile in the sorted list at its default place CorrelationTile firstTile = this.CorrelationTiles[0]; CorrelationTile.Origin = firstTile.BackgroundBoundsWithinMosaic.Location; // FreeImageAlgorithmsBitmap fib = firstTile.Tile.LoadFreeImageBitmap(); FreeImageAlgorithmsBitmap fib = TileImage(firstTile.Tile); firstTile.Tile.IsAdjusted = true; firstTile.PerformedCorrelation = true; NumberOfCorrelatedTiles++; firstTile.Tile.AdjustedPosition = firstTile.Tile.OriginalPosition; this.SendTileCorrelatationBegin(firstTile, fib); this.SendTileCorrelated(firstTile, firstTile.Tile.Bounds, fib, true); this.ThreadController.ReportThreadPercentage(this, "Placed Tile " + firstTile.Tile.FileName + Environment.NewLine, NumberOfCorrelatedTiles, CorrelationTiles.Count); //fib.Dispose(); }
private void DrawPreviouslyPlacedTiles(CorrelationTile tile) { this.BackgroundImage.Clear(); // Paste the previous placed images (correlated) onto the temporary (bg) image foreach (CorrelationTile t in this.CorrelationTiles) { if (t.PerformedCorrelation == false) { continue; } if (!t.BoundsRelativeToMosaic.IntersectsWith(tile.BoundsRelativeToMosaic)) { continue; } // FreeImageAlgorithmsBitmap fib = Tile.LoadFreeImageBitmapFromFile(t.Tile.FilePath); // fib.ConvertToStandardType(true); FreeImageAlgorithmsBitmap fib = TileImage(t.Tile); // Paste first image. We blend as it may improve the correlation. try { this.BackgroundImage.PasteFromTopLeft(fib, t.CorrelatedBoundsRelativeToOrigin.Location, true); } catch (FreeImageException) { this.SendFeedback("Tile positions do not intersect for pasting together" + Environment.NewLine , Color.Red); } finally { fib.Dispose(); } } }
public static int GetMostTopPosition(List <CorrelationTile> tiles) { return(CorrelationTile.GetMostTopTile(tiles).Tile.Position.Y); }
// If quick is true the the tile is correlated with only the previously placed // tile that is overlapping by the largest area. quick is opposite to SearchAllEdges private bool CorrelateTileWithPreviousPlacedTiles(CorrelationTile tile, bool quick) { bool success = false; // Here we keep a reference to the one that correlates best. double measure = 0.0; int count = 0; double[] measures = new double[4]; Point[] points = new Point[4]; if (tile.DontCorrelate) { return(success); } // Return max of four tiles List <CorrelationTile> overLappingTiles = GetFourBorderingTiles(tile); tile.PerformedCorrelation = true; // FreeImageAlgorithmsBitmap fib = tile.Tile.LoadFreeImageBitmap(); // fib.ConvertToStandardType(true); FreeImageAlgorithmsBitmap fib = TileImage(tile.Tile); if (overLappingTiles == null || overLappingTiles.Count < 1) { success = false; this.NumberOfFailedCorrelations++; tile.CorrelationFailed = true; this.SendTileCorrelated(tile, tile.Tile.Bounds, fib, false); return(false); } if (quick) // just use the first of these 4 bordering tiles { overLappingTiles = overLappingTiles.GetRange(0, 1); } if (overLappingTiles != null) { foreach (CorrelationTile t in overLappingTiles) { success = false; Point pt = new Point(); if (this.knownOverlapCorrelatorOptionPanel.AdjustPosBeforeCorrelate) { // We are trying to correlate tile with tile (t) // Tile t should have been correlated so here we first adjust the position of // tile so it is moved the same amount that tile t was. pt = new Point(tile.Tile.OriginalPosition.X + t.Tile.AdjustedPositionShift.X, tile.Tile.OriginalPosition.Y + t.Tile.AdjustedPositionShift.Y); tile.CorrelationPosition = pt; } measure = this.Correlate(this.BackgroundImage, fib, tile, t, false, out pt); measures[count] = measure; points[count] = pt; count++; } } // Search the array of measures, one value for each correlation performed, and find the largest int maxIndex = FindMaxIndex(measures); Color colour = Color.Red; if (measures[maxIndex] > KernalBasedOverlapCorrelator.GoodCorrelation) { colour = Color.Blue; NumberOfCorrelatedTiles++; // We have a good correlation so we need to store the correlation point tile.CorrelationPosition = tile.Tile.AdjustedPosition = points[maxIndex]; tile.CorrelationFailed = false; tile.Tile.IsAdjusted = true; this.SendTileCorrelated(tile, tile.Tile.AdjustedBounds, fib, true); success = true; SendFeedback("Correlating "); SendFeedback(String.Format("{0} x {1} ", tile.Tile.FileName, overLappingTiles[maxIndex].Tile.FileName), Color.Green); SendFeedback("resulted in a factor of "); SendFeedback(String.Format(" {0:0.00}", measures[maxIndex]), colour); SendFeedback(String.Format(" Δ {0},{1}", tile.Tile.AdjustedPositionShift.X, tile.Tile.AdjustedPositionShift.Y)); SendFeedback(Environment.NewLine, Color.Red); } else { // Set the tile adjusted position to its normal position by default. tile.Tile.AdjustedPosition = tile.CorrelationPosition; success = false; this.NumberOfFailedCorrelations++; tile.Tile.IsAdjusted = false; tile.CorrelationFailed = true; this.SendTileCorrelated(tile, tile.Tile.Bounds, fib, false); SendFeedback("Correlating "); SendFeedback(String.Format("{0} x {1} ", tile.Tile.FileName, overLappingTiles[maxIndex].Tile.FileName), Color.Green); SendFeedback("resulted in a factor of "); SendFeedback(String.Format(" {0:0.00}", measures[maxIndex]), colour); SendFeedback(String.Format(" Δ {0},{1}", tile.Tile.AdjustedPositionShift.X, tile.Tile.AdjustedPositionShift.Y)); SendFeedback(Environment.NewLine, Color.Red); } this.ThreadController.ReportThreadPercentage(this, null, NumberOfCorrelatedTiles, this.CorrelationTiles.Count); return(success); }
public static int GetVerticalRangeOfTiles(List <CorrelationTile> tiles) { return(CorrelationTile.GetMostBottomPosition(tiles) - CorrelationTile.GetMostTopPosition(tiles)); }
public static int GetHorizontalRangeOfTiles(List <CorrelationTile> tiles) { return(CorrelationTile.GetMostRightPosition(tiles) - CorrelationTile.GetMostLeftPosition(tiles)); }
public static int GetMostBottomPosition(List <CorrelationTile> tiles) { return(CorrelationTile.GetMostBottomTile(tiles).Tile.Bounds.Bottom); }
public static int GetMostRightPosition(List <CorrelationTile> tiles) { return(CorrelationTile.GetMostRightTile(tiles).Tile.Bounds.Right); }
public static int GetMostLeftPosition(List <CorrelationTile> tiles) { return(CorrelationTile.GetMostLeftTile(tiles).Tile.Position.X); }
public double Correlate(FreeImageAlgorithmsBitmap backgroundImage, FreeImageAlgorithmsBitmap fib, CorrelationTile tile1, CorrelationTile tile2, bool randomise, out Point pt) { this.backgroundIntersectArea = Rectangle.Empty; this.searchArea = Rectangle.Empty; this.searchAreaWithinMosaic = Rectangle.Empty; double measure = 0.0; pt = new Point(); // Find the intersection between the tile and the background drawn bounds. this.backgroundIntersectArea = Rectangle.Intersect(tile1.CorrelatedBoundsRelativeToOrigin, tile2.CorrelatedBoundsRelativeToOrigin); if (this.backgroundIntersectArea == Rectangle.Empty) { SendFeedback(String.Format("{0} and {1} did not intersect ?", tile1.Tile.FileName, tile2.Tile.FileName) + Environment.NewLine, Color.Red); return(0.0); } // determine the area over which to perform the correlation // defines the maximum shift allowed of the new tile. this.searchArea = this.SearchBounds(this.backgroundIntersectArea, randomise); // find the kernel area in the bg image this.kernelAreaWithinBackground = this.KernelBounds(this.backgroundIntersectArea, this.searchArea, randomise); // locate the area in the new image this.kernelArea = this.kernelAreaWithinBackground; this.kernelArea.X -= tile1.CorrelatedBoundsRelativeToOrigin.X; this.kernelArea.Y -= tile1.CorrelatedBoundsRelativeToOrigin.Y; // Call start correlation delegate, for screen update this.SendTileCorrelatationBegin(tile1, fib); if (KernalBasedOverlapCorrelator.prefilter == null) { backgroundImage.KernelCorrelateImageRegions(fib, backgroundIntersectArea, kernelArea, this.searchArea, out pt, out measure); } else { backgroundImage.KernelCorrelateImageRegions(fib, backgroundIntersectArea, kernelArea, this.searchArea, KernalBasedOverlapCorrelator.prefilter, out pt, out measure); } if (measure > KernalBasedOverlapCorrelator.GoodCorrelation) { pt = CorrelationTile.TranslateBackgroundPointToMosaicPoint(pt); return(measure); } if (tile1.NumberOfAtemptedCorrelations < CorrelationTile.MaxNumberOfCorrelationAttempts) { tile1.NumberOfAtemptedCorrelations++; return(this.Correlate(backgroundImage, fib, tile1, tile2, this.knownOverlapCorrelatorOptionPanel.RandomKernelSearch, out pt)); } else { // If we are debugging lets pause the thread for closer inspection #if DEBUG this.CorrelationPause(); #endif } return(measure); }