Example #1
0
        public static Image <Rgba32> CloneWithLookupTable(this Image <HalfSingle> source, Rgba32[] gradient)
        {
            if (gradient == null)
            {
                gradient = new Rgba32[] { Rgba32.Black, Rgba32.White }
            }
            ;

            var vgradient = gradient.Select(item => item.ToVector4()).ToArray();

            var target = new Image <Rgba32>(source.Width, source.Height);

            for (int y = 0; y < target.Height; ++y)
            {
                for (int x = 0; x < target.Width; ++x)
                {
                    var z = source[x, y].ToSingle().Clamp(0, 1);

                    z *= (vgradient.Length - 1);

                    var lowerIdx = (int)(z); if (lowerIdx >= vgradient.Length)
                    {
                        lowerIdx = vgradient.Length - 1;
                    }
                    var upperIdx = (lowerIdx + 1); if (upperIdx >= vgradient.Length)
                    {
                        upperIdx = vgradient.Length - 1;
                    }

                    z -= (int)z;

                    var c = System.Numerics.Vector4.Lerp(vgradient[lowerIdx], vgradient[upperIdx], z);

                    target[x, y] = new Rgba32(c);
                }
            }

            return(target);
        }
    }
Example #2
0
        private static async Task Test()
        {
            using (var pf = new Pixelflut(_hostname, _ports))
            {
                // connect and get resolution
                Console.WriteLine($"Connecting ...");
                await pf.Connect();

                Console.WriteLine($"Connected, retrieving res ...");
                var res = await pf.GetResolutionAsync();

                Console.WriteLine($"Screen res: {res.X}x{res.Y}");

                var imageX = res.X - _leftMargin - _rightMargin;
                var imageY = res.Y - _topMargin - _bottomMargin;

                // decode image and resize to screen res
                Rgba32[] pixels;
                using (var image = Image.Load(_file))
                {
                    pixels = new Rgba32[imageX * imageY];
                    Console.WriteLine($"Img size: {image.Width}x{image.Height}");
                    // https://stackoverflow.com/questions/1940581/c-sharp-image-resizing-to-different-size-while-preserving-aspect-ratio
                    var ratioX    = imageX / (double)image.Width;
                    var ratioY    = imageY / (double)image.Height;
                    var ratio     = ratioX < ratioY ? ratioX : ratioY;
                    var newHeight = Convert.ToInt32(image.Height * ratio);
                    var newWidth  = Convert.ToInt32(image.Width * ratio);
                    Console.WriteLine($"Resizing image to: {newWidth}x{newHeight}");
                    image.Mutate(x => x.Resize(new ResizeOptions {
                        Size = new Size(newWidth, newHeight)
                    }));
                    Console.WriteLine($"Image resized!");
                    image.Mutate(x => x.Pad(imageX, imageY));
                    Console.WriteLine($"Image padded!");
                    var pixelBytes = image.SavePixelData();
                    Console.WriteLine($"Saved pixel data!");
                    for (var i = 0; i < pixelBytes.Length; i += 4)
                    {
                        pixels[i / 4] = new Rgba32(pixelBytes[i], pixelBytes[i + 1], pixelBytes[i + 2], pixelBytes[i + 3]);
                    }
                }

                var hexPixels = pixels.Select(x => x.ToHex().Substring(0, 6)).ToArray();
                Console.WriteLine("Starting threads");
                for (var i = 0; i < _threads; i++)
                {
                    var t = new Thread(async() =>
                    {
                        using (var tpf = new Pixelflut(_hostname, _ports))
                        {
                            while (true)
                            {
                                try
                                {
                                    await tpf.Connect();
                                    tpf.LoadImage(hexPixels, imageX, _bulkPixels, _leftMargin, _topMargin);
                                    while (true)
                                    {
                                        await tpf.SendImage();
                                        //Console.Out.Write('*');
                                    }
                                }
                                catch (Exception ex)
                                {
                                    // thread crash
                                    lock (Console.Out)
                                    {
                                        Console.Out.WriteLine(ex);
                                    }
                                }
                            }
                        }
                    });
                    t.Start();
                }
            }
        }