/*
* @Description: In User Settings Edit
* @Author: xiaoying
* @Date: 2019-08-22 17:10:01
* @LastEditTime: 2019-08-31 13:33:20
* @LastEditors: mayuanye
*/
import { NativeModules } from 'react-native';
let SR = NativeModules.JSSRefData;
/**
* @class SRefData
* @description android空间参考系对象功能组件
*/
export default class SRefData {
/**
* 构造一个新的SRefData对象。
* @memberof SRefData
* @returns {Promise.<SRefData>}
*/
async createObj() {
try {
var { SRefDataId } = await SR.createObj();
var sRefData = new SRefData();
sRefData._MGSRefDataId = SRefDataId;
return sRefData;
} catch (e) {
console.error(e);
}
}
/**
* 获取空间坐标系在地理数据库中的唯一标识
* @memberOf SRefData
* @returns {Promise<*>}
*/
async getSRSID() {
try {
let srsID = await SR.getSRSID(this._MGSRefDataId);
return srsID;
} catch (e) {
console.error(e);
}
}
/**
* 设置空间坐标系在地理数据库中的唯一标识
* @memberOf SRefData
* @param {int} srsID 空间坐标系在地理数据库中的唯一标识
* @returns {Promise<*>}
*/
async setSRSID(srsID) {
try {
await SR.setSRSID(this._MGSRefDataId, srsID);
} catch (e) {
console.error(e);
}
}
/**
* 获取名称
* @memberOf SRefData
* @returns{String}
*/
async getSRSName() {
try {
let srsName = await SR.getSRSName(this._MGSRefDataId);
return srsName;
} catch (e) {
console.error(e);
}
}
/**
* 设置名称
* @memberOf SRefData
* @param {String} name 名称
* @returns {Promise<*>}
*/
async setSRSName(name) {
try {
await SR.setSRSName(this._MGSRefDataId, name);
} catch (e) {
console.error(e);
}
}
/**
* 获取别名
* @memberof SRefData
* @returns {String}
*/
async getAlias() {
try {
let alias = await SR.getAlias(this._MGSRefDataId);
return alias;
} catch (e) {
console.error(e);
}
}
/**
* 设置别名
* @memberof SRefData
* @param {String} alias 别名
* @returns {Promise<*>}
*/
async setAlias(alias) {
try {
await SR.setAlias(this._MGSRefDataId, alias);
} catch (e) {
console.error(e);
}
}
/**
* 获取缩写
* @memberof SRefData
* @returns {String}
*/
async getAbbreviation() {
try {
let abbreviation = await SR.getAbbreviation(this._MGSRefDataId);
return abbreviation;
} catch (e) {
console.error(e);
}
}
/**
* 设置缩写
* @memberof SRefData
* @param {String} abbreviation 缩写
* @returns {Promise<*>}
*/
async setAbbreviation(abbreviation) {
try {
await SR.setAbbreviation(this._MGSRefDataId, abbreviation);
} catch (e) {
console.error(e);
}
}
/**
* 获取备注
* @memberof SRefData
* @returns {String}
*/
async getRemark() {
try {
let remark = await SR.getRemark(this._MGSRefDataId);
return remark;
} catch (e) {
console.error(e);
}
}
/**
* 设置备注
* @memberof SRefData
* @param {String} remark 备注
* @returns {Promise<*>}
*/
async setRemark(remark) {
try {
await SR.setRemark(this._MGSRefDataId, remark);
} catch (e) {
console.error(e);
}
}
/**
* 获取类型
* @memberof SRefData
* @returns {int}
*/
async getType() {
try {
let type = await SR.getType(this._MGSRefDataId);
return type;
} catch (e) {
console.error(e);
}
}
/**
* 设置空间参考系类型
* @memberof SRefData
* @param {int} type 类型
* @returns {Promise<*>}
*/
async setType(type) {
try {
await SR.setType(this._MGSRefDataId, type);
} catch (e) {
console.error(e);
}
}
/**
* 获取地理坐标系名称
* @memberof SRefData
* @returns {String}
*/
async getGCSName() {
try {
let gcsName = await SR.getGCSName(this._MGSRefDataId);
return gcsName;
} catch (e) {
console.error(e);
}
}
/**
* 设置地理坐标系名称
* @param {String} gcsName 地理坐标系名称
* @memberof SRefData
* @returns {Promise<*>}
*/
async setGCSName(gcsName) {
try {
await SR.setGCSName(this._MGSRefDataId, gcsName);
} catch (e) {
console.error(e);
}
}
/**
* 获取椭球体索引
* @memberof SRefData
* @returns {int}
*/
async getSpheroid() {
try {
let spheroid = await SR.getSpheroid(this._MGSRefDataId);
return spheroid;
} catch (e) {
console.error(e);
}
}
/**
* 设置椭球体索引
* @memberof SRefData
* @param {int} spheroid 椭球体索引
* @returns {Promise<*>}
*/
async setSpheroid(spheroid) {
try {
await SR.setSpheroid(this._MGSRefDataId, spheroid);
} catch (e) {
console.error(e);
}
}
/**
* 获取地球椭球长轴
* @memberof SRefData
* @returns {double}
*/
async getA() {
try {
let a = await SR.getA(this._MGSRefDataId);
return a;
} catch (e) {
console.error(e);
}
}
/**
* 设置地球椭球长轴
* @memberof SRefData
* @param {double} a 地球椭球长轴
* @returns {Promise<*>}
*/
async setA(a) {
try {
await SR.setA(this._MGSRefDataId, a);
} catch (e) {
console.error(e);
}
}
/**
* 获取地球椭球短轴
* @memberof SRefData
* @returns {double}
*/
async getB() {
try {
let b = await SR.getB(this._MGSRefDataId);
return b;
} catch (e) {
console.error(e);
}
}
/**
* 设置地球椭球短轴
* @memberof SRefData
* @param {double} b 地球椭球短轴
* @returns {Promise<*>}
*/
async setB(b) {
try {
await SR.setB(this._MGSRefDataId, b);
} catch (e) {
console.error(e);
}
}
/**
* 获取地球椭球扁率
* @memberof SRefData
* @returns {double}
*/
async getAf() {
try {
let af = await SR.getAf(this._MGSRefDataId);
return af;
} catch (e) {
console.error(e);
}
}
/**
* 设置地球椭球扁率
* @memberof SRefData
* @param {double} af 地球椭球扁率
* @returns {Promise<*>
*/
async setAf(af) {
try {
await SR.setAf(this._MGSRefDataId, af);
} catch (e) {
console.error(e);
}
}
/**
* 获取本初子午线(Prime Meridian)名称
* @memberof SRefData
* @returns {String}
*/
async getPMName() {
try {
let pmName = await SR.getPMName(this._MGSRefDataId);
return pmName;
} catch (e) {
console.error(e);
}
}
/**
* 设置本初子午线(Prime Meridian)名称
* @memberof SRefData
* @param {String} pmName 本初子午线(Prime Meridian)名称
* @returns {Promise<*>}
*/
async setPMName(pmName) {
try {
await SR.setPMName(this._MGSRefDataId, pmName);
} catch (e) {
console.error(e);
}
}
/**
* 获取本初子午线与国标偏移量(DMS)
* @memberof SRefData
* @returns {double}
*/
async getPMOffset() {
try {
let pmOffset = await SR.getPMOffset(this._MGSRefDataId);
return pmOffset;
} catch (e) {
console.error(e);
}
}
/**
* 设置本初子午线与国标偏移量(DMS)
* @memberof SRefData
* @param {double} pmOffset 本初子午线与国标偏移量(DMS)
* @returns {Promise<*>}
*/
async setPMOffset(pmOffset) {
try {
await SR.setPMOffset(this._MGSRefDataId, pmOffset);
} catch (e) {
console.error(e);
}
}
/**
* 获取几何码
* @memberof SRefData
* @returns {String}
*/
async getGeoCode() {
try {
let geoCode = await SR.getGeoCode(this._MGSRefDataId);
return geoCode;
} catch (e) {
console.error(e);
}
}
/**
* 设置几何码
* @memberof SRefData
* @param {String} geoCode 几何码
* @returns {Promise<*>}
*/
async setGeoCode(geoCode) {
try {
await SR.setGeoCode(this._MGSRefDataId, geoCode);
} catch (e) {
console.error(e);
}
}
/**
* 获取投影坐标系名称
* @memberof sRefData
* @returns {String}
*/
async getPCSName() {
try {
let pcsName = await SR.getPCSName(this._MGSRefDataId);
return pcsName;
} catch (e) {
console.error(e);
}
}
/**
* 设置投影坐标系名称
* @memberof SRefData
* @param {String} pcsName 投影坐标系名称
* @returns {Promise<*>}
*/
async setPCSName(pcsName) {
try {
await SR.setPCSName(this._MGSRefDataId, pcsName);
} catch (e) {
console.error(e);
}
}
/**
* 获取投影名
* @memberof SRefData
* @returns {String}
*/
async getProjName() {
try {
let projName = await SR.getProjName(this._MGSRefDataId);
return projName;
} catch (e) {
console.error(e);
}
}
/**
* 设置投影名
* @memberof SRefData
* @param {String} projName 投影名
* @returns {Promise<*>}
*/
async setProjName(projName) {
try {
await SR.setProjName(this._MGSRefDataId, projName);
} catch (e) {
console.error(e);
}
}
/**
* 获取空间数据投影类型索引
* @memberof SRefData
* @returns {int}
*/
async getProjTypeID() {
try {
let projTypeID = await SR.getProjTypeID(this._MGSRefDataId);
return projTypeID;
} catch (e) {
console.error(e);
}
}
/**
* 设置空间数据投影类型索引
* @memberof SRefData
* @param {int} projTypeID 空间数据投影类型索引
* @returns {Promise<*>}
*/
async setProjTypeID(projTypeID) {
try {
await SR.setProjTypeID(this._MGSRefDataId, projTypeID);
} catch (e) {
console.error(e);
}
}
/**
* 获取投影分带类型
* @memberof SRefData
* @returns {int}
*/
async getZoneType() {
try {
let zoneType = await SR.getZoneType(this._MGSRefDataId);
return zoneType;
} catch (e) {
console.error(e);
}
}
/**
* 设置投影分带类型
* @memberof SRefData
* @param {int} zoneType 投影分带类型
* @returns {Promise<*>}
*/
async setZoneType(zoneType) {
try {
await SR.setZoneType(this._MGSRefDataId, zoneType);
} catch (e) {
console.error(e);
}
}
/**
* 获取投影带号
* @memberof SRefData
* @returns {int}
*/
async getZone() {
try {
let zone = await SR.getZone(this._MGSRefDataId);
return zone;
} catch (e) {
console.error(e);
}
}
/**
* 设置投影带号
* @memberof SRefData
* @param {int} zone 投影带号
* @returns {Promise<*>}
*/
async setZone(zone) {
try {
await SR.setZone(this._MGSRefDataId, zone);
} catch (e) {
console.error(e);
}
}
/**
* 获取空间数据中央经线经度
* @memberof SRefData
* @returns {double}
*/
async getLon() {
try {
let lon = await SR.getLon(this._MGSRefDataId);
return lon;
} catch (e) {
console.error(e);
}
}
/**
* 设置空间数据中央经线经度
* @memberof SRefData
* @param {double} lon 设置空间数据中央经线经度
* @returns {Promise<*>}
*/
async setLon(lon) {
try {
await SR.setLon(this._MGSRefDataId, lon);
} catch (e) {
console.error(e);
}
}
/**
* 获取空间数据双经线1 经度
* @memberof SRefData
* @returns {double}
*/
async getLon1() {
try {
let lon1 = await SR.getLon1(this._MGSRefDataId);
return lon1;
} catch (e) {
console.error(e);
}
}
/**
* 设置空间数据双经线1经度
* @memberof SRefData
* @param {double} lon1 空间数据双经线1经度
* @returns {Promise<*>}
*/
async setLon1(lon1) {
try {
await SR.setLon1(this._MGSRefDataId, lon1);
} catch (e) {
console.error(e);
}
}
/**
* 获取空间数据双经线2经度
* @memberof SRefData
* @returns {double}
*/
async getLon2() {
try {
let lon2 = await SR.getLon2(this._MGSRefDataId);
return lon2;
} catch (e) {
console.error(e);
}
}
/**
* 设置空间数据双经线2 经度
* @memberof SRefData
* @param {double} lon2 空间数据双经线2 经度
* @returns {Promise<*>}
*/
async setLon2(lon2) {
try {
await SR.setLon2(this._MGSRefDataId, lon2);
} catch (e) {
console.error(e);
}
}
/**
* 获取空间数据投影原点纬度
* @memberof SRefData
* @returns {double}
*/
async getLat() {
try {
let lat = await SR.getLat(this._MGSRefDataId);
return lat;
} catch (e) {
console.error(e);
}
}
/**
* 设置空间数据投影原点纬度
* @memberof SRefData
* @param {double} lat 空间数据投影原点纬度
* @returns {Promise<*>}
*/
async setLat(lat) {
try {
await SR.setLat(lat);
} catch (e) {
console.error(e);
}
}
/**
* 获取空间数据双纬线1 纬度
* @memberof SRefData
* @returns {double}
*/
async getLat1() {
try {
let lat1 = await SR.getLat1(this._MGSRefDataId);
return lat1;
} catch (e) {
console.error(e);
}
}
/**
* 设置空间数据双纬线1 纬度
* @memberof SRefData
* @param {double} lat1 空间数据双纬线1 纬度
* @returns {Promise<*>}
*/
async setLat1(lat1) {
try {
await SR.setLat1(this._MGSRefDataId, lat1);
} catch (e) {
console.error(e);
}
}
/**
* 获取空间数据双纬线2 纬度
* @memberof SRefData
* @returns {double}
*/
async getLat2() {
try {
let lat2 = await SR.getLat2(this._MGSRefDataId);
return lat2;
} catch (e) {
console.error(e);
}
}
/**
* 设置空间数据双纬线2 纬度
* @memberof SRefData
* @param {double} lat2 空间数据双纬线2 纬度
* @returns {Promise<*>}
*/
async setLat2(lat2) {
try {
await SR.setLat2(this._MGSRefDataId, lat2);
} catch (e) {
console.error(e);
}
}
/**
* 获取投影东偏
* @memberof SRefData
* @returns {double}
*/
async getFalseE() {
try {
let falseE = await SR.getFalseE(this._MGSRefDataId);
return falseE;
} catch (e) {
console.error(e);
}
}
/**
* 设置投影东偏
* @memberof SRefData
* @param {double} falseE 投影东偏
* @returns {Promise<*>}
*/
async setFalseE(falseE) {
try {
await SR.setFalseE(this._MGSRefDataId, falseE);
} catch (e) {
console.error(e);
}
}
/**
* 获取投影北偏
* @memberof SRefData
* @returns {double}
*/
async getFalseN() {
try {
let falseN = await SR.getFalseN(this._MGSRefDataId);
return falseN;
} catch (e) {
console.error(e);
}
}
/**
* 设置投影北偏
* @memberof SRefData
* @param {double} falseN 投影北偏
* @returns {Promise<*>}
*/
async setFalseN(falseN) {
try {
await SR.setFalseN(this._MGSRefDataId, falseN);
} catch (e) {
console.error(e);
}
}
/**
* 获取图纸坐标原点在投影坐标系中的x值
* @memberof SRefData
* @returns {double}
*/
async getX() {
try {
let x = await SR.getX(this._MGSRefDataId);
return x;
} catch (e) {
console.error(e);
}
}
/**
* 获取图纸坐标原点在投影坐标系中的x值
* @memberof SRefData
* @param {double} x 图纸坐标原点在投影坐标系中的x值
* @returns {Promise<*>}
*/
async setX(x) {
try {
await SR.setX(this._MGSRefDataId, x);
} catch (e) {
console.error(e);
}
}
/**
* 获取图纸坐标原点在投影坐标系中的y值
* @memberof SRefData
* @returns {double}
*/
async getY() {
try {
let y = await SR.getY(this._MGSRefDataId);
return y;
} catch (error) {
console.error(error);
}
}
/**
* 设置图纸坐标原点在投影坐标系中的y值
* @memberof SRefData
* @param {double} y 图纸坐标原点在投影坐标系中的y值
* @returns {Promise<*>}
*/
async setY(y) {
try {
await SR.setY(this._MGSRefDataId, y);
} catch (e) {
console.error(e);
}
}
/**
* 获取数据维数
* @memberof SRefData
* @returns {int}
*/
async getDimension() {
try {
let dimension = await SR.getDimension(this._MGSRefDataId);
return dimension;
} catch (e) {
console.error(e);
}
}
/**
* 设置数据维数
* @memberof SRefData
* @param {int} dimension 数据维数
* @returns {Promise<*>}
*/
async setDimension(dimension) {
try {
await SR.setDimension(this._MGSRefDataId, dimension);
} catch (e) {
console.error(e);
}
}
/**
* 获取0轴名
* @memberof SRefData
* @returns {String}
*/
async getAxisName0() {
try {
let axisName0 = await SR.getAxisName0(this._MGSRefDataId);
return axisName0;
} catch (e) {
console.error(e);
}
}
/**
* 设置0轴名
* @memberof SRefData
* @param {String} axisName0 0轴名
* @returns {Promise<*>}
*/
async setAxisName0(axisName0) {
try {
await SR.setAxisName0(this._MGSRefDataId, axisName0);
} catch (e) {
console.error(e);
}
}
/**
* 获取0轴单位
* @memberof SRefData
* @returns {int}
*/
async getAxisUnit0() {
try {
let axisUnit0 = await SR.getAxisUnit0(this._MGSRefDataId);
return axisUnit0;
} catch (e) {
console.error(e);
}
}
/**
* 设置0轴单位
* @memberof SRefData
* @param {int} axisUnit0 0轴单位
* @returns {Promise<*>}
*/
async setAxisUnit0(axisUnit0) {
try {
await SR.setAxisUnit0(this._MGSRefDataId, axisUnit0);
} catch (e) {
console.error(e);
}
}
/**
* 获取0轴最小值
* @memberof SRefData
* @returns {double}
*/
async getAxisMin0() {
try {
let axisMin0 = await SR.getAxisMin0(this._MGSRefDataId);
return axisMin0;
} catch (e) {
console.error(e);
}
}
/**
* 设置0轴最小值
* @memberof SRefData
* @param {double} axisMin0 0轴最小值
* @returns {Promise<*>}
*/
async setAxisMin0(axisMin0) {
try {
await SR.setAxisMin0(this._MGSRefDataId, axisMin0);
} catch (e) {
console.error(e);
}
}
/**
* 获取0轴最大值
* @memberof SRefData
* @returns {double}
*/
async getAxisMax0() {
try {
let axisMax0 = await SR.getAxisMax0(this._MGSRefDataId);
return axisMax0;
} catch (e) {
console.error(e);
}
}
/**
* 设置0轴最大值
* @memberof SRefData
* @param {double} axisMax0 0轴最大值
* @returns {Promise<*>}
*/
async setAxisMax0(axisMax0) {
try {
await SR.setAxisMax0(this._MGSRefDataId, axisMax0);
} catch (e) {
console.error(e);
}
}
/**
* 获取0轴精度
* @memberof SRefData
* @returns {double}
*/
async getPrecision0() {
try {
let precision0 = await SR.getPrecision0(this._MGSRefDataId);
return precision0;
} catch (error) {
console.error(error);
}
}
/**
* 设置0轴精度
* @memberof SRefData
* @param {double} precision0 0轴精度
* @returns {Promise<*>}
*/
async setPrecision0(precision0) {
try {
await SR.setPrecision0(this._MGSRefDataId, precision0);
} catch (e) {
console.error(e);
}
}
/**
* 获取1轴名
* @memberof SRefData
* @returns {String}
*/
async getAxisName1() {
try {
let axisName1 = await SR.getAxisName1(this._MGSRefDataId);
return axisName1;
} catch (e) {
console.error(e);
}
}
/**
* 设置1轴名
* @memberof SRefData
* @param {String} axisName1 1轴名
* @returns {Promise<*>}
*/
async setAxisName1(axisName1) {
try {
await SR.setAxisName1(this._MGSRefDataId, axisName1);
} catch (e) {
console.error(e);
}
}
/**
* 获取1轴单位
* @memberof SRefData
* @returns {int}
*/
async getAxisUnit1() {
try {
let axisUnit1 = await SR.getAxisUnit1(this._MGSRefDataId);
return axisUnit1;
} catch (e) {
console.error(e);
}
}
/**
* 设置1轴单位
* @memberof SRefData
* @param {int} axisUnit1 1轴单位
* @returns {Promise<*>}
*/
async setAxisUnit1(axisUnit1) {
try {
await SR.setAxisUnit1(this._MGSRefDataId, axisUnit1);
} catch (e) {
console.error(e);
}
}
/**
* 获取1轴最小值
* @memberof SRefData
* @returns {double}
*/
async getAxisMin1() {
try {
let axisMin1 = await SR.getAxisMin1(this._MGSRefDataId);
return axisMin1;
} catch (e) {
console.error(e);
}
}
/**
* 设置1轴最小值
* @memberof SRefData
* @param {double} axisMin1 1轴最小值
* @returns {Promise<*>}
*/
async setAxisMin1(axisMin1) {
try {
await SR.setAxisMin1(this._MGSRefDataId, axisMin1);
} catch (e) {
console.error(e);
}
}
/**
* 获取1轴最大值
* @memberof SRefData
* @returns {double}
*/
async getAxisMax1() {
try {
let axisMax1 = await SR.getAxisMax1(this._MGSRefDataId);
return axisMax1;
} catch (e) {
console.error(e);
}
}
/**
* 设置1轴最大值
* @memberof SRefData
* @param {double} axisMax1 1轴最大值
* @returns {Promise<*>}
*/
async setAxisMax1(axisMax1) {
try {
await SR.setAxisMax1(this._MGSRefDataId, axisMax1);
} catch (e) {
console.error(e);
}
}
/**
* 获取1轴精度
* @memberof SRefData
* @returns {double}
*/
async getPrecision1() {
try {
let precision1 = await SR.getPrecision1(this._MGSRefDataId);
return precision1;
} catch (e) {
console.error(e);
}
}
/**
* 设置1轴精度
* @memberof SRefData
* @param {double} precision1 1轴精度
* @returns {Promise<*>}
*/
async setPrecision1(precision1) {
try {
await SR.setPrecision1(this._MGSRefDataId, precision1);
} catch (e) {
console.error(e);
}
}
/**
* 获取2轴名
* @memberof SRefData
* @returns {String}
*/
async getAxisName2() {
try {
let axisName2 = await SR.getAxisName2(this._MGSRefDataId);
return axisName2;
} catch (e) {
console.error(e);
}
}
/**
* 设置2轴名
* @memberof SRefData
* @param {String} axisName2 2轴名
* @returns {Promise<*>}
*/
async setAxisName2(axisName2) {
try {
await SR.setAxisName2(this._MGSRefDataId, axisName2);
} catch (e) {
console.error(e);
}
}
/**
* 获取2轴单位
* @memberof SRefData
* @returns {int}
*/
async getAxisUnit2() {
try {
let axisUnit2 = await SR.getAxisUnit2(this._MGSRefDataId);
return axisUnit2;
} catch (e) {
console.error(e);
}
}
/**
* 设置2轴单位
* @memberof SRefData
* @param {int} axisUnit2 2轴单位
* @returns {Promise<*>}
*/
async setAxisUnit2(axisUnit2) {
try {
await SR.setAxisUnit2(axisUnit2);
} catch (e) {
console.error(e);
}
}
/**
* 获取2轴最小值
* @memberof SRefData
* @returns {double}
*/
async getAxisMin2() {
try {
let axisMin2 = await SR.getAxisMin2(this._MGSRefDataId);
return axisMin2;
} catch (e) {
console.error(e);
}
}
/**
* 设置2轴最小值
* @memberof SRefData
* @param {double} axisMin2 2轴最小值
* @returns {Promise<*>}
*/
async setAxisMin2(axisMin2) {
try {
await SR.setAxisMin2(this._MGSRefDataId, axisMin2);
} catch (e) {
console.error(e);
}
}
/**
* 获取2轴最大值
* @memberof SRefData
* @returns {double}
*/
async getAxisMax2() {
try {
let axisMax2 = await SR.getAxisMax2(this._MGSRefDataId);
return axisMax2;
} catch (e) {
console.error(e);
}
}
/**
* 设置2轴最大值
* @memberof SRefData
* @param {double} axisMax2 2轴最大值
* @returns {Promise<*>}
*/
async setAxisMax2(axisMax2) {
try {
await SR.setAxisMax2(this._MGSRefDataId, axisMax2);
} catch (e) {
console.error(e);
}
}
/**
* 获取2轴精度
* @memberof SRefData
* @returns {double}
*/
async getPrecision2() {
try {
let precision2 = await SR.getPrecision2(this._MGSRefDataId);
return precision2;
} catch (e) {
console.error(e);
}
}
/**
* 设置2轴精度
* @memberof SRefData
* @param {double} precision2 2轴精度
* @returns {Promise<*>}
*/
async setPrecision2(precision2) {
try {
await SR.setPrecision2(precision2);
} catch (e) {
console.error(e);
}
}
/**
* 获取3轴名
* @memberof SRefData
* @returns {String}
*/
async getAxisName3() {
try {
let axisName3 = await SR.getAxisName3(this._MGSRefDataId);
return axisName3;
} catch (e) {
console.error(e);
}
}
/**
* 设置3轴名
* @memberof SRefData
* @param {String} axisName3 3轴名
* @returns {Promise<*>}
*/
async setAxisName3(axisName3) {
try {
await SR.setAxisName3(this._MGSRefDataId, axisName3);
} catch (e) {
console.error(e);
}
}
/**
* 获取3轴单位
* @memberof SRefData
* @returns {int}
*/
async getAxisUnit3() {
try {
let axisUnit3 = await SR.getAxisUnit3(this._MGSRefDataId);
return axisUnit3;
} catch (e) {
console.error(e);
}
}
/**
* 设置3轴单位
* @memberof SRefData
* @param {int} axisUnit3 3轴单位
* @returns {Promise<*>}
*/
async setAxisUnit3(axisUnit3) {
try {
await SR.setAxisUnit3(this._MGSRefDataId, axisUnit3);
} catch (e) {
console.error(e);
}
}
/**
* 获取3轴最小值
* @memberof SRefData
* @returns {double}
*/
async getAxisMin3() {
try {
let axisMin3 = await SR.getAxisMin3(this._MGSRefDataId);
return axisMin3;
} catch (e) {
console.error(e);
}
}
/**
* 设置3轴最小值
* @memberof SRefData
* @param {double} axisMin3 3轴最小值
* @returns {Promise<*>}
*/
async setAxisMin3(axisMin3) {
try {
await SR.setAxisMin3(this._MGSRefDataId, axisMin3);
} catch (e) {
console.error(e);
}
}
/**
* 获取3轴最大值
* @memberof SRefData
* @returns {double}
*/
async getAxisMax3() {
try {
let axisMax3 = await SR.getAxisMax3(this._MGSRefDataId);
return axisMax3;
} catch (e) {
console.error(e);
}
}
/**
* 设置3轴最大值
* @memberof SRefData
* @param {double} axisMax3 3轴最大值
* @returns {Promise<*>}
*/
async setAxisMax3(axisMax3) {
try {
await SR.setAxisMax3(this._MGSRefDataId, axisMax3);
} catch (e) {
console.error(e);
}
}
/**
* 获取3轴精度
* @memberof SRefData
* @returns {double}
*/
async getPrecision3() {
try {
let precision3 = await SR.getPrecision3(this._MGSRefDataId);
return precision3;
} catch (e) {
console.error(e);
}
}
/**
* 设置3轴精度
* @memberof SRefData
* @param {double} precision3 3轴精度
* @returns {Promise<*>}
*/
async setPrecision3(precision3) {
try {
await SR.setPrecision3(this._MGSRefDataId, precision3);
} catch (e) {
console.error(e);
}
}
/**
* 获取空间数据水平坐标单位：长度
* @memberof SRefData
* @returns {int}
*/
async getUnit() {
try {
let unit = await SR.getUnit(this._MGSRefDataId);
return unit;
} catch (e) {
console.error(e);
}
}
/**
* 设置空间数据水平坐标单位：长度
* @memberof SRefData
* @param {int} unit 空间数据水平坐标单位：长度
* @returns {Promise<*>}
*/
async setUnit(unit) {
try {
await SR.setUnit(this._MGSRefDataId, unit);
} catch (e) {
console.error(e);
}
}
/**
* 获取米/unit
* @memberof SRefData
* @returns {double}
*/
async getUnitFactor() {
try {
let unitFactor = await SR.getUnitFactor(this._MGSRefDataId);
return unitFactor;
} catch (e) {
console.error(e);
}
}
/**
* 设置米/unit
* @memberof SRefData
* @param {double} unitFactor 米/unit
* @returns {Promise<*>}
*/
async setUnitFactor(unitFactor) {
try {
await SR.setUnitFactor(this._MGSRefDataId, unitFactor);
} catch (e) {
console.error(e);
}
}
/**
* 获取空间数据水平坐标单位：角度
* @memberof SRefData
* @returns {int}
*/
async getAngUnit() {
try {
let angUnit = await SR.getAngUnit(this._MGSRefDataId);
return angUnit;
} catch (e) {
console.error(e);
}
}
/**
* 设置空间数据水平坐标单位：角度
* @memberof SRefData
* @param {int} angUnit 空间数据水平坐标单位：角度
* @returns {Promise<*>}
*/
async setAngUnit(angUnit) {
try {
await SR.setAngUnit(this._MGSRefDataId, angUnit);
} catch (e) {
console.error(e);
}
}
/**
* 获取弧度/unit
* @memberof SRefData
* @returns {double}
*/
async getAngUnitFactor() {
try {
let angUnitFactor = await SR.getAngUnitFactor(this._MGSRefDataId);
return angUnitFactor;
} catch (e) {
console.error(e);
}
}
/**
* 设置弧度/unit
* @memberof SRefData
* @param {double} angUnitFactor 弧度/unit
* @returns {Promise<*>}
*/
async setAngUnitFactor(angUnitFactor) {
try {
await SR.setAngUnitFactor(this._MGSRefDataId, angUnitFactor);
} catch (e) {
console.error(e);
}
}
/**
* 获取空间数据水平比例尺倒数
* @memberof SRefData
* @returns {double}
*/
async getRate() {
try {
let rate = await SR.getRate(this._MGSRefDataId);
return rate;
} catch (e) {
console.error(e);
}
}
/**
* 设置空间数据水平比例尺倒数
* @memberof SRefData
* @param {double} rate 空间数据水平比例尺倒数
* @returns {Promise<*>}
*/
async setRate(rate) {
try {
await SR.setRate(this._MGSRefDataId, rate);
} catch (e) {
console.error(e);
}
}
/**
* 获取空间数据大地水准面类型
* @memberof SRefData
* @returns {int}
*/
async getLevelType() {
try {
let levelType = await SR.getLevelType(this._MGSRefDataId);
return levelType;
} catch (e) {
console.error(e);
}
}
/**
* 设置空间数据大地水准面类型
* @memberof SRefData
* @param {int} levelType 空间数据大地水准面类型
* @returns {Promise<*>}
*/
async setLevelType(levelType) {
try {
await SR.setLevelType(this._MGSRefDataId, levelType);
} catch (e) {
console.error(e);
}
}
/**
* 获取空间数据大地水准面名称
* @memberof SRefData
* @returns {String}
*/
async getLevelName() {
try {
let levelName = await SR.getLevelName(this._MGSRefDataId);
return levelName;
} catch (e) {
console.error(e);
}
}
/**
* 设置空间数据大地水准面名称
* @memberof SRefData
* @param {String} levelName 空间数据大地水准面名称
* @returns {Promise<*>}
*/
async setLevelName(levelName) {
try {
await SR.setLevelName(this._MGSRefDataId, levelName);
} catch (e) {
console.error(e);
}
}
/**
* 获取当前高程的偏移量
* @memberof SRefData
* @returns {double}
*/
async getLevelOffset() {
try {
let levelOffset = await SR.getLevelOffset(this._MGSRefDataId);
return levelOffset;
} catch (e) {
console.error(e);
}
}
/**
* 设置当前高程的偏移量
* @memberof SRefData
* @param {double} levelOffset 当前高程的偏移量
* @returns {Promise<*>}
*/
async setLevelOffset(levelOffset) {
try {
await SR.setLevelOffset(this._MGSRefDataId, levelOffset);
} catch (e) {
console.error(e);
}
}
/**
* 获取空间数据大地水准面与参考椭球面之间的高差
* @memberof SRefData
* @returns {double}
*/
async getN() {
try {
let n = await SR.getN(this._MGSRefDataId);
return n;
} catch (e) {
console.error(e);
}
}
/**
* 设置空间数据大地水准面与参考椭球面之间的高差
* @memberof SRefData
* @param {double} n 空间数据大地水准面与参考椭球面之间的高差
* @returns {Promise<*>}
*/
async setN(n) {
try {
await SR.setN(this._MGSRefDataId, n);
} catch (e) {
console.error(e);
}
}
/**
* 获取空间数据投影平面与大地水准面的高差
* @memberof SRefData
* @returns {double}
*/
async getH() {
try {
let h = await SR.getH(this._MGSRefDataId);
return h;
} catch (e) {
console.error(e);
}
}
/**
* 设置空间数据投影平面与大地水准面的高差
* @memberof SRefData
* @param {double} h 空间数据投影平面与大地水准面的高差
* @returns {Promise<*>}
*/
async setH(h) {
try {
await SR.setH(this._MGSRefDataId, h);
} catch (e) {
console.error(e);
}
}
/**
* 获取空间数据垂向比例尺倒数
* @memberof SRefData
* @returns {double}
*/
async getVRate() {
try {
let vRate = await SR.getVRate(this._MGSRefDataId);
return vRate;
} catch (e) {
console.error(e);
}
}
/**
* 设置空间数据垂向比例尺倒数
* @memberof SRefData
* @param {double} vRate 设置空间数据垂向比例尺倒数
* @returns {Promise<*>}
*/
async setVRate(vRate) {
try {
await SR.setVRate(this._MGSRefDataId, vRate);
} catch (e) {
console.error(e);
}
}
/**
* 获取空间数据垂向数据单位
* @memberof SRefData
* @returns {int}
*/
async getVUnit() {
try {
let vUnit = await SR.getVUnit(this._MGSRefDataId);
return vUnit;
} catch (e) {
console.error(e);
}
}
/**
* 设置空间数据垂向数据单位
* @memberof SRefData
* @param {int} vUnit 空间数据垂向数据单位
* @returns {Promise<*>}
*/
async setVUnit(vUnit) {
try {
await SR.setVUnit(this._MGSRefDataId, vUnit);
} catch (e) {
console.error(e);
}
}
/**
* 获取垂直数据类型
* @memberof SRefData
* @returns {int}
*/
async getVerticalDatumType() {
try {
let verticalDatumType = await SR.getVerticalDatumType(this._MGSRefDataId);
return verticalDatumType;
} catch (e) {
console.error(e);
}
}
/**
* 设置垂直数据类型
* @memberof SRefData
* @param {int} verticalDatumType 垂直数据类型
* @returns {Promise<*>}
*/
async setVerticalDatumType(verticalDatumType) {
try {
await SR.setVerticalDatumType(this._MGSRefDataId, verticalDatumType);
} catch (e) {
console.error(e);
}
}
/**
* 克隆空间参考系对象
* @memberof SRefData
* @returns {Promise<SRefData>}
*/
async clone() {
try {
var { SRefDataId } = await SR.clone(this._MGSRefDataId);
var sRefData = new SRefData();
sRefData._MGSRefDataId = SRefDataId;
return sRefData;
} catch (e) {
console.error(e);
}
}
/**
* 加载
* @memberof SRefData
* @param {Array} array int类型的Array
* @returns {Boolean}
*/
async load(array) {
try {
let loadResult = await SR.load(this._MGSRefDataId, array);
return loadResult;
} catch (e) {
console.error(e);
}
}
/**
* 保存
* @memberof SRefData
* @returns {Array} int类型的Array
*/
async save() {
try {
let array = await SR.save(this._MGSRefDataId);
return array;
} catch (e) {
console.error(e);
}
}
/**
* 获取Web墨卡托空间参考
* @memberof SRefData
* @returns {Promise<SRefData>}
*/
async getWebMercator() {
try {
var { SRefDataId } = await SR.getWebMercator(this._MGSRefDataId);
var sRefData = new SRefData();
sRefData._MGSRefDataId = SRefDataId;
return sRefData;
} catch (e) {
console.error(e);
}
}
/**
* 获取WGS 1984空间参考
* @memberof SRefData
* @returns {Promise<SRefData>}
*/
async getWGS84() {
try {
var { SRefDataId } = await SR.getWGS84(this._MGSRefDataId);
var sRefData = new SRefData();
sRefData._MGSRefDataId = SRefDataId;
return sRefData;
} catch (e) {
console.error(e);
}
}
}