public Bitmap Process(Bitmap source, IPointsDetector detector) { LockableBitmap processedBitmap = new LockableBitmap(source); processedBitmap.LockBits(); try { СharacteristicPoint[] characteristicsPoints = null; try { characteristicsPoints = detector.Detect(processedBitmap); } finally { processedBitmap.UnlockBits(); } ProcessOutput(source, characteristicsPoints); } catch (Exception ex) { Log.Current.Error(ex); } return(source); }
public Bitmap Determine( Bitmap source, int clustersNumber, Region[] regions, IClusteringAlgorithmFactory clusteringAlgorithmFactory) { LockableBitmap lockableBitmap = new LockableBitmap(source); lockableBitmap.LockBits(); IClusteringAlgorithm <double> clusteringAlgorithm = clusteringAlgorithmFactory.Create(clustersNumber, lockableBitmap); try { Region[] clusteredRegions = clusteringAlgorithm.Distribute(regions); foreach (Region region in clusteredRegions) { FillRegion(region, lockableBitmap); } } finally { lockableBitmap.UnlockBits(); } return(source); }
public Bitmap Process(Bitmap source, params IPerItemAlgorithm[] perItemAlgorithms) { LockableBitmap lockableBitmap = new LockableBitmap(source); lockableBitmap.LockBits(); try { foreach (IPerItemAlgorithm algorithm in perItemAlgorithms) { for (int x = 0; x < lockableBitmap.Width; x++) { for (int y = 0; y < lockableBitmap.Height; y++) { Color processedColor = algorithm.Execute(lockableBitmap.GetPixel(x, y)); lockableBitmap.SetPixel(x, y, processedColor); } } } } finally { lockableBitmap.UnlockBits(); } return(source); }
public Bitmap MarkRegions(Bitmap source, IScanner scanner, int threshold) { IDictionary <int, List <ScanInfo> > regions = scanner.Scan(source); LockableBitmap lockableBitmap = new LockableBitmap(source); lockableBitmap.LockBits(); try { int regionIndex = 1; foreach (KeyValuePair <int, List <ScanInfo> > region in regions.Where(region => region.Value.Count >= threshold)) { FillRegion(regionIndex, region, lockableBitmap); regionIndex++; } } finally { lockableBitmap.UnlockBits(); } return(source); }
public int[] Calculate(Bitmap bitmap) { int[] lumininances = new int[256]; LockableBitmap lockableBitmap = new LockableBitmap(bitmap); lockableBitmap.LockBits(); try { for (int i = 0; i < lockableBitmap.Width; i++) { for (int j = 0; j < lockableBitmap.Height; j++) { byte brightness = lockableBitmap.GetPixel(i, j).Brightness(); lumininances[brightness]++; } } } finally { lockableBitmap.UnlockBits(); } return(lumininances); }
public Bitmap Process(Bitmap source, IFilter filter) { Bitmap copiedSource = (Bitmap)source.Clone(); LockableBitmap outBitmap = new LockableBitmap(copiedSource); outBitmap.LockBits(); LockableBitmap processedBitmap = new LockableBitmap(source); processedBitmap.LockBits(); try { SobelImageEnumerator enumerator = new SobelImageEnumerator(processedBitmap); while (enumerator.MoveNext()) { try { ExecuteStep(enumerator.Current, filter, processedBitmap, outBitmap); } catch (Exception ex) { Log.Current.Error(ex); } } } finally { processedBitmap.UnlockBits(); outBitmap.UnlockBits(); } return(copiedSource); }
public Bitmap Process(Bitmap sourceToProcess) { Bitmap copiedSource = (Bitmap)sourceToProcess.Clone(); LockableBitmap outBitmap = new LockableBitmap(copiedSource); outBitmap.LockBits(); LockableBitmap lockableBitmap = new LockableBitmap(sourceToProcess); lockableBitmap.LockBits(); try { IPattern <double> pattern = RetrievePatternValue(lockableBitmap); double[] processedPattern = hopfieldNeuralNetwork.Determine(pattern); ApplyPatternValues(processedPattern, outBitmap); } finally { lockableBitmap.UnlockBits(); outBitmap.UnlockBits(); } return(copiedSource); }
private void CalculateGradientsForAperture(int x, int y, LockableBitmap source) { double dx = 0.0; double dy = 0.0; int centerX = convolutionX.GetLength(0) / 2; int centerY = convolutionY.GetLength(0) / 2; for (int i = 0; i < convolutionX.GetLength(0); i++) { for (int j = 0; j < convolutionY.GetLength(0); j++) { int indexX = x + (i - centerX); int indexY = y + (j - centerY); dx += apertureSelector.Invoke(indexX, indexY, x, y, source) * convolutionX[j, i]; dy += apertureSelector.Invoke(indexX, indexY, x, y, source) * convolutionY[j, i]; } } dfx [x, y] = dx; dfy [x, y] = dy; dfxy[x, y] = dx * dy; }
public SobelImageEnumerator(LockableBitmap source) { if (source == null) { throw new ArgumentNullException("source"); } this.source = source; }
public AverageBrightness(LockableBitmap source) { if (source == null) { throw new ArgumentNullException("source"); } this.source = source; }
private void InitializeGradients(LockableBitmap source) { dfx = new double[source.Width, source.Height]; dfy = new double[source.Width, source.Height]; dfxy = new double[source.Width, source.Height]; for (int x = 0; x < source.Width; x++) { for (int y = 0; y < source.Height; y++) { CalculateGradientsForAperture(x, y, source); } } }
private void ApplyPatternValues(IEnumerable <double> processedPattern, LockableBitmap source) { Color[] colors = processedPattern.Select(BinaryToColor).ToArray(); int colorIndex = 0; for (int x = 0; x < source.Width; x++) { for (int y = 0; y < source.Height; y++) { source.SetPixel(x, y, colors[colorIndex]); colorIndex++; } } }
public void AddPattern(Bitmap source) { LockableBitmap lockableBitmap = new LockableBitmap(source); lockableBitmap.LockBits(); try { IPattern <double> pattern = RetrievePatternValue(lockableBitmap); hopfieldNeuralNetwork.Teach(pattern); } finally { lockableBitmap.UnlockBits(); } }
private void FillRegion( Region region, LockableBitmap lockableBitmap) { Color color; if (!ColorMapper.TryMap(region.Number, out color)) { color = colorGenerator.RandomColor(); } foreach (ScanInfo info in region.Infos) { lockableBitmap.SetPixel(info.Coords.X, info.Coords.Y, color); } }
private void FillRegion( int regionIndex, KeyValuePair <int, List <ScanInfo> > region, LockableBitmap lockableBitmap) { Color color; if (!ColorMapper.TryMap(regionIndex, out color)) { color = colorGenerator.RandomColor(); } foreach (ScanInfo info in region.Value) { lockableBitmap.SetPixel(info.Coords.X, info.Coords.Y, color); } }
public LockableBitmapWrapper(LockableBitmap source) { if (source == null) { throw new ArgumentNullException("source"); } this.source = source; infos = new ScanInfo[source.Width, source.Height]; for (int y = 0; y < source.Height; y++) { for (int x = 0; x < source.Width; x++) { infos[x, y] = new ScanInfo(source.GetPixel(x, y), new Point(x, y)); } } }
private IPattern <double> RetrievePatternValue(LockableBitmap lockableBitmap) { List <double> patternValues = new List <double>(); for (int x = 0; x < lockableBitmap.Width; x++) { for (int y = 0; y < lockableBitmap.Height; y++) { Color processedColor = perItemAlgorithm .Execute(lockableBitmap.GetPixel(x, y)); patternValues.Add( ColorToBinary(processedColor)); } } return(new Pattern(patternValues.ToArray())); }
public Bitmap Process(Bitmap source, IMultiFilter filter) { Bitmap copiedSource = (Bitmap)source.Clone(); LockableBitmap outBitmap = new LockableBitmap(copiedSource); outBitmap.LockBits(); LockableBitmap processedBitmap = new LockableBitmap(source); processedBitmap.LockBits(); try { GaussEnumerator enumerator = new GaussEnumerator(processedBitmap); while (enumerator.MoveNext()) { try { Color processedColor = filter.Execute(enumerator.Current); ApertureItem processedApertureItem = enumerator.Current[enumerator.Current.GetLength(0) / 2, enumerator.Current.GetLength(0) / 2]; ProcessOutput(processedApertureItem, processedColor, outBitmap); } catch (Exception exception) { Log.Current.Error(exception); } } } finally { processedBitmap.UnlockBits(); outBitmap.UnlockBits(); } return(copiedSource); }
public IClusteringAlgorithm <double> Create( int clustersNumber, LockableBitmap source) { ISign <double>[] signs = { //new AverageBrightness(source), //new AverageColor(source), //new BrightnessDispersion(), new Density(new Square(), new Perimeter()), new Elongation(), new PrincipalAxisOrientation(), new Square(), new Perimeter(), }; return(new Kmedian.Implementation.Kmedian( clustersNumber, signs, new EuclideanDistance(), new StartSignsVectorGenerator(), new MedianAlgorithm())); }
public СharacteristicPoint[] Detect(LockableBitmap source) { InitializeGradients(source); СharacteristicPoint[,] responces = new СharacteristicPoint[source.Width, source.Height]; for (int y = 0; y < source.Height; y++) { for (int x = 0; x < source.Width; x++) { double response = responseAngle.Calculate(dfx[x, y], dfy[x, y], dfxy[x, y]); response = response > threshold ? response : default(double); responces[x, y] = new СharacteristicPoint( new Point(x, y), response); } } List <СharacteristicPoint> filteredPoints = DetectLocalMaximumPoints(responces); return(filteredPoints.ToArray()); }
protected static void ProcessOutput(Aperture aperture, LockableBitmap outBitmap, Color filteredColor) { outBitmap.SetPixel(aperture.CurrentX, aperture.CurrentY, filteredColor); }
protected virtual void ExecuteStep(Aperture aperture, IFilter filter, LockableBitmap processed, LockableBitmap outBitmap) { Color filteredColor = filter.Execute(aperture.CurrentColor, ref aperture); ProcessOutput(aperture, outBitmap, filteredColor); }
public IDictionary <int, List <ScanInfo> > Scan(Bitmap source) { LockableBitmap lockableBitmap = new LockableBitmap(source); lockableBitmap.LockBits(); LockableBitmapWrapper lockableBitmapWrapper = new LockableBitmapWrapper(lockableBitmap); try { SequentialEnumerator enumerator = new SequentialEnumerator(lockableBitmapWrapper); while (enumerator.MoveNext()) { AbcMask mask = enumerator.Current; if (mask.Current.Color.IsWhite()) { if (!mask.Left.IsLabeled && !mask.Top.IsLabeled) { if (regions.Count > 0) { mask.Current.RegionNumber = regions.Keys.Max() + 1; } else { mask.Current.RegionNumber = 0; } AddRegionAndMove( regionNumber: mask.Current.RegionNumber, info: mask.Current); } else if (!mask.Left.IsLabeled && mask.Top.IsLabeled) { mask.Current.RegionNumber = mask.Top.RegionNumber; Move(regionNumber: mask.Current.RegionNumber, info: mask.Current); } else if (mask.Left.IsLabeled && !mask.Top.IsLabeled) { mask.Current.RegionNumber = mask.Left.RegionNumber; Move(regionNumber: mask.Current.RegionNumber, info: mask.Current); } else if (mask.Left.IsLabeled && mask.Top.IsLabeled) { if (mask.Left.RegionNumber == mask.Top.RegionNumber) { mask.Current.RegionNumber = mask.Left.RegionNumber; Move(regionNumber: mask.Current.RegionNumber, info: mask.Current); } else { ReAllocate(mask); } } mask.Current.IsLabeled = true; } } } finally { lockableBitmap.UnlockBits(); } return(regions); }
private void ProcessOutput(ApertureItem processedApertureItem, Color processedColor, LockableBitmap outBitmap) { outBitmap.SetPixel( processedApertureItem.Coords.X, processedApertureItem.Coords.Y, processedColor); }