public CheckDataInput(IFeatureSet originalData, string field, string trans)
 {
     this._originalData = originalData;
     this.field = field;
     this.trans = trans;
 
 }

 /// <summary>
 /// Show the dialog to join an Excel table with a feature set.
 /// </summary>
 /// <param name="e"></param>
 public void ExcelJoin(IFeatureSet e)
 {
     using (var jd = new JoinDialog(e))
     {
         ShowDialog(jd);
     }
 }

 /// <summary>
 /// Creates a new instance of a GeoPointLayer without sending any status messages
 /// </summary>
 /// <param name="featureSet">The IFeatureLayer of data values to turn into a graphical GeoPointLayer</param>
 public MapPointLayer(IFeatureSet featureSet)
     : base(featureSet)
 {
     // this simply handles the default case where no status messages are requested
     Configure();
     OnFinishedLoading();
 }

        //when clicking "OK"
        private void btnOK_Click(object sender, EventArgs e)
        {
            queryResult = null;
            SpatiaLiteHelper slh = new SpatiaLiteHelper();
            queryResult = slh.ReadFeatureSet(connString, txtQuery.Text);

            dgQueryResult.DataSource = queryResult.DataTable;

            //SpatiaLiteHelper slh = new SpatiaLiteHelper();

            //foreach (DataGridViewRow r in dgGeometryColumns.Rows)
            //{
            //    if (r.Selected)
            //    {
            //        GeometryColumnInfo item = r.DataBoundItem as GeometryColumnInfo;
            //        if (item != null)
            //        {
            //            IFeatureSet fs = slh.ReadFeatureSet(connString, item);

            //            IMapFeatureLayer lay = mainMap.Layers.Add(fs);
            //            //lay.EditMode = false;

            //        }
            //    }
            //}
        }

 /// <summary>
 /// Generates an empty featureset that has the combined fields from this featureset
 /// and the specified featureset.
 /// </summary>
 /// <param name="self">This featureset</param>
 /// <param name="other">The other featureset to combine fields with.</param>
 /// <returns></returns>
 public static IFeatureSet CombinedFields(this IFeatureSet self, IFeatureSet other)
 {
     IFeatureSet result = new FeatureSet(self.FeatureType);
     Dictionary<string, DataColumn> resultColumns = new Dictionary<string, DataColumn>();
     foreach (DataColumn dc in self.DataTable.Columns)
     {
         string name = dc.ColumnName;
         int i = 1;
         while (resultColumns.ContainsKey(name))
         {
             name = dc.ColumnName + i;
             i++;
         }
         resultColumns.Add(name, dc);
     }
     foreach (DataColumn dc in other.DataTable.Columns)
     {
         string name = dc.ColumnName;
         int i = 1;
         while (resultColumns.ContainsKey(name))
         {
             name = dc.ColumnName + i;
             i++;
         }
         resultColumns.Add(name, dc);
     }
     foreach (KeyValuePair<string, DataColumn> pair in resultColumns)
     {
         result.DataTable.Columns.Add(new DataColumn(pair.Key, pair.Value.DataType));
     }
     return result;
 }

 public static IMapFeatureLayer Insert(this IMapLayerCollection collection, int index, IFeatureSet featureSet)
 {
     if (featureSet != null)
     {
         featureSet.ProgressHandler = collection.ProgressHandler;
         if ((featureSet.FeatureType == FeatureType.Point) || (featureSet.FeatureType == FeatureType.MultiPoint))
         {
             IMapPointLayer item = new MapPointLayer(featureSet);
             collection.Insert(index, item);
             item.ProgressHandler = collection.ProgressHandler;
             return item;
         }
         if (featureSet.FeatureType == FeatureType.Line)
         {
             IMapLineLayer layer2 = new MapLineLayer(featureSet);
             collection.Insert(index, layer2);
             layer2.ProgressHandler = collection.ProgressHandler;
             return layer2;
         }
         if (featureSet.FeatureType == FeatureType.Polygon)
         {
             IMapPolygonLayer layer3 = new MapPolygonLayer(featureSet);
             collection.Insert(index, layer3);
             layer3.ProgressHandler = collection.ProgressHandler;
             return layer3;
         }
     }
     return null;
 }

       public static IFeatureSet FeatureFromPoints(List<Kpoint> points, IFeatureSet refe)
        {
            foreach(Kpoint p in points)
               {
                }

            return refe;
        }

        private void Configure(IFeatureSet inFeatureSet)
        {
            if (inFeatureSet == null) throw new ArgumentNullException("inFeatureSet");
            if (inFeatureSet.FeatureType != FeatureType.Polygon) throw new PolygonFeatureTypeException();

            Symbology = new PolygonScheme();
            Symbology.SetParentItem(this);
        }

 /// <summary>
 ///
 /// </summary>
 /// <param name="featureSet"></param>
 /// <param name="inFilter"></param>
 /// <param name="activeType"></param>
 /// <param name="isReadOnly"></param>
 public FeatureSelection(IFeatureSet featureSet, IDrawingFilter inFilter, FilterType activeType, bool isReadOnly)
 {
     _filter = inFilter;
     _activeType = activeType;
     _isReadOnly = isReadOnly;
     _featureSet = featureSet;
     Configure();
 }

 private void Configure(IFeatureSet inFeatureSet)
 {
     if (inFeatureSet.FeatureType != FeatureType.Line)
     {
         throw new LineFeatureTypeException();
     }
     Symbology = new LineScheme();
 }

        /// <summary>
        /// Initializes a new instance of the IDW class
        /// </summary>
        /// <param name="shapeLayer">Shapefile type point</param>
        /// <param name="idField">Position of field that contains the Z value</param>
        public IDW(IFeatureSet shapeLayer, int idField) :
            base(shapeLayer, idField)
        {
            this.method = "IDW";

           // this.CreatePoints(shapeLayer, idField);
          //  this.CalculateDistances();
        }

        public SearchResultItem(string serviceCode, IFeatureSet featureSet)
        {
            if (serviceCode == null) throw new ArgumentNullException("serviceCode");
            if (featureSet == null) throw new ArgumentNullException("featureSet");
            Contract.EndContractBlock();

            ServiceCode = serviceCode;
            FeatureSet = featureSet;
        }

 /// <summary>
 /// Creates a new instance of Selection
 /// </summary>
 public Selection(IFeatureSet fs, IDrawingFilter inFilter):base(fs, inFilter, FilterTypes.Selection)
 {
     Selected = true;
     UseSelection = true;
     UseCategory = false;
     UseVisibility = false;
     UseChunks = false;
     SelectionMode = SelectionModes.IntersectsExtent;
 }

 public LocalTrend(IFeatureSet shapeLayer, int idField, int order) :
     base(shapeLayer, idField)
 {
     this.method = "LocalTrend";
     this.order = order;
     if (order >= 1 || order <= 3)
     {
         serie = SerieCoef(order);
     }
 }

 private void Configure(IFeatureSet inFeatureSet)
 {
     if (inFeatureSet.FeatureType != FeatureType.Polygon)
     {
         throw new PolygonFeatureTypeException();
     }
     PolygonScheme ps = new PolygonScheme();
     ps.SetParentItem(this);
     Symbology = ps;
 }

 public Trend(IFeatureSet shapeLayer, int idField, int order, double meanValue) :
       base(shapeLayer, idField)
 {
     this.method = "Trend";
     this.meanValue=meanValue;
     this.order = order;
     if (order>=1  || order <=3){
     serie = SerieCoef(order);
     GenerateMatrix(order, this.npoints, this.Kpoints);
     }
 }

        /// <summary>
        /// Calculates the unique colors as a scheme 
        /// </summary>
        /// <param name="fs">The featureset with the data Table definition</param>
        /// <param name="uniqueField">The unique field</param>
        public Hashtable GenerateUniqueColors(IFeatureSet fs, string uniqueField)
        {
            Hashtable result = new Hashtable(); // a hashtable of colors
            DataTable dt = fs.DataTable;
            ArrayList vals = new ArrayList();
            int i = 0;
            foreach (DataRow row in dt.Rows)
            {
                if (uniqueField != "FID")
                {

                    if (vals.Contains(row[uniqueField]) == false)
                    {
                        vals.Add(row[uniqueField]);
                    }
                }
                else
                {
                    vals.Add(i);
                    i++;
                }
            }
           
            Random rnd = new Random();
            foreach (object item in vals)
            {
                Color c = rnd.NextColor();
                while(result.ContainsKey(c))
                {
                   c = rnd.NextColor();
                }
                PolygonCategory cat = new PolygonCategory(c, c, 1);
                string flt = "[" + uniqueField + "] = ";
                if (uniqueField == "FID")
                {
                    flt += item;
                }
                else
                {
                    if (dt.Columns[uniqueField].DataType == typeof(string))
                    {
                        flt += "'" + item + "'";
                    }
                    else
                    {
                        flt += item.ToString();
                    }
                }
                cat.FilterExpression = flt;
                Categories.Add(cat);
                result.Add(c, item);
            }
            return result;
        }

 /// <summary>
 /// Initializes a new instance of the Kriging class
 /// </summary>
 /// <param name="shapeLayer">Shapefile type point</param>
 /// <param name="idField">Position of field that contains the Z value</param>
 public UniversalKriging(IFeatureSet shapeLayer, int idField) :
     base(shapeLayer, idField)
 {
     this.method = "Universal Kriging";
     var modelLineal = new ModelLineal
                           {
                               C0 = 0,
                               C1 = 1,
                               Range = 1
                           };
     // this.CreatePoints(shapeLayer, idField);
     this.CalculateDistances();
 }

 public RequestContext(IRequest request, IResponse response,
     ISessionStore sessionStore, IAuthenticator authenticator,
     IIoCContainer container, IFeatureSet features,
     Interceptors interceptors = null)
 {
     Request = request;
     Response = response;
     _sessionStore = sessionStore;
     _authenticator = authenticator;
     _container = new ContainerWrapper(container);
     Features = features;
     _interceptors = interceptors ?? new Interceptors();
 }

 /// <summary>
 /// The Voronoi Graph calculation creates a delaunay tesselation where
 /// each point is effectively converted into triangles.
 /// </summary>
 /// <param name="points">The points to use for creating the tesselation.</param>
 /// <returns>The generated line featureset.</returns>
 public static IFeatureSet DelaunayLines(IFeatureSet points)
 {
     double[] vertices = points.Vertex;
     VoronoiGraph gp = Fortune.ComputeVoronoiGraph(vertices);
     FeatureSet result = new FeatureSet();
     foreach (VoronoiEdge edge in gp.Edges)
     {
         Coordinate c1 = edge.RightData.ToCoordinate();
         Coordinate c2 = edge.LeftData.ToCoordinate();
         LineString ls = new LineString(new List<Coordinate> { c1, c2 });
         Feature f = new Feature(ls);
         result.AddFeature(f);
     }
     return result;
 }