BAB 15: Lemari Data yang Patuh: Atribut, Seleksi, Digitasi, dan Laporan dengan Skrip

Studi kasus: "Ada berapa petak, dan jenis apa saja?" #

Kepala Seksi ingin ringkasan cepat: berapa petak di KPH Contoh, dan tanaman apa saja yang tumbuh di sana? Anda bisa membuka tabel atribut lalu menghitung sendiri. Dengan skrip, jawabannya muncul dalam sekali jalan. Pekan depan permintaannya bertambah: pilih jati yang sudah tua, gambar jalan baru, gabungkan hasil inventarisasi, lalu buat rekap. Tujuh skrip di bab ini menjawab semuanya, dan Anda tahu bagian mana yang diganti untuk data lain.

Konsep: tabel atribut dalam tiga kalimat #

Setiap layer vektor punya tabel di belakangnya, seperti lemari arsip. Tiap laci adalah satu fitur (satu petak, satu titik, atau satu jalan di peta), dan tiap lembar keterangan di dalam laci adalah satu kolom. Skrip PyQGIS membuka lemari itu, membaca laci satu per satu, lalu mengambil kolom yang Anda minta.

Empat istilah yang perlu Anda kenal sekarang:

• Fitur (feature): satu objek di layer, misalnya satu petak.
• Kolom (field): satu jenis keterangan, misalnya JENIS atau LUAS_LAMA_HA.
• QgsVectorLayer: perkakas QGIS yang membuka sebuah layer vektor dari berkas.
• import: perintah untuk memanggil perkakas yang tidak ikut otomatis. Cara kerjanya dibahas lengkap di Bab 8.

Setelah bisa membaca lemari, Anda akan memerintahnya. Enam istilah berikut muncul bertahap di skrip berikutnya, dan masing-masing dijelaskan di tempatnya:

• Seleksi: menandai sebagian fitur, seperti memberi stabilo pada beberapa baris.
• Digitasi: menambah atau mengubah gambar fitur, di sini lewat koordinat yang diketik.
• Topologi: aturan "rapi" antar bentuk, misalnya petak tidak boleh tumpang tindih.
• Kalkulasi kolom: mengisi kolom baru dengan rumus.
• Join: menempelkan kolom dari tabel lain berdasarkan kolom kunci yang sama.
• Rekap: ringkasan akhir untuk dibaca atasan.

Peta jalan bab ini:

Skrip 15.1 sampai 15.4 berdiri sendiri. Skrip 15.5, 15.6, dan 15.7 harus dijalankan berurutan, karena hasil yang satu menjadi bahan yang berikutnya.

Satu catatan jalur sebelum mulai. Ketujuh skrip membaca lokasi data dari pengaturan B2_DATA, dan skrip yang menulis berkas membaca B2_KELUAR. Bila pengaturan itu tidak ada, jalur cadangan C:/KPH_Contoh/paket-b2 dan C:/KPH_Contoh/keluaran yang dipakai. Anda bisa membuat folder itu, atau mengganti jalur di skripnya.

Skrip 15.1: Membaca tabel atribut #

Berkas b2_01_atribut.py sama dengan yang dipakai di Buku B2. Di dalam berkasnya tertulis "Skrip 1.1" mengikuti penomoran buku itu.

Tujuan. Memeriksa bahwa layer terbaca, menampilkan nama kolom dan jenisnya, melihat tiga petak pertama, lalu merangkum luas dan jenis tanaman.

Bahan. Paket data paket-b2, berkas Petak_KPH.gpkg, layer Petak (16 petak). Skrip dijalankan dari editor skrip QGIS atau dari terminal QGIS, seperti yang Anda siapkan di Bab 3.

Skrip ini bekerja dalam enam tahap. Gambar berikut menunjukkan urutannya, lengkap dengan nomor baris.

Skrip utuh:

# Skrip 1.1: membaca tabel atribut lapisan Petak (QGIS Python Console)
# Penulis: Badar Mubarok Yogaswara
import os
from qgis.core import QgsVectorLayer, QgsProject, QgsDistanceArea, QgsCoordinateTransformContext

DATA = os.environ.get("B2_DATA", r"C:/KPH_Contoh/paket-b2")
petak = QgsVectorLayer(DATA + "/Petak_KPH.gpkg|layername=Petak", "Petak", "ogr")
if not petak.isValid():
    raise SystemExit("Lapisan Petak tidak terbaca. Periksa DATA: " + DATA)
print("Valid:", petak.isValid(), "| Jumlah baris:", petak.featureCount())

# Kolom (field) dan tipenya
for fld in petak.fields():
    print(fld.name(), "-", fld.typeName())

# Tiga baris pertama
for i, fitur in enumerate(petak.getFeatures()):
    print(fitur["KODE_PETAK"], fitur["NAMA_KPH"], fitur["JENIS"], fitur["TAHUN_TANAM"], fitur["STATUS"])
    if i == 2:
        break

# Ringkasan dasar: jumlah dan rata-rata LUAS_LAMA_HA
nilai = [f["LUAS_LAMA_HA"] for f in petak.getFeatures()]
print("Jumlah LUAS_LAMA_HA:", round(sum(nilai), 2), "| Rata-rata:", round(sum(nilai) / len(nilai), 4))
print("Jenis unik:", sorted(set(f["JENIS"] for f in petak.getFeatures())))

Penjelasan baris demi baris. Nomor baris mengikuti berkas di atas.

Hasil. Layar menampilkan (berdasarkan uji pada QGIS 4.0.2):

Valid: True | Jumlah baris: 16
fid - Integer64
KODE_PETAK - String
NAMA_KPH - String
JENIS - String
TAHUN_TANAM - Integer
STATUS - String
LUAS_LAMA_HA - Real
P-01 KPH Alpha Jati 2008 Produksi
P-02 KPH Alpha Jati 2008 Produksi
P-03 KPH Beta Mahoni 2012 Produksi
Jumlah LUAS_LAMA_HA: 16.0 | Rata-rata: 1.0
Jenis unik: ['Akasia', 'Jati', 'Mahoni', 'Sengon']

Dari hasil ini Anda tahu: ada 16 petak, ada tujuh kolom, dan empat jenis tanaman.

Bagian yang boleh diubah.

• Baris 6, lokasi data. Ini yang paling sering Anda ubah. Ganti jalur di ujung dengan lokasi folder paket-b2 di komputer Anda, misalnya r"D:/Latihan/paket-b2". Gunakan garis miring biasa / agar aman di semua sistem.
• Baris 7, nama berkas dan layer. Ganti Petak_KPH.gpkg dan layername=Petak untuk membuka layer lain. Contoh: Titik_Plot.gpkg|layername=Titik_Plot.
• Baris 19, angka 2. Angka ini menentukan berapa petak yang dicetak. Ganti menjadi 4 untuk menampilkan lima petak, karena nomor urut mulai dari 0.
• Baris 18, nama kolom. Ganti dengan kolom lain dari hasil baris 13-14. Salin nama persis seperti di daftar itu. Di QGIS 4.0.2, fitur["jenis"] tetap terbaca walau hurufnya kecil semua, tetapi fields().indexOf("jenis") mengembalikan -1. Menyalin nama persis menghindari kejutan itu.
• Baris 23-25, kolom hitungan. LUAS_LAMA_HA boleh diganti kolom angka lain, dan JENIS boleh diganti kolom teks lain.

Jebakan.

• Jalur salah. Bila baris 6 menunjuk folder yang tidak ada, baris 8-9 menghentikan skrip dengan pesan Lapisan Petak tidak terbaca. Periksa DATA: ..., diikuti jalur yang Anda isi. Pesan itu muncul sebelum ada hasil apa pun. Pelajarannya: baca pesan paling atas lebih dulu, lalu periksa jalur di baris 6. Bila baris 8-9 dihapus, layer yang gagal dibuka melaporkan jumlah baris -2 (artinya "tidak diketahui"). Skrip lalu terus berjalan dan berhenti di baris 24 dengan ZeroDivisionError, pesan yang tidak menunjuk ke penyebab sebenarnya.
• Satuan tidak dicek. Angka 16.0 dan 1.0 hanyalah isi kolom. Skrip tidak tahu apakah satuannya hektare atau meter persegi. Cek arti kolom pada dokumentasi data.
• Nama kolom salah ketik. Nama yang benar-benar salah, misalnya JNS, menimbulkan KeyError. Salin nama kolom langsung dari hasil baris 13-14, termasuk huruf besarnya.

Latihan variasi.

1. Tampilkan lima petak pertama, bukan tiga.
2. Tampilkan daftar status yang ada (STATUS), bukan jenis tanaman.

Contoh jawaban, hanya bagian yang berubah:

    if i == 4:
        break
print("Status unik:", sorted(set(f["STATUS"] for f in petak.getFeatures())))

Layar menampilkan lima petak, lalu Status unik: ['Lindung', 'Produksi', 'Rehabilitasi'].

Skrip 15.2: Memilih fitur dengan seleksi #

Seleksi itu seperti memberi stabilo kuning pada baris-baris tertentu di tabel. Fitur yang disorot ikut tampil terpilih di peta. Skrip ini mencoba tujuh cara menyorot, dari yang paling sederhana sampai yang memakai lokasi. Berkasnya b2_02_seleksi.py; di dalamnya tertulis "Skrip 2.1".

Tujuan. Memilih petak dan plot dengan syarat, membalik pilihan, memilih menurut lokasi, mempersempit pilihan, lalu menyaring layer.

Bahan. Paket data paket-b2: layer Petak (16 petak) di Petak_KPH.gpkg dan layer Titik_Plot (24 titik pengukuran) di Titik_Plot.gpkg. Skrip memakai processing, alat bawaan Konsol Python QGIS. Cara menjalankannya ada di Bab 3.

Istilah baru di skrip ini:

• seleksi.
• ekspresi: Kalimat syarat yang dipahami QGIS.
• fungsi: def, dibahas di Bab 7.
• alat: processing.run.
• filter layer: Menyembunyikan baris yang tidak memenuhi syarat.

Skrip utuh:

# Skrip 2.1: query dan seleksi pada lapisan Petak dan Titik_Plot (QGIS Python Console)
# Penulis: Badar Mubarok Yogaswara
import os
import processing
from qgis.core import Qgis, QgsVectorLayer

DATA = os.environ.get("B2_DATA", r"C:/KPH_Contoh/paket-b2")
petak = QgsVectorLayer(DATA + "/Petak_KPH.gpkg|layername=Petak", "Petak", "ogr")
plot = QgsVectorLayer(DATA + "/Titik_Plot.gpkg|layername=Titik_Plot", "Titik_Plot", "ogr")


def kode_terpilih(lyr):
    return sorted(f["KODE_PETAK"] for f in lyr.selectedFeatures())


# 1. Seleksi dengan ekspresi: jati yang ditanam sebelum 2010
petak.selectByExpression("\"JENIS\" = 'Jati' AND \"TAHUN_TANAM\" < 2010")
print("Jati sebelum 2010:", petak.selectedFeatureCount(), kode_terpilih(petak))

# 2. Seleksi gabungan: status Produksi DAN bukan Jati
petak.selectByExpression("\"STATUS\" = 'Produksi' AND \"JENIS\" <> 'Jati'")
print("Produksi bukan Jati:", petak.selectedFeatureCount())

# 3. Memakai LIKE dan ATAU
petak.selectByExpression("\"JENIS\" LIKE 'S%' OR \"STATUS\" = 'Lindung'")
print("Jenis berawalan S atau Lindung:", petak.selectedFeatureCount(), kode_terpilih(petak))

# 4. Balikkan seleksi
petak.invertSelection()
print("Setelah dibalik:", petak.selectedFeatureCount())
petak.removeSelection()

# 5. Seleksi menurut lokasi: plot yang berada di dalam petak
hasil = processing.run("native:selectbylocation", {
    "INPUT": plot, "PREDICATE": [6], "INTERSECT": petak, "METHOD": 0})   # 6 = within
print("Plot di dalam petak:", plot.selectedFeatureCount(), "dari", plot.featureCount())
plot.selectByExpression("\"ID_PLOT\" IN ('PL-23','PL-24')")
print("Plot di luar (cek):", sorted(f["ID_PLOT"] for f in plot.selectedFeatures()))

# 6. Plot sehat dan berdiameter 30 cm ke atas, di dalam petak
plot.removeSelection()
processing.run("native:selectbylocation", {"INPUT": plot, "PREDICATE": [6], "INTERSECT": petak, "METHOD": 0})
dalam = plot.selectedFeatureCount()
plot.selectByExpression("\"KONDISI\" = 'Sehat' AND \"DIAMETER_CM\" >= 30", Qgis.SelectBehavior.IntersectSelection)   # persempit seleksi yang ada
print("Sehat, diameter >= 30, di dalam petak:", plot.selectedFeatureCount(), "(dari", dalam, "plot di dalam petak)")

# 7. Filter lapisan (Provider Feature Filter): hanya Jati yang tampil
petak.removeSelection()
petak.setSubsetString("\"JENIS\" = 'Jati'")
print("Setelah filter Jati, baris yang tampil:", petak.featureCount())
petak.setSubsetString("")
print("Filter dilepas, baris:", petak.featureCount())

Penjelasan baris demi baris.

Hasil. Layar menampilkan (uji pada QGIS 4.0.2):

Jati sebelum 2010: 4 ['P-01', 'P-02', 'P-05', 'P-13']
Produksi bukan Jati: 8
Jenis berawalan S atau Lindung: 6 ['P-04', 'P-06', 'P-07', 'P-11', 'P-13', 'P-15']
Setelah dibalik: 10
Plot di dalam petak: 22 dari 24
Plot di luar (cek): ['PL-23', 'PL-24']
Sehat, diameter >= 30, di dalam petak: 5 (dari 22 plot di dalam petak)
Setelah filter Jati, baris yang tampil: 5
Filter dilepas, baris: 16

Cocokkan: 6 terpilih dibalik menjadi 10, dan 6 + 10 = 16 petak. Plot di dalam petak 22, ditambah 2 di luar, sama dengan 24 plot.

Bagian yang boleh diubah.

• Baris 17, 21, 25, dan 44: syarat seleksi. Ganti jenis, tahun, status, atau ambang diameter. Contoh: "JENIS" = 'Mahoni'.
• Baris 35 dan 42, angka predikat. Angka 6 berarti "di dalam". Dari uji di komputer ini: 0 (bersinggungan atau beririsan) memilih 22 plot, dan 2 (terpisah) memilih 2 plot, yaitu plot yang di luar petak. Nomor ini hanya berlaku untuk alat selectbylocation.
• Baris 35, METHOD. Dari uji: 0 pilihan baru, 1 tambahkan ke pilihan, 2 ambil irisan dengan pilihan sekarang, 3 buang dari pilihan. [CEK] pada versi QGIS Anda.
• Baris 49, filter. Ganti 'Jati' dengan jenis lain.

Jebakan.

• Nama kolom salah tidak menimbulkan galat. Menulis "TAHUN" < 2010 padahal kolomnya TAHUN_TANAM tidak memunculkan pesan apa pun. Hasilnya hanya 0 petak terpilih. Bila hasil seleksi 0 yang tidak Anda duga, periksa dulu ejaan kolom.
• Huruf besar dan kecil pada nilai. "JENIS" = 'jati' memilih 0 petak, karena nilainya tertulis Jati.
• Kode plot tertulis tetap. Baris 37 memakai PL-23 dan PL-24, yang cocok hanya dengan data latihan ini. Untuk data lain, ambil plot di luar petak dengan alat yang sama dan predikat 2.
• Filter menempel. Bila skrip berhenti sebelum baris 51, filter Jati masih terpasang pada layer (uji: featureCount tinggal 5 dari 16). Selalu kosongkan filter setelah selesai.
• Hasil processing.run baris 34 tidak dipakai. Variabel hasil hanya sisa. Pilihannya sudah menempel pada layer plot.

Latihan variasi.

1. Pilih petak berjenis Mahoni dengan status Produksi, lalu cetak kodenya.
2. Cetak kode plot yang berada di luar petak, tanpa menulis PL-23 dan PL-24.

Contoh jawaban, hanya bagian yang berubah:

petak.selectByExpression("\"JENIS\" = 'Mahoni' AND \"STATUS\" = 'Produksi'")
print(kode_terpilih(petak))

processing.run("native:selectbylocation", {"INPUT": plot, "PREDICATE": [2], "INTERSECT": petak, "METHOD": 0})
print(sorted(f["ID_PLOT"] for f in plot.selectedFeatures()))

Layar menampilkan ['P-03', 'P-10', 'P-14'] dan ['PL-23', 'PL-24'].

Skrip 15.3: Menggambar dan membelah dengan koordinat #

Biasanya Anda menggambar jalan dengan mouse. Skrip ini menggambarnya dengan koordinat yang diketik, seperti memberi tahu tukang gambar titik demi titik. Berkasnya b2_03_digitasi.py; di dalamnya tertulis "Skrip 3.1".

Tujuan. Menggambar satu jalan (garis) dan satu persemaian (poligon), lalu membelah petak P-12 menjadi dua, pada salinan data agar berkas asli aman.

Bahan. Paket data paket-b2: Jalan_Baru.gpkg, Persemaian_Baru.gpkg, Petak_KPH.gpkg, dan citra Citra_Sketsa.tif. Skrip membuat folder keluaran sendiri (B2_KELUAR) dan menulis salinannya di sana.

Istilah baru di skrip ini:

• digitasi.
• simpul: vertex, titik sudut sebuah garis atau poligon.
• geometri: Bentuk fitur.
• commit: Menyimpan hasil edit ke berkas.
• koordinat UTM: Angka posisi dalam meter.

Skrip utuh:

# Skrip 3.1: menggambar (digitasi) jalan dan persemaian lewat Python, lalu membelah satu petak (QGIS Python Console)
# Penulis: Badar Mubarok Yogaswara
# Hasilnya sama dengan yang Anda kerjakan dengan mouse di Bab 3, tetapi simpul diketik sebagai koordinat.
import os
import shutil
from qgis.core import (QgsVectorLayer, QgsRasterLayer, QgsFeature, QgsGeometry, QgsPointXY, QgsPoint, QgsLineString)

DATA = os.environ.get("B2_DATA", r"C:/KPH_Contoh/paket-b2")
KELUAR = os.environ.get("B2_KELUAR", r"C:/KPH_Contoh/keluaran")
os.makedirs(KELUAR, exist_ok=True)
X0, Y0 = 312000.0, 9996000.0          # sudut barat-daya area contoh

# Salin lapisan kosong agar berkas asli di paket data tidak berubah
for nama in ("Jalan_Baru.gpkg", "Persemaian_Baru.gpkg", "Petak_KPH.gpkg"):
    shutil.copy(os.path.join(DATA, nama), os.path.join(KELUAR, nama))

jalan = QgsVectorLayer(KELUAR + "/Jalan_Baru.gpkg|layername=Jalan_Baru", "Jalan_Baru", "ogr")
semai = QgsVectorLayer(KELUAR + "/Persemaian_Baru.gpkg|layername=Persemaian_Baru", "Persemaian_Baru", "ogr")
petak = QgsVectorLayer(KELUAR + "/Petak_KPH.gpkg|layername=Petak", "Petak", "ogr")
citra = QgsRasterLayer(DATA + "/Citra_Sketsa.tif", "Citra_Sketsa")


def titik(x, y):
    return QgsPointXY(X0 + x, Y0 + y)


# 1. Jalan (garis): 6 simpul, diukur dari sudut barat-daya (meter)
simpul_jalan = [(0, 150), (90, 160), (180, 210), (260, 215), (330, 260), (400, 275)]
# Pemeriksaan: warna citra di tiap simpul harus cokelat (jalan tanah), bukan hijau
for x, y in simpul_jalan:
    xs = min(x, 399)      # simpul di tepi citra digeser 1 m ke dalam agar terbaca
    nilai = [citra.dataProvider().sample(titik(xs, y), b)[0] for b in (1, 2, 3)]
    print("Citra di simpul", (x, y), "RGB =", [int(v) for v in nilai])

jalan.startEditing()
f = QgsFeature(jalan.fields())
f.setGeometry(QgsGeometry.fromPolylineXY([titik(x, y) for x, y in simpul_jalan]))
f["NAMA_JALAN"] = "Jalan Inspeksi Timur"
f["KELAS"] = "Jalan tanah"
f["PANJANG_M"] = round(f.geometry().length(), 1)
jalan.addFeature(f)
print("Commit jalan:", jalan.commitChanges(), "| panjang (m):", round(f.geometry().length(), 1))

# 2. Persemaian (poligon): 5 simpul
simpul_semai = [(220, 25), (280, 20), (290, 70), (250, 85), (215, 65)]
semai.startEditing()
g = QgsGeometry.fromPolygonXY([[titik(x, y) for x, y in simpul_semai]])
f = QgsFeature(semai.fields())
f.setGeometry(g)
f["NAMA"] = "Persemaian Utara"
f["LUAS_M2"] = round(g.area(), 1)
semai.addFeature(f)
print("Commit persemaian:", semai.commitChanges(), "| luas (m2):", round(g.area(), 1), "| ha:", round(g.area() / 10000, 4))

# 3. Membelah petak P-12 dengan garis tegak x = 350 (pilih P-12 lebih dulu supaya petak lain tidak ikut terbelah)
petak.selectByExpression("\"KODE_PETAK\" = 'P-12'")
if petak.selectedFeatureCount() == 0:
    raise SystemExit("P-12 tidak ditemukan; pembelahan dibatalkan agar petak lain tidak ikut terbelah.")
luas_awal = sum(ft.geometry().area() for ft in petak.selectedFeatures())
petak.startEditing()
garis_belah = QgsLineString([QgsPoint(X0 + 350, Y0 + 190), QgsPoint(X0 + 350, Y0 + 310)])
hasil, _ = petak.splitFeatures(garis_belah, False, False)
print("Hasil belah:", hasil)
print("Jumlah petak setelah belah (sebelum commit):", petak.featureCount())
print("Commit petak:", petak.commitChanges())
print("Jumlah petak setelah commit:", petak.featureCount())
for ft in petak.getFeatures():
    if ft["KODE_PETAK"] == "P-12":
        print("P-12 bagian:", ft.id(), round(ft.geometry().area(), 1), "m2")
sisa = sum(ft.geometry().area() for ft in petak.getFeatures() if ft["KODE_PETAK"] == "P-12")
print("Luas P-12 sebelum:", round(luas_awal, 1), "| jumlah dua bagian:", round(sisa, 1))

Penjelasan baris demi baris.

Hasil. Layar menampilkan (uji pada QGIS 4.0.2):

Citra di simpul (0, 150) RGB = [150, 118, 78]
Citra di simpul (90, 160) RGB = [150, 118, 78]
Citra di simpul (180, 210) RGB = [150, 118, 78]
Citra di simpul (260, 215) RGB = [150, 118, 78]
Citra di simpul (330, 260) RGB = [150, 118, 78]
Citra di simpul (400, 275) RGB = [150, 118, 78]
Commit jalan: True | panjang (m): 428.5
Commit persemaian: True | luas (m2): 3700.0 | ha: 0.37
Hasil belah: 0
Jumlah petak setelah belah (sebelum commit): 17
Commit petak: True
Jumlah petak setelah commit: 17
P-12 bagian: 12 4906.9 m2
P-12 bagian: 17 4443.1 m2
Luas P-12 sebelum: 9350.0 | jumlah dua bagian: 9350.0

Keenam warna sama, [150, 118, 78], yaitu cokelat: jalan tanah, bukan hijau. Luas dua bagian P-12 bila dijumlah sama dengan luas awal, 9350 meter persegi. Itu bukti pembelahan tidak menghilangkan bagian apa pun.

Bagian yang boleh diubah.

• Baris 11, titik acuan. Harus cocok dengan lokasi data Anda. Salah angka berarti gambar jatuh di tempat lain.
• Baris 28 dan 45, daftar simpul. Tambah, kurangi, atau ubah pasangan angkanya. Jalan butuh minimal dua simpul, poligon minimal tiga.
• Baris 38-39 dan 50, isi kolom. Ganti nama jalan atau nama persemaian.
• Baris 56 dan 61, petak dan garis belah. Ganti 'P-12' dan angka 350. Garis belah harus benar-benar memotong petak yang dipilih. Bila Anda mengganti kode petak, pesan di baris 58 masih menyebut P-12; ubah juga agar tidak membingungkan.

Jebakan.

• Jalur data salah. Bila B2_DATA menunjuk folder yang tidak ada, skrip berhenti di baris 15: FileNotFoundError: [Errno 2] No such file or directory: 'C:/tidak_ada\\Jalan_Baru.gpkg' Perhatikan jalur dalam pesan itu: garis miring biasa dan terbalik bercampur. Itu normal, jangan bingung.
• Salinan ditimpa tiap kali dijalankan. shutil.copy menimpa tanpa bertanya. Dari uji: dijalankan dua kali berturut-turut, hasilnya tetap 17 petak, karena salinan dibuat ulang dari data asli. Bahayanya muncul bila skrip lain memakai folder hasil yang sama.
• Tidak ada petak terpilih. Bila kode di baris 56 tidak ditemukan (misalnya salah ketik atau data lain), baris 57-58 menghentikan skrip dengan pesan P-12 tidak ditemukan; pembelahan dibatalkan .... Ini disengaja. Tanpa pengaman itu, luas_awal menjadi 0, dan garis belah bisa membelah setiap petak yang dilewatinya. Pada data bawaan, garis hanya memotong P-12, tetapi pada data lain hasilnya bisa lebih banyak petak yang terbelah. Itulah alasan komentar di baris 55.
• Lupa commitChanges(). Fitur baru hanya ada di memori dan hilang bila QGIS ditutup (uji: berkas dibaca ulang berisi 0 fitur).
• Koordinat harus dalam meter. Layer ini memakai UTM (EPSG:32749), jadi luas bernilai meter persegi. Pada koordinat derajat, angka luas tidak berarti.
• Hasil commit tetap perlu dibaca. Baris 42, 53, dan 65 mencetak hasil commitChanges(). Bila tertulis False, perubahan tidak tersimpan. Jangan lanjut sebelum penyebabnya jelas.

Latihan variasi.

1. Geser garis belah ke 330 meter. Berapa luas dua bagian P-12?
2. Ganti nama jalan menjadi Jalan Inspeksi Barat, lalu cetak isi kolom jalan dari layer salinan.

Contoh jawaban. Untuk nomor 1, ganti angka 350 di baris 61 menjadi 330 (dua tempat). Layar menampilkan bagian 4906.9 dan 4443.1 berubah menjadi 6817.6 dan 2532.4 meter persegi, dengan jumlah tetap 9350. Untuk nomor 2, ganti teks di baris 38, lalu tambahkan di akhir skrip:

for ft in jalan.getFeatures():
    print(ft["NAMA_JALAN"], ft["KELAS"], ft["PANJANG_M"])

Layar menampilkan Jalan Inspeksi Barat Jalan tanah 428.5 pada baris terakhir.

Skrip 15.4: Memeriksa dan memperbaiki geometri #

Sebuah peta yang rapi punya aturan: bentuk harus sah, tidak ganda, tidak bertindihan, dan tidak berlubang. Memeriksanya satu per satu dengan mata sangat melelahkan. Skrip ini memeriksanya dengan alat. Berkasnya b2_04_topologi.py; di dalamnya tertulis "Skrip 4.1".

Tujuan. Menemukan dan memperbaiki geometri tidak sah, petak ganda, dan petak tumpang tindih pada layer latihan Petak_Rusak, lalu melaporkan celah.

Bahan. Paket data paket-b2, berkas Petak_Rusak.gpkg, layer Petak_Rusak (18 objek; rusaknya disengaja). Semua hasil disimpan di memori, jadi tidak ada berkas keluaran.

Istilah baru di skrip ini:

• geometri sah: Bentuk yang tidak menyilang dirinya sendiri.
• duplikat: Dua fitur yang sama persis.
• tumpang tindih: overlap.
• celah: gap, lubang di antara petak bertetangga.
• **param: Cara fungsi menerima isian dengan nama apa saja.

Skrip utuh:

# Skrip 4.1: memeriksa dan memperbaiki galat topologi dasar pada Petak_Rusak (QGIS Python Console)
# Penulis: Badar Mubarok Yogaswara
import os
import processing
from qgis.core import QgsVectorLayer, QgsWkbTypes

DATA = os.environ.get("B2_DATA", r"C:/KPH_Contoh/paket-b2")
KELUAR = os.environ.get("B2_KELUAR", r"C:/KPH_Contoh/keluaran")
os.makedirs(KELUAR, exist_ok=True)
rusak = QgsVectorLayer(DATA + "/Petak_Rusak.gpkg|layername=Petak_Rusak", "Petak_Rusak", "ogr")
print("Jumlah objek Petak_Rusak:", rusak.featureCount())


def jalankan(alg, **param):
    return processing.run(alg, param)


# 1. Geometri tidak sah (mis. garis menyilang sendiri)
v = jalankan("native:checkvalidity", INPUT_LAYER=rusak, METHOD=2,
             VALID_OUTPUT="memory:", INVALID_OUTPUT="memory:", ERROR_OUTPUT="memory:")
print("Sah:", v["VALID_COUNT"], "| Tidak sah:", v["INVALID_COUNT"], "| Titik galat:", v["ERROR_COUNT"])
for f in v["INVALID_OUTPUT"].getFeatures():
    print("   tidak sah:", f["KODE_PETAK"], "|", f["_errors"])

# 2. Perbaiki geometri tidak sah lebih dulu (alat pemeriksa lain menolak geometri rusak)
perbaiki = jalankan("native:fixgeometries", INPUT=rusak, METHOD=1, OUTPUT="memory:")
fix = perbaiki["OUTPUT"]
print("Setelah perbaiki geometri:", fix.featureCount(), "objek")
v2 = jalankan("native:checkvalidity", INPUT_LAYER=fix, METHOD=2,
              VALID_OUTPUT="memory:", INVALID_OUTPUT="memory:", ERROR_OUTPUT="memory:")
print("Ulang cek: sah", v2["VALID_COUNT"], "| tidak sah", v2["INVALID_COUNT"])
for f in fix.getFeatures():
    if f["KODE_PETAK"] == "P-18":
        print("   P-18 setelah perbaikan:", QgsWkbTypes.displayString(f.geometry().wkbType()), "| luas m2:", round(f.geometry().area(), 1))

# 3. Duplikat
d = jalankan("native:checkgeometryduplicate", INPUT=fix, UNIQUE_ID="fid", ERRORS="memory:")
print("Galat duplikat:", d["ERRORS"].featureCount())

# 4. Tumpang tindih (overlap) dan celah (gap)
o = jalankan("native:checkgeometryoverlap", INPUT=fix, UNIQUE_ID="fid", MIN_OVERLAP_AREA=0, ERRORS="memory:")
print("Galat tumpang tindih:", o["ERRORS"].featureCount())
print("   kolom:", [x.name() for x in o["ERRORS"].fields()])
for f in o["ERRORS"].getFeatures():
    print("   ", f.attributes()[1:])
g = jalankan("native:checkgeometrygap", INPUT=fix, UNIQUE_ID="fid", GAP_THRESHOLD=5000,
             NEIGHBORS="memory:", ERRORS="memory:", OUTPUT="memory:")
print("Galat celah:", g["ERRORS"].featureCount())
print("   kolom:", [x.name() for x in g["ERRORS"].fields()])
for f in g["ERRORS"].getFeatures():
    print("   ", f.attributes()[1:])

# 5. Perbaikan duplikat
bersih = jalankan("native:deleteduplicategeometries", INPUT=fix, OUTPUT="memory:", DUPLICATES="memory:")
print("Setelah hapus duplikat:", bersih["OUTPUT"].featureCount(), "objek | duplikat dibuang:", bersih["DUPLICATE_COUNT"])

# 6. Perbaiki tumpang tindih (alat "Delete overlaps") pada lapisan yang sudah bebas duplikat
bersih_l = bersih["OUTPUT"]
o2 = jalankan("native:checkgeometryoverlap", INPUT=bersih_l, UNIQUE_ID="fid", MIN_OVERLAP_AREA=0, ERRORS="memory:")
tanpa_tumpang = jalankan("native:fixgeometryoverlap", INPUT=bersih_l, ERRORS=o2["ERRORS"], UNIQUE_ID="fid",
                         OVERLAP_FEATURE_UNIQUE_IDX="gc_overlap_feature_fid", ERROR_VALUE_ID="gc_error",
                         OUTPUT="memory:", REPORT="memory:")["OUTPUT"]
o3 = jalankan("native:checkgeometryoverlap", INPUT=tanpa_tumpang, UNIQUE_ID="fid", MIN_OVERLAP_AREA=0, ERRORS="memory:")
print("Setelah Delete overlaps | objek:", tanpa_tumpang.featureCount(), "| tumpang tindih tersisa:", o3["ERRORS"].featureCount())
for f in tanpa_tumpang.getFeatures():
    if f["KODE_PETAK"] in ("P-06", "P-07"):
        print("   ", f["KODE_PETAK"], "luas m2:", round(f.geometry().area(), 1))
# Celah: alat "Fill gaps" dicoba pada data latihan dan melaporkan "Failed to merge with neighbor".
# Celah ini diperbaiki dengan tangan (Vertex Tool + snapping), seperti di Bab 4.

Penjelasan baris demi baris.

Hasil. Layar menampilkan (uji pada QGIS 4.0.2):

Jumlah objek Petak_Rusak: 18
Sah: 17 | Tidak sah: 1 | Titik galat: 1
   tidak sah: P-18 | Self-intersection
Setelah perbaiki geometri: 18 objek
Ulang cek: sah 18 | tidak sah 0
   P-18 setelah perbaikan: MultiPolygon | luas m2: 450.0
Galat duplikat: 1
Galat tumpang tindih: 1
   kolom: ['gc_layerid', 'gc_layername', 'gc_errorx', 'gc_errory', 'gc_error', 'fid', 'gc_overlap_feature_fid']
    ['output', 312206.0, 9996165.0, 840.0, 7, 6]
Galat celah: 1
   kolom: ['gc_layerid', 'gc_layername', 'gc_partidx', 'gc_ringidx', 'gc_vertidx', 'gc_errorx', 'gc_errory', 'gc_error', 'gc_errorid']
    ['output', -1, -1, -1, 312101.875, 9996266.25, '265', 0]
Setelah hapus duplikat: 17 objek | duplikat dibuang: 1
Setelah Delete overlaps | objek: 17 | tumpang tindih tersisa: 0
    P-07 luas m2: 9350.0
    P-06 luas m2: 9900.0

Cara membacanya. P-18 menyilang dirinya sendiri (Self-intersection), dan setelah diperbaiki luasnya 450 meter persegi. Kolom gc_error pada galat tumpang tindih bernilai 840.0: itu luas irisan dalam meter persegi, antara petak bernomor fid 7 dan 6. Buktinya, P-06 di data awal berluas 10740 dan setelah diperbaiki 9900. Selisihnya tepat 840. Nilai 265 pada galat celah kemungkinan luas celah. [kemungkinan]

Bagian yang boleh diubah.

• Baris 46, GAP_THRESHOLD. Ambang luas celah. Dari uji: bila diganti 100, hasilnya Galat celah: 0, karena celah di data ini lebih luas daripada 100.
• Baris 41, 59, dan 63, MIN_OVERLAP_AREA. Tumpang tindih yang lebih kecil dari angka ini diabaikan. Nilai 0 melaporkan semuanya.
• Baris 33 dan 66, kode petak yang dicetak. Ganti sesuai petak yang ingin dilihat.

Jebakan.

• Alat pemeriksa menolak bentuk rusak. Dari uji: menjalankan checkgeometryduplicate langsung pada Petak_Rusak memberi pesan: QgsProcessingException: Feature (18) from “r” has invalid geometry. Please fix the geometry or change the “Invalid features filtering” option for this input or globally in Processing settings. Karena itu perbaikan geometri (baris 26) harus lebih dulu.
• Hasil hilang saat QGIS ditutup. Semua hasil bertempat di memori. Bila perlu disimpan, tambahkan alat penyimpan seperti di Skrip 15.5.
• Kode petak tertulis tetap. P-18, P-06, dan P-07 hanya cocok dengan data latihan.
• Celah tidak diperbaiki skrip. Skrip hanya melaporkannya. Perbaikannya dilakukan dengan tangan, seperti di Buku B2.
• fid dan gc_.... fid adalah nomor urut bawaan GeoPackage. Awalan gc_ kemungkinan singkatan geometry checker, nama kelompok alat ini. [kemungkinan]

Latihan variasi.

1. Cetak hanya kode petak yang tidak sah, tanpa jenis galatnya.
2. Naikkan GAP_THRESHOLD menjadi 10000. Apakah jumlah celah berubah?

Contoh jawaban. Nomor 1: ubah baris 23 menjadi print(f["KODE_PETAK"]). Layar menampilkan P-18. Nomor 2: ganti angka di baris 46. Hasilnya tetap Galat celah: 1, karena celah di data ini hanya satu dan luasnya jauh di bawah ambang itu.

Skrip 15.5: Menambah kolom dengan rumus #

Menghitung luas, umur, dan kelas untuk 16 petak dengan kalkulator itu membosankan. Skrip ini menyuruh QGIS mengisinya sekaligus. Berkas b2_05_kalkulasi.py; di dalamnya tertulis "Skrip 5.1".

Tujuan. Menambah lima kolom (luas, selisih luas, umur, kelas umur, kode lengkap), memeriksa hasilnya, lalu menyimpannya ke Petak_Hitung.gpkg.

Bahan. Petak_KPH.gpkg, layer Petak, dari paket paket-b2. Hasilnya, Petak_Hitung.gpkg, ditulis ke folder B2_KELUAR dan dipakai oleh Skrip 15.6 dan 15.7.

Istilah baru di skrip ini:

• konstanta: Kotak yang isinya tidak diubah, ditulis huruf besar.
• kamus: dict, pasangan nama dan nilai.
• parameter bawaan: Isian yang sudah punya nilai awal.
• docstring: Catatan di bawah def.
• ekspresi QGIS: Rumus di dalam teks.

Skrip utuh:

# Skrip 5.1: kalkulasi field pada lapisan Petak dengan ekspresi (QGIS Python Console)
# Penulis: Badar Mubarok Yogaswara
import os
import processing
from qgis.core import QgsVectorLayer

DATA = os.environ.get("B2_DATA", r"C:/KPH_Contoh/paket-b2")
KELUAR = os.environ.get("B2_KELUAR", r"C:/KPH_Contoh/keluaran")
os.makedirs(KELUAR, exist_ok=True)
petak = QgsVectorLayer(DATA + "/Petak_KPH.gpkg|layername=Petak", "Petak", "ogr")

TEKS, DESIMAL, BULAT = 2, 0, 1            # kode tipe field untuk alat Field calculator


def tambah(lyr, nama, tipe, rumus, panjang=0, presisi=0):
    """Menjalankan alat Field calculator dan mengembalikan lapisan hasil (sementara di memori)."""
    return processing.run("native:fieldcalculator", {
        "INPUT": lyr, "FIELD_NAME": nama, "FIELD_TYPE": tipe, "FIELD_LENGTH": panjang,
        "FIELD_PRECISION": presisi, "FORMULA": rumus, "OUTPUT": "memory:"})["OUTPUT"]


h = tambah(petak, "LUAS_HA", DESIMAL, "round(area($geometry) / 10000, 3)", 10, 3)
h = tambah(h, "SELISIH_HA", DESIMAL, "round(\"LUAS_HA\" - \"LUAS_LAMA_HA\", 3)", 10, 3)
h = tambah(h, "UMUR", BULAT, "2026 - \"TAHUN_TANAM\"")
h = tambah(h, "KELAS_UMUR", TEKS,
           "CASE WHEN \"UMUR\" < 10 THEN 'Muda' WHEN \"UMUR\" < 15 THEN 'Sedang' ELSE 'Tua' END", 10)
h = tambah(h, "KODE_LENGKAP", TEKS, "\"NAMA_KPH\" || ' / ' || \"KODE_PETAK\"", 30)

print("Kolom:", [f.name() for f in h.fields()])
for f in h.getFeatures():
    print(f["KODE_PETAK"], f["LUAS_HA"], f["LUAS_LAMA_HA"], f["SELISIH_HA"], f["UMUR"], f["KELAS_UMUR"], f["KODE_LENGKAP"])

# Pemeriksaan: jumlah luas tiap KPH dan jumlah petak tiap kelas umur
luas = {}
kelas = {}
for f in h.getFeatures():
    luas[f["NAMA_KPH"]] = round(luas.get(f["NAMA_KPH"], 0) + f["LUAS_HA"], 3)
    kelas[f["KELAS_UMUR"]] = kelas.get(f["KELAS_UMUR"], 0) + 1
print("Luas per KPH (ha):", luas)
print("Petak per kelas umur:", kelas)
print("Total LUAS_HA:", round(sum(f["LUAS_HA"] for f in h.getFeatures()), 3))
beda = [f["KODE_PETAK"] for f in h.getFeatures() if abs(f["SELISIH_HA"]) > 0.06]
print("Petak dengan selisih lebih dari 0,06 ha:", beda)

# Simpan hasil agar dipakai di Bab 6 dan 7
processing.run("native:savefeatures", {"INPUT": h, "OUTPUT": KELUAR + "/Petak_Hitung.gpkg", "LAYER_NAME": "Petak_Hitung"})
print("Tersimpan:", os.path.exists(KELUAR + "/Petak_Hitung.gpkg"))

Penjelasan baris demi baris.

Hasil. Layar menampilkan (uji pada QGIS 4.0.2):

Kolom: ['fid', 'KODE_PETAK', 'NAMA_KPH', 'JENIS', 'TAHUN_TANAM', 'STATUS', 'LUAS_LAMA_HA', 'LUAS_HA', 'SELISIH_HA', 'UMUR', 'KELAS_UMUR', 'KODE_LENGKAP']
P-01 1.01 1.0 0.01 18 Tua KPH Alpha / P-01
P-02 0.93 1.0 -0.07 18 Tua KPH Alpha / P-02
P-03 0.995 0.95 0.045 14 Sedang KPH Beta / P-03
P-04 1.065 1.0 0.065 8 Muda KPH Beta / P-04
P-05 1.07 1.0 0.07 21 Tua KPH Alpha / P-05
P-06 0.99 1.05 -0.06 14 Sedang KPH Alpha / P-06
P-07 0.935 1.0 -0.065 8 Muda KPH Beta / P-07
P-08 1.005 1.0 0.005 11 Sedang KPH Beta / P-08
P-09 1.005 0.98 0.025 16 Tua KPH Gamma / P-09
P-10 1.055 1.0 0.055 14 Sedang KPH Gamma / P-10
P-11 0.995 1.0 -0.005 7 Muda KPH Gamma / P-11
P-12 0.935 1.0 -0.065 11 Sedang KPH Gamma / P-12
P-13 0.945 1.0 -0.055 21 Tua KPH Gamma / P-13
P-14 0.995 1.02 -0.025 12 Sedang KPH Gamma / P-14
P-15 1.065 1.0 0.065 6 Muda KPH Gamma / P-15
P-16 1.005 1.0 0.005 10 Sedang KPH Gamma / P-16
Luas per KPH (ha): {'KPH Alpha': 4.0, 'KPH Beta': 4.0, 'KPH Gamma': 8.0}
Petak per kelas umur: {'Tua': 5, 'Sedang': 7, 'Muda': 4}
Total LUAS_HA: 16.0
Petak dengan selisih lebih dari 0,06 ha: ['P-02', 'P-04', 'P-05', 'P-07', 'P-12', 'P-15']
Tersimpan: True

Pemeriksaan: 4 + 4 + 8 = 16 hektare, dan 5 + 7 + 4 = 16 petak. Angka-angka itu cocok dengan kolom lama.

Bagian yang boleh diubah.

• Baris 24, tahun acuan 2026. Ganti dengan tahun Anda. Dari uji: dengan 2030, P-01 berumur 22 dan kelas umur menjadi {'Tua': 11, 'Sedang': 5}.
• Baris 26, batas kelas umur. Ganti angka 10 dan 15. Dari uji: dengan 12 dan 20, hasilnya {'Sedang': 7, 'Muda': 7, 'Tua': 2}.
• Baris 22-27, rumus. Tiap rumus adalah ekspresi QGIS yang sama dengan di kalkulator kolom. Ganti nama kolom dan hitungannya.
• Baris 42, ambang 0.06. Ganti sesuai toleransi selisih luas Anda.
• Baris 46, nama berkas hasil. Bila diganti, Skrip 15.6 harus ikut diubah.

Jebakan.

• Tahun 2026 tertulis tetap. Hasil umur berbeda bila skrip dipakai di tahun lain.
• Kode jenis kolom bergantung pada alat. Angka 2, 0, dan 1 di baris 12 adalah urutan pilihan pada alat. [CEK] bila versi QGIS Anda berbeda.
• Satuan luas. area($geometry) memakai satuan layer. Layer ini UTM (meter), jadi hasilnya meter persegi dan dibagi 10.000 menjadi hektare. Pada layer berkoordinat derajat, angkanya tidak berarti. Skrip tidak mengingatkan hal ini.
• Selisih dihitung dari kolom lama. Selisih bisa bernilai None bila kolom lama kosong, dan abs(None) menimbulkan galat. [kemungkinan]
• Menjalankan ulang aman. Dari uji: dua kali berturut-turut tetap menghasilkan 16 petak di Petak_Hitung.gpkg, karena berkas ditimpa.

Latihan variasi.

1. Ganti tahun acuan menjadi 2030 lalu lihat jumlah petak tiap kelas umur.
2. Tambahkan kolom LUAS_M2 (luas dalam meter persegi, tanpa dibagi 10.000).

Contoh jawaban. Nomor 1 hanya mengganti angka di baris 24, hasilnya {'Tua': 11, 'Sedang': 5}. Nomor 2 menambah satu baris sesudah baris 22. Dari uji, dua petak pertama berluas 10100.0 dan 9300.0 meter persegi:

h = tambah(h, "LUAS_M2", DESIMAL, "round(area($geometry), 1)", 12, 1)

Skrip 15.6: Menggabungkan tabel dengan join #

Hasil pengukuran di lapangan sering datang sebagai tabel terpisah, misalnya berkas CSV. Join menempelkan kolomnya ke tabel petak, dengan kunci yang sama sebagai pencocok, seperti menyatukan dua daftar nama lewat nomor induk. Berkas b2_06_join.py; di dalamnya tertulis "Skrip 6.1".

Tujuan. Menempelkan jumlah pohon dan volume dari Inventarisasi.csv ke petak dan memperbaiki kunci yang tidak cocok. Lalu menghitung kepadatan dan volume per hektare, mencoba join virtual, dan menyimpan hasilnya.

Bahan. Hasil Skrip 15.5 (Petak_Hitung.gpkg di B2_KELUAR) dan Inventarisasi.csv dari paket paket-b2. Jalankan Skrip 15.5 lebih dulu.

Istilah baru di skrip ini:

• CSV: Tabel teks dengan koma sebagai pemisah.
• kunci join: Kolom pencocok.
• join permanen: Hasilnya layer baru.
• join virtual: Hanya tampilan di layer, tanpa berkas baru.
• lambda: Fungsi sekali pakai, dibahas di Bab 7.

Skrip utuh:

# Skrip 6.1: menggabungkan (join) tabel Inventarisasi.csv ke lapisan Petak (QGIS Python Console)
# Penulis: Badar Mubarok Yogaswara
# Jalankan Skrip 5.1 lebih dulu (menghasilkan Petak_Hitung.gpkg di folder keluaran).
import os
import processing
from qgis.core import QgsVectorLayer, QgsVectorLayerJoinInfo

DATA = os.environ.get("B2_DATA", r"C:/KPH_Contoh/paket-b2")
KELUAR = os.environ.get("B2_KELUAR", r"C:/KPH_Contoh/keluaran")
petak = QgsVectorLayer(KELUAR + "/Petak_Hitung.gpkg|layername=Petak_Hitung", "Petak_Hitung", "ogr")
uri = "file:///" + DATA.replace("\\", "/") + "/Inventarisasi.csv?type=csv&delimiter=,&detectTypes=yes&geomType=none"
inv = QgsVectorLayer(uri, "Inventarisasi", "delimitedtext")
print("Tabel valid:", inv.isValid(), "| baris:", inv.featureCount())
print("Tipe kolom:", [(f.name(), f.typeName()) for f in inv.fields()])

# 1. Join permanen (hasilnya lapisan baru): kunci KODE_PETAK di kedua tabel
g = processing.run("native:joinattributestable", {
    "INPUT": petak, "FIELD": "KODE_PETAK", "INPUT_2": inv, "FIELD_2": "KODE_PETAK",
    "FIELDS_TO_COPY": ["JML_POHON", "VOLUME_M3", "TGL_UKUR"], "METHOD": 1, "DISCARD_NONMATCHING": False, "PREFIX": "inv_",
    "OUTPUT": "memory:", "NON_MATCHING": "memory:"})
hasil = g["OUTPUT"]
cocok = [f["KODE_PETAK"] for f in hasil.getFeatures() if f["inv_JML_POHON"] is not None]
kosong = [f["KODE_PETAK"] for f in hasil.getFeatures() if f["inv_JML_POHON"] is None]
print("Join 1 | petak cocok:", len(cocok), "| petak tanpa pasangan:", kosong)
kode_petak = {f["KODE_PETAK"] for f in petak.getFeatures()}
print("          baris tabel yang tidak punya petak:", sorted(f["KODE_PETAK"] for f in inv.getFeatures() if f["KODE_PETAK"] not in kode_petak))

# 2. Perbaiki kuncinya: huruf kecil menjadi huruf besar. Kolom bantu dibuat di tabel, lalu join diulang.
inv2 = processing.run("native:fieldcalculator", {
    "INPUT": inv, "FIELD_NAME": "KUNCI", "FIELD_TYPE": 2, "FIELD_LENGTH": 10, "FIELD_PRECISION": 0,
    "FORMULA": "upper(trim(\"KODE_PETAK\"))", "OUTPUT": "memory:"})["OUTPUT"]
g2 = processing.run("native:joinattributestable", {
    "INPUT": petak, "FIELD": "KODE_PETAK", "INPUT_2": inv2, "FIELD_2": "KUNCI",
    "FIELDS_TO_COPY": ["JML_POHON", "VOLUME_M3", "TGL_UKUR"], "METHOD": 1, "DISCARD_NONMATCHING": False, "PREFIX": "inv_",
    "OUTPUT": "memory:", "NON_MATCHING": "memory:"})
h2 = g2["OUTPUT"]
cocok2 = [f for f in h2.getFeatures() if f["inv_JML_POHON"] is not None]
kosong2 = [f["KODE_PETAK"] for f in h2.getFeatures() if f["inv_JML_POHON"] is None]
print("Join 2 | petak cocok:", len(cocok2), "| petak tanpa pasangan:", kosong2,
      "| baris tabel tanpa petak:", sorted(f["KUNCI"] for f in inv2.getFeatures() if f["KUNCI"] not in kode_petak))

# 3. Hitung kepadatan pohon dan volume per hektare dari hasil join
h3 = processing.run("native:fieldcalculator", {
    "INPUT": h2, "FIELD_NAME": "POHON_HA", "FIELD_TYPE": 0, "FIELD_LENGTH": 10, "FIELD_PRECISION": 1,
    "FORMULA": "round(\"inv_JML_POHON\" / \"LUAS_HA\", 1)", "OUTPUT": "memory:"})["OUTPUT"]
h3 = processing.run("native:fieldcalculator", {
    "INPUT": h3, "FIELD_NAME": "VOL_HA", "FIELD_TYPE": 0, "FIELD_LENGTH": 10, "FIELD_PRECISION": 1,
    "FORMULA": "round(\"inv_VOLUME_M3\" / \"LUAS_HA\", 1)", "OUTPUT": "memory:"})["OUTPUT"]
for f in h3.getFeatures():
    print(f["KODE_PETAK"], f["LUAS_HA"], f["inv_JML_POHON"], f["POHON_HA"], f["inv_VOLUME_M3"], f["VOL_HA"])
tot_pohon = sum(f["inv_JML_POHON"] for f in cocok2)
tot_vol = round(sum(f["inv_VOLUME_M3"] for f in cocok2), 1)
print("Total pohon (15 petak):", tot_pohon, "| total volume m3:", tot_vol)
tertinggi = max((f for f in h3.getFeatures() if f["VOL_HA"] is not None), key=lambda x: x["VOL_HA"])
print("Volume per ha tertinggi:", tertinggi["KODE_PETAK"], tertinggi["VOL_HA"])

# 4. Join virtual (tidak membuat berkas baru), setara Layer Properties > Joins
info = QgsVectorLayerJoinInfo()
info.setJoinLayer(inv)
info.setJoinFieldName("KODE_PETAK")
info.setTargetFieldName("KODE_PETAK")
info.setPrefix("inv_")
info.setUsingMemoryCache(True)
petak.addJoin(info)
print("Join virtual | kolom setelah join:", [f.name() for f in petak.fields()][-5:])
n = sum(1 for f in petak.getFeatures() if f["inv_JML_POHON"] is not None)
print("Join virtual | petak yang terisi:", n)

# 5. Simpan hasil akhir untuk Bab 7
processing.run("native:savefeatures", {"INPUT": h3, "OUTPUT": KELUAR + "/Petak_Inventarisasi.gpkg", "LAYER_NAME": "Petak_Inventarisasi"})
print("Tersimpan:", os.path.exists(KELUAR + "/Petak_Inventarisasi.gpkg"))

Penjelasan baris demi baris.

Hasil. Layar menampilkan (uji pada QGIS 4.0.2):

Tabel valid: True | baris: 16
Tipe kolom: [('KODE_PETAK', 'text'), ('JML_POHON', 'integer'), ('VOLUME_M3', 'double'), ('TGL_UKUR', 'date'), ('REGU', 'text')]
Join 1 | petak cocok: 14 | petak tanpa pasangan: ['P-09', 'P-12']
          baris tabel yang tidak punya petak: ['P-17', 'p-09']
Join 2 | petak cocok: 15 | petak tanpa pasangan: ['P-12'] | baris tabel tanpa petak: ['P-17']
P-01 1.01 970 960.4 246.8 244.4
P-02 0.93 842 905.4 235.0 252.7
P-03 0.995 989 994.0 202.7 203.7
P-04 1.065 796 747.4 125.0 117.4
P-05 1.07 920 859.8 275.7 257.7
P-06 0.99 863 871.7 181.7 183.5
P-07 0.935 846 904.8 119.8 128.1
P-08 1.005 844 839.8 148.5 147.8
P-09 1.005 920 915.4 218.1 217.0
P-10 1.055 813 770.6 180.5 171.1
P-11 0.995 892 896.5 113.0 113.6
P-12 0.935 None None None None
P-13 0.945 915 968.3 279.2 295.4
P-14 0.995 845 849.2 179.8 180.7
P-15 1.065 829 778.4 99.6 93.5
P-16 1.005 978 973.1 156.3 155.5
Total pohon (15 petak): 13262 | total volume m3: 2761.7
Volume per ha tertinggi: P-13 295.4
Join virtual | kolom setelah join: ['KODE_LENGKAP', 'inv_JML_POHON', 'inv_VOLUME_M3', 'inv_TGL_UKUR', 'inv_REGU']
Join virtual | petak yang terisi: 14
Tersimpan: True

Tiga pelajaran dari hasil ini. Pertama, join pertama hanya cocok 14: p-09 huruf kecil gagal bertemu P-09. Kedua, setelah kunci dirapikan, 15 cocok. Satu petak (P-12) memang tidak punya data, dan satu baris tabel (P-17) tidak punya petak. Ketiga, join virtual hanya 14 petak terisi, karena ia memakai kunci asli yang belum dirapikan. Tabel tipe kolom juga memuat kolom REGU yang tidak ikut dicopy di join permanen, tetapi ikut tampil pada join virtual.

Bagian yang boleh diubah.

• Baris 19 dan 34, FIELDS_TO_COPY. Tambah atau kurangi kolom. Dari uji: menambah "REGU" membuat kolom inv_REGU ikut tersedia, misalnya ('P-01', 'Regu 1').
• Baris 19 dan 34, PREFIX. Ganti awalan inv_, lalu ganti juga di baris 22, 23, 37, 38, 45, 48, dan seterusnya.
• Baris 11, delimiter=,. Ganti bila CSV Anda memakai titik koma.
• Baris 31, rumus kunci. Ganti upper(trim(...)) sesuai jenis ketidakcocokan.
• Baris 44 dan 47, angka 1 pada pembulatan. Ganti jumlah desimal.

Jebakan.

• Lupa menjalankan Skrip 15.5. Layer petak tidak valid, dan baris 17 berhenti dengan: _core.QgsProcessingException: Invalid join field from layer 1: “KODE_PETAK” does not exist Pesannya menyesatkan: kolomnya ada, hanya berkasnya belum ada. Cek Skrip 15.5 dulu.
• Kunci tidak cocok tanpa galat. Join tidak pernah protes bila ada yang tidak cocok. Baris 24 dan 26 ada untuk memeriksanya. Selalu baca keduanya.
• Angka tetap. "15 petak" di baris 53 hanya benar untuk data ini.
• Join virtual tidak tersimpan. Join di baris 64 hilang bila QGIS ditutup, dan ia tidak membuat berkas.
• Tipe kolom CSV. Jenis kolom ditebak dari isi (detectTypes=yes). Kolom dengan isi campur bisa terbaca sebagai teks.
• Dua variabel serupa. hasil dan h2 dipakai bergantian untuk dua join. Jangan tertukar.

Latihan variasi.

1. Cetak kode petak yang kepadatannya (POHON_HA) di atas 900.
2. Ikutkan kolom REGU dalam join permanen kedua, lalu cetak regu empat petak pertama.

Contoh jawaban. Nomor 1, tambahkan di akhir skrip:

padat = [f["KODE_PETAK"] for f in h3.getFeatures() if f["POHON_HA"] is not None and f["POHON_HA"] > 900]
print("Petak dengan POHON_HA di atas 900:", padat)

Layar menampilkan ['P-01', 'P-02', 'P-03', 'P-07', 'P-09', 'P-13', 'P-16']. Nomor 2: tambahkan "REGU" di baris 34 dan cetak [(f["KODE_PETAK"], f["inv_REGU"]) for f in h2.getFeatures()][:4]. Layar menampilkan [('P-01', 'Regu 1'), ('P-02', 'Regu 2'), ('P-03', 'Regu 3'), ('P-04', 'Regu 1')].

Skrip 15.7: Membuat rekap untuk Kepala Seksi #

Semua kerja tadi bermuara di sini: ringkasan yang bisa dibaca atasan dan diekspor. Berkas b2_07_laporan.py; di dalamnya tertulis "Skrip 7.1".

Tujuan. Merekap pohon per KPH, mendaftar petak tanpa data, memilih jati kelas umur Tua yang diurutkan menurut volume, lalu mengekspor ke GeoPackage dan CSV.

Bahan. Petak_Inventarisasi.gpkg di B2_KELUAR, hasil Skrip 15.5 dan 15.6. Jalankan keduanya lebih dulu. Skrip ini tidak memakai B2_DATA.

Istilah baru di skrip ini:

• rekap per kategori: Statistik tiap kelompok.
• ekspor: Menyimpan hasil ke berkas lain.
• with open: Membuka berkas dan otomatis menutupnya, Bab 9.
• csv.writer: Penulis baris CSV.

Skrip utuh:

# Skrip 7.1: rekap akhir untuk Kepala Seksi dari lapisan Petak_Inventarisasi (QGIS Python Console)
# Penulis: Badar Mubarok Yogaswara
# Jalankan Skrip 5.1 dan 6.1 lebih dulu (menghasilkan Petak_Inventarisasi.gpkg di folder keluaran).
import csv
import os
import processing
from qgis.core import QgsVectorLayer

KELUAR = os.environ.get("B2_KELUAR", r"C:/KPH_Contoh/keluaran")
lap = QgsVectorLayer(KELUAR + "/Petak_Inventarisasi.gpkg|layername=Petak_Inventarisasi", "Petak_Inventarisasi", "ogr")
print("Baris:", lap.featureCount())

# 1. Rekap per KPH dengan alat "Statistics by categories"
rek = processing.run("qgis:statisticsbycategories", {
    "INPUT": lap, "VALUES_FIELD_NAME": "inv_JML_POHON", "CATEGORIES_FIELD_NAME": ["NAMA_KPH"], "OUTPUT": "memory:"})["OUTPUT"]
print("Kolom rekap:", [f.name() for f in rek.fields()])
for f in rek.getFeatures():
    print(f["NAMA_KPH"], "| jumlah petak berisi data:", f["count"], "| total pohon:", f["sum"], "| rata-rata:", round(f["mean"], 1))

# 2. Petak yang datanya belum lengkap
kosong = [f["KODE_PETAK"] for f in lap.getFeatures() if f["inv_JML_POHON"] is None]
print("Petak tanpa data inventarisasi:", kosong)

# 3. Jati kelas umur Tua, diurutkan menurut volume per hektare
lap.selectByExpression("\"JENIS\" = 'Jati' AND \"KELAS_UMUR\" = 'Tua'")
print("Jati Tua terpilih:", lap.selectedFeatureCount())
for f in sorted(lap.selectedFeatures(), key=lambda x: -x["VOL_HA"]):
    print("  ", f["KODE_PETAK"], f["NAMA_KPH"], f["VOL_HA"], "m3/ha")

# 4. Ekspor yang terpilih ke GeoPackage dan ke CSV
processing.run("native:saveselectedfeatures", {"INPUT": lap, "OUTPUT": KELUAR + "/Jati_Tua.gpkg"})
with open(KELUAR + "/Jati_Tua.csv", "w", newline="", encoding="utf-8") as fh:
    w = csv.writer(fh)
    w.writerow(["KODE_PETAK", "NAMA_KPH", "LUAS_HA", "UMUR", "POHON_HA", "VOL_HA"])
    for f in lap.selectedFeatures():
        w.writerow([f["KODE_PETAK"], f["NAMA_KPH"], f["LUAS_HA"], f["UMUR"], f["POHON_HA"], f["VOL_HA"]])
hasil = QgsVectorLayer(KELUAR + "/Jati_Tua.gpkg", "Jati_Tua", "ogr")
print("Berkas Jati_Tua.gpkg:", hasil.featureCount(), "objek | Jati_Tua.csv ada:", os.path.exists(KELUAR + "/Jati_Tua.csv"))

Penjelasan baris demi baris.

Hasil. Layar menampilkan (uji pada QGIS 4.0.2):

Baris: 16
Kolom rekap: ['NAMA_KPH', 'count', 'unique', 'min', 'max', 'range', 'sum', 'mean', 'median', 'stddev', 'minority', 'majority', 'q1', 'q3', 'iqr']
KPH Alpha | jumlah petak berisi data: 4 | total pohon: 3595.0 | rata-rata: 898.8
KPH Beta | jumlah petak berisi data: 4 | total pohon: 3475.0 | rata-rata: 868.8
KPH Gamma | jumlah petak berisi data: 7 | total pohon: 6192.0 | rata-rata: 884.6
Petak tanpa data inventarisasi: ['P-12']
Jati Tua terpilih: 5
   P-13 KPH Gamma 295.4 m3/ha
   P-05 KPH Alpha 257.7 m3/ha
   P-02 KPH Alpha 252.7 m3/ha
   P-01 KPH Alpha 244.4 m3/ha
   P-09 KPH Gamma 217.0 m3/ha
Berkas Jati_Tua.gpkg: 5 objek | Jati_Tua.csv ada: True

Pada sebagian komputer, dua baris peringatan DeprecationWarning tentang parameterAsFields() muncul sebelum hasil. Itu peringatan dari QGIS tentang alatnya, bukan galat, dan hasilnya tetap benar. Cek: 3595 + 3475 + 6192 = 13262, sama dengan total pohon di Skrip 15.6.

Bagian yang boleh diubah.

• Baris 25, syarat seleksi. Ganti jenis atau kelas umur.
• Baris 27, tanda minus. Hapus minus untuk mengurutkan dari terkecil.
• Baris 34 dan 36, kolom CSV. Daftar judul dan daftar isian harus sama panjang dan sama urutan.
• Baris 31 dan 32, nama berkas hasil. Ganti Jati_Tua sesuai isi.
• Baris 15, kolom statistik dan kategori. Ganti inv_JML_POHON menjadi inv_VOLUME_M3 untuk rekap volume.

Jebakan.

• Lupa Skrip 15.5 dan 15.6. Layer tidak valid, dan baris 14 berhenti dengan: _core.QgsProcessingException: Field "NAMA_KPH" does not exist. Seperti pada Skrip 15.6, pesannya menyesatkan: yang kurang adalah berkasnya.
• Nilai kosong mematahkan pengurutan. Bila VOL_HA kosong (misalnya petak P-12 ikut terpilih), baris 27 berhenti dengan TypeError: bad operand type for unary -: 'NoneType'. Dari uji, ini terjadi saat hanya P-12 yang dipilih.
• Baris 18 memakai round(f["mean"], 1). Bila mean kosong, ia gagal juga. [kemungkinan]
• Baris 37 membuka Jati_Tua.gpkg tanpa nama layer. Cukup bila hanya ada satu layer di berkas.
• CSV memakai titik desimal. Pembaca Indonesia yang membukanya di Excel berbahasa Indonesia mungkin melihat angka terbaca sebagai teks. [CEK]

Latihan variasi.

1. Pilih petak berjenis Sengon dan urutkan dari volume per hektare terkecil.
2. Ganti rekap per KPH menjadi rekap volume (inv_VOLUME_M3).

Contoh jawaban. Nomor 1: ganti baris 25 menjadi lap.selectByExpression("\"JENIS\" = 'Sengon'") dan hapus tanda minus di baris 27. Layar menampilkan empat petak: P-15 93.5, P-11 113.6, P-04 117.4, dan P-07 128.1. Tulisan "Jati Tua terpilih" tetap tercetak di baris 26 walau isinya Sengon, jadi ganti juga kata di dalamnya. Nomor 2: ganti "inv_JML_POHON" di baris 15 menjadi "inv_VOLUME_M3". Dari uji, baris pertama rekap menjadi KPH Alpha | jumlah petak berisi data: 4 | total pohon: 939.2 | rata-rata: 234.8. Tulisan "total pohon" tetap tercetak walau isinya volume, jadi ganti juga katanya di baris 18.

Cek paham #

1. Apa bedanya seleksi dengan filter layer (setSubsetString)?
2. Mengapa Skrip 15.3 menyalin berkas dulu sebelum menggambar?
3. Mengapa join pertama di Skrip 15.6 hanya cocok 14 petak, padahal ada 15 petak yang punya data?
4. Mengapa Skrip 15.7 gagal bila Skrip 15.5 dan 15.6 belum dijalankan?

Jawaban.

1. Seleksi hanya menandai fitur yang terpilih, sedangkan fitur lain tetap ada. Filter menyembunyikan fitur lain sampai filternya dikosongkan.
2. Agar berkas asli di paket data tidak berubah. Semua edit terjadi di salinan.
3. Kunci p-09 di tabel CSV ditulis huruf kecil, sehingga tidak sama dengan P-09. Setelah dirapikan dengan upper dan trim, 15 petak cocok.
4. Skrip 15.7 membaca Petak_Inventarisasi.gpkg, yang dibuat oleh Skrip 15.6 dari hasil Skrip 15.5. Tanpa berkas itu, layar tidak valid dan alat gagal.

Kesalahan umum #

• Membiarkan jalur contoh. Jalur cadangan menunjuk folder di komputer penulis. Perbaikan: ganti jalur cadangan, atau isi pengaturan B2_DATA dan B2_KELUAR.
• Salah ketik nama kolom di ekspresi. Seleksi tidak galat, hanya memilih 0 fitur. Perbaikan: salin nama kolom dari hasil Skrip 15.1.
• Menjalankan skrip tidak berurutan. Skrip 15.6 dan 15.7 memakai berkas buatan skrip sebelumnya. Perbaikan: jalankan 15.5, 15.6, lalu 15.7.
• Lupa commitChanges() setelah edit. Perubahan tidak tersimpan. Perbaikan: akhiri tiap edit dengan commitChanges() dan baca hasilnya (True atau False).
• Percaya join tanpa memeriksa kunci. Perbaikan: selalu cetak yang tidak cocok, seperti baris 24 dan 26 di Skrip 15.6.

Ringkasan dan latihan #

• Layer vektor punya tabel atribut. Skrip membacanya per fitur dan per kolom.
• selectByExpression menandai fitur dengan syarat, dan selectbylocation memilih menurut lokasi.
• Mengubah layer lewat skrip: salin, startEditing, tambah atau ubah, commitChanges.
• Alat pemeriksa topologi menolak bentuk rusak. Perbaiki bentuk lebih dulu, lalu periksa ulang.
• Tambah kolom lewat native:fieldcalculator, tempel tabel lewat native:joinattributestable.
• Rekap akhir: statistik per kelompok, seleksi, urut, lalu ekspor ke GeoPackage dan CSV.
• Tiga hal yang diganti untuk data baru: lokasi data, nama berkas dan layer, nama kolom.

Latihan. Buka Titik_Plot.gpkg dengan layer Titik_Plot. Cetak nama kolomnya saja, tanpa baris datanya. Lalu pilih plot sehat dan berdiameter 40 cm ke atas, dan cetak kodenya. Bagian mana dari Skrip 15.1 yang boleh Anda hapus?

Tabel perbandingan: pekerjaan di menu dan padanannya di skrip #