Пример #1
0
 public DialogEditPolygon(Waypoint_Path_Gen wpg, GMAP gmap, TreeView treeview, int poly_index)
 {
     _wpg        = wpg;
     _gmap       = gmap;
     _treeview   = treeview;
     _poly_index = poly_index;
     _poly       = _wpg.ShapeAt(_poly_index);
     InitializeComponent();
     txtPolyName.Text = _poly.name;
 }
Пример #2
0
 public DialogPolyPerimPath(Waypoint_Path_Gen wpg, GMAP gmap, Options options, TreeView treeview)
 {
     _wpg      = wpg;
     _gmap     = gmap;
     _options  = options;
     _treeview = treeview;
     InitializeComponent();
     txtAltPolyPath.Text = Convert.ToString(_options.def_altitude);
     cmbPolyPath.Items.Clear();
     for (int i = 0; i < _wpg.ShapeCount(); i++)
     {
         cmbPolyPath.Items.Add(_wpg.ShapeAt(i).name);
     }
 }
Пример #3
0
        private void BuildPath()
        {
            int polyindex = cmbPolyPath.SelectedIndex;

            if (polyindex == -1)
            {
                return;
            }

            // Get Path

            double lat, lat_next;
            double lon, lon_next;
            double alt = Convert.ToDouble(txtAltPolyPath.Text);
            double head;
            int    gimblemode  = 0;
            double gimblepitch = 0;
            double curvesize   = 0;
            double rotdir      = 0;

            int[,] actions = new int[, ] {
                { -1, 0 }, { -1, 0 }, { -1, 0 }, { -1, 0 }, { -1, 0 }, { -1, 0 }, { -1, 0 }, { -1, 0 }, { -1, 0 }, { -1, 0 }, { -1, 0 }, { -1, 0 }, { -1, 0 }, { -1, 0 }, { -1, 0 }
            };
            Models.Shape           poly      = _wpg.ShapeAt(polyindex);
            LinkedList <PolyPoint> points    = poly.points;
            LinkedList <WayPoints> waypoints = new LinkedList <WayPoints>();
            string path_name = poly.name;

            for (int i = 0; i < points.Count; i++)
            {
                lat = points.ElementAt(i).lat;
                lon = points.ElementAt(i).lon;
                if (i < (points.Count - 1))
                {
                    lat_next = points.ElementAt(i + 1).lat;
                    lon_next = points.ElementAt(i + 1).lon;
                    head     = GPS.GPS_Bearing(lat, lon, lat_next, lon_next);
                }
                else
                {
                    lat_next = points.ElementAt(0).lat;
                    lon_next = points.ElementAt(0).lon;
                    head     = GPS.GPS_Bearing(lat, lon, lat_next, lon_next);
                }
                _wp.Add_Waypoint_List(waypoints, lat, lon, alt, head, curvesize, rotdir, gimblemode, gimblepitch, actions);
            }

            // Add Path

            if (_current_path_index != -1)
            {
                _wpg.DeletePath(_wpg.PathAt(_current_path_index));
            }

            int index = cmbPolyPath.SelectedIndex;

            path_name = _wpg.ShapeAt(index).name;
            if (path_name == "")
            {
                path_name = "Untitled - Perimeter";
            }
            _path.Add_Path(_wpg, _gmap, path_name, "Perimeter", waypoints);
            index = _wpg.PathCount() - 1;
            _current_path_index = index;

            Models.Path path          = _wpg.PathAt(index);
            string      exist_type    = path.type;
            bool        exist_select  = path.selected;
            bool        exist_visible = path.visible;

            if (exist_type == "Perimeter")
            {
                _wpg.ChangePathWP(index, waypoints);
                string pathname = path.name;
                int    id       = path.id;
                string type     = path.type;
                _gmap.Delete_gMapPath(path);
                Models.Path newpath = new Models.Path();
                newpath.name      = pathname;
                newpath.id        = id;
                newpath.type      = type;
                newpath.selected  = exist_select;
                newpath.visible   = exist_visible;
                newpath.waypoints = waypoints;
                _gmap.Add_gMapPath(path, false);
            }

            _gmap.ReDrawgMap();
        }
Пример #4
0
        public void BuildgMap()
        {
            /*
             * switch (index)
             * {
             *  case 0:
             *      _mapcontrol.MapProvider = global::GMap.NET.MapProviders.BingSatelliteMapProvider.Instance;
             *      break;
             *  case 1:
             *      _mapcontrol.MapProvider = global::GMap.NET.MapProviders.GoogleMapProvider.Instance;
             *      break;
             *  case 2:
             *      _mapcontrol.MapProvider = global::GMap.NET.MapProviders.GoogleTerrainMapProvider.Instance;
             *      break;
             *  case 3:
             *      _mapcontrol.MapProvider = global::GMap.NET.MapProviders.GoogleHybridMapProvider.Instance;
             *      break;
             *  case 4:
             *      _mapcontrol.MapProvider = global::GMap.NET.MapProviders.ArcGIS_Topo_US_2D_MapProvider.Instance;
             *      break;
             *  case 5:
             *      _mapcontrol.MapProvider = global::GMap.NET.MapProviders.GoogleSatelliteMapProvider.Instance;
             *      break;
             * }
             *
             *
             *
             * global::GMap.NET.GMaps.Instance.Mode = global::GMap.NET.AccessMode.ServerOnly;
             */
            _markers.Clear();
            _mapcontrol.Overlays.Clear();
            //_mapcontrol.ShowCenter = false;
            _overmarkers = new GMapOverlay("markers");
            _overroutes  = new GMapOverlay("routes");
            _overpolys   = new GMapOverlay("polygons");
            _mapcontrol.Overlays.Add(_overmarkers);
            _mapcontrol.Overlays.Add(_overroutes);
            _mapcontrol.Overlays.Add(_overpolys);

            _drone_image_notselected = (Bitmap)Image.FromFile("drone.png", true);
            _drone_image_selected    = (Bitmap)Image.FromFile("drone_selected.png", true);


            // Map POI

            int poicount = _wpg.POICount();

            for (int i = 0; i < poicount; i++)
            {
                GMapMarker marker;
                POIPoints  pnt     = _wpg.POIPointAt(i);
                string     poiname = pnt.name;
                if (i == 0)
                {
                    _mapcontrol.Position = new global::GMap.NET.PointLatLng(pnt.lat, pnt.lon);
                }
                if (pnt.selected)
                {
                    marker = new GMarkerGoogle(new PointLatLng(pnt.lat, pnt.lon), _poi_selected_image);
                }
                else
                {
                    marker = new GMarkerGoogle(new PointLatLng(pnt.lat, pnt.lon), _poi_image);
                }

                //    GMarkerGoogleType.blue_pushpin);

                //marker.Size = new Size(32, 32);
                marker.Offset           = new Point(-16, -16);
                marker.ToolTipText      = poiname;
                marker.Tag              = poiname;
                marker.IsVisible        = pnt.visible;
                marker.IsHitTestVisible = true;
                _overmarkers.Markers.Add(marker);
            }

            // Map Path

            int pathcount = _wpg.PathCount();


            for (int i = 0; i < pathcount; i++)
            {
                Path   path    = _wpg.PathAt(i);
                string name    = path.name;
                bool   visible = path.visible;
                LinkedList <WayPoints> wplist = path.waypoints;
                int wpcount = wplist.Count;

                List <PointLatLng> points = new List <PointLatLng>();
                int count = 0;
                foreach (WayPoints wp in wplist)
                {
                    bool selected = wp.selected;
                    points.Add(new PointLatLng(wp.lat, wp.lon));
                    GMapMarker marker;

                    if (selected)
                    {
                        _drone_image = _drone_image_selected;
                        _drone_image = RotateImage(_drone_image_selected, wp.head);
                        marker       = new GMarkerGoogle(new PointLatLng(wp.lat, wp.lon), _drone_image);
                        //GMarkerGoogleType.red_pushpin);
                    }
                    else
                    {
                        _drone_image = _drone_image_notselected;
                        _drone_image = RotateImage(_drone_image_notselected, wp.head);
                        marker       = new GMarkerGoogle(new PointLatLng(wp.lat, wp.lon), _drone_image);
                        //GMarkerGoogleType.blue_pushpin);
                    }
                    //marker.Size = new Size(64,64);
                    marker.Position    = new PointLatLng(wp.lat, wp.lon);
                    marker.Offset      = new Point(-16, -16);
                    marker.Tag         = Convert.ToString(i) + "." + Convert.ToString(count);
                    marker.IsVisible   = visible;
                    marker.ToolTipText = "WP(" + Convert.ToString(count) + ") - Alt:" + Convert.ToString(wp.alt);
                    _overmarkers.Markers.Add(marker);
                    wp.marker = marker;
                    GMAPWPMarker wpmarker = new GMAPWPMarker();
                    wpmarker.path     = i;
                    wpmarker.wp       = count;
                    wpmarker.marker   = marker;
                    wpmarker.selected = wp.selected;
                    _markers.Add(wpmarker);
                    count++;
                }
                GMapRoute route = new GMapRoute(points, name);
                route.Stroke           = new Pen(Color.Blue, 2);
                route.Tag              = i;
                route.IsVisible        = visible;
                route.IsHitTestVisible = true;
                _overroutes.Routes.Add(route);
                //mapcontrol.Overlays.Add(overroutes);
                //mapcontrol.Overlays.Add(markers);
            }

            //mapcontrol.Overlays.Add(markers);

            // Map Polygon

            int polycount = _wpg.ShapeCount();

            for (int i = 0; i < polycount; i++)
            {
                Shape  polyshape = _wpg.ShapeAt(i);
                string name      = polyshape.name;
                bool   visible   = polyshape.visible;
                LinkedList <PolyPoint> wplist = polyshape.points;
                int wpcount = wplist.Count;


                List <PointLatLng> points = new List <PointLatLng>();
                foreach (PolyPoint wp in wplist)
                {
                    points.Add(new PointLatLng(wp.lat, wp.lon));
                }
                GMapPolygon poly = new GMapPolygon(points, name);
                if (polyshape.selected)
                {
                    poly.Stroke = new Pen(Color.Red, 1);
                }
                else
                {
                    poly.Stroke = new Pen(Color.Yellow, 1);
                }
                poly.Fill      = new SolidBrush(Color.FromArgb(25, Color.Yellow));
                poly.Tag       = polyshape.name;
                poly.IsVisible = visible;

                _overpolys.Polygons.Add(poly);
            }

            if (!Form1.Globals.Map_FirstDraw)
            {
                _mapcontrol.Position        = Form1.Globals.map_center;
                Form1.Globals.Map_FirstDraw = false;
            }
            _center = _mapcontrol.Position;
        }
        public DialogAddPolyGridPath(Waypoint_Path_Gen wpg, GMAP gmap, Options options, Path path, double lat, double lon)
        {
            _wpg         = wpg;
            _gmap        = gmap;
            _options     = options;
            _wp          = new WayPoints();
            _lat         = lat;
            _lon         = lon;
            _cam_ang_hor = _options.focal_angle_hor;
            _cam_ang_ver = _options.focal_angle_ver;
            _over_wid    = _options.hor_overlap_percent;
            _over_hgt    = _options.ver_overlap_percent;

            InitializeComponent();

            // Get selected Polygon


            int shape_count = _wpg.ShapeCount();

            for (int i = 0; i < shape_count; i++)
            {
                if (_wpg.ShapeAt(i).selected)
                {
                    _poly_index   = i;
                    _poly_intid   = _wpg.ShapeAt(i).internal_id;
                    _poly         = _wpg.ShapeAt(i);
                    _poly.visible = true;
                    break;
                }
            }

            if (path == null)
            {
                _new_path       = true;
                _first_pass     = true;
                _path           = new Path();
                _path.visible   = true;
                _path.selected  = false;
                _build          = false;
                txtGridAlt.Text = Convert.ToString(_options.def_altitude);
                _build          = true;
            }
            else
            {
                _new_path      = false;
                _path          = path;
                _path.selected = false;
                _current_intid = path.internal_id;
                _build         = false;
                PolygonGridGUI gui = _path.polygridgui;
                txtPolyPathName.Text = gui.name;
                radioVideo.Checked   = gui.video;
                chkRectHome.Checked  = gui.startend;
                txtGridAlt.Text      = Convert.ToString(gui.altitude);
                txtHeading.Text      = Convert.ToString(gui.heading);
                _poly_intid          = gui.poly_internal_id;
                _poly         = _wpg.ShapeWithId(_poly_intid);
                _poly.visible = true;
                _build        = true;
            }
            BuildPolyGridPath();
        }