การตั้งค่าสภาพแวดล้อม Python สำหรับภูมิสารสนเทศ (Windows)

ขั้นตอนที่ 1: ติดตั้ง Anaconda (แนะนำ Python 3.10):

ดาวน์โหลด Anaconda ได้ที่ Anaconda Download

คู่มือนี้จะแนะนำวิธีการตั้งค่าสภาพแวดล้อม Python สำหรับภูมิสารสนเทศใน Windows พร้อมกับไลบรารีที่สำคัญทั้งหมดสำหรับการวิเคราะห์ข้อมูลภูมิสารสนเทศ การแสดงผล และการประมวลผล

    
conda create -n geo_env python=3.10
conda activate geo_env
    

    
    conda install -c conda-forge rasterio geopandas xarray geemap localtileserver jupyterlab notebook earthengine-api ipykernel
    

ขั้นตอนที่ 4. เพิ่ม geo_env ไปยังเคอร์เนล Jupyter Notebook

    
    python -m ipykernel install --user --name=geo_env --display-name "Python (geo_env)"
    

ขั้นตอนที่ 5. เปิด Jupyter Notebook

    
    jupyter notebook
    

✅ ทดสอบการตั้งค่าของคุณ

    
import rasterio
import geemap
print("ทุกอย่างทำงานได้ ✅")    
    

    
conda activate geo_env
jupyter notebook    
    

6. การแก้ไขปัญหาทั่วไป

    
conda install -c conda-forge rasterio
conda install -c conda-forge geopandas
conda install -c conda-forge xarray
# และอื่นๆ...    
    

    
conda install -c conda-forge gdal    
    

ข้อผิดพลาดหน่วยความจำระหว่างการติดตั้ง

ความขัดแย้งของเวอร์ชัน Python

    
conda create -n geo_env python=3.9  # หรือเวอร์ชันอื่น    
    

การอัปเดตสภาพแวดล้อมของคุณ

    
conda update --all    
    

    
pip install rasterio geopandas xarray geemap    
    

แพ็คเกจที่เป็นประโยชน์เพิ่มเติม

    
conda install -c conda-forge matplotlib seaborn plotly contextily folium rasterstats    
    

🔗 พิเศษ: การตั้งค่าการยืนยันตัวตน Google Earth Engine

หากคุณกำลังใช้ Google Earth Engine (GEE) คุณจะต้องยืนยันตัวตน:

    
import ee
ee.Authenticate()  # ทำตามคำแนะนำในเบราว์เซอร์ของคุณ
ee.Initialize()    
    

การจัดการข้อมูล GeoTIFF และการแสดงผล

คู่มือแนะนำนี้แสดงวิธีการทำงานกับข้อมูล GeoTIFF แบบออฟไลน์โดยใช้ Python คุณจะได้เรียนรู้วิธีการดาวน์โหลด อ่าน แสดงผล และปรับเปลี่ยนข้อมูลแรสเตอร์ภูมิสารสนเทศ โดยทั้งหมดจะดำเนินการในเครื่องของคุณเอง วิธีนี้เหมาะอย่างยิ่งสำหรับสภาพแวดล้อมที่มีการเชื่อมต่ออินเทอร์เน็ตจำกัดหรือเมื่อทำงานกับชุดข้อมูลขนาดใหญ่

ข้อกำหนดเบื้องต้น – ตรวจสอบการติดตั้งแพ็คเกจ เพื่อให้มั่นใจว่าแพ็คเกจทั้งหมดถูกติดตั้งอย่างถูกต้อง:

ตรวจสอบการติดตั้งแพ็กเกจ

    
# ทดสอบการนำเข้าแต่ละแพ็กเกจ
import rasterio
import geopandas
import matplotlib
import numpy
import requests

print("นำเข้าแพ็กเกจทั้งหมดสำเร็จ!")    
    

ขั้นตอนการทำงาน

ขั้นตอนที่ 1. ดาวน์โหลด GeoTIFF จากแพลตฟอร์มของเราและบันทึกในเครื่อง

    
import requests

# ลิงก์ดาวน์โหลดโดยตรงจากแพลตฟอร์ม
url = "https://dl.dropboxusercontent.com/scl/fi/ijfjpdntc1qv068wjlbbb/AvgSurfT.tif?rlkey=wx9lgdgkcf2ahrymemln1y37v&dl=0"
output_path = "AvgSurfT.tif"

# ดาวน์โหลดและบันทึกในเครื่อง
response = requests.get(url)
with open(output_path, "wb") as f:
    f.write(response.content)
    
print("ดาวน์โหลดไฟล์และบันทึกเป็น:", output_path)    
    

ขั้นตอนที่ 2. อ่านไฟล์ GeoTIFF และสำรวจคุณสมบัติ

    
import rasterio

# เปิดไฟล์ GeoTIFF
with rasterio.open("AvgSurfT.tif") as dataset:
    print("ข้อมูลเมตา:", dataset.profile)
    print("CRS:", dataset.crs)
    print("จำนวนแบนด์:", dataset.count)    
    

ขั้นตอนที่ 3. อ่านข้อมูลแบนด์และคำนวณสถิติ

    
import numpy as np

with rasterio.open("AvgSurfT.tif") as dataset:
    band1 = dataset.read(1).astype("float64")  # อ่านแบนด์แรก
    valid_data = band1[~np.isnan(band1)]  # ตัด NaNs ออก
    
    stats = {
        'min': float(np.min(valid_data)),
        'max': float(np.max(valid_data)),
        'mean': float(np.mean(valid_data)),
        'std': float(np.std(valid_data))
    }
    
    print("สถิติแบนด์ 1:", stats)    
    

ขั้นตอนที่ 4. แสดงภาพข้อมูลแบนด์

    
import matplotlib.pyplot as plt

plt.figure(figsize=(6, 8))
plt.imshow(band1, cmap='hot_r', vmin=280, vmax=320)
plt.colorbar(label="อุณหภูมิ (K)")
plt.title("AvgSurfT - แบนด์ 1")
plt.xlabel("X (พิกเซล)")
plt.ylabel("Y (พิกเซล)")
plt.show()    
    

ขั้นตอนที่ 5. แทนที่พิกัดพิกเซลด้วยพิกัดภูมิศาสตร์

    
with rasterio.open("AvgSurfT.tif") as src:
    band1 = src.read(1)
    transform = src.transform
    
    from rasterio.transform import xy
    
    # รับขนาด
    nrows, ncols = band1.shape
    
    # รับลองจิจูด/ละติจูดของมุมบนซ้ายและมุมล่างขวา
    lon_min, lat_max = xy(transform, 0, 0)
    lon_max, lat_min = xy(transform, nrows - 1, ncols - 1)
    
    # สร้างขอบเขต
    extent = [lon_min, lon_max, lat_min, lat_max]

plt.figure(figsize=(10, 6))
plt.imshow(band1, cmap='hot_r', vmin=280, vmax=320, extent=extent)
plt.colorbar(label="อุณหภูมิ (K)")
plt.title("AvgSurfT - แบนด์ 1")
plt.xlabel("ลองจิจูด")
plt.ylabel("ละติจูด")
plt.show()    
    

ขั้นตอนที่ 6. แสดงภาพทุกแบนด์

    
# เปิดชุดข้อมูล
with rasterio.open("AvgSurfT.tif") as dataset:
    num_bands = dataset.count  # จำนวนแบนด์
    transform = dataset.transform
    height = dataset.height
    width = dataset.width
    
    # รับขอบเขตภูมิศาสตร์
    lon_min, lat_max = xy(transform, 0, 0)
    lon_max, lat_min = xy(transform, height - 1, width - 1)
    extent = [lon_min, lon_max, lat_min, lat_max]
    
    # สร้างแผนภาพย่อยสำหรับแต่ละแบนด์
    fig, axes = plt.subplots(1, num_bands, figsize=(5 * num_bands, 6))
    
    if num_bands == 1:
        axes = [axes]  # ทำให้แน่ใจว่า axes เป็นรูปแบบที่วนซ้ำได้เสมอ
        
    for i in range(num_bands):
        band = dataset.read(i + 1)  # อ่านแบนด์ (ดัชนีเริ่มที่ 1)
        ax = axes[i]
        im = ax.imshow(band, cmap='hot_r', vmin=280, vmax=320, extent=extent)
        ax.set_title(f"แบนด์ {i + 1}")
        ax.set_xlabel("ลองจิจูด")
        ax.set_ylabel("ละติจูด")
        plt.colorbar(im, ax=ax, shrink=1)
        
    plt.tight_layout()
    plt.show()    
    

ขั้นตอนที่ 7. ตัดข้อมูล GeoTIFF ให้เป็นพื้นที่เฉพาะ (ขอบเขตประเทศไทย)

    
import geopandas as gpd
from rasterio.mask import mask

# โหลดไฟล์ shapefile GADM ระดับ 1 สำหรับประเทศไทย
thailand = gpd.read_file("path/to/your/shapefile.shp")  # อัปเดตด้วยพาธของคุณ

# ตัดเฉพาะจังหวัดที่ต้องการ
bangkok = thailand[thailand["shapeName"] == "Bangkok"]

# เปิด GeoTIFF และทำการตัด
with rasterio.open("AvgSurfT.tif") as src:
    if bangkok.crs != src.crs:
        bangkok = bangkok.to_crs(src.crs)
        
    # ตัดราสเตอร์
    out_image, out_transform = mask(src, bangkok.geometry, crop=True)
    out_meta = src.meta.copy()
    
    # อัปเดตข้อมูลเมตาสำหรับผลลัพธ์
    out_meta.update({
        "height": out_image.shape[1],
        "width": out_image.shape[2],
        "transform": out_transform
    })    
    

ขั้นตอนที่ 8. บันทึกและแสดงภาพผลลัพธ์ที่ตัดแล้ว

    
# บันทึก GeoTIFF ที่ตัดแล้ว
with rasterio.open("AvgSurfT_bkk.tif", "w", **out_meta) as dest:
    dest.write(out_image)

# รับจำนวนแถวและคอลัมน์
nrows, ncols = out_image.shape[1], out_image.shape[2]

# รับพิกัดขอบเขตโดยใช้การแปลงแบบ affine
lon_min, lat_max = xy(out_transform, 0, 0)
lon_max, lat_min = xy(out_transform, nrows - 1, ncols - 1)

# สร้างขอบเขตสำหรับ imshow (ซ้าย, ขวา, ล่าง, บน)
extent = [lon_min, lon_max, lat_min, lat_max]

# แสดงราสเตอร์และขอบเขต
fig, ax = plt.subplots(figsize=(10, 6))
raster = ax.imshow(out_image[0], cmap='hot_r', vmin=300, vmax=320, extent=extent)
bangkok.boundary.plot(ax=ax, edgecolor='black', linewidth=0.5)
plt.colorbar(raster, ax=ax, label="อุณหภูมิ (K)")
ax.set_title("AvgSurfT - ตัดขอบเขตกรุงเทพฯ พร้อมแสดงเส้นขอบ")
ax.set_xlabel("ลองจิจูด")
ax.set_ylabel("ละติจูด")
ax.set_axis_on()
plt.savefig("AvgSurfT_bkk_with_boundary.png", dpi=300)
plt.show()    
    

บทสรุป

หมายเหตุ: บทเรียนนี้สันนิษฐานว่าคุณมีความคุ้นเคยพื้นฐานกับการเขียนโปรแกรม Python และแนวคิดเชิงพื้นที่ สำหรับคำอธิบายที่ละเอียดเกี่ยวกับฟังก์ชันเฉพาะ โปรดดูเอกสารประกอบสำหรับ rasterio, GeoPandas และ Matplotlib

🔍 ตัวอย่างโค้ดบน : GeoTiff in Python

การประมวลผลและการแสดงผลข้อมูล NetCDF

คู่มือนี้มีคำแนะนำอย่างครบถ้วนเกี่ยวกับการทำงานกับไฟล์ NetCDF (.nc) โดยใช้ Python รวมถึงการโหลดข้อมูล การวิเคราะห์ และการสร้างภาพข้อมูลหลากหลายประเภท โดยเน้นไปที่ข้อมูลทางอุตุนิยมวิทยาและภูมิสารสนเทศ

ข้อกำหนดเบื้องต้น – ดาวน์โหลดไฟล์ NetCDF

ขั้นตอนที่ 1. การติดตั้งไลบรารีที่จำเป็น

    
    pip install xarray netCDF4 matplotlib numpy scipy cartopy geopandas
    

ขั้นตอนที่ 2. การโหลดและสำรวจข้อมูล NetCDF

    
import xarray as xr
import os
import matplotlib.pyplot as plt
import geopandas as gpd
import numpy as np
import pandas as pd

# เส้นทางไปยังไฟล์ NetCDF ของคุณ
nc_file_path = r"C:\Users\ASUS\Jupyter\ALICE\data\AvgSurfT.nc"

# เปิดชุดข้อมูล
ds = xr.open_dataset(nc_file_path)

# สำรวจโครงสร้างชุดข้อมูล
print("ภาพรวมชุดข้อมูล:")
print(ds)

# ดูตัวแปรที่มีอยู่ในชุดข้อมูล
print(f"ตัวแปรที่มีอยู่: {list(ds.data_vars)}")

# แยกตัวแปรที่สนใจ
var_data = ds['AvgSurfT']  # แทนที่ด้วยชื่อตัวแปรของคุณหากแตกต่าง

# ตรวจสอบข้อมูลเมตาและคุณลักษณะ
print(f"คุณลักษณะของตัวแปร: {var_data.attrs}")
print(f"มิติ: {var_data.dims}")
print(f"พิกัด: {var_data.coords}")
print(f"รูปร่าง: {var_data.shape}")    
    

ขั้นตอนที่ 3. สถิติพื้นฐานและการสำรวจข้อมูล

    
# คำนวณสถิติพื้นฐาน
ds_mean_value = var_data.mean().values
ds_min_value = var_data.min().values
ds_max_value = var_data.max().values
ds_std_dev = var_data.std().values

# รับช่วงเวลา
min_date = str(var_data.time.values.min())[:10]
max_date = str(var_data.time.values.max())[:10]

# แสดงสถิติ
print(f"ช่วงเวลา: {min_date} ถึง {max_date}")
print(f"ค่าเฉลี่ย: {ds_mean_value:.4f} {var_data.attrs.get('units', '')}")
print(f"ค่าต่ำสุด: {ds_min_value:.4f} {var_data.attrs.get('units', '')}")
print(f"ค่าสูงสุด: {ds_max_value:.4f} {var_data.attrs.get('units', '')}")
print(f"ค่าเบี่ยงเบนมาตรฐาน: {ds_std_dev:.4f} {var_data.attrs.get('units', '')}")

# สถิติเชิงพื้นที่เพิ่มเติม
print("\nการวิเคราะห์เชิงพื้นที่:")
spatial_mean = var_data.mean(dim=['lat', 'lon']).values
print(f"ค่าเฉลี่ยในทุกตำแหน่ง: {spatial_mean.mean():.4f}")

# สถิติเชิงเวลา
print("\nการวิเคราะห์เชิงเวลา:")
if 'time' in var_data.dims:
    temporal_mean = var_data.mean(dim='time')
    print(f"รูปร่างค่าเฉลี่ยเชิงเวลา: {temporal_mean.shape}")
    print(f"ค่าสูงสุดในค่าเฉลี่ยเชิงเวลา: {temporal_mean.max().values:.4f}")
    print(f"ค่าต่ำสุดในค่าเฉลี่ยเชิงเวลา: {temporal_mean.min().values:.4f}")    
    

ขั้นตอนที่ 4. การแสดงผลภาพเชิงพื้นที่พร้อมขอบเขตทางภูมิศาสตร์

    
# โหลดขอบเขตประเทศไทย
thailand_boundary = gpd.read_file("https://geodata.ucdavis.edu/gadm/gadm4.1/json/gadm41_THA_0.json")

# สร้างรูปภาพที่มีสองแผนภาพย่อย
fig, axes = plt.subplots(1, 2, figsize=(14, 6), constrained_layout=True)

# ค่าเฉลี่ยเชิงพื้นที่ในอดีต (แผนภาพย่อยซ้าย)
temp = ds  # ใช้ชุดข้อมูลเดิม
temp['AvgSurfT'].mean(dim="time").plot(
    cmap="hot_r", ax=axes[0], vmin=290, vmax=310,
    cbar_kwargs={"label": "ค่าเฉลี่ย AvgSurfT ในอดีต (K)"}
)
thailand_boundary.plot(edgecolor="black", facecolor="none", lw=0.7, ax=axes[0])
axes[0].set_title(f"ค่าเฉลี่ย AvgSurfT ในอดีต\n{min_date} ถึง {max_date}")
axes[0].set_xlabel("ลองจิจูด")
axes[0].set_ylabel("ละติจูด")

# แผนภาพค่าเบี่ยงเบนมาตรฐาน (แผนภาพย่อยขวา)
temp['AvgSurfT'].std(dim="time").plot(
    cmap="viridis", ax=axes[1],
    cbar_kwargs={"label": "ค่าเบี่ยงเบนมาตรฐานของ AvgSurfT (K)"}
)
thailand_boundary.plot(edgecolor="black", facecolor="none", lw=0.7, ax=axes[1])
axes[1].set_title(f"ความแปรปรวนของ AvgSurfT\n{min_date} ถึง {max_date}")
axes[1].set_xlabel("ลองจิจูด")
axes[1].set_ylabel("ละติจูด")

# บันทึกรูปภาพ
fig.savefig(r"C:\Users\ASUS\Jupyter\ALICE\data\AvgSurfT\ncAvgSurfT_map.png", dpi=300, bbox_inches='tight')
plt.show()    
    

ขั้นตอนที่ 5. การแสดงผลภาพหลายช่วงเวลา

    
# รับจำนวนช่วงเวลาที่มีอยู่
time_steps = len(var_data.time)

# กำหนดจำนวนที่จะแสดง (สูงสุด 6)
n_plots = min(time_steps, 6)

# สร้างแผนภาพย่อย 1xn
fig, axes = plt.subplots(nrows=1, ncols=n_plots, figsize=(4*n_plots, 4), constrained_layout=True)

# หากมีแผนภาพย่อยเพียงหนึ่ง ทำให้ axes เป็นรูปแบบที่วนซ้ำได้
if n_plots == 1:
    axes = [axes]

# แสดงแต่ละช่วงเวลาในแผนภาพย่อยของมัน
for i, time_idx in enumerate(range(n_plots)):
    ax = axes[i]
    time_value = var_data.time.values[time_idx]
    time_data = var_data.sel(time=time_value)
    
    # แสดงอุณหภูมิและซ้อนทับขอบเขต
    time_data.plot(ax=ax, cmap="hot_r", vmin=280, vmax=315, 
                  cbar_kwargs={'label': '' if i < n_plots-1 else 'AvgSurfT (K)'})  # แสดงป้ายแถบสีเฉพาะแผนภาพสุดท้าย
    thailand_boundary.plot(ax=ax, edgecolor="black", facecolor="none", linewidth=0.7)
    
    # จัดรูปแบบสตริงเวลาสำหรับชื่อเรื่อง
    time_str = str(time_value)[:10]  # รับรูปแบบ YYYY-MM-DD
    ax.set_title(f"{time_str}")
    ax.set_xlabel("")
    ax.set_ylabel("" if i > 0 else "ละติจูด")
    
    # เพิ่มป้ายลองจิจูดเฉพาะในแผนภาพด้านล่าง
    if i == n_plots // 2:
        ax.set_xlabel("ลองจิจูด")

# ชื่อเรื่องรวม
plt.suptitle(f"แผนที่ AvgSurfT ({min_date} ถึง {max_date})", fontsize=16, y=1.05)

# บันทึกรูปภาพ
plt.savefig(r"C:\Users\ASUS\Jupyter\ALICE\data\AvgSurfT\ncAvgSurfT_allmap.png", dpi=300, bbox_inches='tight')
plt.show()    
    

ขั้นตอนที่ 6. ตัดข้อมูล NetCDF ให้เป็นพื้นที่เฉพาะ (ขอบเขตกรุงเทพฯ)

    
import rioxarray as rio

# ทำให้แน่ใจว่าข้อมูล NetCDF มีมิติเชิงพื้นที่และ CRS ที่เหมาะสม
ds_geo = temp['AvgSurfT'].rio.set_spatial_dims(x_dim="lon", y_dim="lat")
ds_geo = ds_geo.rio.write_crs("EPSG:4326")  # ตั้งค่าเป็นระบบพิกัด WGS84

# กรองกรอบข้อมูลเชิงภูมิศาสตร์เพื่อเลือกเฉพาะกรุงเทพฯ
thailand_boundary = gpd.read_file("https://geodata.ucdavis.edu/gadm/gadm4.1/json/gadm41_THA_1.json")
bangkok = thailand_boundary[thailand_boundary["NAME_1"].isin(["BangkokMetropolis"])]

# ตรวจสอบว่าขอบเขตอยู่ใน CRS ที่ถูกต้อง
if bangkok.crs != "EPSG:4326":
    bangkok = bangkok.to_crs("EPSG:4326")

# ตัดข้อมูล NetCDF ให้เป็นขอบเขตกรุงเทพฯ
bangkok_data = ds_geo.rio.clip(bangkok.geometry, bangkok.crs)

# คำนวณค่าเฉลี่ยเชิงเวลาสำหรับการแสดงผลภาพ
bangkok_mean = bangkok_data.mean(dim='time')

# แสดงผลภาพข้อมูลที่ตัดแล้ว
plt.figure(figsize=(10, 8))
im = bangkok_mean.plot(cmap='hot_r', vmin=300, vmax=315, add_colorbar=False)  # ลบแถบสีเริ่มต้น
plt.colorbar(im, shrink=0.8)  # เพิ่มแถบสีที่มีขนาดกำหนดเอง (ปรับค่า shrink ตามต้องการ)
bangkok.boundary.plot(edgecolor='black', linewidth=1.5, ax=plt.gca())
plt.title(f"อุณหภูมิพื้นผิวเฉลี่ยในกรุงเทพฯ\n{min_date} ถึง {max_date}")
plt.xlabel("ลองจิจูด")
plt.ylabel("ละติจูด")
plt.tight_layout()

# บันทึกข้อมูลที่ตัดแล้วหากจำเป็น
plt.savefig("Bangkok_AvgSurfT.png", dpi=300, bbox_inches='tight')
plt.show()    
    

บทสรุป

เมื่อทำงานกับไฟล์ NetCDF (.nc) ใน Python โปรดจำขั้นตอนสำคัญเหล่านี้:

1. การสำรวจเบื้องต้น: เปิดไฟล์ด้วย xarray และตรวจสอบโครงสร้าง ตัวแปร และมิติของมัน

2. การสกัดข้อมูล: เลือกตัวแปรและพื้นที่เฉพาะที่สนใจจากชุดข้อมูล

3. การวิเคราะห์ทางสถิติ: คำนวณสถิติพื้นฐานและทำการวิเคราะห์เชิงเวลา/เชิงพื้นที่

4. การแสดงผลภาพ: สร้างแผนภาพที่มีความหมายเพื่อแสดงผลภาพข้อมูลของคุณ (อนุกรมเวลา แผนที่ ฯลฯ)

5. การส่งออกข้อมูล: บันทึกข้อมูลที่ประมวลผลแล้วและผลลัพธ์ในรูปแบบที่เหมาะสม

โดยการปฏิบัติตามคู่มือนี้ คุณควรจะสามารถประมวลผล วิเคราะห์ และแสดงผลภาพข้อมูลจากไฟล์ NetCDF สำหรับการประยุกต์ใช้ด้านอุตุนิยมวิทยา สภาพภูมิอากาศ และข้อมูลเชิงพื้นที่ได้อย่างมีประสิทธิภาพ

โปรดจำไว้เสมอว่าให้ตรวจสอบระบบพิกัด หน่วย และข้อมูลเมตาของไฟล์ NetCDF ของคุณ เนื่องจากสิ่งเหล่านี้อาจแตกต่างกันไปขึ้นอยู่กับแหล่งที่มาและประเภทของข้อมูล

🔍 ตัวอย่างโค้ดบน : NetCDF in Python