예제 #1
0
        /// <summary>
        /// Generate height map texture from height map, as a 16 bit grayscale PNG image. Grayscale is mapped from local min (black) to local highest point (white)
        /// Note : heightMap should be in projected coordinates (see ReprojectToCartesian())
        /// </summary>
        /// <param name="heightMap">heightMap in projected coordinates</param>
        /// <param name="outputDirectory"></param>
        /// <returns></returns>
        public TextureInfo GenerateHeightMap(HeightMap heightMap, string outputDirectory,
                                             string fileName = "heightmap.png")
        {
            using (Image <Gray16> outputImage = new Image <Gray16>(heightMap.Width, heightMap.Height))
            {
                int hMapIndex = 0;
                foreach (var coord in heightMap.Coordinates)
                {
                    // index is i + (j * heightMap.Width);
                    var j = hMapIndex / heightMap.Width;
                    var i = hMapIndex - j * heightMap.Width;

                    float gray = MathHelper.Map(heightMap.Minimum, heightMap.Maximum, 0, ushort.MaxValue, (float)(coord.Elevation ?? 0f), true);

                    outputImage[i, j] = new Gray16((ushort)Math.Round(gray, 0));

                    hMapIndex++;
                }

                outputImage.Save(System.IO.Path.Combine(outputDirectory, fileName));
            }

            TextureInfo normal = new TextureInfo(System.IO.Path.Combine(outputDirectory, fileName), TextureImageFormat.image_png,
                                                 heightMap.Width, heightMap.Height);

            return(normal);
        }
예제 #2
0
        /// <summary>
        /// Generate height map texture from height map, as a 16 bit grayscale PNG image. Grayscale is mapped from local min (black) to local highest point (white)
        /// Note : heightMap should be in projected coordinates (see ReprojectToCartesian())
        /// </summary>
        /// <param name="heightMap">heightMap in projected coordinates</param>
        /// <param name="outputDirectory"></param>
        /// <returns></returns>
        public TextureInfo GenerateHeightMap(HeightMap heightMap, string outputDirectory, string fileName = "heightmap.png")
        {
#if NETSTANDARD
            using (Image <Gray16> outputImage = new Image <Gray16>(heightMap.Width, heightMap.Height))
            {
                // Slow way: bake coordinates to list
                var coords = heightMap.Coordinates.ToList();
                for (int j = 0; j < heightMap.Height; j++)
                {
                    for (int i = 0; i < heightMap.Width; i++)
                    {
                        int      index = i + (j * heightMap.Width);
                        GeoPoint point = coords[index];
                        Gray16   color = FromGeoPointToHeightMapColor(point, heightMap.Minimum, heightMap.Maximum);

                        outputImage[i, j] = color;
                    }
                }

                outputImage.Save(Path.Combine(outputDirectory, fileName));
            }
#elif NETFULL
            throw new NotImplementedException();
#endif


            TextureInfo normal = new TextureInfo(Path.Combine(outputDirectory, fileName), TextureImageFormat.image_png, heightMap.Width, heightMap.Height);
            return(normal);
        }
예제 #3
0
        public void AreEqual()
        {
            var color1 = new Gray16(3000);
            var color2 = new Gray16(3000);

            Assert.Equal(color1, color2);
        }
예제 #4
0
        //{

        //    float[] outMap = new float[(width + margin) * (height + margin)];

        //    using (Image<Gray16> outputImage = new Image<Gray16>(heightMap.Width, heightMap.Height))
        //    {

        //        int hMapIndex = 0;
        //        foreach (var coord in heightMap.Coordinates)
        //        {
        //            var j = hMapIndex / heightMap.Width;
        //            var i = hMapIndex - j * heightMap.Width;

        //            float gray = MathHelper.Map(heightMap.Minimum, heightMap.Maximum, 0, (float)ushort.MaxValue, (float)(coord.Elevation ?? 0f), true);

        //            outputImage[i, j] = new Gray16((ushort)Math.Round(gray, 0));

        //            hMapIndex++;
        //        }

        //        // Resize
        //        outputImage.Mutate(i => i.Resize(width, height));

        //        // Read heights from pixels again
        //        for (int j = 0; j < height + margin; j++)
        //            for (int i = 0; i < width + margin; i++)
        //            {
        //                Gray16 color = outputImage[Math.Min(i, width - 1), Math.Min(j, height - 1)];
        //                outMap[i + (j * width)] = FromColorToHeight(color, heightMap.Minimum, heightMap.Maximum);
        //            }
        //    }

        //    return outMap;
        //}
        public float[] ResizeHeightMap_RTIN(IEnumerable <float> heightMap, int sourceWidth, int sourceHeight, int destWidth, int destHeight, float minElevation, float maxElevation, int margin)
        {
            float[] outMap = new float[(destWidth + margin) * (destHeight + margin)];

            using (Image <Gray16> outputImage = new Image <Gray16>(sourceWidth, sourceHeight))
            {
                int hMapIndex = 0;
                foreach (var coord in heightMap)
                {
                    var j = hMapIndex / sourceWidth;
                    var i = hMapIndex - j * sourceWidth;

                    float gray = MathHelper.Map(minElevation, maxElevation, 0, (float)ushort.MaxValue, coord, true);

                    outputImage[i, j] = new Gray16((ushort)Math.Round(gray, 0));

                    hMapIndex++;
                }

                // Resize
                outputImage.Mutate(i => i.Resize(destWidth, destHeight));

                // Read heights from pixels again
                for (int j = 0; j < destHeight + margin; j++)
                {
                    for (int i = 0; i < destWidth + margin; i++)
                    {
                        Gray16 color = outputImage[Math.Min(i, destWidth - 1), Math.Min(j, destHeight - 1)];
                        outMap[i + (j * destWidth)] = FromColorToHeight(color, minElevation, maxElevation);
                    }
                }
            }

            return(outMap);
        }
예제 #5
0
파일: Program.cs 프로젝트: TrueGoric/benoit
        static void SaveMovie(string path, RenderingOptions options, I2DMap <int>[] maps)
        {
            Console.WriteLine($"Saving movie to {path}...");

            using (Image <Gray16> movie = new Image <Gray16>(options.FrameWidth, options.FrameHeight))
            {
                for (int i = 0; i < maps.Length; i++)
                {
                    var map = maps[i];

                    var frame = movie.Frames.CreateFrame();

                    for (int y = 0; y < map.Height; y++)
                    {
                        for (int x = 0; x < map.Width; x++)
                        {
                            frame[x, y] = new Gray16((ushort)Lerp(ushort.MaxValue, 0, map[x, y] / (double)options.MaxIteration));
                        }
                    }

                    var metaData = frame.MetaData.GetFormatMetaData(GifFormat.Instance);

                    metaData.FrameDelay = 12;
                }

                movie.Frames.RemoveFrame(0);

                using (var file = File.Open(path, FileMode.Create))
                    movie.SaveAsGif(file);
            }

            Console.WriteLine("Successfully saved!");
        }
예제 #6
0
        public TextureInfo GenerateHeightMap(float[] heightMap, int width, int height, float minHeight, float maxHeight, string outputDirectory,
                                             string fileName = "heightmap.png")
        {
            using (Image <Gray16> outputImage = new Image <Gray16>(width, height))
            {
                int hMapIndex = 0;
                foreach (var coord in heightMap)
                {
                    // index is i + (j * heightMap.Width);
                    var j = hMapIndex / width;
                    var i = hMapIndex - j * height;

                    float gray = MathHelper.Map(minHeight, maxHeight, 0, ushort.MaxValue, coord, true);

                    outputImage[i, j] = new Gray16((ushort)Math.Round(gray, 0));

                    hMapIndex++;
                }

                outputImage.Save(System.IO.Path.Combine(outputDirectory, fileName));
            }

            TextureInfo normal = new TextureInfo(System.IO.Path.Combine(outputDirectory, fileName), TextureImageFormat.image_png,
                                                 width, height);

            return(normal);
        }
예제 #7
0
        /// <summary>
        /// Generate height map texture from height map, as a 16 bit grayscale PNG image. Grayscale is mapped from local min (black) to local highest point (white)
        /// Note : heightMap should be in projected coordinates (see ReprojectToCartesian())
        /// </summary>
        /// <param name="heightMap">heightMap in projected coordinates</param>
        /// <param name="outputDirectory"></param>
        /// <returns></returns>
        public TextureInfo GenerateHeightMap(HeightMap heightMap, string outputFileName)
        {
            using (Image <Gray16> outputImage = new Image <Gray16>(heightMap.Width, heightMap.Height))
            {
                int hMapIndex = 0;
                foreach (var coord in heightMap.Coordinates)
                {
                    // index is i + (j * heightMap.Width);
                    var j = hMapIndex / heightMap.Width;
                    var i = hMapIndex - j * heightMap.Width;

                    float gray = MathHelper.Map(heightMap.Minimum, heightMap.Maximum, 0, ushort.MaxValue, (float)(coord.Elevation ?? 0f), true);

                    outputImage[i, j] = new Gray16((ushort)Math.Round(gray, 0));

                    hMapIndex++;
                }

                outputImage.Save(outputFileName, new PngEncoder()
                {
                    BitDepth = PngBitDepth.Bit16
                });
            }

            TextureInfo normal = new TextureInfo(outputFileName, TextureImageFormat.image_png,
                                                 heightMap.Width, heightMap.Height);

            return(normal);
        }
예제 #8
0
        public void AreNotEqual()
        {
            var color1 = new Gray16(12345);
            var color2 = new Gray16(54321);

            Assert.NotEqual(color1, color2);
        }
예제 #9
0
            public static (uint, uint, uint, uint) RGBA(this Gray16 c)
            {
                uint r = default;
                uint g = default;
                uint b = default;
                uint a = default;

                var y = uint32(c.Y);

                return(y, y, y, 0xffffUL);
            }
예제 #10
0
        public void Gray16_FromVector4()
        {
            // Arrange
            Gray16       gray     = default;
            const ushort expected = 32767;
            var          vector   = new Gray16(expected).ToVector4();

            // Act
            gray.FromVector4(vector);
            ushort actual = gray.PackedValue;

            // Assert
            Assert.Equal(expected, actual);
        }
예제 #11
0
        public void Gray16_FromRgba32()
        {
            // Arrange
            Gray16     gray      = default;
            const byte rgb       = 128;
            ushort     scaledRgb = ImageMaths.UpscaleFrom8BitTo16Bit(rgb);
            ushort     expected  = ImageMaths.Get16BitBT709Luminance(scaledRgb, scaledRgb, scaledRgb);

            // Act
            gray.FromRgba32(new Rgba32(rgb, rgb, rgb));
            ushort actual = gray.PackedValue;

            // Assert
            Assert.Equal(expected, actual);
        }
예제 #12
0
        public void Gray16_ToVector4(ushort input)
        {
            // Arrange
            var gray = new Gray16(input);

            // Act
            var actual = gray.ToVector4();

            // Assert
            float vectorInput = input / 65535F;

            Assert.Equal(vectorInput, actual.X);
            Assert.Equal(vectorInput, actual.Y);
            Assert.Equal(vectorInput, actual.Z);
            Assert.Equal(1F, actual.W);
        }
예제 #13
0
        public void Gray16_ToRgba32(ushort input)
        {
            // Arrange
            ushort expected = ImageMaths.DownScaleFrom16BitTo8Bit(input);
            var    gray     = new Gray16(input);

            // Act
            Rgba32 actual = default;

            gray.ToRgba32(ref actual);

            // Assert
            Assert.Equal(expected, actual.R);
            Assert.Equal(expected, actual.G);
            Assert.Equal(expected, actual.B);
            Assert.Equal(byte.MaxValue, actual.A);
        }
예제 #14
0
파일: Program.cs 프로젝트: TrueGoric/benoit
        static void SaveFrame(string path, RenderingOptions options, I2DMap <int> map)
        {
            Console.WriteLine($"Saving frame to {path}...");

            using (Image <Gray16> image = new Image <Gray16>(map.Width, map.Height))
            {
                for (int y = 0; y < map.Height; y++)
                {
                    for (int x = 0; x < map.Width; x++)
                    {
                        image[x, y] = new Gray16((ushort)Lerp(ushort.MaxValue, 0, map[x, y] / (double)options.MaxIteration));
                    }
                }

                using (var file = File.Open(path, FileMode.Create))
                    image.SaveAsPng(file);
            }

            Console.WriteLine("Successfully saved!");
        }
            public void ToGray16Bytes(int count)
            {
                Gray8[] source   = CreatePixelTestData(count);
                byte[]  expected = new byte[count * 2];
                Gray16  gray     = default;

                for (int i = 0; i < count; i++)
                {
                    int i2 = i * 2;
                    gray.FromScaledVector4(source[i].ToScaledVector4());
                    OctetBytes bytes = Unsafe.As <Gray16, OctetBytes>(ref gray);
                    expected[i2]     = bytes[0];
                    expected[i2 + 1] = bytes[1];
                }

                TestOperation(
                    source,
                    expected,
                    (s, d) => Operations.ToGray16Bytes(this.Configuration, s, d.GetSpan(), count)
                    );
            }
예제 #16
0
        public TextureInfo GenerateHeightMap(List <GeoPoint> heightMap, int width, int height, string outputFileName)
        {
            double min = double.MaxValue;
            double max = double.MinValue;

            foreach (var coord in heightMap)
            {
                min = Math.Min(min, coord.Elevation.GetValueOrDefault(0));
                max = Math.Max(max, coord.Elevation.GetValueOrDefault(0));
            }
            using (Image <Gray16> outputImage = new Image <Gray16>(width, height))
            {
                int hMapIndex = 0;
                foreach (var coord in heightMap)
                {
                    // index is i + (j * heightMap.Width);
                    var j = hMapIndex / width;
                    var i = hMapIndex - j * width;

                    float gray = MathHelper.Map((float)min, (float)max, 0, ushort.MaxValue, (float)(coord.Elevation ?? 0f), true);

                    outputImage[i, j] = new Gray16((ushort)Math.Round(gray, 0));

                    hMapIndex++;
                }

                outputImage.Save(outputFileName, new PngEncoder()
                {
                    BitDepth = PngBitDepth.Bit16
                });
            }

            TextureInfo normal = new TextureInfo(outputFileName, TextureImageFormat.image_png,
                                                 width, height);

            return(normal);
        }
예제 #17
0
        private float FromColorToHeight(Gray16 color, float min, float max)
        {
            float height = MathHelper.Map(0, (float)ushort.MaxValue, min, max, color.PackedValue, true);

            return(height);
        }
예제 #18
0
 public void FromGray16(Gray16 source)
 {
 }