1

13693261870

2024-10-08 7f0a7fab2e035d1b5b3a3e21fa5f779d6b7a850a

1

 src/main/java/com/se/simu/helper/GdalHelper.java

@@ -195,7 +195,7 @@
        //{
        point.TransformTo(SR4326);
        //}
        point.SwapXY();
        //point.SwapXY();

        return point;
    }

 src/main/java/com/se/simu/service/ResultService.java

@@ -10,16 +10,19 @@
import lombok.extern.slf4j.Slf4j;
import org.gdal.gdal.Band;
import org.gdal.gdal.Dataset;
import org.gdal.gdal.WarpOptions;
import org.gdal.gdal.gdal;
import org.gdal.gdalconst.gdalconst;
import org.gdal.ogr.Geometry;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.*;
import java.util.*;
import java.util.List;

/**
 * 处理结果服务类
@@ -35,6 +38,20 @@
    PropertiesConfig config;

    public final static double MAX_X_OFFSET = 0.002;

    public String test() throws Exception {
        ResultDto dto = new ResultDto(
                "202409",
                "D:\\simu\\input\\tongzhou-local-mesh2-terrain.tif",
                "D:\\simu\\input\\tongzhou-local-mesh2-buildings.tif",
                "D:\\simu\\input\\waters",
                "D:\\simu\\input\\flows",
                "D:\\simu\\out",
                "");
        process(dto);

        return "OK";
    }

    public void process(ResultDto dto) throws Exception {
        try {
@@ -90,24 +107,195 @@
        return ((long) Math.ceil(val * radix)) / radix;
    }

    private void setWaterInfo(ResultDto dto, LayerDto layer) {
    private void createTerrainPng(ResultDto dto, Dataset ds, LayerDto layer) {
        String terrainPath = dto.getOutPath() + File.separator + "terrain";
        File f = new File(terrainPath);
        if (!f.exists() || !f.isDirectory()) f.mkdirs();

        for (int[] sizes : layer.getTerrain().getSize()) {
            String tif = dto.getTemp() + File.separator + "terrain_" + sizes[0] + "_" + sizes[1] + ".tif";
            Resample(ds, tif, sizes[0], sizes[1], layer);
            if (!new File(tif).exists()) continue;

            String png = terrainPath + File.separator + sizes[0] + "_" + sizes[1] + ".png";
            Terrain2Png(layer, tif, png, sizes[0], sizes[1]);
        }
    }

    private void createTerrainPng(ResultDto dto, Dataset ds, LayerDto layer) {
    private static void Resample(Dataset ds, String dest, int width, int height, LayerDto layer) {
        Vector<String> vector = new Vector<>();
        //vector.add("-s_srs");
        //vector.add("EPSG:" + 4326);
        vector.add("-t_srs");
        vector.add("EPSG:" + 4326);
        vector.add("-r");
        vector.add("bilinear");
        vector.add("-of");
        vector.add("GTiff");
        vector.add("-te");
        vector.add("" + layer.getExtension().getMinx());
        vector.add("" + layer.getExtension().getMiny());
        vector.add("" + layer.getExtension().getMaxx());
        vector.add("" + layer.getExtension().getMaxy());
        vector.add("-te_srs");
        vector.add("EPSG:" + 4326);
        WarpOptions warpOptions = new WarpOptions(vector);

        Dataset destDs = gdal.Warp(dest, new Dataset[]{ds}, warpOptions);
        destDs.delete();
    }

    private static void Terrain2Png(LayerDto layer, String tif, String png, int width, int height) {
        Dataset ds = null;
        try {
            ds = gdal.Open(tif, gdalconst.GA_ReadOnly);
            if (null == ds || 0 == ds.getRasterCount()) return;

            Band band = ds.GetRasterBand(1);
            float[] buffer = new float[width * height];
            //band.ReadRaster(0, 0, width, height, buffer, width, height, 0, 0);
            band.ReadRaster(0, 0, width, height, buffer);

            BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
            Graphics2D graphic = image.createGraphics();
            Color transparent = new Color(0, 0, 0, 0);
            graphic.setColor(transparent);
            graphic.clearRect(0, 0, width, height);
            graphic.dispose();

            double differ = layer.getExtension().getMaxHeight() - layer.getExtension().getMinHeight(), minHeight = layer.getExtension().getMinHeight();
            for (int x = 0; x < width; x++) {
                for (int y = 0; y < height; y++) {
                    int offset = x + y * width;
                    if (Float.isNaN(buffer[offset]) || buffer[offset] < -999 || buffer[offset] < minHeight) continue;

                    int r = 0, g, b;
                    if (buffer[offset] - layer.getExtension().getMaxHeight() > 0) {
                        g = b = 255;
                    } else {
                        int val = (int) ((buffer[offset] - minHeight) / differ * 65535);
                        g = val / 256;
                        b = val % 256;
                    }

                    Color color = new Color(r, g, b, 127);
                    //image.setRGB(x, y, color.getRGB());
                    graphic.drawImage(image, x, y, 1, 1, color, null);
                }
            }

            try {
                ImageIO.write(image, "png", new File(png));
            } catch (Exception ex) {
                log.error(ex.getMessage(), ex);
            }
        } finally {
            if (null != ds) ds.delete();
        }
    }

    private void copeBuilding(ResultDto dto, LayerDto layer) {
        //
        Dataset ds = null;
        try {
            ds = gdal.Open(dto.getBuildingFile(), gdalconst.GA_ReadOnly);
            if (null == ds || 0 == ds.getRasterCount()) return;

            for (int[] sizes : layer.getTerrain().getSize()) {
                String tif = dto.getTemp() + File.separator + "building_" + sizes[0] + "_" + sizes[1] + ".tif";
                Resample(ds, tif, sizes[0], sizes[1], layer);
                if (!new File(tif).exists()) continue;

                Dataset dataset = gdal.Open(tif, gdalconst.GA_ReadOnly);
                if (null == dataset || 0 == dataset.getRasterCount()) return;

                float[] buffer = new float[sizes[0] * sizes[1]];
                //dataset.GetRasterBand(1).ReadRaster(0, 0, sizes[0], sizes[1], buffer, sizes[0], sizes[1], 0, 0);
                //args.buildings[sizes[0] + "_" + sizes[1]] = buffer;

                dataset.delete();
            }
        } finally {
            if (null != ds) ds.delete();
        }
    }

    private void setWaterInfo(ResultDto dto, LayerDto layer) {
        List<String> files = getFiles(dto.getWaterPath(), "");
        layer.getWaters().setFiles(files);
        if (null == files || files.size() == 0) return;

        setWaterData(layer, files);
        setWaterHeight(layer, files);
    }

    private void copeWater(ResultDto dto, LayerDto layer) {
        //
    }

    private static List<String> getFiles(String path, String prefix) {

        return new ArrayList<String>();
    }

    private static void setWaterData(LayerDto layer, List<String> files) {
        //
    }

    private static void setWaterHeight(LayerDto layer, List<String> files) {
        //
    }

    private static void processWaters(ResultDto dto, List<String> files, LayerDto layer) {
        //
    }

    private static void createWaterPng(ResultDto dto, Dataset ds, LayerDto layer, long ticks) {
        //
    }

    private static void water2Png(ResultDto dto, LayerDto layer, String tif, String png, int width, int height) {
        //
    }

    private void copeFlow(ResultDto dto, LayerDto layer) {
        //
    }

    private static void createFlowPng(ResultDto dto, Dataset vxDs, Dataset vyDs, LayerDto layer, long ticks) {
        //
    }

    private static void vxyTif2Png(LayerDto layer, String vxTif, String vyTif, String png, int width, int height) {
        Dataset vxDs = null, vyDs = null;
        try {
            vxDs = gdal.Open(vxTif, gdalconst.GA_ReadOnly);
            vyDs = gdal.Open(vyTif, gdalconst.GA_ReadOnly);
            if (null == vxDs || 0 == vxDs.getRasterCount() || null == vyDs || 0 == vyDs.getRasterCount()) return;

            float[] vxBuffer = new float[width * height], vyBuffer = new float[width * height];
            //vxDs.GetRasterBand(1).ReadRaster(0, 0, width, height, vxBuffer, width, height, 0, 0);
            //vyDs.GetRasterBand(1).ReadRaster(0, 0, width, height, vyBuffer, width, height, 0, 0);

            //createFlowPng(vxBuffer, vyBuffer, png, width, height);
        } finally {
            if (null != vxDs) vxDs.delete();
            if (null != vyDs) vyDs.delete();
        }
    }

    private static void createFlowPng(float[] vxBuffer, float[] vyBuffer, String png, int width, int height) {
        //
    }

    private static float getFloatValue(float val) {
        return (Float.isNaN(val) || val < -999) ? Float.NaN : val;
    }

    private static int getSafeValue(int val) {
        if (val < 0) return 0;
        if (val > 255) return 255;

        return val;
    }

    private void copeLayerJson(ResultDto dto, LayerDto layer) throws IOException {
@@ -119,19 +307,5 @@
        bw.write(json);
        bw.close();
        fw.close();
    }

    public String test() throws Exception {
        ResultDto dto = new ResultDto(
                "202409",
                "D:\\simu\\input\\tongzhou-local-mesh2-terrain.tif",
                "D:\\simu\\input\\tongzhou-local-mesh2-buildings.tif",
                "D:\\simu\\input\\waters",
                "D:\\simu\\input\\flows",
                "D:\\simu\\out",
                "");
        process(dto);

        return "OK";
    }
}