예제 #1
0
 protected ImageBuffer GetBitmap()
 {
     string key = "BMP:" + SourcePath;
     var bmp = bmpCache[key] as ImageBuffer;
     if (bmp == null)
     {
         bmp = new ImageBuffer(new Bitmap(SourcePath));
         bmpCache.Add(key, bmp);
     }
     return bmp;
 }
예제 #2
0
 protected ImageBuffer GetBitmap()
 {
     string key = CacheKeyPrefix + SourcePath;
     var bmp = MemoryCache.Default[key] as ImageBuffer;
     if (bmp == null)
     {
         bmp = new ImageBuffer(new Bitmap(SourcePath));
         MemoryCache.Default[key] = bmp;
         Console.WriteLine("Added to cache: " + SourcePath);
     }
     return bmp;
 }
예제 #3
0
 protected ImageBuffer GetBitmap()
 {
     string key = CacheKeyPrefix + SourcePath;
     var bmp = MemoryCache.Default[key] as ImageBuffer;
     if (bmp == null)
     {
         bmp = new ImageBuffer(new Bitmap(SourcePath));
         MemoryCache.Default.Add(key, bmp, new DateTimeOffset(DateTime.UtcNow.AddSeconds(60)));
         Console.WriteLine("Added to cache: " + SourcePath);
     }
     return bmp;
 }
예제 #4
0
 private static void AddNoise(ImageBuffer source, double noiseLevel)
 {
     Parallel.For(0, source.Height, (y) =>
     {
         for (int x = 0; x < source.Width; x++)
         {
             var px = source.SafeGetPixel(x, y);
             byte r = Noise.Add(px.R, noiseLevel), g = Noise.Add(px.G, noiseLevel), b = Noise.Add(px.B, noiseLevel);
             source.SafeSetPixel(x, y, Color.FromArgb(r, g, b));
         }
     });
     source.Save("noised.png", ImageFormat.Png); 
 }
예제 #5
0
        private static void RemoveNoise(NeuralNetwork neuralNetwork, string imagePath, double noiseLevel)
        {
            ImageBuffer source, dest;
            using (var sourceBmp = new Bitmap(imagePath))
            {
                source = new ImageBuffer(sourceBmp);
                AddNoise(source, noiseLevel);
                dest = new ImageBuffer(source.Width, source.Height);
            }

            var rem = new RecurrentNoiseRemoval(neuralNetwork, source, noiseLevel);
            rem.RemoveNoise((row) => Console.WriteLine("Processing: {0}/{1}", row, source.Height));

            Console.WriteLine("Remove Time: {0}ms, Computation Time: {1}ms", rem.LastRemoveTime.TotalMilliseconds, rem.LastComputationTime.TotalMilliseconds);

            rem.Dest.Save("result.png", ImageFormat.Png); 
        }
예제 #6
0
        public RecurrentNoiseRemoval(NeuralNetwork network, ImageBuffer source, double noiseLevel)
        {
            Contract.Requires(network != null);
            Contract.Requires(source != null);
            Contract.Requires(noiseLevel >= 0.0 && noiseLevel <= 1.0);

            Network = network;
            VerifyNetwork();
            Source = source;
            NoiseLevel = noiseLevel;
            Dest = new ImageBuffer(source.Width, source.Height);
            rNetwork = Network;
            gNetwork = Network.Clone();
            bNetwork = Network.Clone();
            rReset = new ResetHandler(rNetwork, false);
            gReset = new ResetHandler(gNetwork, false);
            bReset = new ResetHandler(bNetwork, false);
            size2 = Size / 2;
            swComp = new Stopwatch();
            swRemove = new Stopwatch();
            this.noiseLevel = ImgNoise.Features.Helpers.GetNoiseLevel(NoiseLevel);
        }
예제 #7
0
        private static void RemoveNoise(NeuralComputation computation, string path, double noiseLevel)
        {
            var comps = Enumerable.Range(0, 15).Select(idx => new NoiseRemovalComputation(computation.Clone())).ToList();
            comps.Add(new NoiseRemovalComputation(computation));
            int compIdx = 0;
            
            ImageBuffer source, dest;
            using (var sourceBmp = new Bitmap(path))
            {
                source = new ImageBuffer(sourceBmp);
                AddNoise(source, noiseLevel);
                dest = new ImageBuffer(source.Width, source.Height);
            }

            int size = 7, blockSize = 16;
            int w = source.Width, h = source.Height, soFar = 0, msTime = 0;
            SpinLock infoLock = new SpinLock(), compLock = new SpinLock();

            Parallel.For(0, h / blockSize + 1, (idx, state) =>
            {
                NoiseRemovalComputation comp;
                bool compTaken = false;
                try
                {
                    compLock.Enter(ref compTaken);
                    comp = comps[compIdx++ % comps.Count];
                }
                finally
                {
                    if (compTaken) compLock.Exit();
                }

                //Console.WriteLine(compIdx);

                int pos = idx * blockSize;
                var rBytes = new byte[size * size];
                var bBytes = new byte[size * size];
                var gBytes = new byte[size * size];
                Color[] sourceColors = new Color[size * size];
                for (int y = pos; y < pos + blockSize && y < h; y++)
                {
                    var sw = new Stopwatch();
                    for (int x = 0; x < w; x++)
                    {
                        ReadBytes(source, rBytes, gBytes, bBytes, size, x, y);

                        sw.Start();
                        byte destByteR = comp.Compute(rBytes, noiseLevel);
                        byte destByteG = comp.Compute(gBytes, noiseLevel);
                        byte destByteB = comp.Compute(bBytes, noiseLevel);
                        sw.Stop();

                        WriteByte(dest, x, y, destByteR, destByteG, destByteB);
                    }

                    bool infoTaken = false;
                    try
                    {
                        infoLock.Enter(ref infoTaken);
                        msTime += (int)sw.ElapsedMilliseconds;
                        Console.WriteLine("Processing line: {0} / {1}", ++soFar, h);
                    }
                    finally
                    {
                        if (infoTaken) infoLock.Exit();
                    }
                }
            });

            Console.WriteLine("Comp: {0}ms", msTime);

            dest.Save("result.png", ImageFormat.Png);  
        }
예제 #8
0
 private static Color ReadColor(ImageBuffer source, int x, int y)
 {
     x = CutCoord(source.Width, x);
     y = CutCoord(source.Height, y);
     return source.SafeGetPixel(x, y);
 }
예제 #9
0
 private static void ReadBytes(ImageBuffer source, byte[] rBytes, byte[] gBytes, byte[] bBytes, int size, int x, int y)
 {
     int size2 = size / 2;
     int xs = x - size2, xe = x + size2 + 1;
     int ys = y - size2, ye = y + size2 + 1;
     int dx = 0, dy = 0;
     for (int ry = ys; ry < ye; ry++, dy++)
     {
         for (int rx = xs; rx < xe; rx++, dx++)
         {
             int addr = dy * size + dx;
             var color = ReadColor(source, rx, ry);
             rBytes[addr] = color.R;
             gBytes[addr] = color.G;
             bBytes[addr] = color.B;
         }
         dx = 0;
     }
 }
예제 #10
0
 private static void WriteByte(ImageBuffer dest, int x, int y, byte r, byte g, byte b)
 {
     if (x < dest.Width && y < dest.Height)
     {
         dest.SafeSetPixel(x, y, Color.FromArgb(r, g, b));
     }
 }
예제 #11
0
 private static ImageBuffer GetBitmap(string path)
 {
     string key = "BMP:" + path;
     var bmp = bmpCache[key] as ImageBuffer;
     if (bmp == null)
     {
         bmp = new ImageBuffer(new Bitmap(path));
         bmpCache.Add(key, bmp);
     }
     return bmp;
 }