コード例 #1
0
        public void AreNotEqual()
        {
            var color1 = new Bgr24(byte.MaxValue, 0, 0);
            var color2 = new Bgr24(byte.MaxValue, 0, byte.MaxValue);

            Assert.NotEqual(color1, color2);
        }
コード例 #2
0
ファイル: Rgba64Tests.cs プロジェクト: Franz1960/ImageSharp
        public void ConstructFrom_Bgr24()
        {
            var expected = new Rgba64(5140, 9766, 19532, ushort.MaxValue);
            var source   = new Bgr24(20, 38, 76);
            var actual   = new Rgba64(source);

            Assert.Equal(expected, actual);
        }
コード例 #3
0
        public void Equals_WhenFalse(byte r1, byte g1, byte b1, byte r2, byte g2, byte b2)
        {
            var a = new Bgr24(r1, g1, b1);
            var b = new Bgr24(r2, g2, b2);

            Assert.False(a.Equals(b));
            Assert.False(a.Equals((object)b));
        }
コード例 #4
0
        public void ToBgr24(ref Bgr24 dest)
        {
            var y = PackedValue;

            dest.R = y;
            dest.G = y;
            dest.B = y;
        }
コード例 #5
0
ファイル: Rgb565.cs プロジェクト: steven1152/maplestory.io
        public void ToBgr24(ref Bgr24 dest)
        {
            Vector4 vector = this.ToVector4() * 255F;

            dest.R = (byte)MathF.Round(vector.X);
            dest.G = (byte)MathF.Round(vector.Y);
            dest.B = (byte)MathF.Round(vector.Z);
        }
コード例 #6
0
        public void ToRgba32()
        {
            var rgb  = new Bgr24(1, 2, 3);
            var rgba = default(Rgba32);

            rgb.ToRgba32(ref rgba);

            Assert.Equal(new Rgba32(1, 2, 3, 255), rgba);
        }
コード例 #7
0
        public void ToBgra32()
        {
            var rgb  = new Bgr24(1, 2, 3);
            var bgra = default(Bgra32);

            rgb.ToBgra32(ref bgra);

            Assert.Equal(new Bgra32(1, 2, 3, 255), bgra);
        }
コード例 #8
0
        public unsafe void ByteLayoutIsSequentialBgr()
        {
            var   color = new Bgr24(1, 2, 3);
            byte *ptr   = (byte *)&color;

            Assert.Equal(3, ptr[0]);
            Assert.Equal(2, ptr[1]);
            Assert.Equal(1, ptr[2]);
        }
コード例 #9
0
        public void Equals_WhenTrue(byte r, byte g, byte b)
        {
            var x = new Bgr24(r, g, b);
            var y = new Bgr24(r, g, b);

            Assert.True(x.Equals(y));
            Assert.True(x.Equals((object)y));
            Assert.Equal(x.GetHashCode(), y.GetHashCode());
        }
コード例 #10
0
        public void ToRgb24()
        {
            var rgb  = new Bgr24(1, 2, 3);
            var dest = default(Rgb24);

            rgb.ToRgb24(ref dest);

            Assert.Equal(new Rgb24(1, 2, 3), dest);
        }
コード例 #11
0
        public void ToBgr24()
        {
            var rgb = new Bgr24(1, 2, 3);
            var bgr = default(Bgr24);

            rgb.ToBgr24(ref bgr);

            Assert.Equal(new Bgr24(1, 2, 3), bgr);
        }
コード例 #12
0
            public void Bgr24()
            {
                var source = new Bgr24(1, 22, 231);

                // Act:
                var color = new Color(source);

                // Assert:
                Bgr24 data = color;

                Assert.Equal(source, data);
            }
コード例 #13
0
            public void Bgr24()
            {
                var source = new Bgr24(1, 22, 231);

                // Act:
                Color color = source;

                // Assert:
                Bgr24 data = color.ToPixel <Bgr24>();

                Assert.Equal(source, data);
            }
コード例 #14
0
ファイル: Rgba64Tests.cs プロジェクト: Franz1960/ImageSharp
        public void ToBgr24_Retval()
        {
            // arrange
            var source   = new Rgba64(5140, 9766, 19532, 29555);
            var expected = new Bgr24(20, 38, 76);

            // act
            var actual = source.ToBgr24();

            // assert
            Assert.Equal(expected, actual);
        }
コード例 #15
0
        public void NormalizedByte4_ToBgr24()
        {
            // arrange
            var short4   = new NormalizedByte4(0.1f, -0.3f, 0.5f, -0.7f);
            var actual   = default(Bgr24);
            var expected = new Bgr24(141, 90, 192);

            // act
            short4.ToBgr24(ref actual);

            // assert
            Assert.Equal(expected, actual);
        }
コード例 #16
0
ファイル: Short2Tests.cs プロジェクト: thedeveus/ImageSharp
        public void Short2_ToBgr24()
        {
            // arrange
            var short2   = new Short2(127.5f, -5.3f);
            var actual   = default(Bgr24);
            var expected = new Bgr24(128, 127, 0);

            // act
            short2.ToBgr24(ref actual);

            // assert
            Assert.Equal(expected, actual);
        }
コード例 #17
0
        public void NormalizedShort2_ToBgr24()
        {
            // arrange
            var short2   = new NormalizedShort2(0.1f, -0.3f);
            var actual   = default(Bgr24);
            var expected = new Bgr24(141, 90, 0);

            // act
            short2.ToBgr24(ref actual);

            // assert
            Assert.Equal(expected, actual);
        }
コード例 #18
0
        public void Rgba1010102_ToBgr24()
        {
            // arrange
            var rgba     = new Rgba1010102(0.1f, -0.3f, 0.5f, -0.7f);
            var actual   = default(Bgr24);
            var expected = new Bgr24(25, 0, 128);

            // act
            rgba.ToBgr24(ref actual);

            // assert
            Assert.Equal(expected, actual);
        }
コード例 #19
0
        public void Rg32_ToBgr24()
        {
            // arrange
            var rg32     = new Rg32(0.1f, -0.3f);
            var actual   = default(Bgr24);
            var expected = new Bgr24(25, 0, 0);

            // act
            rg32.ToBgr24(ref actual);

            // assert
            Assert.Equal(expected, actual);
        }
コード例 #20
0
ファイル: Rgba64Tests.cs プロジェクト: viktortat/ImageSharp
        public void Rgba64_ToBgr24()
        {
            // arrange
            var rgba64   = new Rgba64(0.08f, 0.15f, 0.30f, 0.45f);
            var actual   = default(Bgr24);
            var expected = new Bgr24(20, 38, 76);

            // act
            rgba64.ToBgr24(ref actual);

            // assert
            Assert.Equal(expected, actual);
        }
コード例 #21
0
ファイル: Bgr565Tests.cs プロジェクト: thedeveus/ImageSharp
        public void Bgr565_ToBgr24()
        {
            // arrange
            var bgra     = new Bgr565(0.1F, -0.3F, 0.5F);
            var actual   = default(Bgr24);
            var expected = new Bgr24(25, 0, 132);

            // act
            bgra.ToBgr24(ref actual);

            // assert
            Assert.Equal(expected, actual);
        }
コード例 #22
0
        public void HalfSingle_ToBgr24()
        {
            // arrange
            var halfVector = new HalfSingle(.5F);
            var actual     = default(Bgr24);
            var expected   = new Bgr24(128, 0, 0);

            // act
            halfVector.ToBgr24(ref actual);

            // assert
            Assert.Equal(expected, actual);
        }
コード例 #23
0
ファイル: Argb32Tests.cs プロジェクト: thedeveus/ImageSharp
        public void Argb32_ToBgr24()
        {
            // arrange
            var argb     = new Argb32(+0.1f, -0.3f, +0.5f, -0.7f);
            var actual   = default(Bgr24);
            var expected = new Bgr24(0x1a, 0, 0x80);

            // act
            argb.ToBgr24(ref actual);

            // assert
            Assert.Equal(expected, actual);
        }
コード例 #24
0
        public void HalfVector4_ToBgr24()
        {
            // arrange
            var halfVector = new HalfVector4(.25F, .5F, .75F, 1F);
            var actual     = default(Bgr24);
            var expected   = new Bgr24(64, 128, 191);

            // act
            halfVector.ToBgr24(ref actual);

            // assert
            Assert.Equal(expected, actual);
        }
コード例 #25
0
        public void Byte4_ToBgr24()
        {
            // arrange
            var byte4    = new Byte4(127.5f, -12.3f, 0.5f, -0.7f);
            var actual   = default(Bgr24);
            var expected = new Bgr24(128, 0, 0);

            // act
            byte4.ToBgr24(ref actual);

            // assert
            Assert.Equal(expected, actual);
        }
コード例 #26
0
ファイル: Bgra4444Tests.cs プロジェクト: thedeveus/ImageSharp
        public void Bgra4444_ToBgr24()
        {
            // arrange
            var bgra     = new Bgra4444(0.1f, -0.3f, 0.5f, -0.7f);
            var actual   = default(Bgr24);
            var expected = new Bgr24(34, 0, 136);

            // act
            bgra.ToBgr24(ref actual);

            // assert
            Assert.Equal(expected, actual);
        }
コード例 #27
0
        public void Short4_ToBgr24()
        {
            // arrange
            var shortValue = new Short4(11547, 12653, 29623, 193);
            var actual     = default(Bgr24);
            var expected   = new Bgr24(172, 177, 243);

            // act
            shortValue.ToBgr24(ref actual);

            // assert
            Assert.Equal(expected, actual);
        }
コード例 #28
0
ファイル: Alpha8Tests.cs プロジェクト: thedeveus/ImageSharp
        public void Alpha8_PackFromScaledVector4_ToBgr24()
        {
            // arrange
            Bgr24   actual   = default;
            Alpha8  alpha    = default;
            var     expected = new Bgr24(0, 0, 0);
            Vector4 scaled   = new Alpha8(.5F).ToScaledVector4();

            // act
            alpha.PackFromScaledVector4(scaled);
            alpha.ToBgr24(ref actual);

            // assert
            Assert.Equal(expected, actual);
        }
コード例 #29
0
        static void Main(string[] args)
        {
            Parser.Default.ParseArguments <Options>(args).WithParsed(o =>
            {
                // TODO:  Refactor everything here and split into functions

                using var reader = File.OpenText(o.ScenePath);
                var yaml         = reader.ReadToEnd();
                var scene        = Serialization.ReadScene(yaml);

                if (o.Height.HasValue)
                {
                    scene.Camera.PixelHeight = o.Height.Value;
                }
                if (o.Ratio.HasValue)
                {
                    scene.Camera.Ratio = o.Ratio.Value;
                }

                var sw     = Stopwatch.StartNew();
                var done   = 0;
                var render = scene.Camera.Render(scene, o.Samples, (_, _, _, _, _, count) =>
                {
                    Interlocked.Increment(ref done);
                    var p = Volatile.Read(ref done) / (float)count;
                    Console.Write($"{p:P1}\r");
                });
                sw.Stop();
                Console.WriteLine($"{sw.Elapsed.TotalSeconds:N3} seconds");
                using var bitmap = new Image <Bgr24>(scene.Camera.PixelWidth, scene.Camera.PixelHeight);
                for (var y = 0; y < bitmap.Height; y++)
                {
                    var pixelRowSpan = bitmap.GetPixelRowSpan(y);
                    for (var x = 0; x < bitmap.Width; x++)
                    {
                        var c           = render[y, x];
                        pixelRowSpan[x] = new Bgr24(c.R, c.G, c.B);
                    }
                }
                bitmap.Save(o.OutputPath);
                Console.WriteLine("done!   ");
            });
        }
コード例 #30
0
        public void SetImageExact(int keyIndex, Image <Bgr24> image)
        {
            int key = ValidateKeyIndex(keyIndex);

            if (image.Height == IconSize && image.Width == IconSize)
            {
                var page1Buf = new byte[NumFirstPagePixels * 3];
                var page2Buf = new byte[NumSecondPagePixels * 3];

                int pixelOffset = 0;
                int bufOffset   = 0;
                for (; pixelOffset < NumFirstPagePixels; pixelOffset++)
                {
                    // reverse the image.
                    int   x     = image.Width - 1 - (pixelOffset % image.Width);
                    int   y     = pixelOffset / image.Width;
                    Bgr24 pixel = image[x, y];
                    page1Buf[bufOffset] = pixel.B;
                    bufOffset++;
                    page1Buf[bufOffset] = pixel.G;
                    bufOffset++;
                    page1Buf[bufOffset] = pixel.R;
                    bufOffset++;
                }

                bufOffset = 0;
                for (; pixelOffset - NumFirstPagePixels < NumSecondPagePixels; pixelOffset++)
                {
                    int   x     = image.Width - 1 - (pixelOffset % image.Width);
                    int   y     = pixelOffset / image.Width;
                    Bgr24 pixel = image[x, y];
                    page2Buf[bufOffset] = pixel.B;
                    bufOffset++;
                    page2Buf[bufOffset] = pixel.G;
                    bufOffset++;
                    page2Buf[bufOffset] = pixel.R;
                    bufOffset++;
                }

                WritePage1(key, page1Buf);
                WritePage2(key, page2Buf);
            }
        }