Ejemplo n.º 1
0
        /// <summary>
        /// Actually build the gray scale image
        /// </summary>
        private void BuildImage()
        {
            MainWindow         parent = MainWindow.Instance;
            MercatorProjection mp     = new MercatorProjection(settings.StartLatitude, settings.StartLongitude);

            Pixels = new short[settings.ImageWidth * settings.ImageHeight];


            int pos = 0;

            for (int y = 0; y < settings.ImageHeight; y++)
            {
                parent.downloadstatus = String.Format("Line {0}", y);
                parent.Dispatcher.BeginInvoke((Action)(() => parent.UpdateMainDisplay(3)));
                double nl = mp.GetNewLatitude(settings.StartLatitude, y * settings.PixelWidthInMetres);
                Delta  d  = mp.GetDelta(nl, settings.StartLongitude);
                for (int x = 0; x < settings.ImageWidth; x++)
                {
                    Pixels[pos + x] = Map[d.mx, d.my].GetHeight(d, settings.PixelWidthInMetres);
                    d = mp.Step(d, settings.PixelWidthInMetres);
                }
                //Parallel.For(0, settings.ImageWidth,
                //   index =>
                //   {
                //       Pixels[pos + index] = Map[d.mx, d.my].GetHeight(d,settings.PixelWidthInMetres);
                //       d = mp.Step(d, settings.PixelWidthInMetres);
                //
                //   }
                //       );
                pos += settings.ImageWidth;
            }
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Draw any overlay files into the map_t image
        /// </summary>
        private void DrawOverlays()
        {
            if (Overlays.Count == 0)
            {
                return;
            }

            if (typeoverlay == null)
            {
                return;
            }

            var settings = core.settings;

            #region Create a bounding region in latitude and longitude
            MercatorProjection mp = new MercatorProjection(settings.StartLatitude, settings.StartLongitude);
            Region             r  = mp.GetRegion(settings.ImageWidth, settings.ImageHeight, (int)settings.PixelWidthInMetres);
            #endregion

            foreach (ShapeFile s in Overlays)
            {
                s.Draw(core.map_t, 32, r, mp, (int)settings.PixelWidthInMetres, settings.ImageWidth, settings.ImageHeight);
            }
            UInt32[] types = new UInt32[settings.ImageHeight * settings.ImageWidth];

            for (int i = 0; i < settings.ImageHeight * settings.ImageWidth; i++)
            {
                byte baset = core.map_t[i];
                if ((baset & 32) == 0)
                {
                    types[i] = core.ColourMappingForMapT[core.map_t[i]];
                }
                else
                {
                    types[i] = 0xffff0000;
                }
            }

            typeoverlay.WritePixels(new Int32Rect(0, 0, settings.ImageWidth, settings.ImageHeight), types, settings.ImageWidth * 4, 0);
            core.UpdateMainDisplay(5);
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Generate map t pressed
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void GenerateMapT(object sender, RoutedEventArgs e)
        {
            UInt32[]           types     = new UInt32[settings.ImageWidth * settings.ImageHeight];
            byte[]             lt        = new byte[settings.ImageHeight * settings.ImageWidth];
            List <byte>        usedtypes = new List <byte>();
            double             start_lat = settings.StartLatitude;
            int                pos       = 0;
            MercatorProjection mp        = new MercatorProjection();

            for (int y = 0; y < settings.ImageHeight; y++)
            {
                double start_lon = settings.StartLongitude;
                for (int x = 0; x < settings.ImageWidth; x++)
                {
                    byte t = landdata.GetType(start_lat, start_lon);
                    if (!usedtypes.Contains(t))
                    {
                        usedtypes.Add(t);
                    }

                    lt[pos++] = t;
                    start_lon = mp.GetNewLongitude(start_lon, start_lat, settings.PixelWidthInMetres);
                }
                start_lat -= (settings.PixelWidthInMetres / 111320.0);
            }


            for (int i = 0; i < settings.ImageWidth * settings.ImageHeight; i++)
            {
                byte  type   = lt[i];
                short height = Pixels[i];

                switch (type)
                {
                case 0:             // water
                {
                    if (height <= 0)
                    {
                        lt[i] = 28;
                    }
                    else
                    {
                        lt[i] = 0;
                    }
                }
                break;

                case 1:             // Jungle
                {
                    if (height == 0)
                    {
                        lt[i] = 29;
                    }
                    else
                    {
                        lt[i] = 27;
                    }
                }
                break;

                case 2:             // Forest
                {
                    if (height == 0)
                    {
                        lt[i] = 29;
                    }
                    else
                    {
                        lt[i] = 24;
                    }
                }
                break;

                case 3:             // snow
                {
                    if (height == 0)
                    {
                        lt[i] = 29;
                    }
                    else
                    {
                        lt[i] = 8;
                    }
                }
                break;

                case 4:             // desert
                {
                    if (height == 0)
                    {
                        lt[i] = 29;
                    }
                    else
                    {
                        lt[i] = 1;
                    }
                }
                break;

                case 5:             // dry scrub
                {
                    if (height == 0)
                    {
                        lt[i] = 29;
                    }
                    else
                    {
                        lt[i] = 2;
                    }
                }
                break;

                case 6:             // city
                {
                    if (height == 0)
                    {
                        lt[i] = 29;
                    }
                    else
                    {
                        lt[i] = 16;
                    }
                }
                break;

                case 7:             // grass
                {
                    if (height == 0)
                    {
                        lt[i] = 29;
                    }
                    else
                    {
                        lt[i] = 3;
                    }
                }
                break;

                case 8:             // hill
                {
                    if (height == 0)
                    {
                        lt[i] = 29;
                    }
                    else
                    {
                        lt[i] = 4;
                    }
                }
                break;

                case 9:             // farmland
                {
                    if (height == 0)
                    {
                        lt[i] = 29;
                    }
                    else
                    {
                        lt[i] = 5;
                    }
                }
                break;

                case 10:             // tropical savannah
                {
                    if (height == 0)
                    {
                        lt[i] = 29;
                    }
                    else
                    {
                        lt[i] = 6;
                    }
                }
                break;

                case 11:             // lake
                {
                    if (height == 0)
                    {
                        lt[i] = 29;
                    }
                    else
                    {
                        lt[i] = 30;
                    }
                }
                break;

                case 12:             // swamp
                {
                    lt[i] = 7;
                }
                break;

                case 13:             // steppe
                {
                    if (height == 0)
                    {
                        lt[i] = 29;
                    }
                    else
                    {
                        lt[i] = 12;
                    }
                }
                break;

                case 14:             // mixed scrub
                {
                    if (height == 0)
                    {
                        lt[i] = 29;
                    }
                    else
                    {
                        lt[i] = 13;
                    }
                }
                break;

                case 15:             // desert scrub
                {
                    if (height == 0)
                    {
                        lt[i] = 29;
                    }
                    else
                    {
                        lt[i] = 14;
                    }
                }
                break;

                case 16:             // mountain
                {
                    if (height == 0)
                    {
                        lt[i] = 29;
                    }
                    else
                    {
                        lt[i] = 9;
                    }
                }
                break;

                case 17:             // sand scrub
                {
                    if (height == 0)
                    {
                        lt[i] = 29;
                    }
                    else
                    {
                        lt[i] = 15;
                    }
                }
                break;
                }
            }
            map_t = lt;

            for (int i = 0; i < settings.ImageHeight * settings.ImageWidth; i++)
            {
                types[i] = ColourMappingForMapT[lt[i]];
            }


            typeoverlay = new WriteableBitmap(settings.ImageWidth, settings.ImageHeight, 96, 96, PixelFormats.Pbgra32, null);
            typeoverlay.WritePixels(new Int32Rect(0, 0, settings.ImageWidth, settings.ImageHeight), types, settings.ImageWidth * 4, 0);
            UpdateMainDisplay(5);
        }