public EffectiveBitmap ProcessHaar(EffectiveBitmap image, bool isRevert, int layers) { var haarColors = new HaarColor[image.Height, image.Width]; for (int i = 0; i < image.Height; i++) { for (int j = 0; j < image.Width; j++) { var color = image.GetPixel(i, j); var haarColor = new HaarColor(color); haarColors[j, i] = haarColor; } } if (!isRevert) { FWT(haarColors, layers); } else { IWT(haarColors, layers); } var haarBitmap = EffectiveBitmap.Create(image.Width, image.Height, image.Depth, (i, j) => { var haarColor = haarColors[j, i]; return(haarColor.GetPixelInfo()); }); return(haarBitmap); }
private EffectiveBitmap Watermark(EffectiveBitmap original, EffectiveBitmap watermark) { return(BitmapOperations.Create((sources, i, j) => { var originalPixel = sources[0].GetPixel(i, j); var watermarkPixel = sources[1].GetPixel(i, j); var r = (int)(originalPixel.R + (watermarkPixel.R * parameters.Ratio)) / 2; var g = (int)(originalPixel.G + (watermarkPixel.G * parameters.Ratio)) / 2; var b = (int)(originalPixel.B + (watermarkPixel.B * parameters.Ratio)) / 2; return new PixelInfo(r, g, b); }, original, watermark)); }
private EffectiveBitmap CleanWatermark(EffectiveBitmap watermarked) { return(BitmapOperations.Create((sources, i, j) => { var watermarkedImgPixel = sources[0].GetPixel(i, j); var divider = (int)(Math.Pow(2, parameters.BitsForWatermark) + 0.5); // TODO better method instead of random bit on last position var r = (byte)(watermarkedImgPixel.R - watermarkedImgPixel.R % divider + CreateRandomNumber(divider)); var g = (byte)(watermarkedImgPixel.G - watermarkedImgPixel.G % divider + CreateRandomNumber(divider)); var b = (byte)(watermarkedImgPixel.B - watermarkedImgPixel.B % divider + CreateRandomNumber(divider)); return new PixelInfo(r, g, b); }, watermarked)); }
private EffectiveBitmap PreprocessToSimplifiedWatermark(EffectiveBitmap watermark) { var divider = (byte)(Math.Ceiling(255 / Math.Pow(2, parameters.BitsForWatermark)) + 0.5); return(BitmapOperations.Create((sources, i, j) => { var watermarkPixel = sources[0].GetPixel(i, j); byte r = (byte)(watermarkPixel.R / divider); byte g = (byte)(watermarkPixel.G / divider); byte b = (byte)(watermarkPixel.B / divider); return new PixelInfo(r, g, b); }, watermark)); }
public override double CalculateDifference(EffectiveBitmap bitmap) { bitmap = bitmap.Resize(target.Width, target.Height); double differenceSum = 0; target.RunOnEveryPixel((x, y) => { var p1 = target.GetPixel(x, y); var p2 = bitmap.GetPixel(x, y); differenceSum += Math.Abs(p1.R - p2.R) + Math.Abs(p1.G - p2.G) + Math.Abs(p1.B - p2.B); }); return(differenceSum); }
private EffectiveBitmap ExtractWatermark(EffectiveBitmap watermarked) { return(BitmapOperations.Create((sources, i, j) => { var watermarkedImgPixel = sources[0].GetPixel(i, j); var divider = (int)Math.Pow(2, parameters.BitsForWatermark); var multiplier = 255 / (divider - 1); byte r = (byte)(watermarkedImgPixel.R % divider * multiplier); byte g = (byte)(watermarkedImgPixel.G % divider * multiplier); byte b = (byte)(watermarkedImgPixel.B % divider * multiplier); return new PixelInfo(r, g, b); }, watermarked)); }
private EffectiveBitmap Watermark(EffectiveBitmap original, EffectiveBitmap watermark) { var simplifiedWatermark = PreprocessToSimplifiedWatermark(watermark); return(EffectiveBitmap.Create(original.Width, original.Height, original.Depth, (i, j) => { var originalPixel = original.GetPixel(i, j); var watermarkPixel = simplifiedWatermark.GetPixel(i, j); var divider = (int)Math.Pow(2, parameters.BitsForWatermark); var r = (byte)(Math.Clamp(originalPixel.R - originalPixel.R % divider + watermarkPixel.R, 0, 255)); var g = (byte)(Math.Clamp(originalPixel.G - originalPixel.G % divider + watermarkPixel.G, 0, 255)); var b = (byte)(Math.Clamp(originalPixel.B - originalPixel.B % divider + watermarkPixel.B, 0, 255)); return new PixelInfo(r, g, b); })); }
private EffectiveBitmap CleanWatermark(EffectiveBitmap imgWatermarked, EffectiveBitmap watermark) { return(BitmapOperations.Create((sources, i, j) => { var watermarkedImgPixel = sources[0].GetPixel(i, j); var watermarkPixel = sources[1].GetPixel(i, j); var r = (int)(watermarkedImgPixel.R * 2 - watermarkPixel.R * parameters.Ratio); var g = (int)(watermarkedImgPixel.G * 2 - watermarkPixel.G * parameters.Ratio); var b = (int)(watermarkedImgPixel.B * 2 - watermarkPixel.B * parameters.Ratio); r = r < 0 ? r + 1 : r; g = g < 0 ? g + 1 : g; b = b < 0 ? b + 1 : b; return new PixelInfo(r, g, b); }, imgWatermarked, watermark)); }
private EffectiveBitmap ExtractWatermark(EffectiveBitmap imgWatermarked, EffectiveBitmap original) { return(BitmapOperations.Create((sources, i, j) => { var watermarkedImgPixel = sources[0].GetPixel(i, j); var originalPixel = sources[1].GetPixel(i, j); var r = (int)((2 * watermarkedImgPixel.R - originalPixel.R) * (1 / parameters.Ratio)); var g = (int)((2 * watermarkedImgPixel.G - originalPixel.G) * (1 / parameters.Ratio)); var b = (int)((2 * watermarkedImgPixel.B - originalPixel.B) * (1 / parameters.Ratio)); r = r < 0 ? 0 : r; g = g < 0 ? 0 : g; b = b < 0 ? 0 : b; return new PixelInfo(r, g, b); }, imgWatermarked, original)); }
public override async IAsyncEnumerable <AlgorithmResultElement> RemoveWatermark([EnumeratorCancellation] CancellationToken ct) { ct.ThrowIfCancellationRequested(); var haaredWatermarked = ProcessHaar(parameters.Watermarked, false, parameters.Layers); ct.ThrowIfCancellationRequested(); var haaredOriginal = ProcessHaar(parameters.Original, false, parameters.Layers); ct.ThrowIfCancellationRequested(); var extractedWatermark = BitmapOperations.Create((sources, i, j) => { var layers = parameters.Layers; var haaredWatermarkedPixel = sources[0].GetPixel(i, j); var haaredPixel = sources[1].GetPixel(i, j); var alpha = parameters.Alpha; var r = (int)((haaredWatermarkedPixel.R - haaredPixel.R) / alpha) % 255; var g = (int)((haaredWatermarkedPixel.G - haaredPixel.G) / alpha) % 255; var b = (int)((haaredWatermarkedPixel.B - haaredPixel.B) / alpha) % 255; return(new PixelInfo(r, g, b)); }, haaredWatermarked, haaredOriginal); EffectiveBitmap croppedRemovedWatermark = null; if (parameters.Layers == 1) { croppedRemovedWatermark = extractedWatermark.Crop(extractedWatermark.Width / 2, 0, extractedWatermark.Width, extractedWatermark.Height / 2); } else if (parameters.Layers == 2) { croppedRemovedWatermark = extractedWatermark.Crop(extractedWatermark.Width * 3 / 4, 0, extractedWatermark.Width, extractedWatermark.Height / 4); } ct.ThrowIfCancellationRequested(); var haaredRemovedWatermark = BitmapOperations.Create((sources, i, j) => { var layers = parameters.Layers; var originalPixel = sources[0].GetPixel(i, j); var watermarkPixel = sources[1].GetPixel(i, j); if (i > sources[0].Height * (2 * layers - 1) / (2 * layers) && j < sources[0].Width / (2 * layers)) { var alpha = parameters.Alpha; var r = (int)(originalPixel.R - (watermarkPixel.R * alpha)) % 255; var g = (int)(originalPixel.G - (watermarkPixel.G * alpha)) % 255; var b = (int)(originalPixel.B - (watermarkPixel.B * alpha)) % 255; return(new PixelInfo(r, g, b)); } return(originalPixel); }, haaredWatermarked, extractedWatermark); var removedWatermark = ProcessHaar(haaredRemovedWatermark, true, parameters.Layers); ct.ThrowIfCancellationRequested(); yield return(new AlgorithmResultElement("Cleaned", removedWatermark, new ResultDescription(ToString()))); ct.ThrowIfCancellationRequested(); yield return(new AlgorithmResultElement("Extracted watermark", croppedRemovedWatermark, new ResultDescription(ToString()))); }
public DwtParameters(EffectiveBitmap original, EffectiveBitmap watermark, EffectiveBitmap watermarked, int layers, decimal alpha) : base(original, watermark, watermarked) { Layers = layers; Alpha = (double)alpha; AlphaM = alpha; }
public abstract double CalculateDifference(EffectiveBitmap bitmap);
public PixelAveragingParameters(EffectiveBitmap original, EffectiveBitmap watermark, EffectiveBitmap watermarked, decimal ratio) : base(original, watermark, watermarked) { Ratio = (double)ratio; RatioM = ratio; }
public LsbParameters(EffectiveBitmap original, EffectiveBitmap watermark, EffectiveBitmap watermarked, int bitsForWatermark) : base(original, watermark, watermarked) { BitsForWatermark = bitsForWatermark; }
private Task <List <AlgorithmResultElement> > GuessResult(IEnumerable <IAsyncEnumerable <AlgorithmResultElement> > results, EffectiveBitmap target, CancellationToken ct) { ct.ThrowIfCancellationRequested(); var evaluatedResults = results.Select(async x => await x.ToListAsync()).ToList(); var bitmapMatcher = new BasicBitmapMatcher(target); var bests = evaluatedResults.OrderBy(x => bitmapMatcher .CalculateDifference( x.Result.Where(r => r.Label == "Cleaned").First().Image.TransformToEffectiveBitmap() ) ); return(bests.First());; }
public DctParameters(EffectiveBitmap original, EffectiveBitmap watermark, EffectiveBitmap watermarked, int key, decimal alpha) : base(original, watermark, watermarked) { Key = key; Alpha = (double)alpha; AlphaM = alpha; }
public BitmapMatcher(EffectiveBitmap target) { this.target = target; }
public RecognizerParameters(EffectiveBitmap original, EffectiveBitmap watermark, EffectiveBitmap watermarked) : base(original, watermark, watermarked) { }
public BasicBitmapMatcher(EffectiveBitmap target) : base(target) { }