新增计算工具

oa-back/pom.xml

@@ -178,6 +178,13 @@
                 <version>${cmc.version}</version>
             </dependency>
 
+            <!-- 高斯正算-->
+            <dependency>
+                <groupId>com.ruoyi</groupId>
+                <artifactId>ruoyi-calculate</artifactId>
+                <version>${cmc.version}</version>
+            </dependency>
+
             <dependency>
                 <groupId>com.google.protobuf</groupId>
                 <artifactId>protobuf-java</artifactId>
@@ -224,6 +231,7 @@
         <module>ruoyi-generator</module>
         <module>ruoyi-common</module>
         <module>ruoyi-flowable</module>
+		<module>ruoyi-calculate</module>
     </modules>
     <packaging>pom</packaging>
 

oa-back/ruoyi-admin/pom.xml

@@ -74,6 +74,12 @@
             <artifactId>ruoyi-llm</artifactId>
         </dependency>
 
+        <!-- 高斯正算-->
+        <dependency>
+            <groupId>com.ruoyi</groupId>
+            <artifactId>ruoyi-calculate</artifactId>
+        </dependency>
+
     </dependencies>
 
     <build>

oa-back/ruoyi-calculate/pom.xml

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+          <groupId>com.ruoyi</groupId>
+          <artifactId>ruoyi</artifactId>
+          <version>3.8.7</version>
+    </parent>
+
+    <artifactId>ruoyi-calculate</artifactId>
+    <properties>
+        <maven.compiler.source>17</maven.compiler.source>
+        <maven.compiler.target>17</maven.compiler.target>
+    </properties>
+    <dependencies>
+        <!-- 核心依赖 -->
+        <dependency>
+            <groupId>com.ruoyi</groupId>
+            <artifactId>ruoyi-common</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.ruoyi</groupId>
+            <artifactId>ruoyi-framework</artifactId>
+        </dependency>
+    </dependencies>
+</project>

oa-back/ruoyi-calculate/src/main/java/com/ruoyi/web/calculate/controller/CmcGaussPositiveController.java

@@ -0,0 +1,132 @@
+package com.ruoyi.web.calculate.controller;
+
+import java.util.ArrayList;
+import java.util.List;
+import javax.servlet.http.HttpServletResponse;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.multipart.MultipartFile;
+
+import com.ruoyi.common.annotation.Log;
+import com.ruoyi.common.core.controller.BaseController;
+import com.ruoyi.common.core.domain.AjaxResult;
+import com.ruoyi.common.enums.BusinessType;
+import com.ruoyi.web.calculate.domain.CmcGaussPositive;
+import com.ruoyi.web.calculate.service.ICmcGaussPositiveService;
+import com.ruoyi.web.calculate.vo.CmcGaussPositiveTemplate;
+import com.ruoyi.common.utils.poi.ExcelUtil;
+import com.ruoyi.common.core.page.TableDataInfo;
+
+/**
+ * 高斯正算Controller
+ * 
+ * @author ruoyi
+ * @date 2026-04-21
+ */
+@RestController
+@RequestMapping("/calculate/gaussPositive")
+public class CmcGaussPositiveController extends BaseController
+{
+    @Autowired
+    private ICmcGaussPositiveService cmcGaussPositiveService;
+
+     /**
+     * 导入Excel数据
+     */
+    @PostMapping("/import")
+    public AjaxResult importExcel(@RequestParam("file") MultipartFile file)
+    {
+        try {
+            // 检查文件是否为空
+            if (file.isEmpty()) {
+                return AjaxResult.error("请选择要导入的文件！");
+            }
+
+            // 检查文件格式
+            String fileName = file.getOriginalFilename();
+            if (fileName == null || (!fileName.endsWith(".xls") && !fileName.endsWith(".xlsx"))) {
+                return AjaxResult.error("请上传Excel文件（.xls或.xlsx格式）！");
+            }
+
+            // 调用Service层解析Excel并返回数据
+            return cmcGaussPositiveService.importExcelData(file);
+
+        } catch (Exception e) {
+            e.printStackTrace();
+            return AjaxResult.error("导入失败：" + e.getMessage());
+        }
+    }
+
+    /**
+     * 导出高斯正算列表
+     */
+    @Log(title = "高斯正算", businessType = BusinessType.EXPORT)
+    @PostMapping("/export")
+    public void export(HttpServletResponse response, @RequestBody List<CmcGaussPositive> dataList)
+    {
+        if (dataList == null || dataList.isEmpty()) {
+            throw new RuntimeException("没有需要导出的数据");
+        }
+        
+        List<CmcGaussPositive> exportList = new ArrayList<>();
+        for (CmcGaussPositive item : dataList) {
+            CmcGaussPositive exportItem = new CmcGaussPositive();
+            exportItem.setPointNumber(item.getPointNumber());
+            exportItem.setCoordinateSystem(item.getCoordinateSystem());
+            exportItem.setLongitude(item.getLongitude());
+            exportItem.setLongitudePosition(item.getLongitudePosition());
+            exportItem.setLatitude(item.getLatitude());
+            exportItem.setLatitudePosition(item.getLatitudePosition());
+            exportItem.setZone(item.getZone());
+            exportItem.setBandwidth(item.getBandwidth());
+            exportItem.setProjectionHeight(item.getProjectionHeight());
+            exportItem.setGaussX(item.getGaussX());
+            exportItem.setGaussY(item.getGaussY());
+            exportItem.setMeridianConvergence(item.getMeridianConvergence());
+            exportList.add(exportItem);
+        }
+        
+        ExcelUtil<CmcGaussPositive> util = new ExcelUtil<CmcGaussPositive>(CmcGaussPositive.class);
+        util.exportExcel(response, exportList, "高斯正算结果");
+    }
+
+    /**
+     * 执行高斯正算（仅计算，不保存）
+     */
+    @PostMapping("/calculate")
+    public AjaxResult calculate(@RequestBody List<CmcGaussPositive> dataList)
+    {
+        List<CmcGaussPositive> result = cmcGaussPositiveService.calculateGaussPositive(dataList);
+        return success(result);
+    }
+
+    @PostMapping("/template")
+    public void downloadTemplate(HttpServletResponse response) {
+        List<CmcGaussPositiveTemplate> templateList = new ArrayList<>();
+
+        // 添加示例数据
+        CmcGaussPositiveTemplate example = new CmcGaussPositiveTemplate();
+        example.setPointNumber("示例点1");
+        example.setCoordinateSystem("WGS84");
+        example.setLongitude(103.3734281951);
+        example.setLongitudePosition("E");
+        example.setLatitude(29.29315636);
+        example.setLatitudePosition("N");
+        example.setZone(35);
+        example.setBandwidth(3);
+        templateList.add(example);
+
+        ExcelUtil<CmcGaussPositiveTemplate> util = new ExcelUtil<CmcGaussPositiveTemplate>(CmcGaussPositiveTemplate.class);
+        util.exportExcel(response, templateList, "高斯正算模板");
+    }
+
+}

oa-back/ruoyi-calculate/src/main/java/com/ruoyi/web/calculate/domain/CmcGaussPositive.java

@@ -0,0 +1,252 @@
+package com.ruoyi.web.calculate.domain;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+
+import org.apache.commons.lang3.builder.ToStringBuilder;
+import org.apache.commons.lang3.builder.ToStringStyle;
+import com.ruoyi.common.annotation.Excel;
+import com.ruoyi.common.annotation.Excel.ColumnType;
+import com.ruoyi.common.core.domain.BaseEntity;
+
+/**
+ * 高斯正算对象 cmc_gauss_positive
+ * 
+ * @author ruoyi
+ * @date 2026-04-21
+ */
+public class CmcGaussPositive extends BaseEntity
+{
+    private static final long serialVersionUID = 1L;
+
+    /** 主键ID */
+    private Long id;
+
+    /** 待求点号 */
+    @Excel(name = "待求点")
+    private String pointNumber;
+
+    /** 坐标系 */
+    @Excel(name = "坐标系")
+    private String coordinateSystem;
+
+    /** 大地经度 */
+    @Excel(name = "大地经度" , cellType = ColumnType.NUMERIC)
+    private Double longitude;
+
+    /** 经度位置 */
+    @Excel(name = "经度位置")
+    private String longitudePosition;
+
+    /** 大地纬度 */
+    @Excel(name = "大地纬度", cellType = ColumnType.NUMERIC)
+    private Double latitude;
+
+    /** 纬度位置 */
+    @Excel(name = "纬度位置")
+    private String latitudePosition;
+
+    /** 带号 */
+    @Excel(name = "带号", cellType = ColumnType.NUMERIC)
+    private Integer zone;
+
+    /** 带宽 */
+    @Excel(name = "带宽", cellType = ColumnType.NUMERIC)
+    private Integer bandwidth;
+
+    /** 带宽 */
+    @Excel(name = "投影面高程", cellType = ColumnType.NUMERIC)
+    private Integer projectionHeight;
+
+    /** 高斯坐标x */
+    @Excel(name = "高斯坐标x", cellType = ColumnType.NUMERIC)
+    private Double gaussX;
+
+    /** 高斯坐标y */
+    @Excel(name = "高斯坐标y", cellType = ColumnType.NUMERIC)
+    private Double gaussY;
+
+    /** 子午线收敛角γ */
+    @Excel(name = "子午线收敛角γ", cellType = ColumnType.NUMERIC)
+    private Double meridianConvergence;
+
+    public void setId(Long id) 
+    {
+        this.id = id;
+    }
+
+    public Long getId() 
+    {
+        return id;
+    }
+    public void setPointNumber(String pointNumber) 
+    {
+        this.pointNumber = pointNumber;
+    }
+
+    public String getPointNumber() 
+    {
+        return pointNumber;
+    }
+    public void setCoordinateSystem(String coordinateSystem) 
+    {
+        this.coordinateSystem = coordinateSystem;
+    }
+
+    public String getCoordinateSystem() 
+    {
+        return coordinateSystem;
+    }
+     public void setLongitude(Double longitude) 
+    {
+        // 大地经度保留10位小数
+        if (longitude != null) {
+            BigDecimal bd = new BigDecimal(longitude);
+            this.longitude = bd.setScale(10, RoundingMode.HALF_UP).doubleValue();
+        } else {
+            this.longitude = null;
+        }
+    }
+
+    public Double getLongitude() 
+    {
+        return longitude;
+    }
+    
+    public void setLongitudePosition(String longitudePosition) 
+    {
+        this.longitudePosition = longitudePosition;
+    }
+
+    public String getLongitudePosition() 
+    {
+        return longitudePosition;
+    }
+    
+    public void setLatitude(Double latitude) 
+    {
+        // 大地纬度保留10位小数
+        if (latitude != null) {
+            BigDecimal bd = new BigDecimal(latitude);
+            this.latitude = bd.setScale(10, RoundingMode.HALF_UP).doubleValue();
+        } else {
+            this.latitude = null;
+        }
+    }
+
+    public Double getLatitude() 
+    {
+        return latitude;
+    }
+    
+    public void setLatitudePosition(String latitudePosition) 
+    {
+        this.latitudePosition = latitudePosition;
+    }
+
+    public String getLatitudePosition() 
+    {
+        return latitudePosition;
+    }
+    
+    public void setZone(Integer zone) 
+    {
+        this.zone = zone;
+    }
+
+    public Integer getZone() 
+    {
+        return zone;
+    }
+    
+    public void setBandwidth(Integer bandwidth) 
+    {
+        this.bandwidth = bandwidth;
+    }
+
+    public Integer getBandwidth() 
+    {
+        return bandwidth;
+    }
+    
+    public void setProjectionHeight(Integer projectionHeight) 
+    {
+        this.projectionHeight = projectionHeight;
+    }
+
+    public Integer getProjectionHeight() 
+    {
+        return projectionHeight;
+    }
+    
+    public void setGaussX(Double gaussX) 
+    {
+        // 高斯X坐标保留4位小数
+        if (gaussX != null) {
+            BigDecimal bd = new BigDecimal(gaussX);
+            this.gaussX = bd.setScale(4, RoundingMode.HALF_UP).doubleValue();
+        } else {
+            this.gaussX = null;
+        }
+    }
+
+    public Double getGaussX() 
+    {
+        return gaussX;
+    }
+    
+    public void setGaussY(Double gaussY) 
+    {
+        // 高斯Y坐标保留4位小数
+        if (gaussY != null) {
+            BigDecimal bd = new BigDecimal(gaussY);
+            this.gaussY = bd.setScale(4, RoundingMode.HALF_UP).doubleValue();
+        } else {
+            this.gaussY = null;
+        }
+    }
+
+    public Double getGaussY() 
+    {
+        return gaussY;
+    }
+    
+    public void setMeridianConvergence(Double meridianConvergence) 
+    {
+        // 子午线收敛角保留7位小数
+        if (meridianConvergence != null) {
+            BigDecimal bd = new BigDecimal(meridianConvergence);
+            this.meridianConvergence = bd.setScale(7, RoundingMode.HALF_UP).doubleValue();
+        } else {
+            this.meridianConvergence = null;
+        }
+    }
+
+    public Double getMeridianConvergence() 
+    {
+        return meridianConvergence;
+    }
+
+
+    @Override
+    public String toString() {
+        return new ToStringBuilder(this,ToStringStyle.MULTI_LINE_STYLE)
+            .append("id", getId())
+            .append("pointNumber", getPointNumber())
+            .append("coordinateSystem", getCoordinateSystem())
+            .append("longitude", getLongitude())
+            .append("longitudePosition", getLongitudePosition())
+            .append("latitude", getLatitude())
+            .append("latitudePosition", getLatitudePosition())
+            .append("zone", getZone())
+            .append("bandwidth", getBandwidth())
+            .append("gaussX", getGaussX())
+            .append("gaussY", getGaussY())
+            .append("meridianConvergence", getMeridianConvergence())
+            .append("createTime", getCreateTime())
+            .append("createBy", getCreateBy())
+            .append("updateTime", getUpdateTime())
+            .append("updateBy", getUpdateBy())
+            .toString();
+    }
+}

oa-back/ruoyi-calculate/src/main/java/com/ruoyi/web/calculate/service/ICmcGaussPositiveService.java

@@ -0,0 +1,36 @@
+package com.ruoyi.web.calculate.service;
+
+import java.util.List;
+
+import javax.servlet.http.HttpServletResponse;
+
+import org.springframework.web.multipart.MultipartFile;
+
+import com.ruoyi.common.core.domain.AjaxResult;
+import com.ruoyi.web.calculate.domain.CmcGaussPositive;
+
+/**
+ * 高斯正算服务接口
+ * 
+ * @author ruoyi
+ * @date 2026-04-21
+ */
+public interface ICmcGaussPositiveService 
+{
+     /**
+     * 导入Excel数据
+     * 
+     * @param file Excel文件
+     * @return 导入结果
+     */
+     public AjaxResult importExcelData(MultipartFile file);
+    
+    /**
+     * 执行高斯正算
+     * 
+     * @param cmcGaussPositive 高斯正算参数
+     * @return 计算结果
+     */
+    public List<CmcGaussPositive> calculateGaussPositive(List<CmcGaussPositive> dataList);
+
+}

oa-back/ruoyi-calculate/src/main/java/com/ruoyi/web/calculate/service/impl/CmcGaussPositiveServiceImpl.java

@@ -0,0 +1,349 @@
+package com.ruoyi.web.calculate.service.impl;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.servlet.http.HttpServletResponse;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.multipart.MultipartFile;
+
+import com.ruoyi.common.core.domain.AjaxResult;
+import com.ruoyi.common.utils.poi.ExcelUtil;
+// import com.ruoyi.web.calculate.mapper.CmcGaussPositiveMapper;
+import com.ruoyi.web.calculate.domain.CmcGaussPositive;
+import com.ruoyi.web.calculate.service.ICmcGaussPositiveService;
+
+/**
+ * 高斯正算服务实现
+ * 
+ * @author ruoyi
+ * @date 2026-04-21
+ */
+@Service
+public class CmcGaussPositiveServiceImpl implements ICmcGaussPositiveService 
+{
+    @Autowired
+    // private CmcGaussPositiveMapper cmcGaussPositiveMapper;
+
+    private static final double A_WGS84 = 6378137.0;
+    private static final double F_WGS84 = 1 / 298.257223563;
+
+    private static final double A_CGCS2000 = 6378137.0;
+    private static final double F_CGCS2000 = 1 / 298.257222101;
+
+    private static final double A_BJ54 = 6378245.0;
+    private static final double F_BJ54 = 1 / 298.3;
+
+    private static final double A_XA80 = 6378140.0;
+    private static final double F_XA80 = 1 / 298.257;
+
+    private static double A;
+    private static double F;
+    private static double E2;
+
+
+    /**
+     * 导入Excel数据
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public AjaxResult importExcelData(MultipartFile file)
+    {
+        try {
+            // 使用若依的ExcelUtil工具类
+            ExcelUtil<CmcGaussPositive> util = new ExcelUtil<CmcGaussPositive>(CmcGaussPositive.class);
+            List<CmcGaussPositive> dataList = util.importExcel(file.getInputStream());
+
+            // 检查是否有数据
+            if (dataList == null || dataList.isEmpty()) {
+                return AjaxResult.error("Excel文件中没有数据！");
+            }
+
+            // 验证数据并转换为前端需要的格式
+            List<Map<String, Object>> validData = new ArrayList<>();
+            int successCount = 0;
+            StringBuilder errorMsg = new StringBuilder();
+
+            for (int i = 0; i < dataList.size(); i++) {
+                CmcGaussPositive item = dataList.get(i);
+
+                try {
+                    // 转换为前端需要的Map格式
+                    Map<String, Object> rowMap = new HashMap<>();
+                    rowMap.put("pointNumber", item.getPointNumber());
+                    rowMap.put("coordinateSystem", item.getCoordinateSystem());
+                    rowMap.put("longitude", item.getLongitude());
+                    rowMap.put("longitudePosition", item.getLongitudePosition());
+                    rowMap.put("latitude", item.getLatitude());
+                    rowMap.put("latitudePosition", item.getLatitudePosition());
+                    rowMap.put("zone", item.getZone());
+                    rowMap.put("bandwidth", item.getBandwidth());
+                    rowMap.put("projectionHeight", item.getProjectionHeight());
+                    rowMap.put("rowNum", i + 2); // Excel中的行号
+
+                    validData.add(rowMap);
+                    successCount++;
+
+                } catch (Exception e) {
+                    errorMsg.append(String.format("第%d行数据验证失败：%s；", i + 2, e.getMessage()));
+                }
+            }
+
+            // 构建返回结果
+            Map<String, Object> result = new HashMap<>();
+            result.put("total", dataList.size());
+            result.put("validCount", successCount);
+            result.put("data", validData);
+
+            if (successCount == 0) {
+                return AjaxResult.error("没有有效数据！" + errorMsg.toString());
+            }
+
+            String message = String.format("导入成功！共解析%d条数据，有效数据%d条", dataList.size(), successCount);
+            if (errorMsg.length() > 0) {
+                message += "；部分数据验证失败：" + errorMsg.toString();
+                return AjaxResult.success(message, result);
+            }
+
+            return AjaxResult.success(message, result);
+
+        } catch (Exception e) {
+            e.printStackTrace();
+            return AjaxResult.error("导入失败：" + e.getMessage());
+        }
+    }
+
+    /**
+     * 执行高斯正算
+     */
+    @Override
+    public List<CmcGaussPositive> calculateGaussPositive(List<CmcGaussPositive> dataList)
+    {
+        List<CmcGaussPositive> resultList = new ArrayList<>();
+        for (CmcGaussPositive item : dataList) {
+            try {
+                CmcGaussPositive result = calculateGaussPositiveSingle(item);
+                resultList.add(result);
+            } catch (Exception e) {
+                e.printStackTrace();
+                // 计算失败时，返回带有错误信息的对象
+                CmcGaussPositive errorResult = new CmcGaussPositive();
+                errorResult.setPointNumber(item.getPointNumber());
+                errorResult.setGaussX(-1.0);
+                errorResult.setGaussY(-1.0);
+                errorResult.setMeridianConvergence(-1.0);
+                resultList.add(errorResult);
+            }
+        }
+
+        return resultList;
+    }
+    
+    /**
+     * 单条高斯正算
+     */
+    private CmcGaussPositive calculateGaussPositiveSingle(CmcGaussPositive cmcGaussPositive)
+    {
+        try {
+            initEllipsoidParams(cmcGaussPositive.getCoordinateSystem());
+
+            double longitude = cmcGaussPositive.getLongitude(); // 经度（度）
+            String longitudePosition = cmcGaussPositive.getLongitudePosition(); // 经度位置（东/西）
+            String latitudePosition = cmcGaussPositive.getLatitudePosition(); // 纬度位置（北/南）
+            double latitude = cmcGaussPositive.getLatitude(); // 纬度（度）
+            Integer zone = cmcGaussPositive.getZone(); // 带号
+            int bandwidth = cmcGaussPositive.getBandwidth(); // 带宽
+            int projectionHeight = cmcGaussPositive.getProjectionHeight(); // 投影面高程
+
+            // 计算中央经线
+            double centralMeridian;
+            if (bandwidth == 6) {
+                centralMeridian = zone * 6 - 3;
+            } else { // 3度带
+                centralMeridian = zone * 3;
+            }
+            // 转换为弧度
+            double B = convertDecimalDegrees(latitude) * Math.PI / 180;
+            double L = convertDecimalDegrees(longitude);
+            // double L0 = Math.toRadians(centralMeridian);
+           
+            // 计算经差
+            double l = (centralMeridian - L) * Math.PI / 180;
+            // 处理西经情况
+            if ("东".equals(longitudePosition) || "E".equalsIgnoreCase(longitudePosition)) {
+                l = (L - centralMeridian) * Math.PI / 180;
+            }
+            double m = Math.cos(B) * l;
+            double ep2 = 1 / Math.pow(1 - F, 2) - 1;
+            double eta2 = ep2 * Math.cos(B) * Math.cos(B);
+
+            // 计算卯酉圈曲率半径
+            double N = (A + projectionHeight) / ((1 - F) * Math.sqrt(1 + eta2));
+            // 计算子午线弧长
+            double X = calculateMeridianArc(B, projectionHeight);
+
+            // 计算Y坐标的系数
+            double t = Math.tan(B);
+            double t2 = t * t;
+            double t4 = t2 * t2;
+            double m2 = m * m;
+            double m4 = m2 * m2;
+
+            // 计算X坐标
+            double x = X + N * Math.cos(B) * Math.cos(B) * t * l * l / 2 +
+                    N * Math.pow(Math.cos(B), 4) * t * (5 - t * t + 9 * eta2 + 4 * eta2 * eta2) * Math.pow(l, 4) / 24 +
+                    N * Math.pow(Math.cos(B), 6) * t * (61 - 58 * t2 + t4 + 270 * eta2 - 330 * eta2 * t2)
+                            * Math.pow(l, 6) / 720;
+            // l 
+            double term1 = m;
+            //  l³ 
+            double term3 = (1 - t2 + eta2) * m2 * m / 6;
+            //  l⁵ 
+            double term5 = (5 - 18 * t2 + t4 + 14 * eta2 - 58 * eta2 * t2) * m4 * m / 120;
+            //计算y坐标
+            double y = N * (term1 + term3 + term5);
+
+            // 计算子午线收敛角
+            double meridianConvergence = t * (m + (1 + 3 * eta2 + 2 * eta2 * eta2) * m2 * m / 3 + (2 - t2) * m4 * m * 12 / 180);
+            meridianConvergence = Math.toDegrees(meridianConvergence);
+            meridianConvergence = decimalToDMS(meridianConvergence);
+            if ("南".equals(latitudePosition) || "S".equalsIgnoreCase(latitudePosition)) {
+                x = 10000000 - x;
+            }
+            // 加入东偏
+            y = 500000 + y;
+            System.out.println("x = " + x + ", y = " + y+", meridianConvergence = "+meridianConvergence);
+            // 设置计算结果
+            cmcGaussPositive.setGaussX(x);
+            cmcGaussPositive.setGaussY(y);
+            cmcGaussPositive.setMeridianConvergence(meridianConvergence);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return cmcGaussPositive;
+    }
+    
+    //选择椭球体参数
+    private void initEllipsoidParams(String coordinateSystem) {
+        if ("CGCS2000".equalsIgnoreCase(coordinateSystem) || "国家2000".equalsIgnoreCase(coordinateSystem)) {
+            A = A_CGCS2000;
+            F = F_CGCS2000;
+        } else if ("1954".equalsIgnoreCase(coordinateSystem) || "北京54".equalsIgnoreCase(coordinateSystem) || "Beijing54".equalsIgnoreCase(coordinateSystem)) {
+            A = A_BJ54;
+            F = F_BJ54;
+        } else if ("1980".equalsIgnoreCase(coordinateSystem) || "西安80".equalsIgnoreCase(coordinateSystem) || "Xian80".equalsIgnoreCase(coordinateSystem)) {
+            A = A_XA80;
+            F = F_XA80;
+        } else {
+            A = A_WGS84;
+            F = F_WGS84;
+        }
+        BigDecimal one = BigDecimal.ONE;
+        BigDecimal divisor = new BigDecimal("298.257222101");
+        BigDecimal db_F = one.divide(divisor, 20, RoundingMode.HALF_UP);
+
+        // 计算 2 * F
+        BigDecimal two = new BigDecimal("2");
+        BigDecimal twoF = two.multiply(db_F);
+
+        // 计算 F * F
+        BigDecimal F_squared = db_F.multiply(db_F);
+
+        // 计算 e2 = 2*F - F*F
+        BigDecimal e2 = twoF.subtract(F_squared);
+        E2 = e2.doubleValue();
+        F = db_F.doubleValue();
+    }
+
+    /**
+     * 计算子午线弧长
+     */
+    private double calculateMeridianArc(double B, double projectionHeight) {
+        double e2 = E2;
+        double e4 = E2 * E2;
+        double e6 = e4 * E2;
+        double e8 = e6 * E2;
+        double e10 = e8 * E2;
+        double d = A + projectionHeight;
+        // 计算子午线弧长系数
+        double a0 = (d - d * e2) * (1
+                + 3.0 / 4.0 * e2
+                + 45.0 / 64.0 * e4
+                + 175.0 / 256.0 * e6
+                + 11025.0 / 16384.0 * e8
+                + 43659.0 / 65536.0 * e10);
+
+        double a2 = (d - d * e2) * (3.0 / 4.0 * e2
+                + 45.0 / 64.0 * e4
+                + 175.0 / 256.0 * e6
+                + 11025.0 / 16384.0 * e8
+                + 43659.0 / 65536.0 * e10);
+
+        double a4 = (d - d * e2) * (15.0 / 32.0 * e4
+                + 175.0 / 384.0 * e6
+                + 3675.0 / 8192.0 * e8
+                + 14553.0 / 32768.0 * e10);
+
+        double a6 = (d - d * e2) * (35.0 / 96.0 * e6
+                + 735.0 / 2048.0 * e8
+                + 14553.0 / 40960.0 * e10);
+
+        double a8 = (d - d * e2) * (315.0 / 1024.0 * e8
+                + 6237.0 / 20480.0 * e10);
+
+        double a10 = (d - d * e2) * (693.0/2560.0)* e10;
+
+        // 计算子午线弧长
+        double sinB = Math.sin(B);
+        double cosB = Math.cos(B);
+
+        double X = a0 * B - (a2 * sinB + a4 * Math.pow(sinB, 3) + a6 * Math.pow(sinB, 5) + a8 * Math.pow(sinB, 7)
+                + a10 * Math.pow(sinB, 9)) * cosB;
+        return X;
+    }
+    
+    /**
+     * 将十进制度数转换为特定格式（
+     * @param decimalDegrees 十进制度数
+     * @return 转换后的值
+     */
+    public static double convertDecimalDegrees(double decimalDegrees) {
+        // 度的整数部分
+        double degrees = Math.floor(decimalDegrees);
+
+        // 分的计算
+        double minutes = Math.floor(100 * (decimalDegrees - degrees)) / 60;
+
+        // 秒的计算
+        double seconds = (decimalDegrees * 100 - Math.floor(decimalDegrees * 100)) / 36;
+
+        return degrees + minutes + seconds;
+    }
+    
+    /**
+     * 将十进制度数转换为度分秒格式数值（DD.MMSSssss）
+     * 
+     * @param decimalDegrees 十进制度数（如 103.373428195）
+     */
+    public static double decimalToDMS(double decimalDegrees) {
+        // 1. 提取度
+        double degrees = Math.floor(decimalDegrees );
+
+        // 2. 提取分
+        double minutesRaw = 60 * (decimalDegrees - degrees);
+        double minutes = Math.floor(minutesRaw) / 100;
+
+        // 3. 提取秒
+        double secondsRaw = 60 * (60 * decimalDegrees - Math.floor(60 * decimalDegrees ));
+        double seconds = secondsRaw / 10000;
+
+        return degrees + minutes + seconds;
+    }
+}

oa-back/ruoyi-calculate/src/main/java/com/ruoyi/web/calculate/vo/CmcGaussPositiveTemplate.java

@@ -0,0 +1,123 @@
+package com.ruoyi.web.calculate.vo;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+
+import com.ruoyi.common.annotation.Excel;
+
+public class CmcGaussPositiveTemplate {
+
+    @Excel(name = "待求点")
+    private String pointNumber;
+
+    @Excel(name = "坐标系")
+    private String coordinateSystem;
+
+    @Excel(name = "大地经度")
+    private Double longitude;
+
+    @Excel(name = "经度位置")
+    private String longitudePosition;
+
+    @Excel(name = "大地纬度")
+    private Double latitude;
+
+    @Excel(name = "纬度位置")
+    private String latitudePosition;
+
+    @Excel(name = "带号")
+    private Integer zone;
+
+    @Excel(name = "带宽")
+    private Integer bandwidth;
+
+    public void setPointNumber(String pointNumber) 
+    {
+        this.pointNumber = pointNumber;
+    }
+
+    public String getPointNumber() 
+    {
+        return pointNumber;
+    }
+    public void setCoordinateSystem(String coordinateSystem) 
+    {
+        this.coordinateSystem = coordinateSystem;
+    }
+
+    public String getCoordinateSystem() 
+    {
+        return coordinateSystem;
+    }
+     public void setLongitude(Double longitude) 
+    {
+        // 大地经度保留10位小数
+        if (longitude != null) {
+            BigDecimal bd = new BigDecimal(longitude);
+            this.longitude = bd.setScale(10, RoundingMode.HALF_UP).doubleValue();
+        } else {
+            this.longitude = null;
+        }
+    }
+
+    public Double getLongitude() 
+    {
+        return longitude;
+    }
+    
+    public void setLongitudePosition(String longitudePosition) 
+    {
+        this.longitudePosition = longitudePosition;
+    }
+
+    public String getLongitudePosition() 
+    {
+        return longitudePosition;
+    }
+    
+    public void setLatitude(Double latitude) 
+    {
+        // 大地纬度保留10位小数
+        if (latitude != null) {
+            BigDecimal bd = new BigDecimal(latitude);
+            this.latitude = bd.setScale(10, RoundingMode.HALF_UP).doubleValue();
+        } else {
+            this.latitude = null;
+        }
+    }
+
+    public Double getLatitude() 
+    {
+        return latitude;
+    }
+    
+    public void setLatitudePosition(String latitudePosition) 
+    {
+        this.latitudePosition = latitudePosition;
+    }
+
+    public String getLatitudePosition() 
+    {
+        return latitudePosition;
+    }
+    
+    public void setZone(Integer zone) 
+    {
+        this.zone = zone;
+    }
+
+    public Integer getZone() 
+    {
+        return zone;
+    }
+    
+    public void setBandwidth(Integer bandwidth) 
+    {
+        this.bandwidth = bandwidth;
+    }
+
+    public Integer getBandwidth() 
+    {
+        return bandwidth;
+    }
+}

oa-ui/src/api/calculate/gausspositive.js

@@ -0,0 +1,42 @@
+import request from '@/utils/request'
+
+
+// 执行高斯正算
+export function calculate(data) {
+    return request({
+        url: `/calculate/gaussPositive/calculate`,
+        method: 'post',
+        data: data
+    })
+}
+
+// 导入Excel
+export function importExcel(data) {
+    return request({
+        url: `/calculate/gaussPositive/import`,
+        method: 'post',
+        data: data,
+        headers: {
+            'Content-Type': 'multipart/form-data'
+        }
+    })
+}
+
+// 导出高斯正算
+export function exportExcel(data) {
+    return request({
+        url: `/calculate/gaussPositive/export`,
+        method: 'post',
+        data: data,
+        responseType: 'blob'
+    })
+}
+
+// 下载模板
+export function downloadTemplate() {
+    return request({
+        url: '/calculate/gaussPositive/template',
+        method: 'get',
+        responseType: 'blob'
+    })
+}

oa-ui/src/views/calculate/index.vue

@@ -0,0 +1,223 @@
+<template>
+  <div class="gauss-calculate">
+    <!-- 工具选择区域 -->
+    <div class="tool-selector-area">
+      <div class="tool-selector-label">
+        <i class="el-icon-s-tools"></i>
+        <span class="label-text">选择工具</span>
+        <span class="label-sub">请从下方选择需要使用的计算工具</span>
+      </div>
+      <el-cascader
+        v-model="selectedToolPath"
+        :options="toolOptions"
+        :props="cascaderProps"
+        placeholder="请选择要使用的工具"
+        @change="handleToolChange"
+        clearable
+        class="tool-cascader"
+      ></el-cascader>
+    </div>
+    
+    <!-- 动态组件：根据选择的工具显示对应的工具页面 -->
+    <div class="tool-content">
+      <transition name="fade" mode="out-in">
+        <component 
+          :is="currentToolComponent" 
+          :key="currentToolKey"
+          ref="currentTool"
+          @tool-event="handleToolEvent"
+        />
+      </transition>
+    </div>
+  </div>
+</template>
+
+<script>
+// 导入各个工具组件
+import GaussPositiveTool from './tools/gausspositive.vue'
+
+export default {
+  name: 'CalculationTools',
+  components: {
+    GaussPositiveTool,
+  },
+  data() {
+    return {
+      // 级联选择器选中的值（路径数组）
+      selectedToolPath: [],
+      // 当前激活的工具组件名称
+      currentToolComponent: 'GaussPositiveTool',
+      // 当前工具的key（用于强制刷新组件）
+      currentToolKey: 0,
+      // 级联选择器的配置
+      cascaderProps: {
+        value: 'id',
+        label: 'name',
+        children: 'children',
+        expandTrigger: 'hover',
+      },
+      // 工具选项配置（分类 + 工具）
+      toolOptions: [
+        {
+          id: 'gauss-category',
+          name: '各种坐标系高斯正算',
+          children: [
+            {
+              id: 'gauss-positive',
+              name: '高斯正算工具',
+              component: 'GaussPositiveTool'
+            }
+          ]
+        },
+        {
+          id: 'other-category',
+          name: '其他计算工具',
+          children: [
+            // 预留其他工具位置
+          ]
+        }
+      ]
+    }
+  },
+  mounted() {
+    // 首次进入，默认选中第一个工具
+    this.setDefaultTool()
+  },
+  methods: {
+    // 设置默认工具（第一个分类下的第一个工具）
+    setDefaultTool() {
+      if (this.toolOptions.length > 0 && this.toolOptions[0].children.length > 0) {
+        const firstCategory = this.toolOptions[0]
+        const firstTool = firstCategory.children[0]
+        this.selectedToolPath = [firstCategory.id, firstTool.id]
+        this.currentToolComponent = firstTool.component
+        // 强制刷新组件
+        this.currentToolKey++
+      }
+    },
+    
+    // 级联选择器值变化时的处理
+    handleToolChange(value) {
+      if (!value || value.length === 0) {
+        // 如果清空了选择，恢复上一个工具
+        if (this.selectedToolPath && this.selectedToolPath.length > 0) {
+          this.$nextTick(() => {
+            this.selectedToolPath = [...this.prevSelectedPath]
+          })
+        }
+        return
+      }
+      
+      // 保存当前路径
+      this.prevSelectedPath = [...value]
+      
+      // 根据路径找到对应的工具组件
+      const categoryId = value[0]
+      const toolId = value[1]
+      
+      const category = this.toolOptions.find(opt => opt.id === categoryId)
+      if (category && category.children) {
+        const tool = category.children.find(child => child.id === toolId)
+        if (tool && tool.component) {
+          this.currentToolComponent = tool.component
+          // 强制刷新组件
+          this.currentToolKey++
+        }
+      }
+    },
+    
+    // 处理工具组件触发的事件
+    handleToolEvent(eventData) {
+      console.log('工具事件:', eventData)
+      if (eventData && eventData.message) {
+        this.$message({
+          message: eventData.message,
+          type: eventData.type || 'info',
+          duration: 2000
+        })
+      }
+    }
+  }
+}
+</script>
+
+<style scoped>
+.gauss-calculate {
+  padding: 20px;
+  background-color: #f5f7fa;
+  min-height: 100vh;
+}
+
+/* 工具选择区域样式 */
+.tool-selector-area {
+  background: linear-gradient(135deg, #11a983 0%, rgba(196, 211, 207, 0.85) 100%);
+  border-radius: 12px;
+  padding: 24px 30px;
+  margin-bottom: 24px;
+  box-shadow: 0 4px 15px rgba(0, 0, 0, 0.1);
+}
+
+.tool-selector-label {
+  display: flex;
+  align-items: baseline;
+  flex-wrap: wrap;
+  gap: 12px;
+  margin-bottom: 16px;
+}
+
+.tool-selector-label i {
+  font-size: 28px;
+  color: #fff;
+}
+
+.label-text {
+  font-size: 24px;
+  font-weight: bold;
+  color: #fff;
+  letter-spacing: 2px;
+}
+
+.label-sub {
+  font-size: 14px;
+  color: rgba(255, 255, 255, 0.85);
+  margin-left: 8px;
+}
+
+.tool-cascader {
+  width: 100%;
+  max-width: 500px;
+}
+
+.tool-cascader /deep/ .el-input__inner {
+  height: 44px;
+  line-height: 44px;
+  font-size: 15px;
+  border-radius: 8px;
+  border: none;
+  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+}
+
+.tool-cascader /deep/ .el-input__inner:focus {
+  box-shadow: 0 0 0 2px rgba(255, 255, 255, 0.5);
+}
+
+/* 工具内容区域 */
+.tool-content {
+  background-color: #ffffff;
+  border-radius: 12px;
+  padding: 24px;
+  box-shadow: 0 2px 12px 0 rgba(0, 0, 0, 0.05);
+  min-height: 500px;
+}
+
+/* 过渡动画 */
+.fade-enter-active,
+.fade-leave-active {
+  transition: opacity 0.3s ease;
+}
+
+.fade-enter,
+.fade-leave-to {
+  opacity: 0;
+}
+</style>

oa-ui/src/views/calculate/tools/gausspositive.vue

@@ -0,0 +1,555 @@
+<!-- 高斯正算工具组件 -->
+<template>
+  <div class="gauss-positive-tool">
+    <!-- 操作按钮区 -->
+    <div class="tool-header">
+      <div class="card-header-buttons">
+        <el-button type="primary" @click="handleImport" size="small" icon="el-icon-upload">
+          导入Excel
+        </el-button>
+
+        <el-button 
+          type="success" 
+          @click="handlePreview" 
+          size="small" 
+          :disabled="!importedData || importedData.length === 0"
+          icon="el-icon-view">
+          预览数据
+        </el-button>
+        <el-button 
+          type="warning" 
+          @click="handleCalculate" 
+          size="small" 
+          :disabled="!importedData || importedData.length === 0 || calculating"
+          :loading="calculating"
+          icon="el-icon-caret-right">
+          {{ calculating ? '计算中...' : '执行计算' }}
+        </el-button>
+        <el-button 
+          type="danger" 
+          @click="clearAll" 
+          size="small" 
+          :disabled="(!importedData || importedData.length === 0) && calculationResults.length === 0"
+          plain
+          icon="el-icon-delete">
+          清空全部
+        </el-button>
+      </div>
+    </div>
+    
+    <!-- 投影面高程设置 -->
+    <div class="height-setting">
+      <div class="setting-label">
+        <span>投影面高程</span>
+      </div>
+      <div class="setting-content">
+        <el-input 
+          v-model="projectionHeight" 
+          size="small" 
+          style="width: 120px; margin-right: 10px;">
+        </el-input>
+        <span class="unit">米 (m)</span>
+        
+      </div>
+    </div>
+
+    <!-- 计算结果展示区 - 只显示计算结果，不包含原始数据 -->
+    <div v-if="calculationResults.length > 0" class="result-section">
+      <div class="section-header">
+        <span class="section-title">
+          <i class="el-icon-tickets"></i>
+          计算结果
+        </span>
+        <span class="section-info">
+          共 {{ calculationResults.length }} 条计算结果
+        </span>
+        <el-button type="text" size="small" @click="handleExport" icon="el-icon-download">
+          导出结果
+        </el-button>
+      </div>
+      
+      <el-table :data="calculationResults" style="width: 100%" border stripe>
+        <el-table-column prop="pointNumber" label="待求点号" width="120" align="center"></el-table-column>
+        <el-table-column prop="gaussX" label="高斯X坐标(m)" width="180" align="center">
+          <template slot-scope="scope">
+            <span class="result-value">{{ formatNumber(scope.row.gaussX,4) }}</span>
+          </template>
+        </el-table-column>
+        <el-table-column prop="gaussY" label="高斯Y坐标(m)" width="180" align="center">
+          <template slot-scope="scope">
+            <span class="result-value">{{ formatNumber(scope.row.gaussY,4) }}</span>
+          </template>
+        </el-table-column>
+        <el-table-column prop="meridianConvergence" label="子午线收敛角γ(°)" width="200" align="center">
+          <template slot-scope="scope">
+            <span class="result-value">{{ formatNumber(scope.row.meridianConvergence, 7) }}</span>
+          </template>
+        </el-table-column>
+      </el-table>
+    </div>
+    
+    <!-- 空状态 -->
+    <div v-else class="empty-state">
+      <i class="el-icon-document"></i>
+      <p>暂无计算结果</p>
+      <p class="empty-tip">请先导入Excel数据，然后点击"执行计算"</p>
+    </div>
+    
+    <!-- 导入Excel对话框 -->
+    <el-dialog title="导入Excel" :visible.sync="importDialogVisible" width="550px" @close="resetImport">
+      <div class="import-tips">
+        <el-alert
+          title="Excel模板格式说明"
+          type="info"
+          :closable="false"
+          show-icon>
+          <div class="template-info">
+            <p>请确保Excel文件包含以下列（第一行为表头）：</p>
+            <ul>
+              <li><strong>待求点</strong> - 点号</li>
+              <li><strong>坐标系</strong> - WGS84/CGCS2000/Beijing54/Xian80</li>
+              <li><strong>大地经度</strong> - 经度数值(° ′ ″)</li>
+              <li><strong>经度位置</strong> - E/W</li>
+              <li><strong>大地纬度</strong> - 纬度数值(° ′ ″)</li>
+              <li><strong>纬度位置</strong> - N/S</li>
+              <li><strong>带号</strong> - 带号数值</li>
+              <li><strong>带宽</strong> - 3或6</li>
+            </ul>
+          </div>
+        </el-alert>
+         <div class="template-download-wrapper">
+            <el-button type="primary" plain size="small" @click="handleDownloadTemplate" icon="el-icon-download">
+              下载Excel模板
+            </el-button>
+          </div>
+      </div>
+      <div style="text-align: center;">
+        <el-upload
+          class="upload-area"
+          :action="''"
+          :auto-upload="false"
+          :on-change="handleFileChange"
+          :show-file-list="true"
+          accept=".xlsx,.xls"
+          drag
+          ref="upload">
+          <i class="el-icon-upload"></i>
+          <div class="el-upload__text">将Excel文件拖到此处，或<em>点击选择</em></div>
+          <div class="el-upload__tip" slot="tip">
+            支持.xlsx和.xls格式文件
+          </div>
+        </el-upload>
+      </div>
+      
+      <span slot="footer" class="dialog-footer">
+        <el-button @click="importDialogVisible = false">取消</el-button>
+        <el-button type="primary" @click="submitImport" :loading="importLoading" :disabled="!importFile">
+          确认导入
+        </el-button>
+      </span>
+    </el-dialog>
+    
+    <!-- 预览数据对话框 - 显示导入的原始数据 -->
+    <el-dialog title="导入数据预览" :visible.sync="previewDialogVisible" width="80%">
+      <div class="preview-info">
+        <span>共 {{ importedData.length }} 条数据</span>
+        <span style="margin-left: 20px;">状态：{{ importedData.filter(item => item.calculated).length }} 条已计算，{{ importedData.filter(item => !item.calculated).length }} 条未计算</span>
+      </div>
+      <el-table :data="importedData" border stripe max-height="500">
+        <el-table-column prop="pointNumber" label="待求点号" width="120" fixed="left"></el-table-column>
+        <el-table-column prop="coordinateSystem" label="坐标系" width="110">
+          <template slot-scope="scope">
+            <el-tag size="small" :type="getCoordinateType(scope.row.coordinateSystem)">
+              {{ scope.row.coordinateSystem }}
+            </el-tag>
+          </template>
+        </el-table-column>
+        <el-table-column prop="longitude" label="大地经度" width="130" align="center">
+          <template slot-scope="scope">
+            {{ scope.row.longitude }}
+          </template>
+        </el-table-column>
+         <el-table-column prop="longitudePosition" label="经度位置" width="130" align="center">
+          <template slot-scope="scope">
+            {{ scope.row.longitudePosition}}
+          </template>
+        </el-table-column>
+        <el-table-column prop="latitude" label="大地纬度" width="130" align="center">
+          <template slot-scope="scope">
+            {{ scope.row.latitude }}
+          </template>
+        </el-table-column>
+         <el-table-column prop="latitudePosition" label="纬度位置" width="130" align="center">
+          <template slot-scope="scope">
+            {{ scope.row.latitudePosition}}
+                   </template>
+        </el-table-column>
+        <el-table-column prop="zone" label="带号" width="80" align="center"></el-table-column>
+        <el-table-column prop="bandwidth" label="带宽" width="80" align="center">
+          <template slot-scope="scope">
+            {{ scope.row.bandwidth }}
+          </template>
+        </el-table-column>
+      </el-table>
+      <span slot="footer" class="dialog-footer">
+        <el-button type="primary" @click="previewDialogVisible = false">关闭</el-button>
+      </span>
+    </el-dialog>
+  </div>
+</template>
+
+<script>
+import { calculate, importExcel,exportExcel,downloadTemplate } from '@/api/calculate/gausspositive'
+
+export default {
+  name: 'GaussPositiveTool',
+  data() {
+    return {
+      importedData: [],        // 导入的原始数据
+      calculationResults: [],  // 计算结果
+      importDialogVisible: false,
+      importLoading: false,
+      importFile: null,
+      calculating: false,
+      previewDialogVisible: false,
+      projectionHeight: 0
+    }
+  },
+  watch: {
+    // 当投影面高程改变时，重新计算（如果已有数据）
+    projectionHeight(newVal, oldVal) {
+      if (this.importedData.length > 0 && this.calculationResults.length > 0) {
+        this.handleCalculate()
+      }
+    }
+  },
+  methods: {
+    // 打开导入对话框
+    handleImport() {
+      this.importDialogVisible = true
+    },
+    
+    // 文件选择变化
+    handleFileChange(file) {
+      this.importFile = file.raw
+    },
+    
+    // 提交导入
+    async submitImport() {
+      if (!this.importFile) {
+        this.$message.warning('请选择文件')
+        return
+      }
+      
+      this.importLoading = true
+      
+      const formData = new FormData()
+      formData.append('file', this.importFile)
+      
+        const response = await importExcel(formData)
+        
+        if (response.code === 200) {
+          const result = response.data
+          
+          // 将后端返回的数据转换为前端格式
+          this.importedData = (result.data || []).map(item => ({
+            pointNumber: item.pointNumber,
+            coordinateSystem: item.coordinateSystem,
+            longitude: item.longitude,
+            longitudePosition: item.longitudePosition,
+            latitude: item.latitude,
+            latitudePosition: item.latitudePosition,
+            zone: item.zone,
+            bandwidth: item.bandwidth
+          }))
+          
+          // 清空之前的计算结果
+          this.calculationResults = []
+          
+          this.$message.success(`${response.msg}`)
+          this.importDialogVisible = false
+          this.importLoading = false
+        } else {
+          this.$message.error(response.msg)
+        }
+    },
+    
+    // 预览数据 - 显示导入的原始数据
+    handlePreview() {
+      if (!this.importedData || this.importedData.length === 0) {
+        this.$message.warning('没有可预览的数据')
+        return
+      }
+      this.previewDialogVisible = true
+    },
+    
+    // 下载模板
+    handleDownloadTemplate() {
+       this.download('/calculate/gaussPositive/template', {}, '高斯正算模板.xlsx')
+    },
+    
+    
+    // 执行计算
+    async handleCalculate() {
+      if (!this.importedData || this.importedData.length === 0) {
+        this.$message.warning('没有数据可计算')
+        return
+      }
+      
+      this.calculating = true
+      const results = []
+      let successCount = 0
+      let failCount = 0
+      
+      // 构建请求参数
+      const requestData = this.importedData.map(item => ({
+        pointNumber: item.pointNumber,
+        coordinateSystem: item.coordinateSystem,
+        longitude: parseFloat(item.longitude),
+        longitudePosition: item.longitudePosition,
+        latitude: parseFloat(item.latitude),
+        latitudePosition: item.latitudePosition,
+        zone: parseInt(item.zone),
+        bandwidth: parseInt(item.bandwidth),
+        projectionHeight: this.projectionHeight
+      }))
+      
+      const response = await calculate(requestData)
+      
+      if (response.code === 200) {
+        const results = response.data || []
+        
+        // 更新计算结果
+        this.calculationResults = results.map(item => ({
+          pointNumber: item.pointNumber,
+          coordinateSystem: item.coordinateSystem,
+          longitude: parseFloat(item.longitude),
+          longitudePosition: item.longitudePosition,
+          latitude: parseFloat(item.latitude),
+          latitudePosition: item.latitudePosition,
+          zone: parseInt(item.zone),
+          bandwidth: parseInt(item.bandwidth),
+          projectionHeight: this.projectionHeight,
+          gaussX: item.gaussX,
+          gaussY: item.gaussY,
+          meridianConvergence: item.meridianConvergence
+        }))
+        
+        // 更新导入数据的计算状态
+        this.importedData.forEach(importItem => {
+          const found = results.find(r => r.pointNumber === importItem.pointNumber)
+          if (found && found.gaussX !== -1) {
+            importItem.calculated = true
+          }
+        })
+        
+        const successCount = results.filter(r => r.gaussX !== -1).length
+        const failCount = results.length - successCount
+        
+        this.$message.success(`计算完成，成功 ${successCount} 条${failCount > 0 ? `，失败 ${failCount} 条` : ''}`)
+        this.calculating = false
+        } else {
+          this.$message.error(response.msg)
+        }
+    },
+    
+    
+    // 导出结果
+    async handleExport() {
+      if (this.calculationResults.length === 0) {
+        this.$message.warning('没有结果可导出')
+        return
+      }
+      
+        const response = await exportExcel(this.calculationResults)
+        
+        const blob = new Blob([response], { 
+          type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+        })
+        
+        const url = window.URL.createObjectURL(blob)
+        const link = document.createElement('a')
+        link.href = url
+        link.download = `高斯正算结果_${new Date().getTime()}.xlsx`
+        link.click()
+        window.URL.revokeObjectURL(url)
+  },
+    
+  // 清空全部
+  clearAll() {
+    if ((!this.importedData || this.importedData.length === 0) && this.calculationResults.length === 0) {
+      return
+    }
+    
+    this.$confirm('确定清空所有数据吗？此操作不可恢复！', '警告', {
+      confirmButtonText: '确定',
+      cancelButtonText: '取消',
+      type: 'warning'
+    }).then(() => {
+      this.importedData = []
+      this.calculationResults = []
+      this.$message.success('已清空所有数据')
+    }).catch(() => {})
+  },
+  
+  // 重置导入状态
+  resetImport() {
+    this.importFile = null
+    if (this.$refs.upload) {
+      this.$refs.upload.clearFiles()
+    }
+  },
+  
+  // 格式化数字显示
+  formatNumber(value, decimals = 3) {
+    if (value === null || value === undefined) return '--'
+    return Number(value).toFixed(decimals)
+  },
+  
+  // 获取坐标系标签类型
+  getCoordinateType(system) {
+    const types = {
+      'WGS84': 'primary',
+      'CGCS2000': 'success',
+      'Beijing54': 'warning',
+      'Xian80': 'info'
+    }
+    return types[system] || 'info'
+  }
+  }
+}
+</script>
+
+<style scoped>
+.gauss-positive-tool {
+  width: 100%;
+}
+
+.tool-header {
+  margin-bottom: 20px;
+}
+
+.card-header-buttons {
+  display: flex;
+  gap: 10px;
+  flex-wrap: wrap;
+}
+
+/* 投影面高程设置样式 */
+.height-setting {
+  background: #f5f7fa;
+  border-radius: 8px;
+  padding: 12px 20px;
+  margin-bottom: 20px;
+  border: 1px solid #e4e7ed;
+  display: flex;
+  align-items: center;
+  gap: 20px;
+  flex-wrap: wrap;
+}
+
+.result-section {
+  margin-top: 10px;
+}
+
+.section-header {
+  padding: 12px 16px;
+  background: #f5f7fa;
+  border-radius: 8px 8px 0 0;
+  border: 1px solid #e4e7ed;
+  border-bottom: none;
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+}
+
+.section-title {
+  font-size: 14px;
+  font-weight: bold;
+  color: #303133;
+}
+
+.section-title i {
+  margin-right: 8px;
+  color: #11a983;
+}
+
+.section-info {
+  font-size: 12px;
+  color: #909399;
+}
+
+.result-value {
+  color: #409eff;
+  font-family: monospace;
+  font-weight: 500;
+}
+
+.empty-state {
+  text-align: center;
+  padding: 60px 20px;
+  background: #fff;
+  border-radius: 8px;
+  border: 1px solid #e4e7ed;
+  color: #909399;
+}
+
+.empty-state i {
+  font-size: 64px;
+  margin-bottom: 16px;
+}
+
+.empty-tip {
+  font-size: 12px;
+  margin-top: 12px;
+  color: #c0c4cc;
+}
+
+.import-tips {
+  margin-bottom: 20px;
+}
+
+.template-info {
+  margin-top: 12px;
+}
+
+.template-info ul {
+  margin: 8px 0;
+  padding-left: 20px;
+}
+
+.template-info li {
+  margin: 4px 0;
+  font-size: 13px;
+}
+
+.upload-area {
+  margin-top: 10px;
+}
+
+.preview-info {
+  margin-bottom: 15px;
+  padding: 10px;
+  background: #f5f7fa;
+  border-radius: 4px;
+  font-size: 14px;
+  color: #606266;
+}
+
+.dialog-footer {
+  width: 100%;
+  display: flex;
+  justify-content: flex-end;
+  gap: 10px;
+}
+
+.template-download-wrapper {
+  margin-top: 12px;
+  display: flex;
+  align-items: center;
+  justify-content: flex-end;
+  gap: 10px;
+  padding-top: 12px;
+  border-top: 1px dashed #e4e7ed;
+}
+</style>