空间分析

支持空间分析，如数据集（几何对象）缓冲区分析、数据集（几何对象）叠加分析、数据集（几何对象）邻近分析、动态分段分析、空间关系分析、插值分析、表面分析（提取等值线、提取等值面）、路由对象的定位及M值的计算。分析结果的获取及展示可在主线程和监听器类中两种方式来实现。

数据集缓冲区分析。点、线和面数据集支持圆头缓存，线数据集暂不支持平头缓冲。下面示例为线数据集进行左右半径不一致、生成结果数据集的圆头缓冲分析，分析结果在主线程中进行获取及展示。

    // 缓冲区分析结果
    public DatasetBufferAnalystResult result;
    public void DatasetBufferAnalyst() throws InterruptedException, ExecutionException {
        // 构造分析参数
        DatasetBufferAnalystParameters parameters = new DatasetBufferAnalystParameters();
        parameters.dataset = "Bounds@Interpolation";
        // 设置分析结果参数
        DataReturnOption resultSet = new DataReturnOption();
        resultSet.dataReturnMode = DataReturnMode.DATASET_ONLY;
        resultSet.dataset = "Result_LineBuffer";
        resultSet.deleteExistResultDataset = true;
        parameters.resultSetting = resultSet;
        // 设置缓冲区分析参数：缓冲端点类型、缓冲半径
        BufferSetting bufferSet = new BufferSetting();
        bufferSet.endType = BufferEndType.ROUND;
        BufferDistance buffervalue = new BufferDistance();
        buffervalue.value = 100;
        BufferDistance buffervalue2 = new BufferDistance();
        buffervalue2.expression = "SMUSERID*2";
        bufferSet.leftDistance = buffervalue;
        bufferSet.rightDistance = buffervalue2;
        parameters.buffersetting = bufferSet;
        DatasetBufferAnalystService service = new DatasetBufferAnalystService(
                "http://MyServerIP:8090/iserver/services/spatialanalyst-sample/restjsr/spatialanalyst");
        MyDatasetBufferAnalystEventListener listener = new MyDatasetBufferAnalystEventListener();
        // 和服务端异步通讯
        service.process(parameters, listener);
        // 等待监听器执行完毕
        try {
            listener.waitUntilProcessed();
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 结果验证：分析成功，返回分析结果的数据集标识
        assertTrue("Analyst is not succeed", result.succeed);       
        assertEquals("The dataset of result", "Result_LineBuffer@Interpolation", result.dataset);      
    }
    // 监听器类
    class MyDatasetBufferAnalystEventListener extends DatasetBufferAnalystEventListener {
        @Override
        public void onDatasetBufferAnalystStatusChanged(Object sourceObject, EventStatus status) {
            // 返回结果
            result = (DatasetBufferAnalystResult) sourceObject;
        }
    }

数据集叠加分析。下面示例为面数据集和面数据集的求交分析，分析结果在监听器中进行获取及展示。

    // 叠加分析结果
    public DatasetOverlayAnalystResult result;
    public void DatasetOverlayAnalyst() throws InterruptedException, ExecutionException {
        // 设置叠加分析参数
        DatasetOverlayAnalystParameters parameters = new DatasetOverlayAnalystParameters();
        parameters.sourceDataset = "BaseMap_R@Jingjin";
        parameters.operateDataset = "Geomor_R@Jingjin";
        parameters.operation = OverlayOperationType.INTERSECT;
        // 设置分析结果参数
        DataReturnOption resultSet = new DataReturnOption();
        resultSet.dataReturnMode = DataReturnMode.DATASET_ONLY;
        resultSet.dataset = "Result_RR_Intersect";
        resultSet.deleteExistResultDataset = true;
        parameters.resutlSetting = resultSet;
        DatasetOverlayAnalystService service = new DatasetOverlayAnalystService(
                "http://MyServerIP:8090/iserver/services/spatialanalyst-sample/restjsr/spatialanalyst");
        MyDatasetOverlayAnalystEventListener listener = new MyDatasetOverlayAnalystEventListener();
        // 和服务端异步通讯
        service.process(parameters, listener);        
    }
    // 监听器类
    class MyDatasetOverlayAnalystEventListener extends DatasetOverlayAnalystEventListener {
        @Override
        public void onDatasetOverlayAnalystStatusChanged(Object sourceObject, EventStatus status) {
            // 返回结果
            result = (DatasetOverlayAnalystResult) sourceObject;
            // 结果验证：分析成功，返回分析结果的数据集标识
            assertTrue("The succeed of result", result.succeed);
            assertEquals("The dataset of result", "Result_RR_Intersect@Jingjin", result.dataset);
        }
    }

数据集邻近分析。下面示例为点数据集的邻近分析，不生成结果数据集，仅返回分析得到的多边形面数组，分析结果在主线程中进行获取及展示。

    // 邻近分析结果
    public ThiessenAnalystResult result;
    public void DatasetThiessenAnalyst() throws InterruptedException, ExecutionException {
        // 设置数据集邻近分析参数
        DatasetThiessenAnalystParameters parameters = new DatasetThiessenAnalystParameters();
        parameters.createResultDataset = false;
        parameters.returnResultRegion = true;
        parameters.dataset = "SamplesP@Interpolation";
        DatasetThiessenAnalystService service = new DatasetThiessenAnalystService(
                "http://MyServerIP:8090/iserver/services/spatialanalyst-sample/restjsr/spatialanalyst");
        MyDatasetThiessenAnalystEventListener listener = new MyDatasetThiessenAnalystEventListener();
        // 和服务端异步通讯
        service.process(parameters, listener);
        // 等待监听器执行完毕
        try {
            listener.waitUntilProcessed();
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 获取分析结果
        int counts = result.regions.length;
    }
    // 监听器类
    class MyDatasetThiessenAnalystEventListener extends DatasetThiessenAnalystEventListener {
        @Override
        public void onDatasetThiessenAnalystStatusChanged(Object sourceObject, EventStatus status) {
            // 返回结果
            result = (ThiessenAnalystResult) sourceObject;
        }
    }

动态分段分析。下面示例为依据点事件表生成空间数据，分析结果在主线程中进行获取及展示。

    // 动态分段分析结果
    public GenerateSpatialDataResult result;
    public void GenerateSpatialData() throws InterruptedException, ExecutionException {
        // 构造分析参数，生成点事件
        GenerateSpatialDataParameters parameters = new GenerateSpatialDataParameters();
        parameters.routeTable = "RouteDT_road@Changchun";
        parameters.routeIDField = "RouteID";
        parameters.eventTable = "PointEventTabDT@Changchun";
        parameters.eventRouteIDField = "RouteID";
        parameters.measureField = "Measure";
        parameters.measureStartField = "";
        parameters.measureEndField = "";
        parameters.measureOffsetField = "";
        parameters.errorInfoField = "";
        // 设置分析结果参数,事件表数据集若已有关联的结果空间数据集，不能重复创建
        DataReturnOption resultSet = new DataReturnOption();
        resultSet.dataReturnMode = DataReturnMode.RECORDSET_ONLY;
        parameters.dataReturnOption = resultSet;
        GenerateSpatialDataService service = new GenerateSpatialDataService(
                "http://MyServerIP:8090/iserver/services/spatialanalyst-changchun/restjsr/spatialanalyst");
        MyGenerateSpatialDataEventListener listener = new MyGenerateSpatialDataEventListener();
        // 和服务端异步通讯
        service.process(parameters, listener);
        // 等待监听器执行完毕
        try {
            listener.waitUntilProcessed();
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 结果分析成功,获取结果对象
        assertTrue("The succeed of result", result.succeed);
        Feature[] resultfeatures = result.recordset.features;
    }
    // 监听器类
    class MyGenerateSpatialDataEventListener extends GenerateSpatialDataEventListener {
        @Override
        public void onGenerateSpatialDataStatusChanged(Object sourceObject, EventStatus status) {
            // 返回结果
            result = (GenerateSpatialDataResult) sourceObject;
        }
    }

几何对象的缓冲区分析。下面示例为点对象的缓冲区分析，分析结果在主线程中进行获取及展示。

    // 缓冲区分析结果
    public GeometryBufferAnalystResult result;
    public void GeometryBufferAnalyst() throws InterruptedException, ExecutionException {
        // 构造分析参数
        GeometryBufferAnalystParameters parameters = new GeometryBufferAnalystParameters();
        // 构造几何对象
        Geometry geo = new Geometry();
        Point2D[] points = { new Point2D(10, 10) };
        geo.points = points;
        geo.type = GeometryType.POINT;
        parameters.sourceGeometry = geo;
        // 设置缓冲区分析参数：缓冲端点类型、缓冲半径       
        BufferSetting bufferSet = new BufferSetting();
        BufferDistance buffervalue = new BufferDistance();
        buffervalue.value = 100;
        bufferSet.leftDistance = buffervalue;
        parameters.buffersetting = bufferSet;
        GeometryBufferAnalystService service = new GeometryBufferAnalystService(
                "http://MyServerIP:8090/iserver/services/spatialanalyst-sample/restjsr/spatialanalyst");
        MyGeometryBufferAnalystEventListener listener = new MyGeometryBufferAnalystEventListener();
        // 和服务端异步通讯
        service.process(parameters, listener);
        // 等待监听器执行完毕
        try {
            listener.waitUntilProcessed();
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 结果分析成功,获取结果对象
        assertTrue("The succeed of result", result.succeed);
        Geometry georesult = result.resultGeometry;
    }
    // 监听器类
    class MyGeometryBufferAnalystEventListener extends GeometryBufferAnalystEventListener {
        @Override
        public void onGeometryBufferAnalystStatusChanged(Object sourceObject, EventStatus status) {
            // 返回结果
            result = (GeometryBufferAnalystResult) sourceObject;
        }
    }

几何对象的叠加分析。下面示例为点对象和面对象的擦除分析，分析结果在主线程中进行获取及展示。

    // 叠加分析结果
    public GeometryOverlayAnalystResult result;
    public void GeometryOverlayAnalyst() throws InterruptedException, ExecutionException {
        // 设置叠加分析参数
        GeometryOverlayAnalystParameters parameters = new GeometryOverlayAnalystParameters();
        // 构造几何对象
        Geometry geo = new Geometry();
        Point2D[] points = { new Point2D(10, 4) };
        geo.points = points;
        geo.type = GeometryType.POINT;
        parameters.sourceGeometry = geo;
        Geometry geo2 = new Geometry();
        Point2D[] points2 = { new Point2D(5, -5), new Point2D(5, 5), new Point2D(20, 5), new Point2D(20, -5) };
        geo2.points = points2;
        geo2.type = GeometryType.REGION;
        parameters.operateGeometry = geo2;
        parameters.operation = OverlayOperationType.ERASE;
        GeometryOverlayAnalystService service = new GeometryOverlayAnalystService(
                "http://MyServerIP:8090/iserver/services/spatialanalyst-sample/restjsr/spatialanalyst");
        MyGeometryOverlayAnalystEventListener listener = new MyGeometryOverlayAnalystEventListener();
        // 和服务端异步通讯
        service.process(parameters, listener);
        // 等待监听器执行完毕
        try {
            listener.waitUntilProcessed();
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 结果分析成功,获取结果对象
        assertTrue("The succeed of result", result.succeed);
        Geometry georesult = result.resultGeometry;
    }
    // 监听器类
    class MyGeometryOverlayAnalystEventListener extends GeometryOverlayAnalystEventListener {
        @Override
        public void onGeometryOverlayAnalystStatusChanged(Object sourceObject, EventStatus status) {
            // 返回结果
            result = (GeometryOverlayAnalystResult) sourceObject;
        }
    }  

几何对象的邻近分析。下面示例为点对象的邻近分析，分析结果在主线程中进行获取及展示。

    // 邻近分析结果
    public ThiessenAnalystResult result;
    public void GeometryThiessenAnalyst() throws InterruptedException, ExecutionException {
        // 构造几何对象邻近分析参数
        Point2D[] points = { new Point2D(0, 0), new Point2D(5, 2), new Point2D(8, 10), new Point2D(20, -5) };
        GeometryThiessenAnalystParameters parameters = new GeometryThiessenAnalystParameters();
        parameters.createResultDataset = false;
        parameters.returnResultRegion = true;
        parameters.points = points;
        GeometryThiessenAnalystService service = new GeometryThiessenAnalystService(
                "http://MyServerIP:8090/iserver/services/spatialanalyst-sample/restjsr/spatialanalyst");
        MyGeometryThiessenAnalystEventListener listener = new MyGeometryThiessenAnalystEventListener();
        // 和服务端异步通讯
        service.process(parameters, listener);
        // 等待监听器执行完毕
        try {
            listener.waitUntilProcessed();
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 结果分析成功,获取结果对象
        assertTrue("The succeed of result", result.succeed);
        Point2D[] resultpoints = result.regions;
    }
    // 监听器类
    class MyGeometryThiessenAnalystEventListener extends GeometryThiessenAnalystEventListener {
        @Override
        public void onGeometryThiessenAnalystStatusChanged(Object sourceObject, EventStatus status) {
            // 返回结果
            result = (ThiessenAnalystResult) sourceObject;
        }
    }  

空间关系分析。下面示例为面包含点的关系分析，分析结果在主线程中进行获取及展示。

    // 空间关系分析结果
    public GeoRelationAnalystResult result;
    public void GeoRelationAnalyst() throws InterruptedException, ExecutionException {
        // 构造分析参数
        GeoRelationAnalystParameters parameters = new GeoRelationAnalystParameters();
        parameters.dataset = "Edit_Point@Changchun";
        QueryParameter reffilter = new QueryParameter();
        reffilter.name = "Edit_AreaPoly@Changchun";
        parameters.referenceFilter = reffilter;
        parameters.expectCount = 100;
        parameters.isBorderInside = true;
        parameters.returnFeature = true;
        parameters.returnGeoRelatedOnly = true;
        parameters.spatialRelationType = SpatialRelationType.CONTAIN;
        parameters.startRecord = 0;
        GeoRelationAnalystService service = new GeoRelationAnalystService(
                "http://MyServerIP:8090/iserver/services/spatialanalyst-changchun/restjsr/spatialanalyst");
        MyGeoRelationAnalystEventListener listener = new MyGeoRelationAnalystEventListener();
        // 和服务端异步通讯
        service.process(parameters, listener);
        // 等待监听器执行完毕
        try {
            listener.waitUntilProcessed();
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 结果分析成功,获取结果对象
        assertNotNull("The GeoRelationAnalyst result is null!", result);
        Feature[] resfeature=(Feature[])result.geoRelationResults[0].result;
    }
    class MyGeoRelationAnalystEventListener extends GeoRelationAnalystEventListener {
        @Override
        public void onGeoRelationAnalystStatusChanged(Object sourceObject, EventStatus status) {
            // 返回结果
            result = (GeoRelationAnalystResult) sourceObject;
        }
    }

插值分析。下面示例为普通克吕金插值分析。

    // 插值分析结果
    public InterpolationAnalystResult result;
    public void InterpolationAnalyst() throws InterruptedException, ExecutionException {
        // 构造分析参数
        InterpolationKrigingAnalystParameters parameters = new InterpolationKrigingAnalystParameters();
        parameters.dataset = "SamplesP@Interpolation";
        parameters.outputDatasetName = "Result_Kriging";
        parameters.type = InterpolationAlgorithmType.KRIGING;
        parameters.zValueFieldName = "AVG_TMP";
        parameters.searchMode = SearchMode.KDTREE_FIXED_COUNT;
        parameters.resolution = 8000;
        // 与服务端交互
        InterpolationAnalystService service = new InterpolationAnalystService(
                "http://MyServerIP:8090/iserver/services/spatialanalyst-sample/restjsr/spatialanalyst");
        MyInterpolationAnalystEventListener listener = new MyInterpolationAnalystEventListener();
        // 和服务端异步通讯
        service.process(parameters, listener);
        // 等待监听器执行完毕
        try {
            listener.waitUntilProcessed();
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 结果分析成功，获取结果数据集标识
        assertTrue("Analyst faild", result.succeed);
                String resultdt=result.dataset;
    }
    // 监听器类
    class MyInterpolationAnalystEventListener extends InterpolationAnalystEventListener {
        @Override
        public void onInterpolationAnalystStatusChanged(Object sourceObject, EventStatus status) {
            // 返回结果
            result = (InterpolationAnalystResult) sourceObject;
        }
    }

提取等值线分析。下面示例为提取等值线，分析结果在主线程中进行获取及展示。

    // 表面分析结果
    public SurfaceAnalystResult result;
    public void IsoLineSurfaceAnalyst() throws InterruptedException, ExecutionException {
        // 设置表面分析通用参数
        SurfaceAnalystParametersSetting paramSetting = new SurfaceAnalystParametersSetting();
        paramSetting.datumValue = 0;
        paramSetting.interval = 10;
        paramSetting.smoothMethod = SmoothMethod.BSPLINE;
        paramSetting.smoothness = 1.2;
        // 设置分析结果参数
        DataReturnOption resultSet = new DataReturnOption();
        resultSet.expectCount = 100;
        // 设置数据集表面分析参数
        DatasetSurfaceAnalystParameters surfaceParams = new DatasetSurfaceAnalystParameters();
        surfaceParams.dataset = "Temp5000@Interpolation";
        surfaceParams.extractParameter = paramSetting;
        surfaceParams.resultSetting = resultSet;
        SurfaceAnalystService service = new SurfaceAnalystService("http://MyServerIP:8090/iserver/services/spatialanalyst-sample/restjsr/spatialanalyst");
        MySurfaceAnalystEventListener listener = new MySurfaceAnalystEventListener();
        // 和服务端异步通讯
        service.process(surfaceParams, listener);
        // 等待监听器执行完毕
        try {
            listener.waitUntilProcessed();
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 结果分析成功,获取结果对象
        assertTrue("Analyst faild", result.succeed);
        Feature[] features=result.recordset.features;
    }
    // 监听器类
    class MySurfaceAnalystEventListener extends SurfaceAnalystEventListener {
        @Override
        public void onSurfaceAnalystStatusChanged(Object sourceObject, EventStatus status) {
            // 返回结果
            result = (SurfaceAnalystResult) sourceObject;
        }
    }

提取等值面分析。下面示例为提取等值面，分析结果在主线程中进行获取及展示。

    // 表面分析结果
    public SurfaceAnalystResult result;
    public void IsoLineSurfaceAnalyst() throws InterruptedException, ExecutionException {
        // 设置表面分析通用参数
        SurfaceAnalystParametersSetting paramSetting = new SurfaceAnalystParametersSetting();
        paramSetting.datumValue = 4;
        paramSetting.interval = 10;
        paramSetting.smoothMethod = SmoothMethod.BSPLINE;
        paramSetting.smoothness = 1.2;
        paramSetting.expectedZValues = new double[] { 10, 20 };
        // 设置分析结果参数
        DataReturnOption resultSet = new DataReturnOption();
        resultSet.expectCount = 3;
        // 设置数据集表面分析参数
        DatasetSurfaceAnalystParameters surfaceParams = new DatasetSurfaceAnalystParameters();
        surfaceParams.dataset = "Temp5000@Interpolation";
        surfaceParams.extractParameter = paramSetting;
        surfaceParams.resultSetting = resultSet;
        surfaceParams.surfaceAnalystMethod = SurfaceAnalystMethod.ISOREGION;
        SurfaceAnalystService service = new SurfaceAnalystService("http://MyServerIP:8090/iserver/services/spatialanalyst-sample/restjsr/spatialanalyst");
        MySurfaceAnalystEventListener listener = new MySurfaceAnalystEventListener();
        // 和服务端异步通讯
        service.process(surfaceParams, listener);
        // 等待监听器执行完毕
        try {
            listener.waitUntilProcessed();
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 结果分析成功,获取结果对象
        assertTrue("Analyst faild", result.succeed);
        Feature[] features=result.recordset.features;
    }
    // 监听器类
    class MySurfaceAnalystEventListener extends SurfaceAnalystEventListener {
        @Override
        public void onSurfaceAnalystStatusChanged(Object sourceObject, EventStatus status) {
            // 返回结果
            result = (SurfaceAnalystResult) sourceObject;
        }
    }

计算路由对象指定点的M值。下面示例为计算路由对象指定点的M值，分析结果在主线程中进行获取。

   // 分析结果
    public RouteCalculateMeasureResult result;
    public void RouteCalculateMeasure() throws InterruptedException, ExecutionException {
        // 设置路由对象定位空间对象参数
        RouteCalculateMeasureParameters params = new RouteCalculateMeasureParameters();
        Route sourceRoute = new Route();
        sourceRoute.type = GeometryType.LINEM;
        sourceRoute.parts = new int[] { 4 };
        PointWithMeasure[] points = new PointWithMeasure[] { new PointWithMeasure(3817.3527876130133, -6674.466867067764, 0),
                new PointWithMeasure(3617.806369901496, -6670.830929417594, 199.57954019411724),
                new PointWithMeasure(3264.1498746678444, -6877.837541432356, 609.3656478634477),
                new PointWithMeasure(2979.846206068903, -7038.687780615184, 936.0174126282958) };
        sourceRoute.points = points;
        params.sourceRoute = sourceRoute;
        params.isIgnoreGap = false;
        Point2D point = new Point2D(3330.77542694170, -6838.8394457216);
        params.point = point;
        params.tolerance = 1;        
        RouteCalculateMeasureService service = new RouteCalculateMeasureService(
                "http://MyServerIP:8090/iserver/services/spatialanalyst-changchun/restjsr/spatialanalyst");
        MyRouteCalculateMeasureEventListener listener = new MyRouteCalculateMeasureEventListener();
        // 和服务端异步通讯
        service.process(params, listener);
        // 等待监听器执行完毕
        try {
            listener.waitUntilProcessed();
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 结果分析成功,获取计算结果
        assertTrue("Calculate faild", result.succeed);
        double resultmeasure = result.measure;
    }
    // 监听器类
    class MyRouteCalculateMeasureEventListener extends RouteCalculateMeasureEventListener {
        @Override
        public void onRouteCalculateMeasureStatusChanged(Object sourceObject, EventStatus status) {
            // 返回结果
            result = (RouteCalculateMeasureResult) sourceObject;
        }
    }

路由对象定位空间对象分析。下面示例为路由对象定位点对象分析，分析结果在主线程中进行获取及展示。

    // 分析结果
    public RouteLocatorResult result;
    public void RouteLocator() throws InterruptedException, ExecutionException {
        // 设置路由对象定位空间对象参数
        RouteLocatorParameters params = new RouteLocatorParameters();
        Route sourceRoute = new Route();
        sourceRoute.type = GeometryType.LINEM;
        sourceRoute.parts = new int[] { 4 };
        PointWithMeasure[] points = new PointWithMeasure[] { new PointWithMeasure(3817.3527876130133, -6674.466867067764, 0),
                new PointWithMeasure(3617.806369901496, -6670.830929417594, 199.57954019411724),
                new PointWithMeasure(3264.1498746678444, -6877.837541432356, 609.3656478634477),
                new PointWithMeasure(2979.846206068903, -7038.687780615184, 936.0174126282958) };
        sourceRoute.points = points;
        params.sourceRoute = sourceRoute;
        params.type = LocateType.POINT;
        params.measure = 10;
        params.offset = 0;
        params.isIgnoreGap = false;
        RouteLocatorService service = new RouteLocatorService("http://MyServerIP:8090/iserver/services/spatialanalyst-changchun/restjsr/spatialanalyst");
        MyRouteLocatorEventListener listener = new MyRouteLocatorEventListener();
        // 和服务端异步通讯
        service.process(params, listener);
        // 等待监听器执行完毕
        try {
            listener.waitUntilProcessed();
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 结果分析成功,获取分析结果
        assertTrue("Calculate faild", result.succeed);
        Geometry resultgeo = result.resultGeometry;
    }
    // 监听器类
    class MyRouteLocatorEventListener extends RouteLocatorEventListener {
        @Override
        public void onRouteLocatorStatusChanged(Object sourceObject, EventStatus status) {
            // 分析结果
            result = (RouteLocatorResult) sourceObject;
        }
    }

完整示例可参考SampleCode中的空间分析。