public List <WebGridCellFeatureStatistics> GetGridFeatureStatistics(WebClientInformation clientInformation,
                                                                     WebFeatureStatisticsSpecification featureStatisticsSpecification,
                                                                     String featuresUrl,
                                                                     String featureCollectionJson,
                                                                     WebGridSpecification gridSpecification,
                                                                     WebCoordinateSystem coordinateSystem)
 {
     using (WebServiceContext context = GetWebServiceContext(clientInformation))
     {
         try
         {
             var featuresUri = string.IsNullOrEmpty(featuresUrl) ? null : new Uri(featuresUrl);
             return(AnalysisManager.GetGridCellFeatureStatistics(context,
                                                                 featuresUri,
                                                                 featureCollectionJson,
                                                                 gridSpecification,
                                                                 coordinateSystem));
         }
         catch (Exception exception)
         {
             WebServiceData.LogManager.LogError(context, exception);
             throw;
         }
     }
 }
        public void GetGridCellFeatureStatisticsWithCompleteUrlTestAndTransformCoordinates()
        {
            // Test accuracy
            String featuresUrl;
            WebCoordinateSystem coordinateSystem;
            WebFeatureStatisticsSpecification featureStatisticsSpecification;
            WebGridSpecification gridSpecification;

            gridSpecification = new WebGridSpecification();
            coordinateSystem  = new WebCoordinateSystem();
            featureStatisticsSpecification = new WebFeatureStatisticsSpecification();

            gridSpecification.BoundingBox     = new WebBoundingBox();
            gridSpecification.BoundingBox.Max = new WebPoint();
            gridSpecification.BoundingBox.Min = new WebPoint();

            gridSpecification.GridCellSize            = 1000;
            gridSpecification.GridCoordinateSystem    = GridCoordinateSystem.SWEREF99_TM;
            gridSpecification.IsGridCellSizeSpecified = true;
            gridSpecification.GridCellGeometryType    = GridCellGeometryType.Polygon;

            //Set returning coordinate system to something different to test the transformations
            coordinateSystem.Id = CoordinateSystemId.GoogleMercator;

            featuresUrl =
                "http://slwgeo.artdata.slu.se:8080/geoserver/wfs?&service=wfs&request=GetFeature&version=1.1.0&typeName=SLW:MapOfSwedishCounties&srsName=EPSG:3006";
            //&srs=3006";

            //IList<WebGridCellFeatureStatistics> gridCellFeatureStatistics =
            //                 AnalysisManager.GetGridCellFeatureStatistics(Context, featureStatistics, featuresUrl, //typeName,
            //                                                          gridSpecification, coordinateSystem //,isCompleteUrl
            //                                                          );

            IList <WebGridCellFeatureStatistics> gridCellFeatureStatistics =
                WebServiceProxy.AnalysisService.GetGridCellFeatureStatistics(GetClientInformation(),
                                                                             featureStatisticsSpecification,
                                                                             featuresUrl,
                                                                             null,
                                                                             gridSpecification,
                                                                             coordinateSystem);

            double y1 = gridCellFeatureStatistics[0].BoundingBox.LinearRings[0].Points[0].Y;
            double y2 = gridCellFeatureStatistics[0].BoundingBox.LinearRings[0].Points[2].Y;
            double y3 = y1 + ((y2 - y1) / 2); //371
            double y4 = gridCellFeatureStatistics[1].CentreCoordinate.Y;

            Assert.IsTrue(gridCellFeatureStatistics.Count > 0);
            Assert.IsTrue(gridCellFeatureStatistics.Count.Equals(100));

            // Assert.IsTrue(y4.Equals(y3));
        }
 /// <summary>
 /// Gets the grid cell feature statistics combined with species observation counts.
 /// </summary>
 /// <param name="clientInformation">Client information.</param>
 /// <param name="gridSpecification">The grid specification: bounding box, grid cell size, etc.</param>
 /// <param name="searchCriteria">The species observation search criteria.</param>
 /// <param name="featureStatisticsSpecification">Information about requested information from a web feature service.</param>
 /// <param name="featuresUrl">Address to data in a web feature service.</param>
 /// <param name="featureCollectionJson">Feature collection json.</param>
 /// <param name="coordinateSystem">Coordinate system used in returned grid.</param>
 /// <returns>A list with combined result from GetGridSpeciesCounts() and GetGridCellFeatureStatistics().</returns>
 public List <WebGridCellCombinedStatistics> GetGridCellFeatureStatisticsCombinedWithSpeciesObservationCounts(
     WebClientInformation clientInformation,
     WebGridSpecification gridSpecification,
     WebSpeciesObservationSearchCriteria searchCriteria,
     WebFeatureStatisticsSpecification featureStatisticsSpecification,
     String featuresUrl,
     String featureCollectionJson,
     WebCoordinateSystem coordinateSystem)
 {
     using (ClientProxy client = new ClientProxy(this, 20))
     {
         return(client.Client.GetGridCellFeatureStatisticsCombinedWithSpeciesObservationCounts(
                    clientInformation, gridSpecification, searchCriteria, featureStatisticsSpecification, featuresUrl, featureCollectionJson, coordinateSystem));
     }
 }
        public void GetGridCellFeatureStatisticsWithCompleteUrlTest()
        {
            // Test accuracy
            String featuresUrl;
            WebCoordinateSystem coordinateSystem;

            WebFeatureStatisticsSpecification featureStatistics;
            WebGridSpecification gridSpecification;

            gridSpecification = new WebGridSpecification();
            coordinateSystem  = new WebCoordinateSystem();
            featureStatistics = new WebFeatureStatisticsSpecification();



            gridSpecification.BoundingBox     = new WebBoundingBox();
            gridSpecification.BoundingBox.Max = new WebPoint();
            gridSpecification.BoundingBox.Min = new WebPoint();

            //Defined in RT90, X=Northing, Y=Easting
            //This bounding box is parsed and extracted from the url?

            gridSpecification.BoundingBox.Max.Y = 1489104;
            gridSpecification.BoundingBox.Max.X = 6858363;
            gridSpecification.BoundingBox.Min.Y = 1400000;
            gridSpecification.BoundingBox.Min.X = 6800000;

            gridSpecification.GridCellSize            = 100000;
            gridSpecification.GridCoordinateSystem    = GridCoordinateSystem.Rt90_25_gon_v;
            gridSpecification.IsGridCellSizeSpecified = true;
            gridSpecification.GridCellGeometryType    = GridCellGeometryType.Polygon;
            coordinateSystem.Id = CoordinateSystemId.Rt90_25_gon_v;

            featuresUrl = "http://slwgeo.artdata.slu.se:8080/geoserver/wfs?&service=wfs&request=GetFeature&version=1.1.0&typeName=SLW:MapOfSwedishCounties&srsName=EPSG:3021";

            IList <WebGridCellFeatureStatistics> gridCellFeatureStatistics =
                WebServiceProxy.AnalysisService.GetGridCellFeatureStatistics(GetClientInformation(), featureStatistics, featuresUrl, null,                //typeName,
                                                                             gridSpecification, coordinateSystem);


            Assert.IsTrue(gridCellFeatureStatistics.Count > 0);
            Assert.IsTrue(gridCellFeatureStatistics.Count.Equals(4));
            Assert.IsTrue(gridCellFeatureStatistics[0].BoundingBox.LinearRings[0].Points[0].Y.Equals(1400000));
            Assert.IsTrue(gridCellFeatureStatistics[3].BoundingBox.LinearRings[0].Points[2].X.Equals(7000000));
        }
 /// <summary>
 /// Get information about spatial features in a grid representation inside a user supplied bounding box.
 /// </summary>
 /// /// <param name="clientInformation">Information about the client that makes this web service call.</param>
 /// <param name="featureStatisticsSpecification">Information about what statistics are requested from a web feature
 /// service and wich spatial feature type that is to be measured</param>
 /// <param name="featuresUrl">Resource address.</param>
 /// <param name="featureCollectionJson">Feature collection as json string.</param>
 /// <param name="gridSpecification">Specifications of requested grid cell size, requested coordinate system
 /// and user supplied bounding box.</param>
 /// <param name="coordinateSystem">Coordinate system used in geometry search criteria.</param>
 /// <returns>Statistical measurements on spatial features in grid format.</returns>
 public List <WebGridCellFeatureStatistics> GetGridCellFeatureStatistics(WebClientInformation clientInformation,
                                                                         WebFeatureStatisticsSpecification
                                                                         featureStatisticsSpecification,
                                                                         String featuresUrl,
                                                                         String featureCollectionJson,
                                                                         //WfsTypeName typeName,
                                                                         WebGridSpecification gridSpecification,
                                                                         WebCoordinateSystem coordinateSystem)
 {
     using (ClientProxy client = new ClientProxy(this, 20))
     {
         return(client.Client.GetGridFeatureStatistics(clientInformation, featureStatisticsSpecification,
                                                       featuresUrl,
                                                       featureCollectionJson,
                                                       gridSpecification,
                                                       coordinateSystem));
     }
 }
 /// <summary>
 /// Gets the grid cell feature statistics combined with species observation counts.
 /// </summary>
 /// <param name="clientInformation">Client information.</param>
 /// <param name="gridSpecification">The grid specification: bounding box, grid cell size, etc.</param>
 /// <param name="searchCriteria">The species observation search criteria.</param>
 /// <param name="featureStatisticsSpecification">Information about requested information from a web feature service.</param>
 /// <param name="featuresUrl">Address to data in a web feature service.</param>
 /// <param name="featureCollectionJson">Feature collecation as json.</param>
 /// <param name="coordinateSystem">Coordinate system used in returned grid.</param>
 /// <returns>A list with combined result from GetGridSpeciesCounts() and GetGridCellFeatureStatistics().</returns>
 public List <WebGridCellCombinedStatistics> GetGridCellFeatureStatisticsCombinedWithSpeciesObservationCounts(
     WebClientInformation clientInformation,
     WebGridSpecification gridSpecification,
     WebSpeciesObservationSearchCriteria searchCriteria,
     WebFeatureStatisticsSpecification featureStatisticsSpecification,
     String featuresUrl,
     String featureCollectionJson,
     WebCoordinateSystem coordinateSystem)
 {
     using (WebServiceContext context = GetWebServiceContext(clientInformation))
     {
         try
         {
             if (SpeciesObservationConfiguration.IsElasticsearchUsed)
             {
                 return(AnalysisManager.GetGridCellFeatureStatisticsCombinedWithSpeciesObservationCountsElasticsearch(context,
                                                                                                                      searchCriteria,
                                                                                                                      gridSpecification,
                                                                                                                      coordinateSystem,
                                                                                                                      featuresUrl,
                                                                                                                      featureCollectionJson));
             }
             else
             {
                 return(AnalysisManager.GetGridCellFeatureStatisticsCombinedWithSpeciesObservationCounts(context,
                                                                                                         searchCriteria,
                                                                                                         gridSpecification,
                                                                                                         coordinateSystem,
                                                                                                         featuresUrl,
                                                                                                         featureCollectionJson));
             }
         }
         catch (Exception exception)
         {
             WebServiceData.LogManager.LogError(context, exception);
             throw;
         }
     }
 }