使用PostGIS进行轨迹分析

最新推荐文章于 2024-09-01 16:39:29 发布
最新推荐文章于 2024-09-01 16:39:29 发布
阅读量6.1k 收藏 10
点赞数 2
分类专栏： Database 文章标签： postgis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/doris_d/article/details/45846365
版权

从 sqlite 数据库中读取轨迹数据，存储到 postgis 数据库中，再利用 postgis 的特性进行轨迹分析。

track.db

Program.cs

class Program
{
    static void Main(string[] args)
    {
        List<Track> tracks = new List<Track>();

        try
        {
            #region 从Sqlite中读取轨迹数据

            //Sqlite数据库路径
            string sqlitePath = Path.Combine(Environment.CurrentDirectory, "track.db");

            //数据表名称
            string sqliteTb = "T_1140204000334";

            using (SqliteDB sqlite = new SqliteDB(sqlitePath))
            {
                sqlite.Open();
                DataTable dt = sqlite.ExecuteSQL("select * from " + sqliteTb + ";");
                if (dt != null && dt.Rows.Count > 0)
                {
                    for (int i = 0; i < dt.Rows.Count; i++)
                    {
                        tracks.Add(new Track()
                        {
                            B = Convert.ToDouble(dt.Rows[i]["B"]) * 180 / Math.PI,
                            L = Convert.ToDouble(dt.Rows[i]["L"]) * 180 / Math.PI,
                            H = Convert.ToSingle(dt.Rows[i]["H"]),
                            Azi = Convert.ToSingle(dt.Rows[i]["Azi"]),
                            AntH = Convert.ToSingle(dt.Rows[i]["AntH"]),
                            UTCTime = Convert.ToDateTime(dt.Rows[i]["UTCTime"]),
                            Hdop = Convert.ToSingle(dt.Rows[i]["Hdop"]),
                            SolType = Convert.ToInt32(Convert.ToByte(dt.Rows[i]["SolType"]))
                        });
                    }
                }
            }

            Console.WriteLine("Sqlite中的轨迹记录数为：" + tracks.Count);
            Console.WriteLine("---------------------------------------------------------------------");

            #endregion

            #region 向PostgreSQL中存入轨迹数据

            using (PostgresqlDB postgresql = new PostgresqlDB("localhost", "5432", "postgres", "123456", "test"))
            {
                postgresql.Open();

                string tableName = "t_1_1_20150519103523";

                StringBuilder sql = new StringBuilder();

                #region 写入数据

                //删除数据表
                if (postgresql.QueryTableIsExist(tableName))
                {
                    sql.Clear();
                    sql.AppendLine("drop table " + tableName + ";");
                    postgresql.ExecuteNonQuery(sql.ToString());
                }

                postgresql.BeginTransaction();

                try
                {
                    //创建数据表
                    sql.Clear();
                    sql.AppendLine("create table " + tableName + "(");
                    sql.AppendLine("id serial not null,");
                    sql.AppendLine("coord geometry(point, 4326) not null,");
                    sql.AppendLine("h real not null,");
                    sql.AppendLine("azi real not null,");
                    sql.AppendLine("ant_h real not null,");
                    sql.AppendLine("utc_time timestamp with time zone not null,");
                    sql.AppendLine("hdop real not null,");
                    sql.AppendLine("sol_type integer not null,");
                    sql.AppendLine("constraint " + tableName + "_pkey primary key (id)");
                    sql.AppendLine(");");

                    postgresql.ExecuteNonQuery(sql.ToString());

                    //插入记录
                    for (int i = 0; i < tracks.Count; i++)
                    {
                        sql.Clear();
                        sql.AppendLine("insert into " + tableName + "(coord,h,azi,ant_h,utc_time,hdop,sol_type) values(");
                        sql.AppendLine(string.Format("ST_GeomFromText('point({0} {1})',4326),", tracks[i].B, tracks[i].L));
                        sql.AppendLine(tracks[i].H + ",");
                        sql.AppendLine(tracks[i].Azi + ",");
                        sql.AppendLine(tracks[i].AntH + ",");
                        sql.AppendLine("'" + tracks[i].UTCTime.ToString("yyyy-MM-dd HH:mm:ss") + "',");
                        sql.AppendLine(tracks[i].Hdop + ",");
                        sql.AppendLine(tracks[i].SolType.ToString());
                        sql.AppendLine(");");

                        postgresql.ExecuteNonQuery(sql.ToString());
                    }

                    postgresql.Commit();

                    Console.WriteLine("写入postgresql成功！");
                    Console.WriteLine("---------------------------------------------------------------------");
                }
                catch (Exception ex)
                {
                    postgresql.Rollback();
                    Console.WriteLine(ex.Message);
                    Console.WriteLine(ex.StackTrace);
                }

                postgresql.EndTransaction();

                #endregion

                #region 读取数据

                tracks.Clear();

                DataTable dt = postgresql.ExecuteQuery("select st_x(coord) as b, st_y(coord) as l, h, azi, ant_h, utc_time, hdop, sol_type from " + tableName + ";");
                if (dt != null && dt.Rows.Count > 0)
                {                        
                    for (int i = 0; i < dt.Rows.Count; i++)
                    {
                        tracks.Add(new Track() { 
                            B = Convert.ToDouble(dt.Rows[i]["b"]),
                            L = Convert.ToDouble(dt.Rows[i]["l"]),
                            H = Convert.ToSingle(dt.Rows[i]["h"]),
                            Azi = Convert.ToSingle(dt.Rows[i]["azi"]),
                            AntH = Convert.ToSingle(dt.Rows[i]["ant_h"]),
                            UTCTime = Convert.ToDateTime(dt.Rows[i]["utc_time"]),
                            Hdop = Convert.ToSingle(dt.Rows[i]["hdop"]),
                            SolType = Convert.ToInt32(dt.Rows[i]["sol_type"])
                        });
                    }
                }
                Console.WriteLine("读取postgresql中的数据成功！记录数为：" + tracks.Count);
                Console.WriteLine("---------------------------------------------------------------------");

                #endregion

                #region 轨迹分析

                //轨迹总长度
                double dist = 0;
                DataTable dtDistance = postgresql.ExecuteQuery("select st_length(st_makeline(st_transform(coord, 4504))) from " + tableName + ";");
                if (dtDistance != null && dtDistance.Rows.Count > 0)
                {
                    dist = Convert.ToDouble(dtDistance.Rows[0][0]);
                    Console.WriteLine("轨迹总长度：" + dist + " 米");
                    Console.WriteLine("---------------------------------------------------------------------");
                }

                //轨迹总时间
                double seconds = 0;
                DataTable dtDateTime = postgresql.ExecuteQuery("select max(utc_time), min(utc_time) from " + tableName + ";");
                if (dtDateTime != null && dtDateTime.Rows.Count > 0)
                {
                    DateTime max = Convert.ToDateTime(dtDateTime.Rows[0][0]);
                    DateTime min = Convert.ToDateTime(dtDateTime.Rows[0][1]);
                    seconds = (max - min).TotalSeconds;
                    Console.WriteLine("轨迹总时间：" + seconds + " 秒");
                    Console.WriteLine("---------------------------------------------------------------------");
                }

                //轨迹平均速度
                if (seconds != 0)
                {
                    Console.WriteLine("轨迹平均速度：" + dist / seconds + " 米/秒");
                    Console.WriteLine("---------------------------------------------------------------------");
                }

                //轨迹瞬时速度（计算相邻两条记录的距离及时间间隔）
                //extract(epoch from time1-time2):计算时间间隔的总秒数
                DataTable dtDelta = postgresql.ExecuteQuery("select st_distance(st_transform(p1.coord,4504),st_transform(p2.coord,4504)) as delta_d, extract(epoch from p1.utc_time-p2.utc_time) as delta_t from " + tableName + " as p1, " + tableName + " as p2 where p1.id = p2.id+1;");
                if (dtDelta != null && dtDelta.Rows.Count > 0)
                {
                    double delta_d = Convert.ToDouble(dtDelta.Rows[dtDelta.Rows.Count - 1]["delta_d"]);
                    double delta_t = Convert.ToDouble(dtDelta.Rows[dtDelta.Rows.Count - 1]["delta_t"]);
                    if (delta_t != 0)
                    {
                        Console.WriteLine("最后一个点的分析结果为：\r\n    瞬时位移：" + delta_d + " 米" +
                            "\r\n    时间间隔：" + delta_t + " 秒" +
                            "\r\n    瞬时速度：" + delta_d / delta_t + " 米/秒");
                        Console.WriteLine("---------------------------------------------------------------------");
                    }
                }

                #endregion
            }

            #endregion
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
            Console.WriteLine(ex.StackTrace);
        }
        Console.Read();
    }
}

运行结果为：

Sqlite中的轨迹记录数为：1521
---------------------------------------------------------------------
写入postgresql成功！
---------------------------------------------------------------------
读取postgresql中的数据成功！记录数为：1521
---------------------------------------------------------------------
轨迹总长度：16775.455657666 米
---------------------------------------------------------------------
轨迹总时间：353325 秒
---------------------------------------------------------------------
轨迹平均速度：0.0474788244751037 米/秒
---------------------------------------------------------------------
最后一个点的分析结果为：
    瞬时位移：5.32844146492802 米
    时间间隔：1 秒
    瞬时速度：5.32844146492802 米/秒
---------------------------------------------------------------------

Track.cs

public class Track
{
    public double B;
    public double L;
    public float H;
    public float Azi;
    public float AntH;
    public DateTime UTCTime;
    public float Hdop;
    public int SolType;
}

SqliteDB.cs

/// <summary>
/// Sqlite数据库操作类
/// </summary>
public class SqliteDB : IDisposable
{
    #region 字段

    /// <summary>
    /// 数据库连接字符串构造器
    /// </summary>
    private SQLiteConnectionStringBuilder _connStr = null;

    /// <summary>
    /// 数据库连接器
    /// </summary>
    private SQLiteConnection _conn = null;

    /// <summary>
    /// 通过连接器创建NpgsqlCommand对象，用于执行SQL语句
    /// </summary>
    private SQLiteCommand _comm = null;

    /// <summary>
    /// 事务管理对象
    /// </summary>
    private SQLiteTransaction _trans = null;

    #endregion

    #region 构造函数

    public SqliteDB(string filePath)
    {
        _connStr = new SQLiteConnectionStringBuilder();
        _connStr.DataSource = filePath;
        _conn = new SQLiteConnection(_connStr.ToString());
        _comm = _conn.CreateCommand();
    }

    ~SqliteDB()
    {
    }

    #endregion

    #region 静态方法

    /// <summary>
    /// 创建数据库
    /// </summary>
    /// <param name="filePath">db文件路径+文件名</param>
    public static void CreateDB(string filePath)
    {
        try
        {
            SQLiteConnection.CreateFile(filePath);
        }
        catch
        {
            throw;
        }
    }

    #endregion

    #region 公共方法

    #region 数据库操作：连接数据库、断开数据库、加密数据库

    /// <summary>
    /// 打开数据库连接
    /// </summary>
    /// <returns>是否连接成功</returns>
    public bool Open()
    {
        try
        {
            _conn.Open();
            return true;
        }
        catch
        {
            Close();
            return false;
            throw;
        }
    }

    /// <summary>
    /// 打开数据库连接
    /// </summary>
    /// <param name="password">密码</param>
    /// <returns>是否连接成功</returns>
    public bool Open(string password)
    {
        try
        {
            _conn.SetPassword(password);
            _conn.Open();
            return true;
        }
        catch
        {
            Close();
            return false;
            throw;
        }
    }

    /// <summary>
    /// 关闭数据库连接
    /// </summary>
    public void Close()
    {
        if (_conn != null)
        {
            _comm.Dispose();
            _conn.Close();
            _conn.Dispose();
        }
    }

    /// <summary>
    /// 给sqlite数据库加密
    /// </summary>
    /// <param name="password">密码</param>
    public void Encrypt(string password)
    {
        try
        {
            if (_conn != null)
            {
                _conn.ChangePassword(password);
            }
        }
        catch
        {
            throw;
        }
    }

    #endregion

    #region 查询

    /// <summary>
    /// 执行sql语句
    /// </summary>
    /// <param name="sql"></param>
    /// <returns></returns>
    public DataTable ExecuteSQL(string sql)
    {
        try
        {
            _comm.Transaction = _trans;
            _comm.CommandText = sql;
            DataTable dt = new DataTable();
            using (SQLiteDataAdapter adapter = new SQLiteDataAdapter(_comm))
            {
                adapter.Fill(dt);
            }
            return dt;
        }
        catch
        {
            throw;
        }
    }

    #endregion

    #region 事务管理

    /// <summary>
    /// 开始执行事务
    /// </summary>
    public void BeginTransaction()
    {
        if (_conn != null)
        {
            _trans = _conn.BeginTransaction();
        }
    }

    /// <summary>
    /// 事务结束，保存并提交数据库数据，
    /// </summary>
    public void Commit()
    {
        if (_trans != null)
        {
            _trans.Commit();
        }
    }

    /// <summary>
    /// 回滚事务
    /// </summary>
    public void Rollback()
    {
        if (_trans != null)
        {
            _trans.Rollback();
        }
    }

    /// <summary>
    /// 结束事务，并释放资源
    /// </summary>
    public void EndTransaction()
    {
        if (_trans != null)
        {
            _trans.Dispose();
            _trans = null;
        }
    }

    #endregion

    #endregion

    #region IDisposable 成员

    public void Dispose()
    {
        this.Close();
    }

    #endregion
}

PostgresqlDB.cs

/// <summary>
/// 数据库管理类
/// 直接操作数据库
/// </summary>
public class PostgresqlDB : IDisposable
{
    #region 字段

    #region 连接配置

    /// <summary>
    /// 服务器地址
    /// </summary>
    private string server;

    /// <summary>
    /// 端口
    /// </summary>
    private string port;

    /// <summary>
    /// 用户名
    /// </summary>
    private string username;

    /// <summary>
    /// 密码
    /// </summary>
    private string password;

    /// <summary>
    /// 数据库名称
    /// </summary>
    private string db;

    #endregion

    #region 数据库操作相关变量

    /// <summary>
    /// 数据库连接器
    /// </summary>
    private NpgsqlConnection _conn;

    /// <summary>
    /// 通过连接器创建NpgsqlCommand对象，用于执行SQL语句
    /// </summary>
    private NpgsqlCommand _comm;

    /// <summary>
    /// 将数据表中获取的记录生成DataSet
    /// </summary>
    private NpgsqlDataAdapter _adapter;

    /// <summary>
    /// 创建一个事务对象
    /// </summary>
    private NpgsqlTransaction _trans;

    #endregion

    #endregion

    #region 构造函数

    private PostgresqlDB() { }

    /// <summary>
    /// 数据库管理类
    /// </summary>
    /// <param name="dbConfig">数据库配置</param>
    public PostgresqlDB(string server, string port, string username, string password, string db)
    {
        this.server = server;
        this.port = port;
        this.username = username;
        this.password = password;
        this.db = db;
    }

    ~PostgresqlDB()
    {
    }

    #endregion

    #region 公共方法

    #region 数据库操作：连接数据库、断开数据库、数据库连接状态

    /// <summary>
    /// 打开数据库连接
    /// </summary>
    /// <returns></returns>
    public bool Open()
    {
        try
        {
            //构造SQL语句
            string sql = String.Format(
                "server={0};port={1};userid={2};password={3};database={4};pooling=true;maxpoolsize=40;timeout=5;",
                server, port, username, password, db);

            //初始化数据库连接参数
            _conn = new NpgsqlConnection(sql);
            //打开数据库连接
            _conn.Open();
            //初始化
            _comm = _conn.CreateCommand();
            _adapter = new NpgsqlDataAdapter(_comm);
            _trans = null;
            return true;
        }
        catch (Exception ex)
        {
            if (_conn != null)
                _conn.Close();
            _conn = null;
            return false;
        }
    }

    /// <summary>
    /// 关闭数据库连接
    /// </summary>
    public void Close()
    {
        if (_conn != null)
        {
            _adapter.Dispose();
            _adapter = null;
            _comm.Dispose();
            _comm = null;
            _conn.Close();
            _conn.Dispose();
            _conn = null;
        }
    }

    /// <summary>
    /// 获取数据库的连接状态
    /// </summary>
    /// <returns>true表示已连接，false表示未连接</returns>
    public bool GetConnStatus()
    {
        return (_conn != null && _conn.State == ConnectionState.Open);
    }

    #endregion

    #region 数据表操作：查询数据表或视图是否存在

    /// <summary>
    /// 查询指定名称的数据表是否存在
    /// </summary>
    /// <param name="tableName">数据表名</param>
    /// <returns>true:存在，false:不存在</returns>
    public bool QueryTableIsExist(string tableName)
    {
        //构建SQL语句
        string sql = String.Format("select count(*) from pg_tables where tablename = '{0}';", tableName.ToLower());

        //执行SQL语句
        _comm.Transaction = _trans;
        _comm.CommandText = sql;
        NpgsqlDataReader readerTemp = _comm.ExecuteReader();

        //获取查询结果
        long value = -1;
        if (readerTemp.HasRows == true)
        {
            readerTemp.Read();
            value = readerTemp.GetInt64(0);
        }

        //释放资源
        readerTemp.Close();

        //value=1表示数据表存在；value=0表示数据表不存在
        if (value > 0)
        {
            return true;
        }
        return false;
    }

    /// <summary>
    /// 查询指定名称的视图是否存在
    /// </summary>
    /// <param name="viewName">视图名</param>
    /// <returns>true:存在，false:不存在</returns>
    public bool QueryViewIsExist(string viewName)
    {
        //构建SQL语句
        string sql = String.Format("select count(*) from pg_views where viewname = '{0}';", viewName.ToLower());

        //执行SQL语句
        _comm.Transaction = _trans;
        _comm.CommandText = sql;
        NpgsqlDataReader readerTemp = _comm.ExecuteReader();

        //获取查询结果
        long value = -1;
        if (readerTemp.HasRows == true)
        {
            readerTemp.Read();
            value = readerTemp.GetInt64(0);
        }

        //释放资源
        readerTemp.Close();

        //value=1表示数据表存在；value=0表示数据表不存在
        if (value == 0)
        {
            return false;
        }
        return true;
    }

    #endregion

    #region 执行sql语句

    /// <summary>
    /// 执行sql语句
    /// </summary>
    /// <param name="sql"></param>
    public void ExecuteNonQuery(string sql)
    {
        try
        {
            _comm.Transaction = _trans;
            _comm.CommandText = sql;
            _comm.ExecuteNonQuery();
        }
        catch
        {
            throw;
        }
    }

    /// <summary>
    /// 执行sql语句
    /// </summary>
    /// <param name="sql"></param>
    /// <returns></returns>
    public DataTable ExecuteQuery(string sql)
    {
        try
        {                
            _comm.Transaction = _trans;
            _comm.CommandText = sql;
            DataTable dt = new DataTable();
            using (NpgsqlDataAdapter adapter = new NpgsqlDataAdapter(_comm))
            {
                adapter.Fill(dt);
            }
            return dt;
        }
        catch (Exception ex)
        {
            throw ex;
        }
    }

    #endregion

    #region 事务管理

    /// <summary>
    /// 开始执行事务
    /// </summary>
    public void BeginTransaction()
    {
        if (_conn != null)
        {
            _trans = _conn.BeginTransaction();
        }
    }

    /// <summary>
    /// 事务结束，保存并提交数据库数据，
    /// </summary>
    public void Commit()
    {
        if (_trans != null)
        {
            _trans.Commit();
        }
    }

    /// <summary>
    /// 回滚事务
    /// </summary>
    public void Rollback()
    {
        if (_trans != null)
        {
            _trans.Rollback();
        }
    }

    /// <summary>
    /// 结束事务，并释放资源
    /// </summary>
    public void EndTransaction()
    {
        if (_trans != null)
        {
            _trans.Dispose();
            _trans = null;
        }
    }

    #endregion

    #endregion

    public void Dispose()
    {
        this.Close();
    }
}
doris_d
关注
专栏目录
PostGIS轨迹分析——AIS数据删除异常点
llc的博客
10-18 733
异常点 红框区域明显断开了，原因是有一个“飞点”异常点一般距离前一个点的距离会大于某一个阈值（比如50000米），当然这个阈值视情况而定，以下是解决此问题的步骤：
PostGIS轨迹分析——简化轨迹
llc的博客
11-01 510
对轨迹线进行简化，并将原始轨迹上的两个特征点拉取到简化后的轨迹上。红色线是简化后的轨迹线，蓝色线是原始轨迹，有两个特征点。最终结果如本文开头截图所示。
PostgreSQL+PostGIS的使用 3
牛魔王的作坊
04-24 5413
四、 PostGIS中的常用函数以下内容包括比较多的尖括号，发布到blogger的时候会显示不正常，内容太多我也无暇一个个手动改代码，因此如有问题就去参考PostGIS官方文档。首先需要说明一下，这里许多函数是以ST_[X]yyy形式命名的，事实上很多函数也可以通过xyyy的形式访问，在PostGIS的函数库中我们可以看到这两种函数定义完全一样。1. OGC标准函数管理函数：添加几何字段 AddGeometryColumn(, , , , , )删除几何字段 DropGeometryColumn(, , )
postgis ST_Dump函数的作用
最新发布
cuisidong1997的博客
09-01 251
对于原子几何类型(POINT、LINESTRING、POLGON)，返回的单个记录为空 路径 数组和输入几何图形为 几何图形。对于集合或多几何图形，返回每个集合组件的记录，并且 路径 表示组件在集合内的位置。它是与 ST_Collect /GROUP BY，因为它创建新行。提取几何体组件的集返回函数(SRF)。它返回一组 geometry_dump 行，每个行包含一个几何图形( 几何图形 字段)和一个整数数组( 路径 字段)。增强：2.0.0引入了对多面体曲面、三角形和三角网的支持。
MobilityDB：MobilityDB是基于PostgreSQL和PostGIS构建的地理空间轨迹数据管理和分析平台
02-05
MobilityDB：MobilityDB是基于PostgreSQL和PostGIS构建的地理空间轨迹数据管理和分析平台
PostGIS轨迹分析——横跨180°经线
llc的博客
12-21 281
在geojson.io上模拟一条轨迹线，可以看到轨迹显示的非常好，红框里面的经纬度超过了180°，实际情况不会产生这种数据。在geojson.io中的展示效果，可以看到虽然说轨迹线没有之前那么乱了，但是在180°经线断开了。遍历轨迹上的每一个点，计算当前点和下一个点经度的差值(diff_x)，当。
Greenplum + PostGIS 在地理空间大数据分析的应用
Greenplum中文社区
03-31 1135
...
PostGIS空间数据表建立及Cesium可视化空间数据.docx
04-28
2. 使用Node.js访问PostGIS空间数据库，我们可以使用PGUtil基础访问类，使用池化连接来访问数据库，并将空间数据返回为GeoJSON格式。 3. 在Cesium中，我们可以使用GeoJsonDataSource加载网络数据，并实现空间数据...
轨迹时空数据存储对比分析
u011843643的博客
03-09 5131
轨迹时空数据存储对比分析 背景 最近有一批车辆的轨迹数据需要用postgresql管理起来。数据格式相对比较简单，就是一堆csv文件，每行一个点，包括x,y,t和其他的一些速度，方向属性信息。 方案对比 能想到的最简答的方法就是把csv映射到数据库的表结构，然后把x,y 够构建成一个坐标点。这样存储上最简单，但是没法进行分析操作。有没有更好的方法呢？ 说到使用postgresql管理空间数据，...
基于PostGIS的轨迹数据修复
做GIS梦的人
04-02 1419
目前有大量的共享单车数据，轨迹数据确是无序的，只有起点和终点坐标是正确的，中间的节点坐标是乱序的。因此需要对轨迹数据进行修复。考虑的效率和操作的方便，选择在Postgresql数据库中，利用PostGIS插件对轨迹进行修复。 现状 在postgresql中进行预览如下图所示： 可以看到中间的轨迹不仅混乱而且几乎没法看，不能称之为轨迹数据。 思路 因为起点和终点固定，中间点是乱序的。有...
PostGIS pgrouting路径分析
weixin_30558305的博客
05-06 260
--让数据库支持PostGIS和pgRouting的函数和基础表（安装后第一次使用时执行，以后都不再执行） CREATE EXTENSION postgis; CREATE EXTENSION pgrouting; CREATE EXTENSION postgis_topology; CREATE EXTENSION fuzzystrmatch; CREATE EXTENSION p...
PostGIS_构造轨迹
beihenanfei的专栏
02-21 148
gis
postgis中批量对矢量数据进行火星坐标加/纠偏
遥想公瑾当年
12-03 6661
postgis中批量对矢量数据进行火星坐标加/纠偏前言最近写了一个批量对postgis中图层进行坐标加偏，纠偏。当然是非严格意义上的精确，只是保证开发者自己的矢量数据能比较正确的叠加常用的在/离线网络底图。下载地址 [下载地址 ]支持的图形类型： Point MULTIPOINT LINESTRING MULTILINESTRING POLYGON MULTIPOLYGON 支持的偏移方式: BD2
POSTGIS 线路规划和爆管分析
@chenk的博客
11-21 382
这个是直接在geoServer 上发布的服务新建视图那种 可以动态传参。
PostGIS 爆管分析之找出上游阀门
guzicheng1990的博客
10-21 1165
环境： Win10 ArcMap10.4（用于数据处理） postgresql9.4 postgis2.2.3 pgRouting2.3（postgresql插件） 说明： 继上一篇文章做了爆管分析找出周围所有影响阀门后（参见：https://www.cnblogs.com/giser-s/p/11662932.html），发现在业务上使用有局限性，因为通常爆管以后我并不需要关闭所有...
java+postgis实现根据两点生成模拟轨迹gps数据
qq_37731856的博客
09-05 3583
基于java和postgis实现根据起终点模拟生成gps轨迹数据
PostGIS管网连通性分析
GIS兵器库
04-27 2858
GIS在管网数据中的很重要的一个应用方向就是”管网空间分析“，其中包括连通性分析、上下游分析、爆管分析等等。下面是我使用postgis来实现该“管网连通性分析”的解决方案，分享给大家，以便相互学习。 使用该分析之前确保已添加扩展postgis、pgrouting CREATE EXTENSION postgis; CREATE EXTENSION pgrouting; 导入数据 将数据导入到postgreSQL数据库，我是从ArcGIS直接导入的，导入方式参考https://blog.csdn.net/e
PostgreSQL + PostGIS 时态分析
weixin_34008784的博客
07-28 711
标签 PostgreSQL , 轨迹 , 时态分析 背景 假设我们有一些物体的轨迹数据（经纬度、measure(通常存为epoch时间戳)），比如车辆、人、传感器等。 给定一个物体在某个时间范围的轨迹数据，查找有没有与这个物体接触的轨迹，并按亲密度排序。 http://postgis.net/docs/manual-2.4/geometry_dist...
利用postgis做路网匹配，将gps轨迹点吸附在路网上，调用路径规划
qq_44838329的博客
04-30 2824
利用postgis做路网匹配，将gps轨迹点吸附在路网上，调用路径规划 因为硬件设备质量的原因，gps定位的坐标出现漂点是不可避免的，这就会造成断路，拐湾都是不可避免的，业务源于生活，逻辑都是真实存在的，该数据为测试数据 利用bigmap将地图路网下载下来，利用arcmap进行处理。粘几条链接 (https://www.jianshu.com/p/92e64c5182e2) (https://www.cnblogs.com/ytwy/p/6817012.html) (https://blog.
使用PostgreSQL/PostGIS和R构建GPS野生动物追踪数据管理系统的实战指南
通过使用PostgreSQL和PostGIS，可以创建一个高效、灵活且可扩展的系统来存储和查询大量的GPS轨迹数据。 书中可能涵盖以下几个关键知识点： 1. **空间数据模型**：介绍如何将地理空间数据（如点、线、多边形）表示...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值