protected override void Load(ContainerBuilder builder)
        {
            base.Load(builder);

            // register route processors
            builder.RegisterAssemblyTypes(typeof(IRouteProcessor).Assembly)
            .Where(t => typeof(IRouteProcessor).IsAssignableFrom(t) &&
                   !t.IsAbstract &&
                   t.GetConstructors().Any() &&
                   GeoExtensions.GetTargetType <RouteProcessorAttribute>(t) != null)
            .Keyed <IRouteProcessor>(t => t.GetCustomAttribute <RouteProcessorAttribute>() !.Type)
            .AsImplementedInterfaces()
            .SingleInstance();

            // register exporters
            builder.RegisterAssemblyTypes(typeof(IRouteProcessor).Assembly)
            .Where(t => typeof(IExporter).IsAssignableFrom(t) &&
                   !t.IsAbstract &&
                   t.GetConstructors().Any() &&
                   GeoExtensions.GetTargetType <ExporterAttribute>(t) != null)
            .Keyed <IExporter>(t => t.GetCustomAttribute <ExporterAttribute>() !.Type)
            .AsImplementedInterfaces()
            .SingleInstance();

            // register importers
            builder.RegisterAssemblyTypes(typeof(IRouteProcessor).Assembly)
            .Where(t => typeof(IImporter).IsAssignableFrom(t) &&
                   !t.IsAbstract &&
                   t.GetConstructors().Any() &&
                   GeoExtensions.GetTargetType <ImporterAttribute>(t) != null)
            .Keyed <IImporter>(t => t.GetCustomAttribute <ImporterAttribute>() !.Type)
            .AsImplementedInterfaces()
            .SingleInstance();
        }
Пример #2
0
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
        protected override async Task <List <Coordinate>?> ExecuteRequestAsync(
#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
            List <Coordinate> coordinates,
            CancellationToken cancellationToken)
        {
            var retVal = new List <Coordinate>();

            switch (coordinates.Count)
            {
            case 0:
                return(retVal);

            case 1:
                retVal.Add(coordinates[0]);

                return(retVal);

            default:
                retVal.Add(coordinates[0]);

                break;
            }

            var curStartingIdx     = 0;
            var ptsSinceLastReport = 0;

            for (var idx = 1; idx < coordinates.Count; idx++)
            {
                if (cancellationToken.IsCancellationRequested)
                {
                    return(null);
                }

                ptsSinceLastReport++;

                if (ptsSinceLastReport >= ReportingInterval)
                {
                    OnReportingInterval(ptsSinceLastReport);
                    ptsSinceLastReport -= ReportingInterval;
                }

                var mostRecentDistance = GeoExtensions
                                         .GetDistance(coordinates[idx - 1], coordinates[idx]);

                var distanceFromOrigin = GeoExtensions
                                         .GetDistance(coordinates[curStartingIdx], coordinates[idx]);

                if (mostRecentDistance <= Configuration.MaxSeparation &&
                    distanceFromOrigin <= Configuration.MaxDistanceMultiplier * Configuration.MaxSeparation)
                {
                    continue;
                }

                retVal.Add(coordinates[idx]);
                curStartingIdx = idx;
            }

            return(retVal);
        }
        private List <Coordinate> InterpolatePoints(LinkedList <Coordinate> nodes)
        {
            var retVal = new List <Coordinate>();

            Coordinate?prevPt = null;

            foreach (var curPt in nodes)
            {
                if (prevPt == null)
                {
                    retVal.Add(curPt);
                    prevPt = curPt;

                    continue;
                }

                var distance = GeoExtensions.GetDistance(prevPt, curPt);

                if (distance <= Configuration.MaxSeparation)
                {
                    retVal.Add(curPt);
                    prevPt = curPt;

                    continue;
                }

                // interpolate
                var numPtsNeeded = Convert.ToInt32(
                    Math.Ceiling(distance.GetValue(Configuration.MaxSeparation.Unit) /
                                 Configuration.MaxSeparation.OriginalValue));

                var deltaLat  = (curPt.Latitude - prevPt.Latitude) / numPtsNeeded;
                var deltaLong = (curPt.Longitude - prevPt.Longitude) / numPtsNeeded;

                for (var idx = 0; idx < numPtsNeeded; idx++)
                {
                    retVal.Add(new Coordinate
                    {
                        Latitude  = prevPt.Latitude + (idx + 1) * deltaLat,
                        Longitude = prevPt.Longitude + (idx + 1) * deltaLong
                    });
                }

                prevPt = curPt;
            }

            return(retVal);
        }