private static DSMultiPoint FromMultiPoint(IMultiPoint geometry, DSGeometryFactory factory, bool setUserData)
        {
            var result = factory.CreateMultiPoint(FromCoordinates(geometry.Coordinates));

            if (setUserData)
            {
                result.UserData = geometry.UserData;
            }
            return(result);
        }
        /*
         * private static DSCoordinateSequence FromCoordinateSequence(ICoordinateSequence coordinateSequence, DSCoordinateSequenceFactory factory)
         * {
         *  var coordinates = ConvertCoordinates(coordinateSequence.ToCoordinateArray());
         *  return factory.Create(coordinates);
         * }
         */

        private static DSPoint FromPoint(IPoint geometry, DSGeometryFactory factory, bool setUserData)
        {
            var coord  = FromCoordinate(geometry.Coordinate);
            var result = factory.CreatePoint(coord);

            if (setUserData)
            {
                result.UserData = geometry.UserData;
            }
            return(result);
        }
        private static DSLineString FromLineString(ILineString geometry, DSGeometryFactory factory, bool setUserData)
        {
            var coordinates = FromCoordinates(geometry.Coordinates);
            var result      = (geometry is ILinearRing)
                             ? factory.CreateLinearRing(coordinates)
                             : factory.CreateLineString(coordinates);

            if (setUserData)
            {
                result.UserData = geometry.UserData;
            }
            return(result);
        }
        private static DSMultiPolygon FromMultiPolygon(IMultiPolygon geometry, DSGeometryFactory factory, bool setUserData)
        {
            var dsPolygons = new DotSpatial.Topology.IPolygon[geometry.NumGeometries];

            for (var i = 0; i < dsPolygons.Length; i++)
            {
                dsPolygons[i] = FromPolygon((IPolygon)geometry.GetGeometryN(i), factory, setUserData);
            }

            var result = factory.CreateMultiPolygon(dsPolygons);

            if (setUserData)
            {
                result.UserData = geometry.UserData;
            }
            return(result);
        }
        private static DSPolygon FromPolygon(IPolygon geometry, DSGeometryFactory factory, bool setUserData)
        {
            var shell = (DSLinearRing)FromLineString(geometry.Shell, factory, setUserData);

            DSLinearRing[] holes = null;
            if (geometry.Holes != null && geometry.Holes.Length > 0)
            {
                holes = new DSLinearRing[geometry.Holes.Length];
                for (var i = 0; i < holes.Length; i++)
                {
                    holes[i] = (DSLinearRing)FromLineString(geometry.Holes[i], factory, setUserData);
                }
            }
            var result = factory.CreatePolygon(shell, holes);

            if (setUserData)
            {
                result.UserData = geometry.UserData;
            }
            return(result);
        }
        private static DSGeometry FromGeometry(IGeometry geometry, DSGeometryFactory factory, bool setUserData)
        {
            if (geometry == null)
            {
                throw new ArgumentNullException("geometry");
            }

            if (factory == null)
            {
                throw new ArgumentNullException("factory");
            }

            switch (geometry.OgcGeometryType)
            {
            case OgcGeometryType.Point:
                return(FromPoint((IPoint)geometry, factory, setUserData));

            case OgcGeometryType.LineString:
                return(FromLineString((ILineString)geometry, factory, setUserData));

            case OgcGeometryType.Polygon:
                return(FromPolygon((IPolygon)geometry, factory, setUserData));

            case OgcGeometryType.MultiPoint:
                return(FromMultiPoint((IMultiPoint)geometry, factory, setUserData));

            case OgcGeometryType.MultiLineString:
                return(FromMultiLineString((IMultiLineString)geometry, factory, setUserData));

            case OgcGeometryType.MultiPolygon:
                return(FromMultiPolygon((IMultiPolygon)geometry, factory, setUserData));

            case OgcGeometryType.GeometryCollection:
                return(FromGeometryCollection((IGeometryCollection)geometry, factory, setUserData));

            default:
                throw new ArgumentException();
            }
        }
 private static DSMultiPoint FromMultiPoint(IMultiPoint geometry, DSGeometryFactory factory, bool setUserData)
 {
     var result = factory.CreateMultiPoint(FromCoordinates(geometry.Coordinates));
     if (setUserData)
         result.UserData = geometry.UserData;
     return result;
 }
        private static DSGeometry FromGeometry(IGeometry geometry, DSGeometryFactory factory, bool setUserData)
        {
            if (geometry == null)
                throw new ArgumentNullException("geometry");

            if (factory == null)
                throw new ArgumentNullException("factory");

            switch (geometry.OgcGeometryType)
            {
                case OgcGeometryType.Point:
                    return FromPoint((IPoint)geometry, factory, setUserData);
                case OgcGeometryType.LineString:
                    return FromLineString((ILineString)geometry, factory, setUserData);
                case OgcGeometryType.Polygon:
                    return FromPolygon((IPolygon)geometry, factory, setUserData);
                case OgcGeometryType.MultiPoint:
                    return FromMultiPoint((IMultiPoint)geometry, factory, setUserData);
                case OgcGeometryType.MultiLineString:
                    return FromMultiLineString((IMultiLineString)geometry, factory, setUserData);
                case OgcGeometryType.MultiPolygon:
                    return FromMultiPolygon((IMultiPolygon)geometry, factory, setUserData);
                case OgcGeometryType.GeometryCollection:
                    return FromGeometryCollection((IGeometryCollection)geometry, factory, setUserData);
                default:
                    throw new ArgumentException();
            }
        }
 /// <summary>
 /// Converts a <see cref="System.Collections.Generic.IList{IGeometry}"/> to a <see cref="System.Collections.Generic.IList{DSGeometry}"/>
 /// </summary>
 /// <param name="geometries">The <see cref="System.Collections.Generic.IList{IGeometry}"/> to convert</param>
 /// <param name="factory">The factory to create the <see cref="System.Collections.Generic.IList{DSGeometry}"/></param>
 /// <param name="setUserData">Sets the <see cref="DSGeometry.UserData"/> to <paramref name="geometries"/>.UserData</param>
 /// <returns>The converted geometry</returns>
 public static IList<DSGeometry> ToDotSpatial(this IList<IGeometry> geometries, DSGeometryFactory factory = null, bool setUserData = false)
 {
     var useFactory = factory ?? Default;
     return geometries.Select(geometry => FromGeometry(geometry, useFactory, setUserData)).ToList();
 }
        /// <summary>
        /// Converts a <see cref="System.Collections.Generic.IList{IGeometry}"/> to a <see cref="System.Collections.Generic.IList{DSGeometry}"/>
        /// </summary>
        /// <param name="geometries">The <see cref="System.Collections.Generic.IList{IGeometry}"/> to convert</param>
        /// <param name="factory">The factory to create the <see cref="System.Collections.Generic.IList{DSGeometry}"/></param>
        /// <param name="setUserData">Sets the <see cref="DSGeometry.UserData"/> to <paramref name="geometries"/>.UserData</param>
        /// <returns>The converted geometry</returns>
        public static IList <DSGeometry> ToDotSpatial(this IList <IGeometry> geometries, DSGeometryFactory factory = null, bool setUserData = false)
        {
            var useFactory = factory ?? Default;

            return(geometries.Select(geometry => FromGeometry(geometry, useFactory, setUserData)).ToList());
        }
 /// <summary>
 /// Converts a <see cref="IPoint"/> to a <see cref="DSPoint"/>
 /// </summary>
 /// <param name="geometry">The <see cref="IPoint"/> to convert</param>
 /// <param name="factory">The factory to create the <see cref="DSPoint"/></param>
 /// <param name="setUserData">Sets the <see cref="DSGeometry.UserData"/> to <paramref name="geometry"/>.UserData</param>
 /// <returns>The converted geometry</returns>
 public static DSPoint ToDotSpatial(this IPoint geometry, DSGeometryFactory factory = null, bool setUserData = false)
 {
     var useFactory = factory ?? Default;
     return FromPoint(geometry, useFactory, setUserData);
 }
        private static DSMultiPolygon FromMultiPolygon(IMultiPolygon geometry, DSGeometryFactory factory, bool setUserData)
        {
            var dsPolygons = new DotSpatial.Topology.IPolygon[geometry.NumGeometries];

            for (var i = 0; i < dsPolygons.Length; i++)
                dsPolygons[i] = FromPolygon((IPolygon)geometry.GetGeometryN(i), factory, setUserData);

            var result = factory.CreateMultiPolygon(dsPolygons);
            if (setUserData)
                result.UserData = geometry.UserData;
            return result;
        }
 private static DSPolygon FromPolygon(IPolygon geometry, DSGeometryFactory factory, bool setUserData)
 {
     var shell = (DSLinearRing)FromLineString(geometry.Shell, factory, setUserData);
     DSLinearRing[] holes = null;
     if (geometry.Holes != null && geometry.Holes.Length > 0)
     {
         holes = new DSLinearRing[geometry.Holes.Length];
         for (var i = 0; i < holes.Length; i++)
             holes[i] = (DSLinearRing)FromLineString(geometry.Holes[i], factory, setUserData);
     }
     var result = factory.CreatePolygon(shell, holes);
     if (setUserData)
         result.UserData = geometry.UserData;
     return result;
 }
        private static DSMultiLineString FromMultiLineString(IMultiLineString geometry, DSGeometryFactory factory, bool setUserData)
        {
            var dsLineStrings = new DotSpatial.Topology.IBasicLineString[geometry.NumGeometries];

            for (var i = 0; i < dsLineStrings.Length; i++)
            {
                dsLineStrings[i] = FromLineString((ILineString)geometry.GetGeometryN(i), factory, setUserData);
            }

            var result = factory.CreateMultiLineString(dsLineStrings);

            if (setUserData)
            {
                result.UserData = geometry.UserData;
            }
            return(result);
        }
        /*
        private static DSCoordinateSequence FromCoordinateSequence(ICoordinateSequence coordinateSequence, DSCoordinateSequenceFactory factory)
        {
            var coordinates = ConvertCoordinates(coordinateSequence.ToCoordinateArray());
            return factory.Create(coordinates);
        }
         */

        private static DSPoint FromPoint(IPoint geometry, DSGeometryFactory factory, bool setUserData)
        {
            var coord = FromCoordinate(geometry.Coordinate);
            var result = factory.CreatePoint(coord);
            if (setUserData)
                result.UserData = geometry.UserData;
            return result;
        }
        private static DSGeometryCollection FromGeometryCollection(IGeometryCollection geometry, DSGeometryFactory factory, bool setUserData)
        {
            var dsGeometries = new DotSpatial.Topology.IGeometry[geometry.NumGeometries];

            for (var i = 0; i < dsGeometries.Length; i++)
            {
                dsGeometries[i] = FromGeometry(geometry.GetGeometryN(i), factory, setUserData);
            }

            var result = factory.CreateGeometryCollection(dsGeometries);

            if (setUserData)
            {
                result.UserData = geometry.UserData;
            }
            return(result);
        }
 private static DSLineString FromLineString(ILineString geometry, DSGeometryFactory factory, bool setUserData)
 {
     var coordinates = FromCoordinates(geometry.Coordinates);
     var result = (geometry is ILinearRing)
                      ? factory.CreateLinearRing(coordinates)
                      : factory.CreateLineString(coordinates);
     if (setUserData)
         result.UserData = geometry.UserData;
     return result;
 }
        /// <summary>
        /// Converts a <see cref="IPoint"/> to a <see cref="DSPoint"/>
        /// </summary>
        /// <param name="geometry">The <see cref="IPoint"/> to convert</param>
        /// <param name="factory">The factory to create the <see cref="DSPoint"/></param>
        /// <param name="setUserData">Sets the <see cref="DSGeometry.UserData"/> to <paramref name="geometry"/>.UserData</param>
        /// <returns>The converted geometry</returns>
        public static DSPoint ToDotSpatial(this IPoint geometry, DSGeometryFactory factory = null, bool setUserData = false)
        {
            var useFactory = factory ?? Default;

            return(FromPoint(geometry, useFactory, setUserData));
        }
        private static DSMultiLineString FromMultiLineString(IMultiLineString geometry, DSGeometryFactory factory, bool setUserData)
        {
            var dsLineStrings = new DotSpatial.Topology.IBasicLineString[geometry.NumGeometries];

            for (var i = 0; i < dsLineStrings.Length; i++)
                dsLineStrings[i] = FromLineString((ILineString)geometry.GetGeometryN(i), factory, setUserData);

            var result = factory.CreateMultiLineString(dsLineStrings);
            if (setUserData)
                result.UserData = geometry.UserData;
            return result;
        }
        /// <summary>
        /// Converts a <see cref="ILinearRing"/> to a <see cref="DSLinearRing"/>
        /// </summary>
        /// <param name="geometry">The <see cref="ILinearRing"/> to convert</param>
        /// <param name="factory">The factory to create the <see cref="DSLinearRing"/></param>
        /// <param name="setUserData">Sets the <see cref="DSGeometry.UserData"/> to <paramref name="geometry"/>.UserData</param>
        /// <returns>The converted geometry</returns>
        public static DSLinearRing ToDotSpatial(this ILinearRing geometry, DSGeometryFactory factory = null, bool setUserData = false)
        {
            var useFactory = factory ?? Default;

            return((DSLinearRing)FromLineString(geometry, useFactory, setUserData));
        }
        private static DSGeometryCollection FromGeometryCollection(IGeometryCollection geometry, DSGeometryFactory factory, bool setUserData)
        {
            var dsGeometries = new DotSpatial.Topology.IGeometry[geometry.NumGeometries];

            for (var i = 0; i < dsGeometries.Length; i++)
                dsGeometries[i] = FromGeometry(geometry.GetGeometryN(i), factory, setUserData);

            var result = factory.CreateGeometryCollection(dsGeometries);
            if (setUserData)
                result.UserData = geometry.UserData;
            return result;
        }
 /// <summary>
 /// Converts a <see cref="IGeometryCollection"/> to a <see cref="DSGeometryCollection"/>
 /// </summary>
 /// <param name="geometry">The <see cref="IGeometryCollection"/> to convert</param>
 /// <param name="factory">The factory to create the <see cref="DSGeometryCollection"/></param>
 /// <param name="setUserData">Sets the <see cref="DSGeometry.UserData"/> to <paramref name="geometry"/>.UserData</param>
 /// <returns>The converted geometry</returns>
 public static DSGeometryCollection ToDotSpatial(this IGeometryCollection geometry, DSGeometryFactory factory = null, bool setUserData = false)
 {
     var useFactory = factory ?? Default;
     return FromGeometryCollection(geometry, useFactory, setUserData);
 }
 /// <summary>
 /// Converts a <see cref="ILinearRing"/> to a <see cref="DSLinearRing"/>
 /// </summary>
 /// <param name="geometry">The <see cref="ILinearRing"/> to convert</param>
 /// <param name="factory">The factory to create the <see cref="DSLinearRing"/></param>
 /// <param name="setUserData">Sets the <see cref="DSGeometry.UserData"/> to <paramref name="geometry"/>.UserData</param>
 /// <returns>The converted geometry</returns>
 public static DSLinearRing ToDotSpatial(this ILinearRing geometry, DSGeometryFactory factory = null, bool setUserData = false)
 {
     var useFactory = factory ?? Default;
     return (DSLinearRing)FromLineString(geometry, useFactory, setUserData);
 }
        /// <summary>
        /// Converts a <see cref="IGeometryCollection"/> to a <see cref="DSGeometryCollection"/>
        /// </summary>
        /// <param name="geometry">The <see cref="IGeometryCollection"/> to convert</param>
        /// <param name="factory">The factory to create the <see cref="DSGeometryCollection"/></param>
        /// <param name="setUserData">Sets the <see cref="DSGeometry.UserData"/> to <paramref name="geometry"/>.UserData</param>
        /// <returns>The converted geometry</returns>
        public static DSGeometryCollection ToDotSpatial(this IGeometryCollection geometry, DSGeometryFactory factory = null, bool setUserData = false)
        {
            var useFactory = factory ?? Default;

            return(FromGeometryCollection(geometry, useFactory, setUserData));
        }