2.6 数据库与数据文件

  # -*- coding: utf-8 -*-
from database import df2SQLite, SQLite2df
import pandas as pd
import re

flatten_lst = lambda lst: (
    [m for n_lst in lst for m in flatten_lst(n_lst)]
    if type(lst) is list
    else [lst]
)


def gjbt599_text_extraction_A(txt_fn, s_mark, e_mark):
    """
    示例区段1，3文本文件格式信息提取方式，包括区段标识符和标题符，例如：
    ######1s
    $落叶灌木：
    木芙蓉(625)、木槿(626)、紫荆(402)
    $竹类：
    青皮竹(646)、慈竹(667)
    #######1e

    Parameters
    ----------
    txt_fn : string
        文本文档路径名.
    s_mark : string
        提取区段开始标识符，例如######1s，######3s等.
    e_mark : string
        提取区段结束标示符，例如#######1e，#######3e等.

    Returns
    -------
    veg_data_df : DataFrame
        返回提取的 DataFrame 格式数据，字段包含：index（为默认生成索引）、category（为标题转化）、name（为树种名提取）和 idx（小括号内的树种索引）.

    """
    i = 0
    start = False
    key = ""
    veg_data = []
    mark = ""
    pattern_idx = re.compile("\((.+?)\)")
    pattern_name = re.compile("(.+?)\(")

    with open(txt_fn, "r", encoding="utf-8") as f:
        for line in f:
            line = line.strip()
            print(f"line------------------------------{i}", end="\r")
            if line == s_mark:
                start = True
                continue
            elif line == e_mark:
                break
            if start:
                # print(line)
                if line and line[0] == "$":
                    key = line[1:].split("：")[0]
                else:
                    line_split = line.split("、")
                    # print(line_split)
                try:
                    line_data = [
                        pattern_name.findall(i) + pattern_idx.findall(i)
                        for i in line_split
                    ]
                    if key and any(line_data):
                        line_data = [
                            [key, i[0].strip(), i[1].strip()] for i in line_data
                        ]
                        veg_data.extend(line_data)
                except:
                    pass
            i += 1
    veg_data_df = pd.DataFrame(veg_data, columns=["category", "name", "idx"])
    return veg_data_df


def gjbt599_text_extraction_B(txt_fn, s_mark, e_mark):
    """
    示例区段2文本文件格式信息提取方式，包括区段标识符，例如：
    ######2s
    1、小叶榕+榄树+朴树+假萍婆一散尾葵一春羽+艳山姜”的行数据
    12、火力楠+红花木莲一含笑+夜合+厚皮香一蚌花
    #######2e

    Parameters
    ----------
    txt_fn : string
        文本文档路径名.
    s_mark : string
        提取区段开始标识符，例如######2s，######5s等.
    e_mark : string
        提取区段结束标示符，例如#######2e，#######5e等.

    Returns
    -------
    veg_data_df : DataFrame
        返回提取的 DataFrame 格式数据，字段为数字索引，每一列为一组群落植被.

    """

    i = 0
    veg_data = []
    start = False
    with open(txt_fn, "r", encoding="utf-8") as f:
        for line in f:
            line = line.strip()
            print(f"line------------------------------{i}", end="\r")
            if line == s_mark:
                start = True
                continue
            elif line == e_mark:
                break
            if start:
                line_lst = re.split("一|—", line)
                line_lst = [i.split("、")[-1] for i in line_lst]
                line_lst = [i.split("+") for i in line_lst]
                line_lst = [
                    [f"{i}-" + j for j in line_lst[i]]
                    for i in range(len(line_lst))
                ]
                line_lst = flatten_lst(line_lst)
                veg_data.append(line_lst)
            i += 1
    veg_data_df = pd.DataFrame(veg_data).T
    return veg_data_df


if __name__ == "__main__":
    gjbt599_SQLite_fp = "../database/gjbt599_SQLite.sqlite"
    txt_fn = r"../data/vegetation_guangzhou.txt"

    # A - Ⅶ区代表城市广州 - 常用园林植物及人工配置植物群落
    gjbt599_veg_text_zoning_representative = gjbt599_text_extraction_A(
        txt_fn, "######1s", "#######1e"
    )
    df2SQLite(
        gjbt599_SQLite_fp,
        gjbt599_veg_text_zoning_representative,
        "veg_zone_repr",
        method="replace",
    )

    # B - 植物群里示例
    gjbt599_veg_biome = gjbt599_text_extraction_B(
        txt_fn, "######2s", "#######2e"
    )
    df2SQLite(
        gjbt599_SQLite_fp, gjbt599_veg_biome, "veg_biome", method="replace"
    )

    # C - 生态性状
    gjbt599_veg_ecological_traits = gjbt599_text_extraction_A(
        txt_fn, "######3s", "#######3e"
    )
    df2SQLite(
        gjbt599_SQLite_fp,
        gjbt599_veg_ecological_traits,
        "veg_ecological_traits",
        method="replace",
    )

    # D-读取植物形状表
    veg_traits_table_fn = "../data/vegetation_traits_table.xlsx"
    veg_traits_table = pd.read_excel(veg_traits_table_fn, index_col=0)
    df2SQLite(
        gjbt599_SQLite_fp,
        veg_traits_table,
        "veg_traits_table",
        method="replace",
    )
  

  def df2SQLite(db_fp,df,table,method='fail'):
    from sqlalchemy import create_engine
    
    '''
    function - pandas 方法，把 DataFrame 格式数据写入数据库（同时创建表）
    
    Paras:
        db_fp - 数据库文件路径
        df - 待写入数据库的DataFrame格式数据
        table - 表名称
        method - 写入方法，'fail'，'replace'或'append'
    '''
    engine=create_engine('sqlite:///'+'\\\\'.join(db_fp.split('\\')),echo=True) 
    try:    
        df.to_sql(table,con=engine,if_exists="%s"%method)
        if method=='replace':            
            print("_"*10,'the %s table has been overwritten...'%table)                  
        elif method=='append':
            print("_"*10,'the %s table has been appended...'%table)
        else:
            print("_"*10,'the %s table has been written......'%table)
    except:
        print("_"*10,'the %s table has been existed......'%table)
        
def SQLite2df(db_fp,table):
    import pandas as pd
    
    '''
    function - pandas 方法，从 SQLite 数据库中读取表数据
    
    Paras:
        db_fp - 数据库文件路径
        table - 所要读取的表        
    '''    
    
    return pd.read_sql_table(table, 'sqlite:///'+'\\\\'.join(db_fp.split('\\'))) #pd.read_sql_table从数据库中读取指定的表
  

  """建立 SQLite 数据库
    Inputs:
        DB_Root: 数据库根目录。DS：Item Access;TH：str
        DB_Name: 数据库名。DS：Item Access;TH：str
    Output:
        DB_Info: 数据库建立情况信息
        db_file： 数据库文件路径"""

ghenv.Component.Name = "Create SQL_DB"
ghenv.Component.NickName = "Create SQL_DB"
ghenv.Component.Description = "Create SQL_DB"
ghenv.Component.Message = "0.0.1"
ghenv.Component.Category = "Moths"
ghenv.Component.SubCategory = "Database"
ghenv.Component.AdditionalHelpFromDocStrings = "1"

import rhinoscriptsyntax as rs
import os
import sqlite3
from sqlite3 import Error


def create_connection(db_file):
    """创建 SQLite 数据库链接"""
    conn = None
    try:
        conn = sqlite3.connect(db_file)
        print(sqlite3.version)
        return sqlite3.version
    except Error as e:
        print(e)
        return e
    finally:
        if conn:
            conn.close()


def create_sqlite_db(DB_Root, DB_Name):
    """
    建立 SQLite 数据库
    """
    db_file = os.path.join(DB_Root, DB_Name + ".sqlite")
    if os.path.exists(db_file):
        print("db_file exists!")
        DB_Info = "{} exists!".format(db_file)
    else:
        info = create_connection(db_file)
        DB_Info = "created {} database; sqlite_version={}".format(DB_Name, info)
    return db_file, DB_Info


if __name__ == "__main__":
    if DB_Root and DB_Name:
        db_file, DB_Info = create_sqlite_db(DB_Root, DB_Name)
  

  """ 从 SQLite 中读取表.
    Inputs:
        SQL_DB_root: SQLite 数据库路径；DS：Item Access;TH：str
        Table_name: 表名。DS：Item Access;TH：str
        Fields: 列名（字段名）。DS：List Access;TH：str
        Attributes: 待写入的数据，每个样本一个列表，各个列名存储样本属性值。DS：Tree Access;TH：Default
        Prefix: 字段名前缀，有时输入的字段名称可能无法用于表的创建，例如indx,或整数等，可以通过加入前缀修正。DS：Item Access;TH：str
        Not_null:字段（列）是否可以为空，默认为可以。DS：Tree Access;TH：bool
        Dump: 为True时将Attribute写入数据库。DS：Tree Access;TH：bool
    Output:
        Prompt: 写入提示"""

ghenv.Component.Name = "SQL DB Dump"
ghenv.Component.NickName = "SQL DB Dump"
ghenv.Component.Message = "0.0.1"
ghenv.Component.Category = "Moths"
ghenv.Component.SubCategory = "Database"
ghenv.Component.AdditionalHelpFromDocStrings = "1"

import rhinoscriptsyntax as rs
import sqlite3
import ghpythonlib.treehelpers as th
from operator import itemgetter

Prompt = "Set Dump as True to dump data to SQLite."


def create_table(conn, sql_table, table_name):
    """
    创建表
    :param conn: Connection object
    :param sql_table: a CREATE TABLE statement
    """
    try:
        c = conn.cursor()
        c.execute("DROP TABLE IF EXISTS %s" % table_name)
        c.execute(sql_table)
    except:
        print("Something going wrong.")


def data2sqlite(conn, table_name, Fields, data):
    """
    给定数据库连接，表名，字段名，将数据写入到数据库
    """
    sql_values_base = """INSERT INTO {}(""".format(table_name)
    for f in Fields:
        sql_values_base = sql_values_base + "{},".format(f)
    sql_values_base = sql_values_base[:-1] + ") VALUES (" + "?," * len(Fields)
    sql_values = sql_values_base[:-1] + ")"
    with conn:
        data_ = [list(i) for i in zip(*data)]
        conn.executemany(sql_values, data)
        conn.commit()


def sqlite_dump(SQL_DB_root, Table_name, Fields, Attributes, Prefix, Not_null):
    """
    数据写入到数据库主程序
    """
    Attributes_lst = th.tree_to_list(Attributes)
    Attributes_flip_lst = list(zip(*Attributes_lst))
    data_type = [type(i) for i in list(map(itemgetter(0), Attributes_flip_lst))]
    data_type_list = {str: "text", int: "integer", float: "real"}
    Fields_type = [data_type_list[i] for i in data_type]

    conn = sqlite3.connect(SQL_DB_root)
    sql_table_base = """CREATE TABLE IF NOT EXISTS {} ( id integer PRIMARY KEY AUTOINCREMENT,""".format(
        Table_name
    )
    if Prefix:
        Fields = [Prefix + i for i in Fields]
    for f, t in zip(Fields, Fields_type):
        if Not_null:
            sql_table_base += "{} {} NOT NULL,".format(f, t)
        else:
            sql_table_base += "{} {},".format(f, t)
    sql_table = sql_table_base[:-1] + ");"
    create_table(conn, sql_table, Table_name)
    data2sqlite(conn, Table_name, Fields, Attributes_lst)

    Prompt = "Data dumped."


if __name__ == "__main__":
    if Dump:
        sqlite_dump(
            SQL_DB_root, Table_name, Fields, Attributes, Prefix, Not_null
        )
  

  """从 SQLite 中读取表.
    Inputs:
        SQL_DB_root: SQLite 数据库路径。DS：Item Access;TH：str
        Table_name: 表名。DS：Item Access;TH：str
    Output:
        table: 读取数据库中的表
        column: 列名（字段名）"""


ghenv.Component.Name = "SQL DB Load"
ghenv.Component.NickName = "SQL DB Load"
ghenv.Component.Message = "0.0.1"
ghenv.Component.Category = "Moths"
ghenv.Component.SubCategory = "Database"
ghenv.Component.AdditionalHelpFromDocStrings = "1"

import rhinoscriptsyntax as rs
import sqlite3
import ghpythonlib.treehelpers as th
import Rhino


def load_sqlite_db(SQL_DB_root, Table_name):
    """
    指定数据库路径和表名，读取 SQLite 数据库文件
    """
    conn = sqlite3.connect(SQL_DB_root)
    with conn:
        cur = conn.cursor()
        cur.execute("SELECT * FROM %s" % Table_name)
        rows = cur.fetchall()
    column = list(map(lambda x: x[0], cur.description))
    layerTree = th.list_to_tree(
        rows,
        source=[
            0,
        ],
    )
    table = layerTree

    return table, column


if __name__ == "__main__":
    if SQL_DB_root and Table_name:
        table, column = load_sqlite_db(SQL_DB_root, Table_name)
  

  # -*- coding: utf-8 -*-
import geopandas as gpd
import pandas as pd

from database import gpd2postSQL, postSQL2gpd
import fiona

fiona.drvsupport.supported_drivers["KML"] = (
    "rw"  
)


def json2gpd(fp, epsg_original=None, epsg_target=None, mask=None):
    """
    读取含有地理信息数据的 json 格式文件为 GeoDataFrame 格式数据

    Parameters
    ----------
    fp : string
        json 文件路径.
    epsg_original : int, optional
        原始投影，epsg 编号. The default is None.
    epsg_target : int, optional
        转换为投影，epsg 编号. The default is None.
    mask : polygon(Shapely), optional
        提取的范围. The default is None.

    Returns
    -------
    gdf : GeoDataFrame
        转换后的数据.

    """
    df = pd.read_json(fp)
    gdf = gpd.GeoDataFrame.from_features(df["features"])
    if epsg_original:
        gdf.set_crs(epsg_original, inplace=True)
    if mask:
        mask_bool = gdf.within(mask)
        gdf = gdf[mask_bool]
    if epsg_target:
        gdf.to_crs(epsg_target, inplace=True)

    return gdf


if __name__ == "__main__":
    # A-用于数据提取的边界
    region4chicago_building_fp = "../data/region4chicago_building.kml"
    region4chicago_building = gpd.read_file(
        region4chicago_building_fp, driver="KML"
    )
    db_args = {
        "myusername": "postgres",
        "mypassword": "123456",
        "mydatabase": "ghpython",
        "geom_col": "geometry",
    }
    gpd2postSQL(region4chicago_building, table_name="region4chicago", **db_args)

    # B-读取芝加哥区域 json 格式建筑地理信息数，并写入数据库和单独存储为 GeoJSON 地理数据格式
    json_3DBuilding_fp = r"../data/Chicago_3dbuildings.json"
    building_gpd = json2gpd(
        json_3DBuilding_fp,
        4326,
        32616,
        region4chicago_building.geometry.values[0],
    )
    gpd2postSQL(building_gpd, table_name="chicago_building_mask", **db_args)
    building_gpd.to_file("../data/chicago_building.geojson", driver="GeoJSON")
  

  def gpd2postSQL(gdf, table_name, **kwargs):
    from sqlalchemy import create_engine

    """
    function - 将 GeoDataFrame 格式数据写入 PostgreSQL 数据库
    
    Paras:
        gdf - GeoDataFrame 格式数据，含 geometry 字段（几何对象，点、线和面，数据值对应定义的坐标系统）
        table_name - 写入数据库中的表名
        **kwargs - 连接数据库相关信息，包括 myusername（数据库的用户名），mypassword（用户密钥），mydatabase（数据库名）
    """
    engine = create_engine(
        "postgresql://{myusername}:{mypassword}@localhost:5432/{mydatabase}".format(
            myusername=kwargs["myusername"],
            mypassword=kwargs["mypassword"],
            mydatabase=kwargs["mydatabase"],
        )
    )
    gdf.to_postgis(
        table_name,
        con=engine,
        if_exists="replace",
        index=False,
    )
    print("_" * 50)
    print(
        "The GeoDataFrame has been written to the PostgreSQL database.The table name is {}.".format(
            table_name
        )
    )


def postSQL2gpd(table_name, geom_col="geometry", **kwargs):
    from sqlalchemy import create_engine
    import geopandas as gpd

    """
    function - 读取 PostgreSQL 数据库中的表为 GeoDataFrame 格式数据
    
    Paras:
        table_name - 待读取数据库中的表名
        geom_col='geometry' - 几何对象，常规默认字段为'geometry'
        **kwargs - 连接数据库相关信息，包括myusername（数据库的用户名），mypassword（用户密钥），mydatabase（数据库名）
    """
    engine = create_engine(
        "postgresql://{myusername}:{mypassword}@localhost:5432/{mydatabase}".format(
            myusername=kwargs["myusername"],
            mypassword=kwargs["mypassword"],
            mydatabase=kwargs["mydatabase"],
        )
    )
    gdf = gpd.read_postgis(table_name, con=engine, geom_col=geom_col)
    print("_" * 50)
    print(
        "The data has been read from PostgreSQL database. The table name is {}.".format(
            table_name
        )
    )
    return gdf
  

  {
  "type": "FeatureCollection",
  "features": [
    {
      "type": "Feature",
      "geometry": {
        "type": "Point",
        "coordinates": [102.0, 0.5]
      },
      "properties": {
        "prop0": "value0"
      }
    },
    {
      "type": "Feature",
      "geometry": {
        "type": "LineString",
        "coordinates": [
          [102.0, 0.0], [103.0, 1.0], [104.0, 0.0], [105.0, 1.0]
        ]
      },
      "properties": {
        "prop0": "value0",
        "prop1": 0.0
      }
    },
    {
      "type": "Feature",
      "geometry": {
        "type": "Polygon",
        "coordinates": [
          [
            [100.0, 0.0], [101.0, 0.0], [101.0, 1.0],
            [100.0, 1.0], [100.0, 0.0]
          ]
        ]
      },
      "properties": {
        "prop0": "value0",
        "prop1": { "this": "that" }
      }
    }
  ]
}
  

  """读取 GeoJSON 数据 
    Inputs:
        File: GeoJSON 文件路径. DS：Item Access;TH：str
        String: 原始的 GeoJSON 字符串. DS：Item Access;TH：str
        replacement_v：Null 替换值.DS：Item Access;TH：str
    Output:
        Type: GeoJSON 的原初类型.
        Geometry: 变换为 Rhino 几何对象.
        Keys: GeoJSON 属性键. 
        Values:  GeoJSON 属性值"""

ghenv.Component.Name = "Read GeoJSON"
ghenv.Component.NickName = "Read GeoJSON"
ghenv.Component.Description = """Reads an GeoJSON file or raw GeoJSON string and translates it's contents into Rhino geometry"""
ghenv.Component.Message = "0.0.1"
ghenv.Component.Category = "Moths"
ghenv.Component.SubCategory = "Database"
ghenv.Component.AdditionalHelpFromDocStrings = "1"

import rhinoscriptsyntax as rs
import ghpythonlib.treehelpers as th


def read_GeoJSON(file=None, string=None, replacement_v="9999"):
    """
    读取 GeoJSON 地理空间信息数据交换格式文件
    """
    if file:
        with open(file, "r") as f:
            geojson_string = f.read().strip()
    elif string:
        geojson_string = string
    else:
        geojson_string = None

    if geojson_string:
        type_lst = []
        geometry_lst = []
        keys_lst = []
        values_list = []
        if replacement_v:
            geojson_string = geojson_string.replace("null", replacement_v)
        geojson_dict = eval(geojson_string)
        if "features" in geojson_dict.keys():
            features = geojson_dict["features"]
        else:
            features = [geojson_dict]

        for f in features:
            type_g = f["geometry"]["type"]
            coordinates = f["geometry"]["coordinates"]
            properties = f["properties"]
            keys = list(properties.keys())
            values = list(properties.values())
            # print(type_g,coordinates,keys,values)
            if type_g == "MultiPolygon":
                geometry = [
                    rs.AddPolyline(
                        [
                            rs.AddPoint([float(j[0]), float(j[1]), 0])
                            for j in i[0]
                        ]
                    )
                    for i in coordinates
                ]
            elif type_g == "Polygon":
                geometry = [
                    rs.AddPolyline(
                        [rs.AddPoint([float(j[0]), float(j[1]), 0]) for j in i]
                    )
                    for i in coordinates
                ]
            elif type_g == "MultiLineString":
                geometry = [
                    rs.AddPolyline(
                        [rs.AddPoint([float(j[0]), float(j[1]), 0]) for j in i]
                    )
                    for i in coordinates
                ]
            elif type_g == "MultiPoint":
                geometry = [
                    rs.AddPoint([float(i[0]), float(i[1]), 0])
                    for i in coordinates
                ]
            else:
                print("The data format does not meet the requirements.")
            type_lst.append(type_g)
            geometry_lst.append(geometry)
            keys_lst.append(keys)
            values_list.append(values)

        type_tree = th.list_to_tree(type_lst)
        geometry_tree = th.list_to_tree(geometry_lst)
        keys_tree = th.list_to_tree(keys_lst)
        values_tree = th.list_to_tree(values_list)

        return type_tree, geometry_tree, keys_tree, values_tree
    else:
        return [None] * 4


if __name__ == "__main__":
    if replacement_v:
        Type, Geometry, Keys, Values = read_GeoJSON(File, String, replacement_v)
    else:
        Type, Geometry, Keys, Values = read_GeoJSON(File, String)
  

  """建立 GeoJSON 点数据
    Inputs:
        Points: Points you want to export (One branch for each feature). DS：List Access;TH：Default
        Keys: Keys to be save in object properties (One branch per feature). DS：List Access;TH：str
        Values: Values to save in object properties (One branch per feature). DS：List Access;TH：str
    Output:
        Features: Strings containing GeoJSON geometry features (not a complete GeoJSON FeatureCollection yet, merge them via Join GeoJSON component). """

ghenv.Component.Name = "Feature from Points"
ghenv.Component.NickName = "Feature from Points"
ghenv.Component.Description = """Converts points into Point GeoJSON features and list of points into MultiPoint features."""
ghenv.Component.Message = "0.0.1"
ghenv.Component.Category = "Moths"
ghenv.Component.SubCategory = "Database"
ghenv.Component.AdditionalHelpFromDocStrings = "1"

import rhinoscriptsyntax as rs


def feature_from_points(points, keys, values):
    properties = dict(zip(keys, values))
    pts = []
    for p_ in points:
        if rs.IsPoint(p_):
            p = rs.PointCoordinates(p_)
            pts_coordi = [p.X, p.Y]
            pts.append(pts_coordi)
    geojson_dict_string = (
        '{"type":"Feature","geometry":{"type":"MultiPoint","coordinates":%s},"properties":%s}'
        % (pts, properties)
    )

    return geojson_dict_string.replace("'", '"')


if __name__ == "__main__":
    if Points and Keys and Values:
        Features = feature_from_points(Points, Keys, Values)
  

  """建立 GeoJSON 线数据
    Inputs:
        Curves: Curves/Polylines you want to export (One branch for each feature). DS：List Access;TH：Default
        Keys: Keys to be save in object properties (One branch per feature). DS：List Access;TH：str
        Values: Values to save in object properties (One branch per feature). DS：List Access;TH：str
    Output:
        Features: Strings containing GeoJSON geometry features (not a complete GeoJSON FeatureCollection yet, merge them via Join GeoJSON component). """

ghenv.Component.Name = "Feature from Lines"
ghenv.Component.NickName = "Feature from Lines"
ghenv.Component.Description = """Converts curves/polylines into GeoJSON LineStrings and list of curves into MultiLineStrings."""
ghenv.Component.Message = "0.0.1"
ghenv.Component.Category = "Moths"
ghenv.Component.SubCategory = "Database"
ghenv.Component.AdditionalHelpFromDocStrings = "1"

import rhinoscriptsyntax as rs


def feature_from_lines(curves, keys, values):
    properties = dict(zip(keys, values))
    pts = []
    for p in curves:
        if rs.IsCurve(p):
            points = rs.CurvePoints(p)
            pts_coordi = [[p.X, p.Y] for p in points]
            pts.append(pts_coordi)
    geojson_dict_string = (
        '{"type":"Feature","geometry":{"type":"MultiLineString","coordinates":%s},"properties":%s}'
        % (pts, properties)
    )

    return geojson_dict_string.replace("'", '"')


if __name__ == "__main__":
    if Curves and Keys and Values:
        Features = feature_from_lines(Curves, Keys, Values)
  

  """建立 GeoJSON 多边形数据
    Inputs:
        Polygons: Closed polylines you want to export (One branch for each feature). . DS：List Access;TH：Default
        Keys: Keys to be save in object properties (One branch per feature). DS：List Access;TH：str
        Values: Values to save in object properties (One branch per feature). DS：List Access;TH：str
    Output:
        Features: Strings containing GeoJSON geometry features (not a complete GeoJSON FeatureCollection yet, merge them via Join GeoJSON component). """

ghenv.Component.Name = "Feature from Polygons"
ghenv.Component.NickName = "Feature from Polygons"
ghenv.Component.Description = """Converts closed polylines into GeoJSON Polygons and lists of closed polylines into MultiPolygons.Doesn't allow creation shapes with holes.If you need shapes with inner holes, use Complex Polygons component instead."""
ghenv.Component.Message = "0.0.1"
ghenv.Component.Category = "Moths"
ghenv.Component.SubCategory = "Database"
ghenv.Component.AdditionalHelpFromDocStrings = "1"

import rhinoscriptsyntax as rs


def feature_from_polygons(polygons, keys, values):
    properties = dict(zip(keys, values))
    pts = []
    for p in polygons:
        if rs.IsPolyline(p):
            points = rs.PolylineVertices(p)
            pts_coordi = [[p.X, p.Y] for p in points]
            pts.append(pts_coordi)
    """
    geojson_dict={
                 "type":"Feature",
                 "geometry":{
                            "type":"MultiPolygon",
                            "coordinates":[[i] for i in pts]
                            },
                 "properties":properties
                 }
    """
    geojson_dict_string = (
        '{"type":"Feature","geometry":{"type":"MultiPolygon","coordinates":%s},"properties":%s}'
        % ([[i] for i in pts], properties)
    )
    return geojson_dict_string.replace("'", '"')


if __name__ == "__main__":
    if Polygons and Keys and Values:
        Features = feature_from_polygons(Polygons, Keys, Values)
  

  """建立 GeoJSON 多边形（拓扑）数据
    Inputs:
        Polygons: Closed polylines you want to export (One branch for each feature). DS：List Access;TH：Default
        Keys: Keys to be save in object properties (One branch per feature). DS：List Access;TH：str
        Values: Values to save in object properties (One branch per feature). DS：List Access;TH：str
    Output:
        Features: Strings containing GeoJSON geometry features (not a complete GeoJSON FeatureCollection yet, merge them via Join GeoJSON component). """


ghenv.Component.Name = "Feature from Polygons(+)"
ghenv.Component.NickName = "Feature from Polygons(+)"
ghenv.Component.Description = """Converts list of closed polylines into GeoJSON Polygon object with first curve as an outer-ringand all other curves as inner-holes in the shape.Doesn't allow creation of MultiPolygons, for that try 'simple' Polygon to Feature component instead."""
ghenv.Component.Message = "0.0.1"
ghenv.Component.Category = "Moths"
ghenv.Component.SubCategory = "Database"
ghenv.Component.AdditionalHelpFromDocStrings = "1"

import rhinoscriptsyntax as rs


def feature_from_polygons_topology(polygons, keys, values):
    properties = dict(zip(keys, values))
    pts = []
    for p in polygons:
        if rs.IsPolyline(p):
            points = rs.PolylineVertices(p)
            pts_coordi = [[p.X, p.Y] for p in points]
            pts.append(pts_coordi)
    geojson_dict_string = (
        '{"type":"Feature","geometry":{"type":"Polygon","coordinates":%s},"properties":%s}'
        % (pts, properties)
    )

    return geojson_dict_string.replace("'", '"')


if __name__ == "__main__":
    if Polygons and Keys and Values:
        Features = feature_from_polygons_topology(Polygons, Keys, Values)
  

  """合并各个类型的 GeoJSON 数据
    Inputs:
        Features: List of complete GeoJSON strings or separate Feature strings to merge. DS：List Access;TH：Default
    Output:
        GeoJSON: Merged GeoJSON string. """

ghenv.Component.Name = "Join GeoJSON"
ghenv.Component.NickName = "Join GeoJSON"
ghenv.Component.Description = """Merges multiple GeoJSON strings."""
ghenv.Component.Message = "0.0.1"
ghenv.Component.Category = "Moths"
ghenv.Component.SubCategory = "Database"
ghenv.Component.AdditionalHelpFromDocStrings = "1"

import rhinoscriptsyntax as rs


def join_geojson(features):
    features_ = ",".join(features)
    geojson_string = '{"type":"FeatureCollection","features":[%s]}' % (
        features_
    )
    return geojson_string


if __name__ == "__main__":
    if Features:
        GeoJSON = join_geojson(Features)
  

  """本地保存 GeoJSON 数据
    Inputs:
        Directory: Path to the directory where files will be created. . DS：Item Access;TH：str
        Filename: Name of the file.The suffix name is geojson. DS：Item Access;TH：str
        Data: Text data you want to save. DS：Item Access;TH：str
        Run: Needs to be True for the file to be created. DS：Item Access;TH：bool
        Overwrite: Existing files will be overwritten only when this is True. DS：Item Access;TH：bool
    Output:
        fp：the file path"""

ghenv.Component.Name = "Write File"
ghenv.Component.NickName = "Write File"
ghenv.Component.Description = """Writes text data to a file on your computer."""
ghenv.Component.Message = "0.0.1"
ghenv.Component.Category = "Moths"
ghenv.Component.SubCategory = "Database"
ghenv.Component.AdditionalHelpFromDocStrings = "1"

import os


def string2file(directory, filename, data, overwrite=False):
    fp = os.path.join(directory, filename + ".geojson")
    if os.path.exists(fp):
        print("File exists.")
        if overwrite:
            with open(fp, "w") as f:
                f.writelines(data)
            print("GeoJson has dumped.")
    else:
        with open(fp, "w") as f:
            f.writelines(data)
        print("GeoJson has dumped.")


if __name__ == "__main__":
    if Directory and Filename and Data:
        if Run:
            string2file(Directory, Filename, Data, Overwrite)
        fp = os.path.join(Directory, Filename + ".geojson")