/// <summary>
 /// Constructor
 /// </summary>
 /// <param name="markertype">The marker type.</param>
 /// <param name="size">The marker size.</param>
 /// <param name="pen">The marker Pen.</param>
 public Marker( MarkerType markertype, int size, Pen pen )
 {
     markerType_ = markertype;
     Size = size;
     Pen = pen;
     filled_ = false;
 }

 public TileData(bool isTileImportant, Color colour, MarkerType hasMarker = MarkerType.Unknown)
 {
     this.isImportant = isTileImportant;
     this.colour = colour;
     this.drawMarker = false;
     this.markerType = hasMarker;
 }

        private static ScatterSeries CreateRandomScatterSeries(int n, MarkerType markerType, bool setSize, bool setValue, LinearColorAxis colorAxis)
        {
            var s1 = new ScatterSeries
            {
                MarkerType = markerType,
                MarkerSize = 6,
                ColorAxisKey = colorAxis != null ? colorAxis.Key : "nix"
            };
            var random = new Random(13);
            for (int i = 0; i < n; i++)
            {
                var p = new ScatterPoint((random.NextDouble() * 2.2) - 1.1, random.NextDouble());
                if (setSize)
                {
                    p.Size = (random.NextDouble() * 5) + 5;
                }

                if (setValue)
                {
                    p.Value = (random.NextDouble() * 2.2) - 1.1;
                }

                s1.Points.Add(p);
            }

            return s1;
        }

 public TokenMarker(int id, Vector2 postion, TouchState state, MarkerType type)
 {
     this._id = id;
     this._position = postion;
     this._state = state;
     this._type = type;
 }

        protected string GetMarkerImage(MarkerType markerType)
        {
            var rawUri = WebConfigurationManager.AppSettings["RawUri"];
            string imagePath;

            switch (markerType)
            {
                case MarkerType.Bus:
                    imagePath = WebConfigurationManager.AppSettings["BusMarkerImagePath"];
                    break;
                case MarkerType.RideOffer:
                    imagePath = WebConfigurationManager.AppSettings["RideOfferMarkerImagePath"];
                    break;
                case MarkerType.RideRequest:
                    imagePath = WebConfigurationManager.AppSettings["RideRequestMarkerImagePath"];
                    break;
                case MarkerType.Help:
                    imagePath = WebConfigurationManager.AppSettings["HelpMarkerImagePath"];
                    break;
                default:
                    imagePath = string.Empty;
                    break;
            }

            var uri = string.Format("{0}{1}", rawUri, imagePath);
            return new Uri(uri).AbsoluteUri;
        }

 public Vector3 Thrust(MarkerType reference)
 {
     Vector3 thrust, torque;
     GameObject marker = RCSBuildAid.GetMarker(reference);
     calcMarkerForces (marker.transform, out thrust, out torque);
     return thrust;
 }

		public TileData()
		{
			this.isImportant = false;
			this.color = Color.Magenta;
            this.officialColor = Color.Magenta;
            this.transparent = false;
			this.markerType = MarkerType.Unknown;
		}

 // Constructor for new Waypoint Generation
 public Waypoint(Point p, MarkerType marker, IslandType island)
 {
     this.Location = Coordinates.FromPoint(p);
     this.Island = island;
     this.Marker = marker;
     this.Name = string.Empty;
     this.Notes = String.Empty;
 }

 private void CloseMarker(MarkerType type, int position)
 {
     if (!IsMarkerOpened(type))
         throw new Exception("Trying to close closed marker");
     var marker = openedMarkers[type];
     markers.Add(new Marker(marker.LInclusive, position, marker.Type));
     openedMarkers.Remove(type);
 }

 private static PlotModel CreateRandomScatterSeriesWithColorAxisPlotModel(int n, OxyPalette palette, MarkerType markerType, AxisPosition colorAxisPosition, OxyColor highColor, OxyColor lowColor)
 {
     var model = new PlotModel { Title = string.Format("ScatterSeries (n={0})", n), Background = OxyColors.LightGray };
     var colorAxis = new LinearColorAxis { Position = colorAxisPosition, Palette = palette, Minimum = -1, Maximum = 1, HighColor = highColor, LowColor = lowColor };
     model.Axes.Add(colorAxis);
     model.Series.Add(CreateRandomScatterSeries(n, markerType, false, true, colorAxis));
     return model;
 }

        public Stamp AddStamp(MarkerType m, int size, Point p)
        {
            if (m == MarkerType.None || HasStamp(p))
                return null;

            Stamp stamp = new Stamp(p, size, m);
            stamps.Add(stamp);
            return stamp;
        }

 public EntityMarker(BankEntity entity, IconType iconType)
 {
     this.Entity = entity;
     this.MarkerOptions = new MarkerOptions ();
     this.MarkerOptions.SetTitle (entity.Description());
     this.MarkerOptions.SetPosition (new LatLng(entity.Latitude, entity.Longitude));
     this.Type = MarkerType.Regular;
     IconType = iconType;
 }

        public Waypoint AddWaypoint(IslandType i, MarkerType m, Point p)
        {
            if (i == IslandType.None && m == MarkerType.None || waypoints.Exists(x => x.GetLocation() == p))
                return null;

            Waypoint wp = new Waypoint(p, m, i);
            waypoints.Add(wp);
            return wp;
        }

 public Marker(MarkerType markertype, Vector3 position, Color color, AnimationType type)
 {
     this.markertype = markertype;
     this.position = position;
     this.color = color;
     this.type = type;
     this.scale = Default_Scale;
     _time = 0;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="Marker"/> class.
        /// </summary>
        /// <param name="offset">The offset of the marked region.</param>
        /// <param name="length">The length of the marked region.</param>
        /// <param name="markerType">Type of the text marker.</param>
        /// <param name="color">The color of the text marker.</param>
        public Marker(int offset, int length, MarkerType markerType, Color color)
        {
            if (length < 1)
            length = 1;

              _offset = offset;
              _length = length;
              _markerType = markerType;
              _color = color;
        }

 public static void ActivateMarkerOnMouse(MarkerType markerType)
 {
     if (CachedDidHit) {
         PlayerManager.OrderMarker.PlayOneShot (CachedHit.point, CachedHit.normal, markerType);
         return;
     }
     Vector3 hitPoint = CachedRay.origin - CachedRay.direction * (CachedRay.origin.y / CachedRay .direction.y);
     if (PlayerManager.OrderMarker != null)
     PlayerManager.OrderMarker.PlayOneShot (hitPoint, Vector3.up, markerType);
 }

      public Marker(PointLatLng pos, MarkerType type, MarkerColor color)
      {
         this.Position = pos;
         this.Type = type;
         this.Color = color;
         this.Text = string.Empty;
         this.TooltipMode = MarkerTooltipMode.OnMouseOver;
         this.Visible = true;
         this.CustomMarkerAlign = CustomMarkerAlign.MiddleMiddle;
         this.CustomMarkerCenter = Point.Empty;

         this.IsMouseOver = false;
         this.ToolTipOffset = new Point(14, -44);
      }

        public static void LoadConfig ()
        {
            configAbsolutePath = Path.Combine (KSPUtil.ApplicationRootPath, configPath);
            settings = ConfigNode.Load (configAbsolutePath) ?? new ConfigNode ();

            com_reference = (MarkerType)GetValue ("com_reference", (int)MarkerType.CoM);
            plugin_mode = (PluginMode)GetValue ("plugin_mode", (int)PluginMode.RCS);
            direction = (Direction)GetValue ("direction", (int)Direction.right);

            menu_vessel_mass = GetValue ("menu_vessel_mass", false);
            menu_res_mass    = GetValue ("menu_res_mass"   , false);
            marker_scale     = GetValue ("marker_scale"    , 1f   );
            include_rcs      = GetValue ("include_rcs"     , true );
            include_wheels   = GetValue ("include_wheels"  , false);
            eng_include_rcs  = GetValue ("eng_include_rcs" , false);
            resource_amount  = GetValue ("resource_amount" , false);
            use_dry_mass     = GetValue ("use_dry_mass"    , true );
            show_marker_com  = GetValue ("show_marker_com" , true );
            show_marker_dcom = GetValue ("show_marker_dcom", true );
            show_marker_acom = GetValue ("show_marker_acom", false);
            marker_autoscale = GetValue ("marker_autoscale", true );
            menu_minimized   = GetValue ("menu_minimized"  , false);
            applauncher      = GetValue ("applauncher"     , true );
            action_screen    = GetValue ("action_screen"   , false);
            toolbar_plugin   = GetValue ("toolbar_plugin"  , true );
            window_x         = GetValue ("window_x"        , 280  );
            window_y         = GetValue ("window_y"        , 114  );

            /* for these resources, set some defaults */
            resource_cfg ["LiquidFuel"] = GetValue (resourceKey ("LiquidFuel"), false);
            resource_cfg ["Oxidizer"]   = GetValue (resourceKey ("Oxidizer")  , false);
            resource_cfg ["SolidFuel"]  = GetValue (resourceKey ("SolidFuel") , false);
            resource_cfg ["XenonGas"]   = GetValue (resourceKey ("XenonGas")  , true );
            resource_cfg ["IntakeAir"]  = GetValue (resourceKey ("IntakeAir") , true );
            resource_cfg ["Ablator"]    = GetValue (resourceKey ("Ablator")   , true );
            resource_cfg ["Ore"]        = GetValue (resourceKey ("Ore")       , false );
            resource_cfg ["MonoPropellant"] = GetValue (resourceKey ("MonoPropellant"), true);

            string bodyname = GetValue ("selected_body", "Kerbin");
            selected_body = PSystemManager.Instance.localBodies.Find (b => b.name == bodyname);
            if (selected_body == null) {
                /* can happen in a corrupted settings.cfg */
                selected_body = Planetarium.fetch.Home;
            }

            Events.ConfigSaving += SaveConfig;
        }

    private static string[] ReadDataSetTrackerName(MarkerType markerType)
    {
        string[] result = new string[2];
        string datasetPath;
        if (markerType == MarkerType.IMAGE)
        {
            datasetPath = IMAGE_DATASET_PATH;
        }
        else
        {
            datasetPath = OBJECT_DATASET_PATH;
        }

        //Get DataSet name
        string[] tempArray = Directory.GetDirectories(Application.dataPath + datasetPath );
        
        if (tempArray.Length == 0)
        {
            EditorApplication.Exit(INVALID_PACKAGE_ERROR_CODE);
        }

        result[0] = Path.GetFileName(tempArray[0]);
        string temp = tempArray[0];
        

        //Get target Name
        tempArray = Directory.GetFiles(temp);
        if (tempArray.Length == 0)
        {
            EditorApplication.Exit(INVALID_PACKAGE_ERROR_CODE);
        }
        temp = Path.GetFileNameWithoutExtension(tempArray[0]);
        
      
        if (temp.Substring(temp.Length - 7, 7).Equals("_scaled"))
        {
            temp = temp.Substring(0, temp.Length-7);
        }

        result[1] = temp;

        return result;
    }

        public static PlotModel CreateRandomScatterSeriesWithColorAxisPlotModel(int n, OxyPalette palette, MarkerType markerType = MarkerType.Square, AxisPosition colorAxisPosition = AxisPosition.Right, OxyColor highColor = null, OxyColor lowColor = null)
        {
            var model = new PlotModel(string.Format("ScatterSeries (n={0})", n)) { Background = OxyColors.LightGray };
            model.Axes.Add(new ColorAxis { Position = colorAxisPosition, Palette = palette, Minimum = -1, Maximum = 1, HighColor = highColor, LowColor = lowColor });

            var s1 = new ScatterSeries
            {
                MarkerType = markerType,
                MarkerSize = 6,
            };
            var random = new Random();
            for (int i = 0; i < n; i++)
            {
                double x = random.NextDouble() * 2.2 - 1.1;
                s1.Points.Add(new ScatterPoint(x, random.NextDouble()) { Value = x });
            }

            model.Series.Add(s1);
            return model;
        }