FlightGear wiki - User contributions [en]

Pure Python script to process NLCD for the USA (does not require using QGIS Python Console)

2026-06-06T03:37:01Z

Wlbragg: /* Pure Python script to process NLCD for the USA (does not require using QGIS Python Console) */

=== Pure Python script to process NLCD for the USA (does not require using QGIS Python Console) ===
This has been tested in Linux, it may or may not need modification to run under Windows OS.

USAGE: python3 gen-scenery.py --part 89-86_29 --canopy 41

This version is used when combining NLCD Tree Canopy rastors with NLCD Land Cover rastors

See all notes in code if not using Tree Canopy rasters.

<syntaxhighlight lang="python">
#!/usr/bin/env python3
import os
import subprocess
import argparse
import tempfile
from pathlib import Path
from osgeo import gdal

# ----------------- CONFIG -----------------

BASE_PATH = Path("/media/wayne/TOSHIBA-EXT/Scenery/ws3.0")
YEAR = "2016"
STATE = "Alaska"
# The following two parameters are now arguments, see ARGUMENT PARSING below
# PART = "89-86_29"
# CANOPY = 41

# upsampling / smoothing
#PERCENTAGE = 11.0
#SIZE = 21
PERCENTAGE = 8.0
SIZE = 11

# GRASS binary
GRASS_BIN = "grass"

# ----------------- ARGUMENT PARSING -----------------

# USAGE python3 gen-scenery.py --part 89-86_29 --canopy 41

#NLCD
# Choose the dominent canopy for the area being processed
# Areas not covered in the Tree Canopy layer will convert retain their original class
#41 = DeciduousForest
#42 = EvergreenForest
#43 = MixedForest

#FG equivelent
#22 = AgroForest
#23 = DeciduousBroadCover
#24 = EvergreenForest
#25 = MixedForest

parser = argparse.ArgumentParser()
parser.add_argument("--part", required=True, help="Tile part ID, e.g. 89-86_29")
parser.add_argument("--canopy", required=True, type=int, help="Tree canopy FG class")
args = parser.parse_args()

PART = args.part
CANOPY = args.canopy

# ----------------- HELPERS -----------------

def run(cmd, check=True, env=None):
print(">>", " ".join(str(c) for c in cmd))
subprocess.run(cmd, check=check, env=env)

def gdal_calc(args):
fixed = []
for a in args:
if a.startswith("--") and "=" in a:
key, val = a.split("=", 1)
fixed.append(key)
fixed.append(val)
else:
fixed.append(a)

cmd = ["gdal_calc.py"] + fixed + ["--overwrite"]
run(cmd)

def gdalwarp(input_path, output_path, t_srs="EPSG:4326",
resampling="near", dtype="Byte", extra=None):
cmd = [
"gdalwarp",
"-t_srs", t_srs,
"-r", resampling,
"-ot", dtype,
"-overwrite",
input_path,
output_path
]
if extra:
cmd.extend(extra)
run(cmd)

def gdal_translate(input_path, output_path,
nodata=0, dtype="Byte", compress="LZW"):
cmd = [
"gdal_translate",
"-a_nodata", str(nodata),
"-ot", dtype,
"-co", f"COMPRESS={compress}",
input_path,
output_path
]
run(cmd)

# ----------------- GRASS SESSION -----------------

# Create a temporary GRASS location with PERMANENT mapset
TMPDIR = tempfile.mkdtemp(prefix="grass_job_")
GRASS_LOCATION = os.path.join(TMPDIR, "location")

# Create the location
subprocess.run([
GRASS_BIN,
"-c", "EPSG:4326",
GRASS_LOCATION,
"--exec", "echo", "Location created"
], check=True)

# The active mapset is PERMANENT
GRASS_MAPSET = os.path.join(GRASS_LOCATION, "PERMANENT")

def grass_exec(args):
cmd = [GRASS_BIN, GRASS_MAPSET, "--exec"] + args
print(">>", " ".join(cmd))
subprocess.run(cmd, check=True)

def grass_exec(args):
cmd = [GRASS_BIN, GRASS_MAPSET, "--exec"] + args
print(">>", " ".join(cmd))
subprocess.run(cmd, check=True)

def grass_r_neighbors(input_raster, output_raster,
method="median", size=7):
in_name = "in_rast"
out_name = "out_rast"

grass_exec([
"r.in.gdal",
f"input={input_raster}",
f"output={in_name}",
"--overwrite"
])

grass_exec([
"g.region",
f"raster={in_name}"
])

grass_exec([
"r.neighbors",
f"input={in_name}",
f"output={out_name}",
f"method={method}",
f"size={size}",
"--overwrite"
])

grass_exec([
"r.out.gdal",
"-f",
f"input={out_name}",
f"output={output_raster}",
"format=GTiff",
"type=Byte",
"--overwrite"
])

def p(*parts):
return str(BASE_PATH.joinpath(STATE, *parts))

# ----------------- STEPS -----------------

def step0_strip_nodata_from_canopy():
src = p("data", "source", f"NLCD_{YEAR}_Tree_Canopy_{STATE}{PART}.tiff")
dst = p("data", f"NLCD_{YEAR}_Tree_Canopy_{STATE}{PART}_NoMask.tiff")

gdal_translate(src, dst, [
"-a_nodata", "none",
"-co", "TILED=YES",
"-co", "COMPRESS=LZW",
"-co", "ALPHA=NO"
])
print("Step 0: Removed NoData + mask from canopy")

def step1_tree_canopy_reclass():
src = p("data", f"NLCD_{YEAR}_Tree_Canopy_{STATE}{PART}_NoMask.tiff")
#src = p("data", "source", f"NLCD_{YEAR}_Tree_Canopy_{STATE}{PART}.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Trees-Combined.tiff")

expr = f"((A > 0) & (A < 255)) * {CANOPY} + (A <= 0) * A"
gdal_calc([
"-A", src,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 1: Trees-Combined")

def step1_5_strip_mask_from_reclassed_canopy():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Trees-Combined.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Trees-Combined_NoMask.tiff")

gdal_translate(src, dst, [
"-a_nodata", "none",
"-co", "TILED=YES",
"-co", "COMPRESS=LZW",
"-co", "ALPHA=NO"
])
print("Step 1.5: Removed mask from reclassed canopy")

def step2_warp_tree_canopy_4326():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Trees-Combined_NoMask.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Canopy_4326.tiff")

gdalwarp(src, dst, extra=[
"-srcnodata", "none",
"-dstnodata", "none",
"-co", "ALPHA=NO"
])

print("Step 2: Tree_Canopy_4326")

def step3_warp_land_cover_4326():
src = p("data", "source", f"NLCD_{YEAR}_Land_Cover_{STATE}{PART}.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Land_Cover_4326.tiff")
gdalwarp(src, dst)
print("Step 3: Land_Cover_4326")

def step4_combine_tree_land_4326():
a = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Canopy_4326.tiff")
b = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Land_Cover_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Land_Combined_4326.tiff")

expr = (
f"((B > 0) & (A != 41) & (A != 42) & (A != 43)) * B + "
f"((B <= 0) | (A == 41) | (A == 42) | (A == 43)) * A"
)
gdal_calc([
"-A", a,
"-B", b,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 4: Tree_Land_Combined_4326")

def step5_replace_urban_clutter_with_grass():
# Replace below
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Land_Combined_4326.tiff")
# with this
#src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Land_Cover_4326.tiff")
# when not combining Land Cover and Tree Canopy
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Grass-Only_4326.tiff")

expr = (
"(A == 0) * 44 + "
"(A == 11) * 41 + "
"(A == 12) * 34 + "
"(A == 21) * 26 + "
"(A == 22) * 26 + "
"(A == 23) * 26 + "
"(A == 24) * 26 + "
"(A == 31) * 27 + "
"(A == 41) * 23 + "
"(A == 42) * 24 + "
"(A == 43) * 25 + "
"(A == 51) * 30 + "
"(A == 52) * 29 + "
"(A == 71) * 26 + "
"(A == 72) * 32 + "
"(A == 73) * 31 + "
"(A == 74) * 31 + "
"(A == 75) * 32 + "
"(A == 81) * 18 + "
"(A == 82) * 19 + "
"(A == 90) * 25 + "
"(A == 95) * 35"
)
gdal_calc([
"-A", src,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 5: Grass-Only_4326")

def step6_reclass_urban():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Land_Combined_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Reclassed-Urban_4326.tiff")

expr = (
"(A == 21)*10 + "
"(A == 22)*1 + "
"(A == 23)*2 + "
"(A == 24)*3"
)
gdal_calc([
"-A", src,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 6: Reclassed-Urban_4326")

def step7_remove_clutter_roads_from_urban():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Reclassed-Urban_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Urban-Only_4326.tiff")

grass_r_neighbors(src, dst, method="median", size=7)
print("Step 7: Urban-Only_4326")

def step8_combine_grass_and_clean_urban():
a = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Urban-Only_4326.tiff")
b = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Grass-Only_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean_4326.tiff")

expr = "((A > 0) & (B > 0)) * A + ((A <= 0) | (B <= 0)) * B"
gdal_calc([
"-A", a,
"-B", b,
"--outfile", dst,
"--calc", expr,
"--NoDataValue", "0",
"--type", "Byte"
])
print("Step 8: Combined-Clean_4326")

def step9_upsample_to_hd():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean-HD_4326.tiff")

ds = gdal.Open(src)
if ds is None:
raise RuntimeError(f"Cannot open {src}")
gt = ds.GetGeoTransform()
original_xRes = gt[1]
original_yRes = abs(gt[5])

new_xRes = original_xRes / PERCENTAGE
new_yRes = original_yRes / PERCENTAGE

gdal.Warp(
dst,
src,
xRes=new_xRes,
yRes=new_yRes,
outputType=gdal.GDT_Byte
)
print("Step 9: Combined-Clean-HD_4326")

def step10_smooth_all_features():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean-HD_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Smoothed-HD_4326.tiff")

grass_r_neighbors(src, dst, method="median", size=SIZE)
print("Step 10: Smoothed-HD_4326")

def step10b_clamp_values():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Smoothed-HD_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Smoothed-HD-Clamped_4326.tiff")

expr = "(A>=1)*(A<=44)*A"
gdal_calc([
"-A", src,
"--outfile", dst,
"--calc", expr,
"--NoDataValue", "0",
"--type", "Byte"
])
print("Step 10b: Smoothed-HD-Clamped_4326")

def step11_convert_to_8bit_compressed():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Smoothed-HD-Clamped_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Smoothed-HD-Compressed_4326.tiff")

gdal_translate(src, dst)
print("Step 11: Smoothed-HD-Compressed_4326")

# ----------------- MAIN -----------------
# When not combining Tree Canopy with Land Cover,
# comment out step0, step1, step1_5, step2 and step4
# and replace src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Land_Combined_4326.tiff")
# with src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Land_Cover_4326.tiff")
# in step5.

def main():
step0_strip_nodata_from_canopy()
step1_tree_canopy_reclass()
step1_5_strip_mask_from_reclassed_canopy()
step2_warp_tree_canopy_4326()
step3_warp_land_cover_4326()
step4_combine_tree_land_4326()
step5_replace_urban_clutter_with_grass()
step6_reclass_urban()
step7_remove_clutter_roads_from_urban()
step8_combine_grass_and_clean_urban()
step9_upsample_to_hd()
step10_smooth_all_features()
step10b_clamp_values()
step11_convert_to_8bit_compressed()

if __name__ == "__main__":
main()
</syntaxhighlight>

== Batch script for multiple processes ==
<syntaxhighlight lang="python">
#!/bin/bash

python3 gen-scenery.py --part 89-86_29 --canopy 41 &
python3 gen-scenery.py --part 89-86_30 --canopy 41 &
python3 gen-scenery.py --part 89-86_31 --canopy 41 &
python3 gen-scenery.py --part 89-86_32 --canopy 41 &
python3 gen-scenery.py --part 89-86_33 --canopy 41 &
python3 gen-scenery.py --part 89-86_34 --canopy 41 &

wait
echo "All scenery jobs completed."
</syntaxhighlight>

Pure Python script to process NLCD for the USA (does not require using QGIS Python Console)

2026-06-05T22:40:43Z

Wlbragg: /* Pure Python script to process NLCD for the USA (does not require using QGIS Python Console) */

=== Pure Python script to process NLCD for the USA (does not require using QGIS Python Console) ===
This has been tested in Linux, it may or may not need modification to run under Windows OS.

USAGE: python3 gen-scenery.py --part 89-86_29 --canopy 41

This version is used when combining NLCD Tree Canopy rastors with NLCD Land Cover rastors

See all notes in code if not using Tree Canopy rasters.

<syntaxhighlight lang="python">
#!/usr/bin/env python3
import os
import subprocess
import argparse
import tempfile
from pathlib import Path
from osgeo import gdal

# ----------------- CONFIG -----------------

BASE_PATH = Path("/media/wayne/TOSHIBA-EXT/Scenery/ws3.0")
YEAR = "2023"
STATE = "Alabama"
# The following two parameters are now arguments, see ARGUMENT PARSING below
# PART = "89-86_29"
# CANOPY = 41

# upsampling / smoothing
PERCENTAGE = 11.0
SIZE = 21

# GRASS binary
GRASS_BIN = "grass"

# ----------------- ARGUMENT PARSING -----------------

# USAGE: python3 gen-scenery.py --part 89-86_29 --canopy 41

#NLCD
# Choose the dominent canopy for the area being processed
# Areas not covered in the Tree Canopy layer will convert retain their original class
#41 = DeciduousForest
#42 = EvergreenForest
#43 = MixedForest

#FG equivalent
#22 = AgroForest
#23 = DeciduousBroadCover
#24 = EvergreenForest
#25 = MixedForest

parser = argparse.ArgumentParser()
parser.add_argument("--part", required=True, help="Tile part ID, e.g. 89-86_29")
parser.add_argument("--canopy", required=True, type=int, help="Tree canopy FG class")
args = parser.parse_args()

PART = args.part
CANOPY = args.canopy

# ----------------- HELPERS -----------------

def run(cmd, check=True, env=None):
print(">>", " ".join(str(c) for c in cmd))
subprocess.run(cmd, check=check, env=env)

def gdal_calc(args):
fixed = []
for a in args:
if a.startswith("--") and "=" in a:
key, val = a.split("=", 1)
fixed.append(key)
fixed.append(val)
else:
fixed.append(a)

cmd = ["gdal_calc.py"] + fixed + ["--overwrite"]
run(cmd)

def gdalwarp(input_path, output_path, t_srs="EPSG:4326",
resampling="near", dtype="Byte", extra=None):
cmd = [
"gdalwarp",
"-t_srs", t_srs,
"-r", resampling,
"-ot", dtype,
"-overwrite",
input_path,
output_path
]
if extra:
cmd.extend(extra)
run(cmd)

def gdal_translate(input_path, output_path,
nodata=0, dtype="Byte", compress="LZW"):
cmd = [
"gdal_translate",
"-a_nodata", str(nodata),
"-ot", dtype,
"-co", f"COMPRESS={compress}",
input_path,
output_path
]
run(cmd)

# ----------------- GRASS SESSION -----------------

# Create a temporary GRASS location with PERMANENT mapset
TMPDIR = tempfile.mkdtemp(prefix="grass_job_")
GRASS_LOCATION = os.path.join(TMPDIR, "location")

# Create the location
subprocess.run([
GRASS_BIN,
"-c", "EPSG:4326",
GRASS_LOCATION,
"--exec", "echo", "Location created"
], check=True)

# The active mapset is PERMANENT
GRASS_MAPSET = os.path.join(GRASS_LOCATION, "PERMANENT")

def grass_exec(args):
cmd = [GRASS_BIN, GRASS_MAPSET, "--exec"] + args
print(">>", " ".join(cmd))
subprocess.run(cmd, check=True)

def grass_exec(args):
cmd = [GRASS_BIN, GRASS_MAPSET, "--exec"] + args
print(">>", " ".join(cmd))
subprocess.run(cmd, check=True)

def grass_r_neighbors(input_raster, output_raster,
method="median", size=7):
in_name = "in_rast"
out_name = "out_rast"

grass_exec([
"r.in.gdal",
f"input={input_raster}",
f"output={in_name}",
"--overwrite"
])

grass_exec([
"g.region",
f"raster={in_name}"
])

grass_exec([
"r.neighbors",
f"input={in_name}",
f"output={out_name}",
f"method={method}",
f"size={size}",
"--overwrite"
])

grass_exec([
"r.out.gdal",
"-f",
f"input={out_name}",
f"output={output_raster}",
"format=GTiff",
"type=Byte",
"--overwrite"
])

def p(*parts):
return str(BASE_PATH.joinpath(STATE, *parts))

# ----------------- STEPS -----------------

def step1_tree_canopy_reclass():
src = p("data", "source", f"NLCD_{YEAR}_Tree_Canopy_{STATE}{PART}.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Trees-Combined.tiff")

expr = f"((A > 0) & (A < 255)) * {CANOPY} + (A <= 0) * A"
gdal_calc([
"-A", src,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 1: Trees-Combined")

def step2_warp_tree_canopy_4326():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Trees-Combined.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Canopy_4326.tiff")
gdalwarp(src, dst)
print("Step 2: Tree_Canopy_4326")

def step3_warp_land_cover_4326():
src = p("data", "source", f"NLCD_{YEAR}_Land_Cover_{STATE}{PART}.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Land_Cover_4326.tiff")
gdalwarp(src, dst)
print("Step 3: Land_Cover_4326")

def get_extent(path):
ds = gdal.Open(path)
gt = ds.GetGeoTransform()
x0 = gt[0]
y0 = gt[3]
x1 = x0 + gt[1] * ds.RasterXSize
y1 = y0 + gt[5] * ds.RasterYSize
return [x0, y1, x1, y0]

def get_size(path):
ds = gdal.Open(path)
return [ds.RasterXSize, ds.RasterYSize]

def warp_canopy_to_landcover_extent():
canopy = p("data", "source", f"NLCD_{YEAR}_Tree_Canopy_{STATE}{PART}.tiff")
land = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Land_Cover_4326.tiff")
out = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Canopy_Aligned_4326.tiff")

gdalwarp(
canopy,
out,
t_srs="EPSG:4326",
resampling="near",
dtype="Byte",
extra = ["-te"] + [str(v) for v in get_extent(land)] + ["-ts"] + [str(v) for v in get_size(land)] + ["-srcnodata", "0", "-dstnodata", "0"]
)

def step4_combine_tree_land_4326():
a = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Canopy_Aligned_4326.tiff")
b = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Land_Cover_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Land_Combined_4326.tiff")

expr = (
# Use canopy where canopy exists
"((A > 0) & (B > 0) & (B < 255) & (B != 41) & (B != 42) & (B != 43)) * A + "
# Use land cover where canopy is 0 OR canopy is NoData OR land cover is forest
"((A <= 0) | (A != A) | (B == 41) | (B == 42) | (B == 43)) * B"
)
gdal_calc([
"-A", a,
"-B", b,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 4: Tree_Land_Combined_4326")

def step5_replace_urban_clutter_with_grass():
# replace
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Land_Combined_4326.tiff")
# with
#src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Land_Cover_4326.tiff")
# if not combining tree canopy raster with land cover raster
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Grass-Only_4326.tiff")

expr = (
"(A == 0) * 44 + "
"(A == 11) * 41 + "
"(A == 12) * 34 + "
"(A == 21) * 26 + "
"(A == 22) * 26 + "
"(A == 23) * 26 + "
"(A == 24) * 26 + "
"(A == 31) * 27 + "
"(A == 41) * 23 + "
"(A == 42) * 24 + "
"(A == 43) * 25 + "
"(A == 51) * 30 + "
"(A == 52) * 29 + "
"(A == 71) * 26 + "
"(A == 72) * 32 + "
"(A == 73) * 31 + "
"(A == 74) * 31 + "
"(A == 75) * 32 + "
"(A == 81) * 18 + "
"(A == 82) * 19 + "
"(A == 90) * 25 + "
"(A == 95) * 35"
)
gdal_calc([
"-A", src,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 5: Grass-Only_4326")

def step6_reclass_urban():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Land_Combined_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Reclassed-Urban_4326.tiff")

expr = (
"(A == 21)*10 + "
"(A == 22)*1 + "
"(A == 23)*2 + "
"(A == 24)*3"
)
gdal_calc([
"-A", src,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 6: Reclassed-Urban_4326")

def step7_remove_clutter_roads_from_urban():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Reclassed-Urban_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Urban-Only_4326.tiff")

grass_r_neighbors(src, dst, method="median", size=7)
print("Step 7: Urban-Only_4326")

def step8_combine_grass_and_clean_urban():
a = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Urban-Only_4326.tiff")
b = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Grass-Only_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean_4326.tiff")

expr = "((A > 0) & (B > 0)) * A + ((A <= 0) | (B <= 0)) * B"
gdal_calc([
"-A", a,
"-B", b,
"--outfile", dst,
"--calc", expr,
"--NoDataValue", "0",
"--type", "Byte"
])
print("Step 8: Combined-Clean_4326")

def step9_upsample_to_hd():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean-HD_4326.tiff")

ds = gdal.Open(src)
if ds is None:
raise RuntimeError(f"Cannot open {src}")
gt = ds.GetGeoTransform()
original_xRes = gt[1]
original_yRes = abs(gt[5])

new_xRes = original_xRes / PERCENTAGE
new_yRes = original_yRes / PERCENTAGE

gdal.Warp(
dst,
src,
xRes=new_xRes,
yRes=new_yRes,
outputType=gdal.GDT_Byte
)
print("Step 9: Combined-Clean-HD_4326")

def step10_smooth_all_features():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean-HD_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Smoothed-HD_4326.tiff")

grass_r_neighbors(src, dst, method="median", size=SIZE)
print("Step 10: Smoothed-HD_4326")

def step11_convert_to_8bit_compressed():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Smoothed-HD_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Smoothed-HD-Compressed_4326.tiff")

gdal_translate(src, dst)
print("Step 11: Smoothed-HD-Compressed_4326")

# ----------------- MAIN -----------------
# Comment out step1, warp_canopy_to_landcover_extent(), and step4 below
# and in step5, replace
# src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Land_Combined_4326.tiff")
# with
# src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Land_Cover_4326.tiff")
# if not combining tree canopy raster with land cover raster

def main():
step1_tree_canopy_reclass()
step2_warp_tree_canopy_4326()
step3_warp_land_cover_4326()
warp_canopy_to_landcover_extent()
step4_combine_tree_land_4326()
step5_replace_urban_clutter_with_grass()
step6_reclass_urban()
step7_remove_clutter_roads_from_urban()
step8_combine_grass_and_clean_urban()
step9_upsample_to_hd()
step10_smooth_all_features()
step10b_clamp_values()
step11_convert_to_8bit_compressed()

if __name__ == "__main__":
main()
</syntaxhighlight>

== Batch script for multiple processes ==
<syntaxhighlight lang="python">
#!/bin/bash

python3 gen-scenery.py --part 89-86_29 --canopy 41 &
python3 gen-scenery.py --part 89-86_30 --canopy 41 &
python3 gen-scenery.py --part 89-86_31 --canopy 41 &
python3 gen-scenery.py --part 89-86_32 --canopy 41 &
python3 gen-scenery.py --part 89-86_33 --canopy 41 &
python3 gen-scenery.py --part 89-86_34 --canopy 41 &

wait
echo "All scenery jobs completed."
</syntaxhighlight>

Pure Python script to process NLCD for the USA (does not require using QGIS Python Console)

2026-06-05T22:40:24Z

Wlbragg: /* Pure Python script to process NLCD for the USA (does not require using QGIS Python Console) */

=== Pure Python script to process NLCD for the USA (does not require using QGIS Python Console) ===
This has been tested in Linux, it may or may not need modification to run under Windows OS.
USAGE: python3 gen-scenery.py --part 89-86_29 --canopy 41

This version is used when combining NLCD Tree Canopy rastors with NLCD Land Cover rastors

See all notes in code if not using Tree Canopy rasters.

<syntaxhighlight lang="python">
#!/usr/bin/env python3
import os
import subprocess
import argparse
import tempfile
from pathlib import Path
from osgeo import gdal

# ----------------- CONFIG -----------------

BASE_PATH = Path("/media/wayne/TOSHIBA-EXT/Scenery/ws3.0")
YEAR = "2023"
STATE = "Alabama"
# The following two parameters are now arguments, see ARGUMENT PARSING below
# PART = "89-86_29"
# CANOPY = 41

# upsampling / smoothing
PERCENTAGE = 11.0
SIZE = 21

# GRASS binary
GRASS_BIN = "grass"

# ----------------- ARGUMENT PARSING -----------------

# USAGE: python3 gen-scenery.py --part 89-86_29 --canopy 41

#NLCD
# Choose the dominent canopy for the area being processed
# Areas not covered in the Tree Canopy layer will convert retain their original class
#41 = DeciduousForest
#42 = EvergreenForest
#43 = MixedForest

#FG equivalent
#22 = AgroForest
#23 = DeciduousBroadCover
#24 = EvergreenForest
#25 = MixedForest

parser = argparse.ArgumentParser()
parser.add_argument("--part", required=True, help="Tile part ID, e.g. 89-86_29")
parser.add_argument("--canopy", required=True, type=int, help="Tree canopy FG class")
args = parser.parse_args()

PART = args.part
CANOPY = args.canopy

# ----------------- HELPERS -----------------

def run(cmd, check=True, env=None):
print(">>", " ".join(str(c) for c in cmd))
subprocess.run(cmd, check=check, env=env)

def gdal_calc(args):
fixed = []
for a in args:
if a.startswith("--") and "=" in a:
key, val = a.split("=", 1)
fixed.append(key)
fixed.append(val)
else:
fixed.append(a)

cmd = ["gdal_calc.py"] + fixed + ["--overwrite"]
run(cmd)

def gdalwarp(input_path, output_path, t_srs="EPSG:4326",
resampling="near", dtype="Byte", extra=None):
cmd = [
"gdalwarp",
"-t_srs", t_srs,
"-r", resampling,
"-ot", dtype,
"-overwrite",
input_path,
output_path
]
if extra:
cmd.extend(extra)
run(cmd)

def gdal_translate(input_path, output_path,
nodata=0, dtype="Byte", compress="LZW"):
cmd = [
"gdal_translate",
"-a_nodata", str(nodata),
"-ot", dtype,
"-co", f"COMPRESS={compress}",
input_path,
output_path
]
run(cmd)

# ----------------- GRASS SESSION -----------------

# Create a temporary GRASS location with PERMANENT mapset
TMPDIR = tempfile.mkdtemp(prefix="grass_job_")
GRASS_LOCATION = os.path.join(TMPDIR, "location")

# Create the location
subprocess.run([
GRASS_BIN,
"-c", "EPSG:4326",
GRASS_LOCATION,
"--exec", "echo", "Location created"
], check=True)

# The active mapset is PERMANENT
GRASS_MAPSET = os.path.join(GRASS_LOCATION, "PERMANENT")

def grass_exec(args):
cmd = [GRASS_BIN, GRASS_MAPSET, "--exec"] + args
print(">>", " ".join(cmd))
subprocess.run(cmd, check=True)

def grass_exec(args):
cmd = [GRASS_BIN, GRASS_MAPSET, "--exec"] + args
print(">>", " ".join(cmd))
subprocess.run(cmd, check=True)

def grass_r_neighbors(input_raster, output_raster,
method="median", size=7):
in_name = "in_rast"
out_name = "out_rast"

grass_exec([
"r.in.gdal",
f"input={input_raster}",
f"output={in_name}",
"--overwrite"
])

grass_exec([
"g.region",
f"raster={in_name}"
])

grass_exec([
"r.neighbors",
f"input={in_name}",
f"output={out_name}",
f"method={method}",
f"size={size}",
"--overwrite"
])

grass_exec([
"r.out.gdal",
"-f",
f"input={out_name}",
f"output={output_raster}",
"format=GTiff",
"type=Byte",
"--overwrite"
])

def p(*parts):
return str(BASE_PATH.joinpath(STATE, *parts))

# ----------------- STEPS -----------------

def step1_tree_canopy_reclass():
src = p("data", "source", f"NLCD_{YEAR}_Tree_Canopy_{STATE}{PART}.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Trees-Combined.tiff")

expr = f"((A > 0) & (A < 255)) * {CANOPY} + (A <= 0) * A"
gdal_calc([
"-A", src,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 1: Trees-Combined")

def step2_warp_tree_canopy_4326():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Trees-Combined.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Canopy_4326.tiff")
gdalwarp(src, dst)
print("Step 2: Tree_Canopy_4326")

def step3_warp_land_cover_4326():
src = p("data", "source", f"NLCD_{YEAR}_Land_Cover_{STATE}{PART}.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Land_Cover_4326.tiff")
gdalwarp(src, dst)
print("Step 3: Land_Cover_4326")

def get_extent(path):
ds = gdal.Open(path)
gt = ds.GetGeoTransform()
x0 = gt[0]
y0 = gt[3]
x1 = x0 + gt[1] * ds.RasterXSize
y1 = y0 + gt[5] * ds.RasterYSize
return [x0, y1, x1, y0]

def get_size(path):
ds = gdal.Open(path)
return [ds.RasterXSize, ds.RasterYSize]

def warp_canopy_to_landcover_extent():
canopy = p("data", "source", f"NLCD_{YEAR}_Tree_Canopy_{STATE}{PART}.tiff")
land = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Land_Cover_4326.tiff")
out = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Canopy_Aligned_4326.tiff")

gdalwarp(
canopy,
out,
t_srs="EPSG:4326",
resampling="near",
dtype="Byte",
extra = ["-te"] + [str(v) for v in get_extent(land)] + ["-ts"] + [str(v) for v in get_size(land)] + ["-srcnodata", "0", "-dstnodata", "0"]
)

def step4_combine_tree_land_4326():
a = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Canopy_Aligned_4326.tiff")
b = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Land_Cover_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Land_Combined_4326.tiff")

expr = (
# Use canopy where canopy exists
"((A > 0) & (B > 0) & (B < 255) & (B != 41) & (B != 42) & (B != 43)) * A + "
# Use land cover where canopy is 0 OR canopy is NoData OR land cover is forest
"((A <= 0) | (A != A) | (B == 41) | (B == 42) | (B == 43)) * B"
)
gdal_calc([
"-A", a,
"-B", b,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 4: Tree_Land_Combined_4326")

def step5_replace_urban_clutter_with_grass():
# replace
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Land_Combined_4326.tiff")
# with
#src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Land_Cover_4326.tiff")
# if not combining tree canopy raster with land cover raster
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Grass-Only_4326.tiff")

expr = (
"(A == 0) * 44 + "
"(A == 11) * 41 + "
"(A == 12) * 34 + "
"(A == 21) * 26 + "
"(A == 22) * 26 + "
"(A == 23) * 26 + "
"(A == 24) * 26 + "
"(A == 31) * 27 + "
"(A == 41) * 23 + "
"(A == 42) * 24 + "
"(A == 43) * 25 + "
"(A == 51) * 30 + "
"(A == 52) * 29 + "
"(A == 71) * 26 + "
"(A == 72) * 32 + "
"(A == 73) * 31 + "
"(A == 74) * 31 + "
"(A == 75) * 32 + "
"(A == 81) * 18 + "
"(A == 82) * 19 + "
"(A == 90) * 25 + "
"(A == 95) * 35"
)
gdal_calc([
"-A", src,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 5: Grass-Only_4326")

def step6_reclass_urban():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Land_Combined_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Reclassed-Urban_4326.tiff")

expr = (
"(A == 21)*10 + "
"(A == 22)*1 + "
"(A == 23)*2 + "
"(A == 24)*3"
)
gdal_calc([
"-A", src,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 6: Reclassed-Urban_4326")

def step7_remove_clutter_roads_from_urban():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Reclassed-Urban_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Urban-Only_4326.tiff")

grass_r_neighbors(src, dst, method="median", size=7)
print("Step 7: Urban-Only_4326")

def step8_combine_grass_and_clean_urban():
a = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Urban-Only_4326.tiff")
b = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Grass-Only_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean_4326.tiff")

expr = "((A > 0) & (B > 0)) * A + ((A <= 0) | (B <= 0)) * B"
gdal_calc([
"-A", a,
"-B", b,
"--outfile", dst,
"--calc", expr,
"--NoDataValue", "0",
"--type", "Byte"
])
print("Step 8: Combined-Clean_4326")

def step9_upsample_to_hd():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean-HD_4326.tiff")

ds = gdal.Open(src)
if ds is None:
raise RuntimeError(f"Cannot open {src}")
gt = ds.GetGeoTransform()
original_xRes = gt[1]
original_yRes = abs(gt[5])

new_xRes = original_xRes / PERCENTAGE
new_yRes = original_yRes / PERCENTAGE

gdal.Warp(
dst,
src,
xRes=new_xRes,
yRes=new_yRes,
outputType=gdal.GDT_Byte
)
print("Step 9: Combined-Clean-HD_4326")

def step10_smooth_all_features():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean-HD_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Smoothed-HD_4326.tiff")

grass_r_neighbors(src, dst, method="median", size=SIZE)
print("Step 10: Smoothed-HD_4326")

def step11_convert_to_8bit_compressed():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Smoothed-HD_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Smoothed-HD-Compressed_4326.tiff")

gdal_translate(src, dst)
print("Step 11: Smoothed-HD-Compressed_4326")

# ----------------- MAIN -----------------
# Comment out step1, warp_canopy_to_landcover_extent(), and step4 below
# and in step5, replace
# src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Land_Combined_4326.tiff")
# with
# src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Land_Cover_4326.tiff")
# if not combining tree canopy raster with land cover raster

def main():
step1_tree_canopy_reclass()
step2_warp_tree_canopy_4326()
step3_warp_land_cover_4326()
warp_canopy_to_landcover_extent()
step4_combine_tree_land_4326()
step5_replace_urban_clutter_with_grass()
step6_reclass_urban()
step7_remove_clutter_roads_from_urban()
step8_combine_grass_and_clean_urban()
step9_upsample_to_hd()
step10_smooth_all_features()
step10b_clamp_values()
step11_convert_to_8bit_compressed()

if __name__ == "__main__":
main()
</syntaxhighlight>

== Batch script for multiple processes ==
<syntaxhighlight lang="python">
#!/bin/bash

python3 gen-scenery.py --part 89-86_29 --canopy 41 &
python3 gen-scenery.py --part 89-86_30 --canopy 41 &
python3 gen-scenery.py --part 89-86_31 --canopy 41 &
python3 gen-scenery.py --part 89-86_32 --canopy 41 &
python3 gen-scenery.py --part 89-86_33 --canopy 41 &
python3 gen-scenery.py --part 89-86_34 --canopy 41 &

wait
echo "All scenery jobs completed."
</syntaxhighlight>

Pure Python script to process NLCD for the USA (does not require using QGIS Python Console)

2026-06-05T22:35:32Z

Wlbragg: /* Pure Python script to process NLCD for the USA (does not require using QGIS Python Console) */

=== Pure Python script to process NLCD for the USA (does not require using QGIS Python Console) ===

This has been tested in Linux, it may or may not need modification to run under Windows OS.

USAGE: python3 gen-scenery.py --part 89-86_29 --canopy 41

<syntaxhighlight lang="python">
#!/usr/bin/env python3
import os
import subprocess
import argparse
import tempfile
from pathlib import Path
from osgeo import gdal

# ----------------- CONFIG -----------------

BASE_PATH = Path("/media/wayne/TOSHIBA-EXT/Scenery/ws3.0")
YEAR = "2023"
STATE = "Alabama"
# The following two parameters are now arguments, see ARGUMENT PARSING below
# PART = "89-86_29"
# CANOPY = 41

# upsampling / smoothing
PERCENTAGE = 11.0
SIZE = 21

# GRASS binary
GRASS_BIN = "grass"

# ----------------- ARGUMENT PARSING -----------------

# USAGE: python3 gen-scenery.py --part 89-86_29 --canopy 41

#NLCD
# Choose the dominent canopy for the area being processed
# Areas not covered in the Tree Canopy layer will convert retain their original class
#41 = DeciduousForest
#42 = EvergreenForest
#43 = MixedForest

#FG equivalent
#22 = AgroForest
#23 = DeciduousBroadCover
#24 = EvergreenForest
#25 = MixedForest

parser = argparse.ArgumentParser()
parser.add_argument("--part", required=True, help="Tile part ID, e.g. 89-86_29")
parser.add_argument("--canopy", required=True, type=int, help="Tree canopy FG class")
args = parser.parse_args()

PART = args.part
CANOPY = args.canopy

# ----------------- HELPERS -----------------

def run(cmd, check=True, env=None):
print(">>", " ".join(str(c) for c in cmd))
subprocess.run(cmd, check=check, env=env)

def gdal_calc(args):
fixed = []
for a in args:
if a.startswith("--") and "=" in a:
key, val = a.split("=", 1)
fixed.append(key)
fixed.append(val)
else:
fixed.append(a)

cmd = ["gdal_calc.py"] + fixed + ["--overwrite"]
run(cmd)

def gdalwarp(input_path, output_path, t_srs="EPSG:4326",
resampling="near", dtype="Byte", extra=None):
cmd = [
"gdalwarp",
"-t_srs", t_srs,
"-r", resampling,
"-ot", dtype,
"-overwrite",
input_path,
output_path
]
if extra:
cmd.extend(extra)
run(cmd)

def gdal_translate(input_path, output_path,
nodata=0, dtype="Byte", compress="LZW"):
cmd = [
"gdal_translate",
"-a_nodata", str(nodata),
"-ot", dtype,
"-co", f"COMPRESS={compress}",
input_path,
output_path
]
run(cmd)

# ----------------- GRASS SESSION -----------------

# Create a temporary GRASS location with PERMANENT mapset
TMPDIR = tempfile.mkdtemp(prefix="grass_job_")
GRASS_LOCATION = os.path.join(TMPDIR, "location")

# Create the location
subprocess.run([
GRASS_BIN,
"-c", "EPSG:4326",
GRASS_LOCATION,
"--exec", "echo", "Location created"
], check=True)

# The active mapset is PERMANENT
GRASS_MAPSET = os.path.join(GRASS_LOCATION, "PERMANENT")

def grass_exec(args):
cmd = [GRASS_BIN, GRASS_MAPSET, "--exec"] + args
print(">>", " ".join(cmd))
subprocess.run(cmd, check=True)

def grass_exec(args):
cmd = [GRASS_BIN, GRASS_MAPSET, "--exec"] + args
print(">>", " ".join(cmd))
subprocess.run(cmd, check=True)

def grass_r_neighbors(input_raster, output_raster,
method="median", size=7):
in_name = "in_rast"
out_name = "out_rast"

grass_exec([
"r.in.gdal",
f"input={input_raster}",
f"output={in_name}",
"--overwrite"
])

grass_exec([
"g.region",
f"raster={in_name}"
])

grass_exec([
"r.neighbors",
f"input={in_name}",
f"output={out_name}",
f"method={method}",
f"size={size}",
"--overwrite"
])

grass_exec([
"r.out.gdal",
"-f",
f"input={out_name}",
f"output={output_raster}",
"format=GTiff",
"type=Byte",
"--overwrite"
])

def p(*parts):
return str(BASE_PATH.joinpath(STATE, *parts))

# ----------------- STEPS -----------------

def step1_tree_canopy_reclass():
src = p("data", "source", f"NLCD_{YEAR}_Tree_Canopy_{STATE}{PART}.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Trees-Combined.tiff")

expr = f"((A > 0) & (A < 255)) * {CANOPY} + (A <= 0) * A"
gdal_calc([
"-A", src,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 1: Trees-Combined")

def step2_warp_tree_canopy_4326():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Trees-Combined.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Canopy_4326.tiff")
gdalwarp(src, dst)
print("Step 2: Tree_Canopy_4326")

def step3_warp_land_cover_4326():
src = p("data", "source", f"NLCD_{YEAR}_Land_Cover_{STATE}{PART}.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Land_Cover_4326.tiff")
gdalwarp(src, dst)
print("Step 3: Land_Cover_4326")

def get_extent(path):
ds = gdal.Open(path)
gt = ds.GetGeoTransform()
x0 = gt[0]
y0 = gt[3]
x1 = x0 + gt[1] * ds.RasterXSize
y1 = y0 + gt[5] * ds.RasterYSize
return [x0, y1, x1, y0]

def get_size(path):
ds = gdal.Open(path)
return [ds.RasterXSize, ds.RasterYSize]

def warp_canopy_to_landcover_extent():
canopy = p("data", "source", f"NLCD_{YEAR}_Tree_Canopy_{STATE}{PART}.tiff")
land = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Land_Cover_4326.tiff")
out = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Canopy_Aligned_4326.tiff")

gdalwarp(
canopy,
out,
t_srs="EPSG:4326",
resampling="near",
dtype="Byte",
extra = ["-te"] + [str(v) for v in get_extent(land)] + ["-ts"] + [str(v) for v in get_size(land)] + ["-srcnodata", "0", "-dstnodata", "0"]
)

def step4_combine_tree_land_4326():
a = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Canopy_Aligned_4326.tiff")
b = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Land_Cover_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Land_Combined_4326.tiff")

expr = (
# Use canopy where canopy exists
"((A > 0) & (B > 0) & (B < 255) & (B != 41) & (B != 42) & (B != 43)) * A + "
# Use land cover where canopy is 0 OR canopy is NoData OR land cover is forest
"((A <= 0) | (A != A) | (B == 41) | (B == 42) | (B == 43)) * B"
)
gdal_calc([
"-A", a,
"-B", b,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 4: Tree_Land_Combined_4326")

def step5_replace_urban_clutter_with_grass():
# replace
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Land_Combined_4326.tiff")
# with
#src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Land_Cover_4326.tiff")
# if not combining tree canopy raster with land cover raster
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Grass-Only_4326.tiff")

expr = (
"(A == 0) * 44 + "
"(A == 11) * 41 + "
"(A == 12) * 34 + "
"(A == 21) * 26 + "
"(A == 22) * 26 + "
"(A == 23) * 26 + "
"(A == 24) * 26 + "
"(A == 31) * 27 + "
"(A == 41) * 23 + "
"(A == 42) * 24 + "
"(A == 43) * 25 + "
"(A == 51) * 30 + "
"(A == 52) * 29 + "
"(A == 71) * 26 + "
"(A == 72) * 32 + "
"(A == 73) * 31 + "
"(A == 74) * 31 + "
"(A == 75) * 32 + "
"(A == 81) * 18 + "
"(A == 82) * 19 + "
"(A == 90) * 25 + "
"(A == 95) * 35"
)
gdal_calc([
"-A", src,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 5: Grass-Only_4326")

def step6_reclass_urban():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Land_Combined_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Reclassed-Urban_4326.tiff")

expr = (
"(A == 21)*10 + "
"(A == 22)*1 + "
"(A == 23)*2 + "
"(A == 24)*3"
)
gdal_calc([
"-A", src,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 6: Reclassed-Urban_4326")

def step7_remove_clutter_roads_from_urban():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Reclassed-Urban_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Urban-Only_4326.tiff")

grass_r_neighbors(src, dst, method="median", size=7)
print("Step 7: Urban-Only_4326")

def step8_combine_grass_and_clean_urban():
a = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Urban-Only_4326.tiff")
b = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Grass-Only_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean_4326.tiff")

expr = "((A > 0) & (B > 0)) * A + ((A <= 0) | (B <= 0)) * B"
gdal_calc([
"-A", a,
"-B", b,
"--outfile", dst,
"--calc", expr,
"--NoDataValue", "0",
"--type", "Byte"
])
print("Step 8: Combined-Clean_4326")

def step9_upsample_to_hd():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean-HD_4326.tiff")

ds = gdal.Open(src)
if ds is None:
raise RuntimeError(f"Cannot open {src}")
gt = ds.GetGeoTransform()
original_xRes = gt[1]
original_yRes = abs(gt[5])

new_xRes = original_xRes / PERCENTAGE
new_yRes = original_yRes / PERCENTAGE

gdal.Warp(
dst,
src,
xRes=new_xRes,
yRes=new_yRes,
outputType=gdal.GDT_Byte
)
print("Step 9: Combined-Clean-HD_4326")

def step10_smooth_all_features():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean-HD_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Smoothed-HD_4326.tiff")

grass_r_neighbors(src, dst, method="median", size=SIZE)
print("Step 10: Smoothed-HD_4326")

def step11_convert_to_8bit_compressed():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Smoothed-HD_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Smoothed-HD-Compressed_4326.tiff")

gdal_translate(src, dst)
print("Step 11: Smoothed-HD-Compressed_4326")

# ----------------- MAIN -----------------
# Comment out step1, warp_canopy_to_landcover_extent(), and step4 below
# and in step5, replace
# src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Land_Combined_4326.tiff")
# with
# src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Land_Cover_4326.tiff")
# if not combining tree canopy raster with land cover raster

def main():
step1_tree_canopy_reclass()
step2_warp_tree_canopy_4326()
step3_warp_land_cover_4326()
warp_canopy_to_landcover_extent()
step4_combine_tree_land_4326()
step5_replace_urban_clutter_with_grass()
step6_reclass_urban()
step7_remove_clutter_roads_from_urban()
step8_combine_grass_and_clean_urban()
step9_upsample_to_hd()
step10_smooth_all_features()
step10b_clamp_values()
step11_convert_to_8bit_compressed()

if __name__ == "__main__":
main()
</syntaxhighlight>

== Batch script for multiple processes ==
<syntaxhighlight lang="python">
#!/bin/bash

python3 gen-scenery.py --part 89-86_29 --canopy 41 &
python3 gen-scenery.py --part 89-86_30 --canopy 41 &
python3 gen-scenery.py --part 89-86_31 --canopy 41 &
python3 gen-scenery.py --part 89-86_32 --canopy 41 &
python3 gen-scenery.py --part 89-86_33 --canopy 41 &
python3 gen-scenery.py --part 89-86_34 --canopy 41 &

wait
echo "All scenery jobs completed."
</syntaxhighlight>

Pure Python script to process NLCD for the USA (does not require using QGIS Python Console)

2026-06-05T22:25:57Z

Wlbragg: /* Pure Python script to process NLCD for the USA (does not require using QGIS Python Console) */

=== Pure Python script to process NLCD for the USA (does not require using QGIS Python Console) ===

This has been tested in Linux, it may or may not need modification to run under Windows OS.

USAGE: python3 gen-scenery.py --part 89-86_29 --canopy 41

<syntaxhighlight lang="python">
#!/usr/bin/env python3
import os
import subprocess
import argparse
import tempfile
from pathlib import Path
from osgeo import gdal

# ----------------- CONFIG -----------------

BASE_PATH = Path("/media/wayne/TOSHIBA-EXT/Scenery/ws3.0")
YEAR = "2023"
STATE = "Alabama"
# The following two parameters are now arguments, see ARGUMENT PARSING below
# PART = "89-86_29"
# CANOPY = 41

# upsampling / smoothing
PERCENTAGE = 11.0
SIZE = 21

# GRASS binary
GRASS_BIN = "grass"

# ----------------- ARGUMENT PARSING -----------------

# USAGE: python3 gen-scenery.py --part 89-86_29 --canopy 41

#NLCD
# Choose the dominent canopy for the area being processed
# Areas not covered in the Tree Canopy layer will convert retain their original class
#41 = DeciduousForest
#42 = EvergreenForest
#43 = MixedForest

#FG equivalent
#22 = AgroForest
#23 = DeciduousBroadCover
#24 = EvergreenForest
#25 = MixedForest

parser = argparse.ArgumentParser()
parser.add_argument("--part", required=True, help="Tile part ID, e.g. 89-86_29")
parser.add_argument("--canopy", required=True, type=int, help="Tree canopy FG class")
args = parser.parse_args()

PART = args.part
CANOPY = args.canopy

# ----------------- HELPERS -----------------

def run(cmd, check=True, env=None):
print(">>", " ".join(str(c) for c in cmd))
subprocess.run(cmd, check=check, env=env)

def gdal_calc(args):
fixed = []
for a in args:
if a.startswith("--") and "=" in a:
key, val = a.split("=", 1)
fixed.append(key)
fixed.append(val)
else:
fixed.append(a)

cmd = ["gdal_calc.py"] + fixed + ["--overwrite"]
run(cmd)

def gdalwarp(input_path, output_path, t_srs="EPSG:4326",
resampling="near", dtype="Byte", extra=None):
cmd = [
"gdalwarp",
"-t_srs", t_srs,
"-r", resampling,
"-ot", dtype,
"-overwrite",
input_path,
output_path
]
if extra:
cmd.extend(extra)
run(cmd)

def gdal_translate(input_path, output_path,
nodata=0, dtype="Byte", compress="LZW"):
cmd = [
"gdal_translate",
"-a_nodata", str(nodata),
"-ot", dtype,
"-co", f"COMPRESS={compress}",
input_path,
output_path
]
run(cmd)

# ----------------- GRASS SESSION -----------------

# Create a temporary GRASS location with PERMANENT mapset
TMPDIR = tempfile.mkdtemp(prefix="grass_job_")
GRASS_LOCATION = os.path.join(TMPDIR, "location")

# Create the location
subprocess.run([
GRASS_BIN,
"-c", "EPSG:4326",
GRASS_LOCATION,
"--exec", "echo", "Location created"
], check=True)

# The active mapset is PERMANENT
GRASS_MAPSET = os.path.join(GRASS_LOCATION, "PERMANENT")

def grass_exec(args):
cmd = [GRASS_BIN, GRASS_MAPSET, "--exec"] + args
print(">>", " ".join(cmd))
subprocess.run(cmd, check=True)

def grass_exec(args):
cmd = [GRASS_BIN, GRASS_MAPSET, "--exec"] + args
print(">>", " ".join(cmd))
subprocess.run(cmd, check=True)

def grass_r_neighbors(input_raster, output_raster,
method="median", size=7):
in_name = "in_rast"
out_name = "out_rast"

grass_exec([
"r.in.gdal",
f"input={input_raster}",
f"output={in_name}",
"--overwrite"
])

grass_exec([
"g.region",
f"raster={in_name}"
])

grass_exec([
"r.neighbors",
f"input={in_name}",
f"output={out_name}",
f"method={method}",
f"size={size}",
"--overwrite"
])

grass_exec([
"r.out.gdal",
"-f",
f"input={out_name}",
f"output={output_raster}",
"format=GTiff",
"type=Byte",
"--overwrite"
])

def p(*parts):
return str(BASE_PATH.joinpath(STATE, *parts))

# ----------------- STEPS -----------------

def step1_tree_canopy_reclass():
src = p("data", "source", f"NLCD_{YEAR}_Tree_Canopy_{STATE}{PART}.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Trees-Combined.tiff")

expr = f"((A > 0) & (A < 255)) * {CANOPY} + (A <= 0) * A"
gdal_calc([
"-A", src,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 1: Trees-Combined")

def step2_warp_tree_canopy_4326():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Trees-Combined.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Canopy_4326.tiff")
gdalwarp(src, dst)
print("Step 2: Tree_Canopy_4326")

def step3_warp_land_cover_4326():
src = p("data", "source", f"NLCD_{YEAR}_Land_Cover_{STATE}{PART}.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Land_Cover_4326.tiff")
gdalwarp(src, dst)
print("Step 3: Land_Cover_4326")

def get_extent(path):
ds = gdal.Open(path)
gt = ds.GetGeoTransform()
x0 = gt[0]
y0 = gt[3]
x1 = x0 + gt[1] * ds.RasterXSize
y1 = y0 + gt[5] * ds.RasterYSize
return [x0, y1, x1, y0]

def get_size(path):
ds = gdal.Open(path)
return [ds.RasterXSize, ds.RasterYSize]

def warp_canopy_to_landcover_extent():
canopy = p("data", "source", f"NLCD_{YEAR}_Tree_Canopy_{STATE}{PART}.tiff")
land = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Land_Cover_4326.tiff")
out = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Canopy_Aligned_4326.tiff")

gdalwarp(
canopy,
out,
t_srs="EPSG:4326",
resampling="near",
dtype="Byte",
extra = ["-te"] + [str(v) for v in get_extent(land)] + ["-ts"] + [str(v) for v in get_size(land)] + ["-srcnodata", "0", "-dstnodata", "0"]
)

def step4_combine_tree_land_4326():
a = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Canopy_Aligned_4326.tiff")
b = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Land_Cover_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Land_Combined_4326.tiff")

expr = (
# Use canopy where canopy exists
"((A > 0) & (B > 0) & (B < 255) & (B != 41) & (B != 42) & (B != 43)) * A + "
# Use land cover where canopy is 0 OR canopy is NoData OR land cover is forest
"((A <= 0) | (A != A) | (B == 41) | (B == 42) | (B == 43)) * B"
)
gdal_calc([
"-A", a,
"-B", b,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 4: Tree_Land_Combined_4326")

def step5_replace_urban_clutter_with_grass():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Land_Combined_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Grass-Only_4326.tiff")

expr = (
"(A == 0) * 44 + "
"(A == 11) * 41 + "
"(A == 12) * 34 + "
"(A == 21) * 26 + "
"(A == 22) * 26 + "
"(A == 23) * 26 + "
"(A == 24) * 26 + "
"(A == 31) * 27 + "
"(A == 41) * 23 + "
"(A == 42) * 24 + "
"(A == 43) * 25 + "
"(A == 51) * 30 + "
"(A == 52) * 29 + "
"(A == 71) * 26 + "
"(A == 72) * 32 + "
"(A == 73) * 31 + "
"(A == 74) * 31 + "
"(A == 75) * 32 + "
"(A == 81) * 18 + "
"(A == 82) * 19 + "
"(A == 90) * 25 + "
"(A == 95) * 35"
)
gdal_calc([
"-A", src,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 5: Grass-Only_4326")

def step6_reclass_urban():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Land_Combined_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Reclassed-Urban_4326.tiff")

expr = (
"(A == 21)*10 + "
"(A == 22)*1 + "
"(A == 23)*2 + "
"(A == 24)*3"
)
gdal_calc([
"-A", src,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 6: Reclassed-Urban_4326")

def step7_remove_clutter_roads_from_urban():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Reclassed-Urban_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Urban-Only_4326.tiff")

grass_r_neighbors(src, dst, method="median", size=7)
print("Step 7: Urban-Only_4326")

def step8_combine_grass_and_clean_urban():
a = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Urban-Only_4326.tiff")
b = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Grass-Only_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean_4326.tiff")

expr = "((A > 0) & (B > 0)) * A + ((A <= 0) | (B <= 0)) * B"
gdal_calc([
"-A", a,
"-B", b,
"--outfile", dst,
"--calc", expr,
"--NoDataValue", "0",
"--type", "Byte"
])
print("Step 8: Combined-Clean_4326")

def step9_upsample_to_hd():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean-HD_4326.tiff")

ds = gdal.Open(src)
if ds is None:
raise RuntimeError(f"Cannot open {src}")
gt = ds.GetGeoTransform()
original_xRes = gt[1]
original_yRes = abs(gt[5])

new_xRes = original_xRes / PERCENTAGE
new_yRes = original_yRes / PERCENTAGE

gdal.Warp(
dst,
src,
xRes=new_xRes,
yRes=new_yRes,
outputType=gdal.GDT_Byte
)
print("Step 9: Combined-Clean-HD_4326")

def step10_smooth_all_features():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean-HD_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Smoothed-HD_4326.tiff")

grass_r_neighbors(src, dst, method="median", size=SIZE)
print("Step 10: Smoothed-HD_4326")

def step11_convert_to_8bit_compressed():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Smoothed-HD_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Smoothed-HD-Compressed_4326.tiff")

gdal_translate(src, dst)
print("Step 11: Smoothed-HD-Compressed_4326")

# ----------------- MAIN -----------------

def main():
step1_tree_canopy_reclass()
step2_warp_tree_canopy_4326()
step3_warp_land_cover_4326()
warp_canopy_to_landcover_extent()
step4_combine_tree_land_4326()
step5_replace_urban_clutter_with_grass()
step6_reclass_urban()
step7_remove_clutter_roads_from_urban()
step8_combine_grass_and_clean_urban()
step9_upsample_to_hd()
step10_smooth_all_features()
step10b_clamp_values()
step11_convert_to_8bit_compressed()

if __name__ == "__main__":
main()
</syntaxhighlight>

== Batch script for multiple processes ==
<syntaxhighlight lang="python">
#!/bin/bash

python3 gen-scenery.py --part 89-86_29 --canopy 41 &
python3 gen-scenery.py --part 89-86_30 --canopy 41 &
python3 gen-scenery.py --part 89-86_31 --canopy 41 &
python3 gen-scenery.py --part 89-86_32 --canopy 41 &
python3 gen-scenery.py --part 89-86_33 --canopy 41 &
python3 gen-scenery.py --part 89-86_34 --canopy 41 &

wait
echo "All scenery jobs completed."
</syntaxhighlight>

Howto:Create WS3.0 terrain

2026-05-21T15:53:06Z

Wlbragg: /* Generating the Terrain using osgdem */

{{WS30 Navbar}}
This article provides instructions on how to generate basic [[WS3.0]] terrain.

WS3.0 terrain consists of three parts:

# A terrain mesh consisting of a landclass texture draped over an elevation model.
# A high resolution water raster used to show water features such as rivers, lakes and coastline with more definition
# Line features such as roads and railways.

The terrain is generated by a set of tools that are packaged in a docker image for convenience.[[File:Diagram-export-21-12-2023-16 29 37.png|thumb|Basic WS3.0 Scenery Generation Process]]

== Prerequisites ==

=== Set up a Workspace ===
Create a directory with the following sub-directories:

* <code>cache</code>
* <code>data</code>
* <code>output/vpb</code>
* <code>output/Terrain</code>

=== Docker ===

# Install [https://docs.docker.com/get-started/ Docker] on your platform.
#Pull the docker image by running the following command

docker pull flightgear/ws30-vpb-generator:latest
Optionally, if you are hitting rate limits:
#Create an account on https://hub.docker.com/. (Note that you will need to click on an email verification link before you can log in for the first time)
#Run <code>docker login</code> before the '''docker pull''' command above

== Getting the base data ==
You need two pieces of data for the area of scenery you are generating:

# An elevation model (aka DEM). This indicates what altitude each point of the surface is.
# Landclass data showing what type of terrain is at each point of the surface. This is often either a Raster (effectively a texture), or vector data.

=== Elevation Model ===
Download the NASADEM elevation model for the area of scenery you wish to generate. This is available in 1x1 degree blocks from [https://lpdaac.usgs.gov/products/nasadem_hgtv001/ here], and with an interactive browser [https://search.earthdata.nasa.gov/search here].

Unzip the files into the <code>data</code> directory.

=== Landclass Raster ===
Download an landclass raster for the area of scenery you wish to generate.

* For Europe, use of [https://land.copernicus.eu/pan-european/corine-land-cover/clc2018 CORINE] is recommended.
* For the USA [https://www.mrlc.gov/viewer/ NLCD] is recommended
* Sentinel-2 data is available for the entire world via [https://livingatlas.arcgis.com/landcoverexplorer/ ESRI], but has limited set of landclasses.

Put these into the <code>data</code> directory.

More detailed terrain can be created by modifying the landclass raster, and/or generating a new raster from vector data. These processes are discussed below.

== Generating Terrain ==
To generate terrain you need to run the tools within the docker container we installed above. The docker image is like a small, independent virtual computing environment running within your system. This particular docker image has all the scenery generation tools already installed.

=== Running the docker container ===
Firstly, get the container running from the directory containing your <code>cache</code>, <code>data</code> and <code>output</code> directories:
docker run --rm --mount "type=bind,source=`pwd`/data,target=/home/flightgear/data,readonly" --mount "type=bind,source=`pwd`/output,target=/home/flightgear/output" --mount "type=bind,source=`pwd`/cache,target=/home/flightgear/cache" -it flightgear/ws30-vpb-generator:latest /bin/bash

You should now find yourself in a bash shell within your container. You should see data and output directories which are linked to the directories you created earlier:
flightgear@ddcac77f7d5e:~$ ls
cache data output bin scripts
In the Windows environment using Docker Desktop, if you need a path to a source of elevation data and a path to the OSM shoreline shapefiles, you can add the following:
docker run --rm --mount "type=bind,source=G:/Scenery/ws3.0/Alabama/data,target=/home/flightgear/data,readonly" --mount "type=bind,source=G:/Scenery/WS3.0-extra/vector/land-polygons-complete-4326,target=/home/flightgear/coastlines" --mount "type=bind,source=G:/Scenery/WS3.0-extra/SRTM-1,target=/home/flightgear/SRTM-3,readonly" --mount "type=bind,source=G:/Scenery/ws3.0/Alabama/output,target=/home/flightgear/output" --mount "type=bind,source=G:/Scenery/ws3.0/Alabama/output/cache,target=/home/flightgear/cache" -it flightgear/ws30-vpb-generator:latest /bin/bash

Note: the --mount "type=bind,source=G:/Scenery/WS3.0-extra/SRTM-1,target=/home/flightgear/SRTM-3,readonly", the genVPB.py script in the Docker container is expecting a location of /home/flightgear/SRTM-3 for the elevation data. In this example I am using SRTM-1 elevation data, but we still map it to the expected /home/flightgear/SRTM-3 Docker container location.
=== Building the terrain ===
To build the terrain mesh, use the <code>genVPB.py</code> tool from inside the docker container:

Usage: genVPB.py --raster <input-raster> [ option ... ]
Usage: genVPB.py --bbox <lat0> <lon0> <lat1> <lon1> --sentinel --reclass <reclass> [ option ... ]

Arguments:
--raster RASTER Input landclass raster.
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--sentinel Use Sentinel2 landclass tiles
--sentinel-dir SENTINEL_DIR Directory for Sentinel Data. Default /home/flightgear/data/Sentinel-2
--hgt-dir HGT_DIR Directory containing HGT DEM files. Default /home/flightgear/data/NASADEM
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/output
--download-sentinel Download Sentinel2 tiles if needed
--reclass RECLASS Reclassify raster using file <reclass>. See ./scripts/mappings/
--coastline COASTLINE Clip against coastline against polygon (.osm)
--shrink-water SHRINK_WATER Shrink water bodies (landclasses 40, 41) by <pixels> pixels
--generate-water-raster Generate a water raster from OSM data
--generate-line-features Generate a water raster from OSM data
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--nasadem-server NASADEM_SERVER Set server to download NASADEM data from. Default https://e4ftl01.cr.usgs.gov/MEASURES/NASADEM_HGT.001/2000.02.11/)
--nasadem-user NASADEM_USER NASA Earthdata username.
--nasadem-password NASADEM_PASSWORD NASA Earthdata password.
--debug Debug output

For example, to generate a piece of terrain around Edinburgh (latitude 55.5, longitude 3 degrees West):
./scripts/genVPB.py --bbox 55 -4 56 -3 --raster ./data/uk_wgs84_10m_N54.tif

Another example, to generate a coastal area with shorelines and lakes, like Alaska:
./scripts/genVPB.py --bbox 68 -167 69 -152 --raster ./data/NLCD_2016_Alaska167-153_68_Smoothed-HD-Compressed_4326.tiff --hgt-dir ./SRTM-3/ --generate-water-raster --shrink-water 4 --coastline ./coastlines/land_polygons.shp

Same thing with roads and rails (line features):
./scripts/genVPB.py --bbox 68 -167 69 -152 --raster ./data/NLCD_2016_Alaska167-153_68_Smoothed-HD-Compressed_4326.tiff --hgt-dir ./SRTM-3/ --generate-water-raster --shrink-water 4 --coastline ./coastlines/land_polygons.shp --generate-line-features

--coastline requires OSM data mask from here [https://osmdata.openstreetmap.de/data/land-polygons.html OSM Shapefiles] Make sure you download the shapefiles on this page and not the alternate "Water polygons or Coastlines". It is the land cover shapefiles that are used as the cutting mask, not the water line data.

If you are using anything other than a CORINE raster you will need to reclassify the data to match the landclasses used by FlightGear. Those classes are defined in [https://gitlab.com/flightgear/fgdata/-/tree/next/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml]. You can reclassify them using the files in the [https://gitlab.com/flightgear/fgmeta/-/tree/next/ws30/mappings/ scripts/mappings] directory. E.g. to reclassify NLCD2019 data you can use <code>--reclassify ./scripts/mappings/nlcd2019.txt</code>.

genVPB.py will output the data to the output/vpb directory, in which you should find a series of files and directories.

=== Adding water ===
'''Update 05/12/2026: Depreciated, it is now built into genVPB.py above.'''

'''Use genVPB.py ...... --generate-water-raster --shrink-water 4 --coastline [path_to_shapefile_mask]'''

The terrain mesh does not have highly detailed water features - as typically the source data has a resolution of 10-25m. Water features are generated from OpenStreetMap data. To generate water features simply run the <code>genwaterraster.py</code> command.

Usage: genwaterraster.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--output-dir OUTPUT_DIR] [--cache-dir CACHE_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--output-dir OUTPUT_DIR Directory to write files into. Default /home/flightgear/output
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache

For example, to generate water for the area around Edinburgh:
./scripts/genwaterraster.py --bbox 55 -4 56 -3

Inside the ./output/vpb directory there should be a set of directories and .png files.

=== Adding roads and railways ===
The terrain mesh does not have any line features - things like roads. These are generated separately from OpenStreetMap data. To generate line features simply run the <code>genroads.py</code> command:

Usage: ./scripts/genroads.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--threads THREADS] [--cache-dir CACHE_DIR] [--output-dir OUTPUT_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--threads THREADS Number of parallel threads to run. Defaults to 1
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/cache/

For example, to generate roads for the area around Edinburgh:
./scripts/genroads.py --bbox 55 -4 56 -3

Inside the ./output/Terrain directory there should be a set of directories and, .STG files text files.

==Running FlightGear with the new WS3.0 Terrain==
To test the new terrain, simply include the output directory in your scenery path and run FlightGear with the <code>--prop:/scenery/use-vpb=true</code> to enable WS3.0.

== Advanced Techniques ==
The following sections describe more complex techniques to generate higher quality WS3.0 terrain. Almost all of them involve using different data sources to generate a more detailed landclass raster before running the final scenery generation processes described above. Generating a highly detailed landclass raster is where the magic happens.

Most techniques use gdal or grass to modify the raster/vector data, typically using the QGIS program.

=== Using a different elevation model ===
If you are using another elevation model other than NASAEM, then you may need to re-project it using QGIS/gdalwarp to the WGS84 CRS (aka EPSG:4326).

=== Landclass Data Requirements ===
For any landclass data we need to ensure the data is in the correct format. That means:

# Is a Raster (geotiff) rather than Vector data. This raster will become the texture on the terrain that the terrain shaders do their magic on.
# Uses the WGS84 Coordinate Reference System. The ensures that the terrain generation step is efficient.
# Has the correct landclass values for each terrain type. We use a set of values based on the CORINE raster set, defined in [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml].

Below is a quick table showing what steps you need to take for common landclass data sources.
{| class="wikitable"
|+
!Landclass Data
!Warp to WGS84 required?
!Landclass re-classification Required?
!Raster Simplification Required?
!Conversion to Raster Required?
|-
|CORINE Raster
|Yes
|No
|No
|No
|-
|CORINE Vector
|Yes
|Yes
|No
|Yes
|-
|NLCD
|No
|Yes
|Yes
|No
|-
|Sentinel-2
|Yes
|Yes
|No
|No
|}
Conversion to Raster must be done manually. Converting to WGS84 and the correct landclasses ''can'' be done by the genVPB.py script, but slows down scenery generation. Therefore if you are planning to generate scenery multiple times it is best to pre-process the files yourself.

The easiest way to do these operations is using QGIS, which is available for most platforms. If you are scripting a toolchain, the QGIS tools include command-line equivalents for all commands.

When using QGIS, set the Project CRS to WGS84 (aka EPSG:4326). You can then add layers of Raster or Vector data from files from the <code>Layer->Add Layer</code> menu. When performing any operations, <u>always</u> write out the data to a real file so you can go back to it later. Disk space is cheap :).

=== Warping Raster Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a raster layer to a different CRS using the Raster->Projections-Warp (Reproject) tool.

Select the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Resampling Method to Use - Nearest Neighbour. (Landclass data is not like normal images. You don't want to interpolate between values.)
* Nodata value for output bands - 0.0 (This means that any data at the edges will be Ocean, usually a reasonable default)
* Advanced Parameters - No Compression
* Output data type - Byte
* Reprojected - Choose a target filename

Alternatively you can do this step from the commandline.
gdalwarp -t_srs EPSG:4326 -dstnodata 0.0 -r near -ot Byte -of GTiff -co COMPRESS=NONE -co BIGTIFF=IF_NEEDED /home/stuart/FlightGear/VPB/data/CORINE/u2018_clc2018_v2020_20u1_raster100m/DATA/U2018_CLC2018_V2020_20u1.tif /home/stuart/FlightGear/VPB/data/scratch/corine_WGS84.tif

=== Warping Vector Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a vector layer using Vector->Data Management Tools->Reproject Layer.

Set the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Reprojected - Choose a target filename

=== Reclassifying Vector Layers ===
For CORINE vector data in particular, the attributes used in the vector data are not the same as those used by the CORINE Raster data. So we need to create a new attribute on the data.
[[File:Field Calculator.png|thumb|QGIS Field Calculator]]
To do this

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialog
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type "Whole Number (Integer)". This will create a new column which we will populate with the correct landclass data
* Click on the <code>Open Field Calculator</code> button (Ctrl + I). (If you get an error about only being able to create Virtual fields, go back to the Layer menu, export it and open the exported file).
* Select the following options:
** Update Existing Field
** Select the Landclass field you just created.
** Copy the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/corine_vector.txt into the Expression box (without the comment lines starting with <code>#</code>). This is just some simple code to set the attribute correctly. The code should be correct for CORINE vector data. If your data is from other sources you will need to work out how you want to map your source data landclasses to the CORINE ones. [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml] can be used as a guide.
* Select <code>OK</code>. You should see that your landclass column is now populated with the landclass data.
* Select <code>Layer->Save Layer Edits</code> to save you changes

=== Creating a Raster from a Vector Layer ===
To create a Raster from a Vector Layer select <code>Raster->Conversion->Rasterize (Vector to Raster)</code>.
[[File:QGIS Rasterize (Vector to Raster).png|thumb|Creating a Raster from a Vector Layer - QGIS Rasterize]]
Select the following options:

* Input Layer - correct layer, check CRS
* Field to use for burn-in value - select the <code>Landclass</code> column you created above.
* Output raster size units. This is going to set the resolution of your raster. You can work out the resolution in two different ways:
** Select "Georeferenced units" and determine how many degrees each pixel is in latitude and longitude.
** Select "Pixels" and determine the size of raster you want in pixels. [https://www.nhc.noaa.gov/gccalc.shtml This] is a good calculator to help. You input e.g. SE and SW coordinates and calculate to get the distance in Km. Then you multiply by thousand and devide by the number of metres per pixel (e.g. 5) -> resolution for width.
* Width/Horizontal Resolution. Enter the values you've calculated for the horizontal resolution (longitudinal), or the width of the raster
* Height/Vertical Resolution. Enter the values you've calculated for the vertical resolution (latitude or the height of the raster)
* Output extent - Select an option from the box on the right. You can edit the text afterwards (NB: East, West, South, North). Best practise is to create long thin strips of 1 degree latitude in height, as this makes subsequent processing much easier.
* Assign a specific nodata value to output bands - Select 0.0 for Ocean. CORINE vector data in particular has a lot of nodata for Oceans
* Advanced Parameters - No Compression
* Output data type - Byte
* Rasterized - Select a new filename

=== Simplifying a Raster Layer ===
Some Raster Landclass data (NLCD included) has too much noise - in particular large US highway systems are identified as Urban areas.

To smooth it out we can use the GRASS <code>n.neighbors</code> function from the Processing Toolbox in QGIS.

Select the following options:

* Input Layer - correct layer, check CRS
* Neighborhood operation - median. (This is not a normal image, so using an average will result in weird values)
* Neighborhood size - 5.
* Neighbors - Select a new filename.

=== Clipping a Raster Layer with OSM Data for Land (Corine) ===
The Corine dataset does not match OSM coastlines exactly. The following multi-stage process makes sure, that no Corine land-use is in the water as defined by OSM.

==== Download OSM Land Data ====

Download land polygons based on OSM data as a Shapefile from [https://osmdata.openstreetmap.de/data/land-polygons.html Land Polygons] and make sure to pick the WGS84 projected download with split polygons ("Large polygons are split, use for larger scales"). Once downloaded unzip the content into a directory.

==== Reclassifying the OSM Land Data Vector Layer ====
I QGIS make sure that only the layer for the raster for land data is selected (e.g. <code>land-polygons-split-4326</code>) -> in the map view you will see the whole earth. NB: typically you do this reclassify only once after download and can reuse the result for future processing.

Then:

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialogue
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type <code>Integer (32 bit)</code>. This will create a new column which we will populate with the correct land class data
* On top of the table on the left side choose "Landclass" in the drop-down menu, then input <code>2</code> into the field to the right and then press button "Update" all to the left of this field.
* Wait a bit and the close the dialogue.
* Select <code>Layer->Save Layer Edits</code> to save your changes (overwrite e.g. <code>land-polygons-split-4326</code>).

==== Convert the Land Data from Vector to Raster ====
Do the same as in chapter "Creating a Raster from a Vector Layer" above. The only difference is that the Input layer will be the land data polygons and you need to choose a different file name for the "Rasterized" (e.g. osm_land_scotland_5m.tif)

==== Remove Novalue Entries in the Land Data Raster ====
To do this:

* Select <code>Processing->Toolbox</code>. You should see a new box on the right side.
* Write "gdal_calc" in the search box and you should see an entry "Raster calculator". Double click on it and you will get a new dialogue window.
* In this dialogue:
** For "Input layer A" choose the raster from the previous chapter ((e.g. osm_land_scotland_5m.tif)
** In field "Calculation in gdalnumeric ..." write: <code>greater(A,0) * A</code>
** In field "Output raster type" choose <code>Byte</code>
** In field "Advanced Parameters" choose Profile <code>No compression</code>
** In field "Additional command-line parameters" write: <code>--hideNoData</code>
** In field "Calculated" choose a file (e.g. osm_land_scotland_allvalues_5m.tif)
** (In the "GDAL/OGR console call" it will have something similar to the follwing - just with different paths: <code>gdal_calc.py --overwrite --calc "greater(A ,0) * A" --format GTiff --type Byte -A /home/vanosten/custom-fg-scenery/data/osm_land_scotland_5m.tif --A_band 1 --co COMPRESS=NONE --co BIGTIFF=IF_NEEDED --hideNoData --outfile /home/vanosten/custom-fg-scenery/data/osm_land_scotland_allvalues_5m.tif</code>
** Press the "Run" button - and when complete close the dialogue.

You should now see a map only black and white. You can check for correctness by pressing <code>CTRL+SHIFT+I</code> to get a cursor with an arrow and an "i". First make sure the new raster is selected on the left side. Next click on the sea/ocean and then check in the "Identify Results" window on the right that the value is < 2. The click on the land and check that the value is 2.

==== Create the Final Clipped Corine Raster Against OSM Land Data =====
Do the following:

* In QGIS make sure that you have only the following two layers: the basis Corine raster (see chapter "Creating a Raster from a Vector Layer" - here e.g. corine_raster_scotland_5m.tif) and plus the raster from the previous step (e.g. osm_land_scotland_allvalues_5m.tif)
* Select <code>Raster->Raster Calculator ...</code> and a corresponding dialogue will open showing on the left hand side the two rasters.
* Choose a new "Output layer" (e.g. corine_raster_scotland_clipped_5m.tif).
* In the "Raster Calculator Expression" field input: <code>if ("osm_land_scotland_all_data_5m@1" < 2, 44, "corine_raster_scotland_5m@1")</code>
* Press button "OK" and wait a while (you will see a new dialogue with showing the progress.

Done. You have now a raster (e.g. corine_raster_scotland_clipped_5m.tif) which does not have land in areas, where OSM data has sea/ocean.

=== Reclassifying a Raster Layer ===
WS3.0 uses CORINE landclass values. If using data from other sources it needs to be reclassified to the correct values. genVPB.py has an option to do this, but you may wish to do so manually.

To do this select <code>GRASS->Raster->r.reclass</code> from the Processing Toolbox.

Select the following options:

* Input Raster Layer - correct layer, check CRS
* Reclass rules text - copy in the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/nlcd2019.txt. Or an appropriate mapping from your landclass data to CORINE. Note that you can also reference a file using the "File containing reclass rules" option. Note a mapping of 22 24 = 1 is the same as 22 and 24 = 1. For a range of 22 to 24 use 22 23 24 = 1.
* Reclassified - Select a new filename.

(If this doesn't work a similar function is available in the Processing Toolbox under <code>Raster analysis->Reclassify by table</code>. However this doesn't save your table once you close the dialog, and entries have to be manually entered individually which takes a lot of effort)

=== Processing NLCD for USA using the Raster Calculator and tools in QGIS ===

[[Processing_NLCD_for_USA_using_Raster_Calculator_and_tools_in_QGIS]]

=== Python script to process NLCD for the USA in the QGIS Python Editor ===

[[Python_script_to_process_NLCD_for_the_USA]]

=== Python script to process Sentinel-2 data ===

[[Python_script_to_process_Sentinel-2_data]]

=== Python script plus Grass to process NLCD data (also in batch) ===

[[Pure_Python_script_to_process_NLCD_for_the_USA_(does_not_require_using_QGIS_Python_Console)]]

===Generating the Terrain using osgdem===
Instead of using genVPB.py, you may wish to run osgdem directly.

In the Windows/Docker platform you can send the generate tile command directly to osgdem.exe, one tile at a time.

Using the NLCD raster processing convention from above, following is the the final step after creating the raster and entering bash shell with the windows version of "docker run..."

osgdem --TERRAIN --image-ext png --RGBA --no-interpolate-imagery --disable-error-diffusion --geocentric --no-mip-mapping -t ./data/California-Southern_4326-84-hd-corrected.tiff -d ./SRTM-3/N32W115.hgt -b -115 32 -114 33 --PagedLOD -l 7 --radius-to-max-visible-distance-ratio 3 -o ./output/vpb/w120n30/w115n32/ws_w115n32.osgb

Note: the --image-ext png --RGBA flags are critical to successfully building correctly placed landclasses in the final VPB generated scenery.

Note: --tile-image-size 256 is the default tile size produced when using genVPB.py. The hi-res rasters produced by the NLCD or Sentinel-2 Python3 processing scripts will not match that resolution in the final scenery unless this flag is set to --tile-image-size 1024. But the tradeoff is a heavier scenery that might not run on lower spec systems.

If you prefer to run the scenery generation manually, running the VPB osgdem process is described in more detail here: [[Virtual Planet Builder#Running VPB]].

After doing this you should have an output directory containing files of the form <code>output/vpb/w010n50/w004n50/ws_w004n50.osgb</code>, plus a host of sub-directories. Each one of these is a 1x1 tile of terrain.

to leave the container simply type <code>exit</code>.

===Packaging the Scenery===
Once you have the terrain and line features they should be packaged in a scenery directory in vpb and Terrain sub-directories respectively. E.g.
MyCoolScenery/Terrain
MyCoolScenery/vpb
It is good practise to document the data sources used in scenery generation. Some source licenses require attribution of the original data source for anything derived, published or distributed.

To assist in fulfilling these license obligations, you can create a source.xml file in the scenery directory which includes attribution information. This will then be available from within the simulator under Help->Scenery Sources, and <u>may</u> fulfil the attribution requirements of your license. '''Note that you are responsible for fulfilling any license requirements from the data, not FlightGear'''.

The format of the file is straightforward:
<?xml version="1.0"?>
<PropertyList>
<nowiki><source></nowiki>
<name>Corine Land Cover (CLC) 2018, Version 2020_20u1</name>
<nowiki><link></nowiki><nowiki>http://web.archive.org/web/20221112175615/https://land.copernicus.eu/pan-european/corine-land-cover/clc2018?tab=metadata%2A</nowiki><nowiki></link></nowiki>
<license>GMES Open License</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>NASADEM Merged DEM Global 1 arc second V001</name>
<nowiki><link></nowiki><nowiki>https://www.earthdata.nasa.gov/</nowiki><nowiki></link></nowiki>
<license>Public Domain</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>OpenStreetMap</name>
<nowiki><link></nowiki><nowiki>https://www.openstreetmap.org/copyright</nowiki><nowiki></link></nowiki>
<license>Open Data Commons Open Database License</license>
<nowiki></source></nowiki>
</PropertyList>

Virtual Planet Builder

2026-05-21T15:46:24Z

Wlbragg: /* Running VPB */

{{WS30 Navbar}}
{{Scenery Core Development}}

VirtualPlanetBuilder (VPB) is an OSG tool that generates native OSG data to represent terrain, usually by draping a GEO-TIFF over an elevation model.

== Building VirtualPlanetBuilder ==

The VPB project and code can be found here: https://github.com/openscenegraph/VirtualPlanetBuilder

There is now[https://sourceforge.net/p/flightgear/mailman/message/37385201/] a VPB {{Wikipedia|Docker_(software)|docker}} container for Linux: https://hub.docker.com/r/flightgear/ws30-vbp-generator and https://github.com/fdalvi/flightgear-ws30-vbp-generator

If you've got an existing FlightGear build, there are some additional dependencies:
* OSG
** Including NVTT. ('sudo apt-get install libnvtt-dev' - oddly VPB builds without it but then checks for the shared library at runtime...)
* GDAL (https://gdal.org/), Note that this needs to 2.4.X
** ... which requires PROJ 6 or above (https://proj.org/)
*** ... which requires the sqlite3.11 or above development package (on linux - 'sudo apt-get install libsqlite3-dev')

Note that GDAL and PROJ do not use cmake, so it builds in the source directory as follows:
./configure -prefix=/path/to/install
make

VPB is built using cmake e.g.

cmake -DOSG_DIR=/path/to/OSG/install /path/to/VPB/src
make

== Getting Landcover Data ==

For CORINE data covering Europe, try here: https://land.copernicus.eu/pan-european/corine-land-cover/clc2018

For US National Landcover Database (NLCD) try here: https://www.mrlc.gov/viewer/

ESRI (akak Sentinel-2) covers the entire world but with fewer distinct landclasses: https://livingatlas.arcgis.com/landcoverexplorer.

Choose RASTER data, which will download a geo-referenced TIF image.

Note that the mapping from landcover to materials is performed in Materials/base/landclass-mapping.xml, and currently only maps CORINE raster landclasses. If you have another landcover source (e.g. the US NLCD. ESRI), you will need to use your GIS (Grass, QGIS) to convert them such that the raster uses the correct landclass indexes.

=== Using Vector Data ===
If you wish to create higher resolution scenery, you may need to convert from vector data.

Key points:

* If required, re-project to WGS84. Ensure you project and layer are in the same projection.
* Map the vector polygons to have the correct landclass. In QGIS, you can do this as follows:
** Open the Attribute Table
** Create a new field (c_index) with type int
** Open the field calculator the update the new field (c_index) using a calculation that maps from the landclass fields in your data. For CORINE vector data this is the c18 field. An example is below, and some mappings are available [https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/ here]:
<syntaxhighlight>
CASE
WHEN c18=111 THEN 1
WHEN c18=112 THEN 2
WHEN c18=121 THEN 3
WHEN c18=122 THEN 4
WHEN c18=123 THEN 5
WHEN c18=124 THEN 6
.
.
.
END
</syntaxhighlight>

* Use a rasterize command to create a raster:

gdal_rasterize -l CORINE_Modified_WGS84 -a Landclass -ts 35000.0 33300.0 -a_nodata 48.0 -te 3.0 51.0 8.0 54.0 -ot Byte -of GTiff -co COMPRESS=NONE -co BIGTIFF=IF_NEEDED /home/stuart/FlightGear/VPB/data/Modified/CORINE_Modified_WGS84.gpkg /home/stuart/FlightGear/VPB/data/10m/Netherlands2.tif

== Getting DEM data. ==

The most commonly used Digital Elevation Model used is SRTM.

SRTM with 90m resolution is available here: http://srtm.csi.cgiar.org/

SRTM with 30m resolution is available here: https://lpdaac.usgs.gov/products/nasadem_hgtv001/ ''([https://e4ftl01.cr.usgs.gov/MEASURES/NASADEM_HGT.001/ Directory] , [https://search.earthdata.nasa.gov/search Interactive search] by selecting areas or points: [https://search.earthdata.nasa.gov/search/granules?p=C1546314043-LPDAAC_ECS&pg[0][v]=f&pg[0][gsk]=-start_date&q=NASADEM%20HGT&tl=1633679290.379!3!! example] . To download you need a free account from [https://urs.earthdata.nasa.gov/users/new here]'')

VPB accepts both raster and HGT files.

== LoD, Mesh size and Framerate ==

Unlike WS2.0 which has a fixed terrain mesh, VPB uses different terrain meshes with different level of detail (LoD) depending on the distance of the viewer from the particular piece of terrain.
[[File:Virtual Planet Builder LoD.png|thumb|Simplified diagram of different LoD tiles being loaded as an aircraft gets closer.]]
[[File:VPB Lod Filename scheme.png|thumb|Diagram showing how the Virtual Planet Builder filenames are built for each LoD level. Note that this just shows 3 LoD Levels. Our scenery goes to "L5".]]

Virtual Planet Builder provides a variety of settings that have a big impact on the eventual terrain mesh. The two main settings (the number of LoD levels, and the ratio of the LoD radius and maximum visible range), have a huge impact on the number of vertices, how the terrain looks, LoD "popping", and framerate.

To attempt to understand the relationship, a test was performed. WS30 terrain was generated for a 2x2 degree section of the European Alps bounded by (7E, 45N), and (8E, 47N), with settings as listed below. FlightGear was then run on a desktop with an NVidia GeForce GTX 1660 with 6GB of VRAM. The system appeared I/O limited as GPU utilization was around 30% and on 2GB of VRAM was used.

The following commandline options were used to place the ufo just to the NE of the Matterhorn, facing SW.
--aircraft=ufo --timeofday=morning --disable-real-weather-fetch --disable-ai-traffic --disable-random-objects --disable-random-vegetation --altitude=15000 --prop:/scenery/use-vpb=true --disable-sound --disable-ai-models --prop:/sim/rendering/texture-cache/cache-enabled=false --lat=46.021023 --lon=7.728291 --altitude=12662.75 --heading=226.0
{| class="wikitable"
|+
Experimental results varying LoD Level and visibility distance ratios
!Dem Resolution
!LoD Levels
!Radius to max visible distance ratio
!Lowest LoD Radius (km)
!Highest LoD Range (km)
!Lowest LoD Range (km)
!Vertices in view
!Triangles in view (M)
!Framerate (M)
!Frame Latency (ms)
!Terrain Size (MB)
|-
|90
|8
|7
|0.6
|1099
|4.3
|15
|30
|28
|40
|128
|-
|30
|8
|7
|0.6
|1099
|4.3
|32
|61
|19
|59
|425
|-
|30
|7
|5
|1.2
|785
|6.1
|5.6
|11
|75
|17
|170
|-
|30
|7
|3
|1.2
|475
|3.7
|3
|6
|105
|14
|170
|-
|30
|6
|5
|2.5
|785
|12
|4
|7
|115
|13 (a)
|80
|-
|30
|4
|5
|9.8
|785
|49
|3
|6
|125
|12 (b)
|25
|}
Notes:

(a) - Using these settings there was a noticeable reduction in apparent heightmap resolution with a 30m DEM, probably because the resolution of the lowest LoD level was ~40m, compared with 20m for an 7 LoD level mesh.

(b) Using these settings, the terrain resolution was unacceptably poor.

These results suggest that using 7 LoD Levels and a radius of "3" will provide a good balance, with high terrain quality and good frame-rate.

== Running VPB ==

FlightGear expects scenery in 1x1 degree tiles in a slightly different format to WS2.0. The scenery needs to be in a "vpb" directory, followed by a directory structure similar to WS20 (10x10, then 1x1 degree directories), with the final file being a 1x1 degree section with a "ws_" prefix, and in the ".osgb" format. E.g. vpb/w010n50/w004n50/ws_w004n50.osgb

VPB is available in a docker image [https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/ws30-vbp-generator-docker/ here]. Instructions on how to install and use it can be found in [[Howto:Create WS3.0 terrain]].

Here are the options I've used to generate some scenery of the UK:

./bin/osgdem --TERRAIN \
--image-ext png
--no-interpolate-imagery \
--disable-error-diffusion \
--geocentric \
-t /home/stuart/FlightGear/VPB/data/CORINE/u2018_clc2018_v2020_20u1_raster100m/DATA/U2018_CLC2018_V2020_20u1.tif \
-d /home/stuart/FlightGear/VPB/data/SRTM90/srtm_34_02.tif \
-d /home/stuart/FlightGear/VPB/data/SRTM90/srtm_35_01.tif \
-d /home/stuart/FlightGear/VPB/data/SRTM90/srtm_35_02.tif \
-d /home/stuart/FlightGear/VPB/data/SRTM90/srtm_36_01.tif \
-d /home/stuart/FlightGear/VPB/data/SRTM90/srtm_36_02.tif \
-b -4 50 -3 51 \
--PagedLOD \
-l 7 \
--radius-to-max-visible-distance-ratio 3 \
-o vpb/w010n50/w004n50/ws_w004n50.osgb

* --TERRAIN to use osgTerrain::Terrain database
* --compressor-nvtt --compression-quality-highest to generate native DDS mipmaps
* --geocentric because that's what FG uses
* -t the texture to drape (in this case CORINE)
* -d the DEM to use (in this case pieces of SRTM90)
* -b is the extents in decimal degrees: LON1 LAT1 LON2 LAT2, in this case from (-4,50) to (-3,51)
* --PagedLOD to generate PagedLOD nodes
* -l 4 the number of LOD levels to generate. At the equator, a 1x1 degree tile has a 157km diagonal. The LoD follows a quad-tree like structure, with each LOD level having 4 sub-tiles in a 2x2 array. If we want our smallest tile to have a ~10km diagonal, we need 4 LoD levels
* --radius-to-max-visible-distance-ratio is self-explanatory. We want the lowest level of LoD to be visible 20km away, so a ratio of 5 is appropriate.
* -o is the output file, in this case native OSG binary format. FG expects WS3.0 data in a vpb subdirectory, with the structure shown.

NOTE: --tile-image-size 256 is the default and the tile size used with genVPB.py. It is not possible to realize the hi-res edge you achieve with the NLCD processing scripts. That requires a --tile-image-size 1024 or greater. The tradeoff though, is a much larger scenery footprint which could possibly too heavy for lower spec systems.
[[Category:Scenery software]]

Pure Python script to process NLCD for the USA (does not require using QGIS Python Console)

2026-05-20T17:24:38Z

Wlbragg: /* Pure Python script to process NLCD for the USA (does not require using QGIS Python Console) */

=== Pure Python script to process NLCD for the USA (does not require using QGIS Python Console) ===

This has been tested in Linux, it may or may not need modification to run under Windows OS.

USAGE: python3 gen-scenery.py --part 89-86_29 --canopy 41

<syntaxhighlight lang="python">
#!/usr/bin/env python3
import os
import subprocess
import argparse
import tempfile
from pathlib import Path
from osgeo import gdal

# ----------------- CONFIG -----------------

BASE_PATH = Path("/media/wayne/TOSHIBA-EXT/Scenery/ws3.0")
YEAR = "2023"
STATE = "Alabama"
# The following two parameters are now arguments, see ARGUMENT PARSING below
# PART = "89-86_29"
# CANOPY = 41

# upsampling / smoothing
PERCENTAGE = 11.0
SIZE = 21

# GRASS binary
GRASS_BIN = "grass"

# ----------------- ARGUMENT PARSING -----------------

# USAGE: python3 gen-scenery.py --part 89-86_29 --canopy 41

#NLCD
# Choose the dominent canopy for the area being processed
# Areas not covered in the Tree Canopy layer will convert retain their original class
#41 = DeciduousForest
#42 = EvergreenForest
#43 = MixedForest

#FG equivalent
#22 = AgroForest
#23 = DeciduousBroadCover
#24 = EvergreenForest
#25 = MixedForest

parser = argparse.ArgumentParser()
parser.add_argument("--part", required=True, help="Tile part ID, e.g. 89-86_29")
parser.add_argument("--canopy", required=True, type=int, help="Tree canopy FG class")
args = parser.parse_args()

PART = args.part
CANOPY = args.canopy

# ----------------- HELPERS -----------------

def run(cmd, check=True, env=None):
print(">>", " ".join(str(c) for c in cmd))
subprocess.run(cmd, check=check, env=env)

def gdal_calc(args):
fixed = []
for a in args:
if a.startswith("--") and "=" in a:
key, val = a.split("=", 1)
fixed.append(key)
fixed.append(val)
else:
fixed.append(a)

cmd = ["gdal_calc.py"] + fixed + ["--overwrite"]
run(cmd)

def gdalwarp(input_path, output_path, t_srs="EPSG:4326",
resampling="near", dtype="Byte", extra=None):
cmd = [
"gdalwarp",
"-t_srs", t_srs,
"-r", resampling,
"-ot", dtype,
"-overwrite",
input_path,
output_path
]
if extra:
cmd.extend(extra)
run(cmd)

def gdal_translate(input_path, output_path,
nodata=0, dtype="Byte", compress="LZW"):
cmd = [
"gdal_translate",
"-a_nodata", str(nodata),
"-ot", dtype,
"-co", f"COMPRESS={compress}",
input_path,
output_path
]
run(cmd)

# ----------------- GRASS SESSION -----------------

# Create a temporary GRASS location with PERMANENT mapset
TMPDIR = tempfile.mkdtemp(prefix="grass_job_")
GRASS_LOCATION = os.path.join(TMPDIR, "location")

# Create the location
subprocess.run([
GRASS_BIN,
"-c", "EPSG:4326",
GRASS_LOCATION,
"--exec", "echo", "Location created"
], check=True)

# The active mapset is PERMANENT
GRASS_MAPSET = os.path.join(GRASS_LOCATION, "PERMANENT")

def grass_exec(args):
cmd = [GRASS_BIN, GRASS_MAPSET, "--exec"] + args
print(">>", " ".join(cmd))
subprocess.run(cmd, check=True)

def grass_exec(args):
cmd = [GRASS_BIN, GRASS_MAPSET, "--exec"] + args
print(">>", " ".join(cmd))
subprocess.run(cmd, check=True)

def grass_r_neighbors(input_raster, output_raster,
method="median", size=7):
in_name = "in_rast"
out_name = "out_rast"

grass_exec([
"r.in.gdal",
f"input={input_raster}",
f"output={in_name}",
"--overwrite"
])

grass_exec([
"g.region",
f"raster={in_name}"
])

grass_exec([
"r.neighbors",
f"input={in_name}",
f"output={out_name}",
f"method={method}",
f"size={size}",
"--overwrite"
])

grass_exec([
"r.out.gdal",
"-f",
f"input={out_name}",
f"output={output_raster}",
"format=GTiff",
"type=Byte",
"--overwrite"
])

def p(*parts):
return str(BASE_PATH.joinpath(STATE, *parts))

# ----------------- STEPS -----------------

def step1_tree_canopy_reclass():
src = p("data", "source", f"NLCD_{YEAR}_Tree_Canopy_{STATE}{PART}.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Trees-Combined.tiff")

expr = f"((A > 0) & (A < 255)) * {CANOPY} + (A <= 0) * A"
gdal_calc([
"-A", src,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 1: Trees-Combined")

def step2_warp_tree_canopy_4326():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Trees-Combined.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Canopy_4326.tiff")
gdalwarp(src, dst)
print("Step 2: Tree_Canopy_4326")

def step3_warp_land_cover_4326():
src = p("data", "source", f"NLCD_{YEAR}_Land_Cover_{STATE}{PART}.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Land_Cover_4326.tiff")
gdalwarp(src, dst)
print("Step 3: Land_Cover_4326")

def step4_combine_tree_land_4326():
a = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Canopy_4326.tiff")
b = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Land_Cover_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Land_Combined_4326.tiff")

expr = (
"(((B > 0) & (B < 255)) & (B != 41) & (B != 42) & (B != 43) & (A > 0)) * A + "
"((B == 41) | (B == 42) | (B == 43) | (A <= 0)) * B"
)
gdal_calc([
"-A", a,
"-B", b,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 4: Tree_Land_Combined_4326")

def step5_replace_urban_clutter_with_grass():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Land_Combined_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Grass-Only_4326.tiff")

expr = (
"(A == 0) * 44 + "
"(A == 11) * 41 + "
"(A == 12) * 34 + "
"(A == 21) * 26 + "
"(A == 22) * 26 + "
"(A == 23) * 26 + "
"(A == 24) * 26 + "
"(A == 31) * 27 + "
"(A == 41) * 23 + "
"(A == 42) * 24 + "
"(A == 43) * 25 + "
"(A == 51) * 30 + "
"(A == 52) * 29 + "
"(A == 71) * 26 + "
"(A == 72) * 32 + "
"(A == 73) * 31 + "
"(A == 74) * 31 + "
"(A == 75) * 32 + "
"(A == 81) * 18 + "
"(A == 82) * 19 + "
"(A == 90) * 25 + "
"(A == 95) * 35"
)
gdal_calc([
"-A", src,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 5: Grass-Only_4326")

def step6_reclass_urban():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Land_Combined_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Reclassed-Urban_4326.tiff")

expr = (
"(A == 21)*10 + "
"(A == 22)*1 + "
"(A == 23)*2 + "
"(A == 24)*3"
)
gdal_calc([
"-A", src,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 6: Reclassed-Urban_4326")

def step7_remove_clutter_roads_from_urban():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Reclassed-Urban_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Urban-Only_4326.tiff")

grass_r_neighbors(src, dst, method="median", size=7)
print("Step 7: Urban-Only_4326")

def step8_combine_grass_and_clean_urban():
a = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Urban-Only_4326.tiff")
b = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Grass-Only_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean_4326.tiff")

expr = "((A > 0) & (B > 0)) * A + ((A <= 0) | (B <= 0)) * B"
gdal_calc([
"-A", a,
"-B", b,
"--outfile", dst,
"--calc", expr,
"--NoDataValue", "0",
"--type", "Byte"
])
print("Step 8: Combined-Clean_4326")

def step9_upsample_to_hd():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean-HD_4326.tiff")

ds = gdal.Open(src)
if ds is None:
raise RuntimeError(f"Cannot open {src}")
gt = ds.GetGeoTransform()
original_xRes = gt[1]
original_yRes = abs(gt[5])

new_xRes = original_xRes / PERCENTAGE
new_yRes = original_yRes / PERCENTAGE

gdal.Warp(
dst,
src,
xRes=new_xRes,
yRes=new_yRes,
outputType=gdal.GDT_Byte
)
print("Step 9: Combined-Clean-HD_4326")

def step10_smooth_all_features():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean-HD_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Smoothed-HD_4326.tiff")

grass_r_neighbors(src, dst, method="median", size=SIZE)
print("Step 10: Smoothed-HD_4326")

def step11_convert_to_8bit_compressed():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Smoothed-HD_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Smoothed-HD-Compressed_4326.tiff")

gdal_translate(src, dst)
print("Step 11: Smoothed-HD-Compressed_4326")

# ----------------- MAIN -----------------

def main():
step1_tree_canopy_reclass()
step2_warp_tree_canopy_4326()
step3_warp_land_cover_4326()
step4_combine_tree_land_4326()
step5_replace_urban_clutter_with_grass()
step6_reclass_urban()
step7_remove_clutter_roads_from_urban()
step8_combine_grass_and_clean_urban()
step9_upsample_to_hd()
step10_smooth_all_features()
step11_convert_to_8bit_compressed()

if __name__ == "__main__":
main()
</syntaxhighlight>

== Batch script for multiple processes ==
<syntaxhighlight lang="python">
#!/bin/bash

python3 gen-scenery.py --part 89-86_29 --canopy 41 &
python3 gen-scenery.py --part 89-86_30 --canopy 41 &
python3 gen-scenery.py --part 89-86_31 --canopy 41 &
python3 gen-scenery.py --part 89-86_32 --canopy 41 &
python3 gen-scenery.py --part 89-86_33 --canopy 41 &
python3 gen-scenery.py --part 89-86_34 --canopy 41 &

wait
echo "All scenery jobs completed."
</syntaxhighlight>

Pure Python script to process NLCD for the USA (does not require using QGIS Python Console)

2026-05-20T17:22:55Z

Wlbragg: /* Pure Python script to process NLCD for the USA (does not require using QGIS Python Console) */

=== Pure Python script to process NLCD for the USA (does not require using QGIS Python Console) ===

This has been tested in Linux, it may or may not need modification to run under Windows OS.

USAGE: python3 gen-scenery.py --part 89-86_29 --canopy 41

<syntaxhighlight lang="python">
#!/usr/bin/env python3
import os
import subprocess
import argparse
import tempfile
from pathlib import Path
from osgeo import gdal

# ----------------- CONFIG -----------------

BASE_PATH = Path("/media/wayne/TOSHIBA-EXT/Scenery/ws3.0")
YEAR = "2023"
STATE = "Alabama"
# Now an argument, see ARGUMENT PARSING below
# PART = "89-86_29"

# upsampling / smoothing
PERCENTAGE = 11.0
SIZE = 21

# GRASS binary
GRASS_BIN = "grass"

# ----------------- ARGUMENT PARSING -----------------

# USAGE: python3 gen-scenery.py --part 89-86_29 --canopy 41

#NLCD
# Choose the dominent canopy for the area being processed
# Areas not covered in the Tree Canopy layer will convert retain their original class
#41 = DeciduousForest
#42 = EvergreenForest
#43 = MixedForest

#FG equivalent
#22 = AgroForest
#23 = DeciduousBroadCover
#24 = EvergreenForest
#25 = MixedForest

parser = argparse.ArgumentParser()
parser.add_argument("--part", required=True, help="Tile part ID, e.g. 89-86_29")
parser.add_argument("--canopy", required=True, type=int, help="Tree canopy FG class")
args = parser.parse_args()

PART = args.part
CANOPY = args.canopy

# ----------------- HELPERS -----------------

def run(cmd, check=True, env=None):
print(">>", " ".join(str(c) for c in cmd))
subprocess.run(cmd, check=check, env=env)

def gdal_calc(args):
fixed = []
for a in args:
if a.startswith("--") and "=" in a:
key, val = a.split("=", 1)
fixed.append(key)
fixed.append(val)
else:
fixed.append(a)

cmd = ["gdal_calc.py"] + fixed + ["--overwrite"]
run(cmd)

def gdalwarp(input_path, output_path, t_srs="EPSG:4326",
resampling="near", dtype="Byte", extra=None):
cmd = [
"gdalwarp",
"-t_srs", t_srs,
"-r", resampling,
"-ot", dtype,
"-overwrite",
input_path,
output_path
]
if extra:
cmd.extend(extra)
run(cmd)

def gdal_translate(input_path, output_path,
nodata=0, dtype="Byte", compress="LZW"):
cmd = [
"gdal_translate",
"-a_nodata", str(nodata),
"-ot", dtype,
"-co", f"COMPRESS={compress}",
input_path,
output_path
]
run(cmd)

# ----------------- GRASS SESSION -----------------

# Create a temporary GRASS location with PERMANENT mapset
TMPDIR = tempfile.mkdtemp(prefix="grass_job_")
GRASS_LOCATION = os.path.join(TMPDIR, "location")

# Create the location
subprocess.run([
GRASS_BIN,
"-c", "EPSG:4326",
GRASS_LOCATION,
"--exec", "echo", "Location created"
], check=True)

# The active mapset is PERMANENT
GRASS_MAPSET = os.path.join(GRASS_LOCATION, "PERMANENT")

def grass_exec(args):
cmd = [GRASS_BIN, GRASS_MAPSET, "--exec"] + args
print(">>", " ".join(cmd))
subprocess.run(cmd, check=True)

def grass_exec(args):
cmd = [GRASS_BIN, GRASS_MAPSET, "--exec"] + args
print(">>", " ".join(cmd))
subprocess.run(cmd, check=True)

def grass_r_neighbors(input_raster, output_raster,
method="median", size=7):
in_name = "in_rast"
out_name = "out_rast"

grass_exec([
"r.in.gdal",
f"input={input_raster}",
f"output={in_name}",
"--overwrite"
])

grass_exec([
"g.region",
f"raster={in_name}"
])

grass_exec([
"r.neighbors",
f"input={in_name}",
f"output={out_name}",
f"method={method}",
f"size={size}",
"--overwrite"
])

grass_exec([
"r.out.gdal",
"-f",
f"input={out_name}",
f"output={output_raster}",
"format=GTiff",
"type=Byte",
"--overwrite"
])

def p(*parts):
return str(BASE_PATH.joinpath(STATE, *parts))

# ----------------- STEPS -----------------

def step1_tree_canopy_reclass():
src = p("data", "source", f"NLCD_{YEAR}_Tree_Canopy_{STATE}{PART}.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Trees-Combined.tiff")

expr = f"((A > 0) & (A < 255)) * {CANOPY} + (A <= 0) * A"
gdal_calc([
"-A", src,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 1: Trees-Combined")

def step2_warp_tree_canopy_4326():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Trees-Combined.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Canopy_4326.tiff")
gdalwarp(src, dst)
print("Step 2: Tree_Canopy_4326")

def step3_warp_land_cover_4326():
src = p("data", "source", f"NLCD_{YEAR}_Land_Cover_{STATE}{PART}.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Land_Cover_4326.tiff")
gdalwarp(src, dst)
print("Step 3: Land_Cover_4326")

def step4_combine_tree_land_4326():
a = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Canopy_4326.tiff")
b = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Land_Cover_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Land_Combined_4326.tiff")

expr = (
"(((B > 0) & (B < 255)) & (B != 41) & (B != 42) & (B != 43) & (A > 0)) * A + "
"((B == 41) | (B == 42) | (B == 43) | (A <= 0)) * B"
)
gdal_calc([
"-A", a,
"-B", b,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 4: Tree_Land_Combined_4326")

def step5_replace_urban_clutter_with_grass():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Land_Combined_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Grass-Only_4326.tiff")

expr = (
"(A == 0) * 44 + "
"(A == 11) * 41 + "
"(A == 12) * 34 + "
"(A == 21) * 26 + "
"(A == 22) * 26 + "
"(A == 23) * 26 + "
"(A == 24) * 26 + "
"(A == 31) * 27 + "
"(A == 41) * 23 + "
"(A == 42) * 24 + "
"(A == 43) * 25 + "
"(A == 51) * 30 + "
"(A == 52) * 29 + "
"(A == 71) * 26 + "
"(A == 72) * 32 + "
"(A == 73) * 31 + "
"(A == 74) * 31 + "
"(A == 75) * 32 + "
"(A == 81) * 18 + "
"(A == 82) * 19 + "
"(A == 90) * 25 + "
"(A == 95) * 35"
)
gdal_calc([
"-A", src,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 5: Grass-Only_4326")

def step6_reclass_urban():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Land_Combined_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Reclassed-Urban_4326.tiff")

expr = (
"(A == 21)*10 + "
"(A == 22)*1 + "
"(A == 23)*2 + "
"(A == 24)*3"
)
gdal_calc([
"-A", src,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 6: Reclassed-Urban_4326")

def step7_remove_clutter_roads_from_urban():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Reclassed-Urban_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Urban-Only_4326.tiff")

grass_r_neighbors(src, dst, method="median", size=7)
print("Step 7: Urban-Only_4326")

def step8_combine_grass_and_clean_urban():
a = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Urban-Only_4326.tiff")
b = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Grass-Only_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean_4326.tiff")

expr = "((A > 0) & (B > 0)) * A + ((A <= 0) | (B <= 0)) * B"
gdal_calc([
"-A", a,
"-B", b,
"--outfile", dst,
"--calc", expr,
"--NoDataValue", "0",
"--type", "Byte"
])
print("Step 8: Combined-Clean_4326")

def step9_upsample_to_hd():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean-HD_4326.tiff")

ds = gdal.Open(src)
if ds is None:
raise RuntimeError(f"Cannot open {src}")
gt = ds.GetGeoTransform()
original_xRes = gt[1]
original_yRes = abs(gt[5])

new_xRes = original_xRes / PERCENTAGE
new_yRes = original_yRes / PERCENTAGE

gdal.Warp(
dst,
src,
xRes=new_xRes,
yRes=new_yRes,
outputType=gdal.GDT_Byte
)
print("Step 9: Combined-Clean-HD_4326")

def step10_smooth_all_features():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean-HD_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Smoothed-HD_4326.tiff")

grass_r_neighbors(src, dst, method="median", size=SIZE)
print("Step 10: Smoothed-HD_4326")

def step11_convert_to_8bit_compressed():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Smoothed-HD_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Smoothed-HD-Compressed_4326.tiff")

gdal_translate(src, dst)
print("Step 11: Smoothed-HD-Compressed_4326")

# ----------------- MAIN -----------------

def main():
step1_tree_canopy_reclass()
step2_warp_tree_canopy_4326()
step3_warp_land_cover_4326()
step4_combine_tree_land_4326()
step5_replace_urban_clutter_with_grass()
step6_reclass_urban()
step7_remove_clutter_roads_from_urban()
step8_combine_grass_and_clean_urban()
step9_upsample_to_hd()
step10_smooth_all_features()
step11_convert_to_8bit_compressed()

if __name__ == "__main__":
main()
</syntaxhighlight>

== Batch script for multiple processes ==
<syntaxhighlight lang="python">
#!/bin/bash

python3 gen-scenery.py --part 89-86_29 --canopy 41 &
python3 gen-scenery.py --part 89-86_30 --canopy 41 &
python3 gen-scenery.py --part 89-86_31 --canopy 41 &
python3 gen-scenery.py --part 89-86_32 --canopy 41 &
python3 gen-scenery.py --part 89-86_33 --canopy 41 &
python3 gen-scenery.py --part 89-86_34 --canopy 41 &

wait
echo "All scenery jobs completed."
</syntaxhighlight>

Howto:Create WS3.0 terrain

2026-05-20T17:19:41Z

Wlbragg: /* Python script to process NLCD for the USA */

{{WS30 Navbar}}
This article provides instructions on how to generate basic [[WS3.0]] terrain.

WS3.0 terrain consists of three parts:

# A terrain mesh consisting of a landclass texture draped over an elevation model.
# A high resolution water raster used to show water features such as rivers, lakes and coastline with more definition
# Line features such as roads and railways.

The terrain is generated by a set of tools that are packaged in a docker image for convenience.[[File:Diagram-export-21-12-2023-16 29 37.png|thumb|Basic WS3.0 Scenery Generation Process]]

== Prerequisites ==

=== Set up a Workspace ===
Create a directory with the following sub-directories:

* <code>cache</code>
* <code>data</code>
* <code>output/vpb</code>
* <code>output/Terrain</code>

=== Docker ===

# Install [https://docs.docker.com/get-started/ Docker] on your platform.
#Pull the docker image by running the following command

docker pull flightgear/ws30-vpb-generator:latest
Optionally, if you are hitting rate limits:
#Create an account on https://hub.docker.com/. (Note that you will need to click on an email verification link before you can log in for the first time)
#Run <code>docker login</code> before the '''docker pull''' command above

== Getting the base data ==
You need two pieces of data for the area of scenery you are generating:

# An elevation model (aka DEM). This indicates what altitude each point of the surface is.
# Landclass data showing what type of terrain is at each point of the surface. This is often either a Raster (effectively a texture), or vector data.

=== Elevation Model ===
Download the NASADEM elevation model for the area of scenery you wish to generate. This is available in 1x1 degree blocks from [https://lpdaac.usgs.gov/products/nasadem_hgtv001/ here], and with an interactive browser [https://search.earthdata.nasa.gov/search here].

Unzip the files into the <code>data</code> directory.

=== Landclass Raster ===
Download an landclass raster for the area of scenery you wish to generate.

* For Europe, use of [https://land.copernicus.eu/pan-european/corine-land-cover/clc2018 CORINE] is recommended.
* For the USA [https://www.mrlc.gov/viewer/ NLCD] is recommended
* Sentinel-2 data is available for the entire world via [https://livingatlas.arcgis.com/landcoverexplorer/ ESRI], but has limited set of landclasses.

Put these into the <code>data</code> directory.

More detailed terrain can be created by modifying the landclass raster, and/or generating a new raster from vector data. These processes are discussed below.

== Generating Terrain ==
To generate terrain you need to run the tools within the docker container we installed above. The docker image is like a small, independent virtual computing environment running within your system. This particular docker image has all the scenery generation tools already installed.

=== Running the docker container ===
Firstly, get the container running from the directory containing your <code>cache</code>, <code>data</code> and <code>output</code> directories:
docker run --rm --mount "type=bind,source=`pwd`/data,target=/home/flightgear/data,readonly" --mount "type=bind,source=`pwd`/output,target=/home/flightgear/output" --mount "type=bind,source=`pwd`/cache,target=/home/flightgear/cache" -it flightgear/ws30-vpb-generator:latest /bin/bash

You should now find yourself in a bash shell within your container. You should see data and output directories which are linked to the directories you created earlier:
flightgear@ddcac77f7d5e:~$ ls
cache data output bin scripts
In the Windows environment using Docker Desktop, if you need a path to a source of elevation data and a path to the OSM shoreline shapefiles, you can add the following:
docker run --rm --mount "type=bind,source=G:/Scenery/ws3.0/Alabama/data,target=/home/flightgear/data,readonly" --mount "type=bind,source=G:/Scenery/WS3.0-extra/vector/land-polygons-complete-4326,target=/home/flightgear/coastlines" --mount "type=bind,source=G:/Scenery/WS3.0-extra/SRTM-1,target=/home/flightgear/SRTM-3,readonly" --mount "type=bind,source=G:/Scenery/ws3.0/Alabama/output,target=/home/flightgear/output" --mount "type=bind,source=G:/Scenery/ws3.0/Alabama/output/cache,target=/home/flightgear/cache" -it flightgear/ws30-vpb-generator:latest /bin/bash

Note: the --mount "type=bind,source=G:/Scenery/WS3.0-extra/SRTM-1,target=/home/flightgear/SRTM-3,readonly", the genVPB.py script in the Docker container is expecting a location of /home/flightgear/SRTM-3 for the elevation data. In this example I am using SRTM-1 elevation data, but we still map it to the expected /home/flightgear/SRTM-3 Docker container location.
=== Building the terrain ===
To build the terrain mesh, use the <code>genVPB.py</code> tool from inside the docker container:

Usage: genVPB.py --raster <input-raster> [ option ... ]
Usage: genVPB.py --bbox <lat0> <lon0> <lat1> <lon1> --sentinel --reclass <reclass> [ option ... ]

Arguments:
--raster RASTER Input landclass raster.
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--sentinel Use Sentinel2 landclass tiles
--sentinel-dir SENTINEL_DIR Directory for Sentinel Data. Default /home/flightgear/data/Sentinel-2
--hgt-dir HGT_DIR Directory containing HGT DEM files. Default /home/flightgear/data/NASADEM
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/output
--download-sentinel Download Sentinel2 tiles if needed
--reclass RECLASS Reclassify raster using file <reclass>. See ./scripts/mappings/
--coastline COASTLINE Clip against coastline against polygon (.osm)
--shrink-water SHRINK_WATER Shrink water bodies (landclasses 40, 41) by <pixels> pixels
--generate-water-raster Generate a water raster from OSM data
--generate-line-features Generate a water raster from OSM data
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--nasadem-server NASADEM_SERVER Set server to download NASADEM data from. Default https://e4ftl01.cr.usgs.gov/MEASURES/NASADEM_HGT.001/2000.02.11/)
--nasadem-user NASADEM_USER NASA Earthdata username.
--nasadem-password NASADEM_PASSWORD NASA Earthdata password.
--debug Debug output

For example, to generate a piece of terrain around Edinburgh (latitude 55.5, longitude 3 degrees West):
./scripts/genVPB.py --bbox 55 -4 56 -3 --raster ./data/uk_wgs84_10m_N54.tif

Another example, to generate a coastal area with shorelines and lakes, like Alaska:
./scripts/genVPB.py --bbox 68 -167 69 -152 --raster ./data/NLCD_2016_Alaska167-153_68_Smoothed-HD-Compressed_4326.tiff --hgt-dir ./SRTM-3/ --generate-water-raster --shrink-water 4 --coastline ./coastlines/land_polygons.shp

Same thing with roads and rails (line features):
./scripts/genVPB.py --bbox 68 -167 69 -152 --raster ./data/NLCD_2016_Alaska167-153_68_Smoothed-HD-Compressed_4326.tiff --hgt-dir ./SRTM-3/ --generate-water-raster --shrink-water 4 --coastline ./coastlines/land_polygons.shp --generate-line-features

--coastline requires OSM data mask from here [https://osmdata.openstreetmap.de/data/land-polygons.html OSM Shapefiles] Make sure you download the shapefiles on this page and not the alternate "Water polygons or Coastlines". It is the land cover shapefiles that are used as the cutting mask, not the water line data.

If you are using anything other than a CORINE raster you will need to reclassify the data to match the landclasses used by FlightGear. Those classes are defined in [https://gitlab.com/flightgear/fgdata/-/tree/next/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml]. You can reclassify them using the files in the [https://gitlab.com/flightgear/fgmeta/-/tree/next/ws30/mappings/ scripts/mappings] directory. E.g. to reclassify NLCD2019 data you can use <code>--reclassify ./scripts/mappings/nlcd2019.txt</code>.

genVPB.py will output the data to the output/vpb directory, in which you should find a series of files and directories.

=== Adding water ===
'''Update 05/12/2026: Depreciated, it is now built into genVPB.py above.'''

'''Use genVPB.py ...... --generate-water-raster --shrink-water 4 --coastline [path_to_shapefile_mask]'''

The terrain mesh does not have highly detailed water features - as typically the source data has a resolution of 10-25m. Water features are generated from OpenStreetMap data. To generate water features simply run the <code>genwaterraster.py</code> command.

Usage: genwaterraster.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--output-dir OUTPUT_DIR] [--cache-dir CACHE_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--output-dir OUTPUT_DIR Directory to write files into. Default /home/flightgear/output
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache

For example, to generate water for the area around Edinburgh:
./scripts/genwaterraster.py --bbox 55 -4 56 -3

Inside the ./output/vpb directory there should be a set of directories and .png files.

=== Adding roads and railways ===
The terrain mesh does not have any line features - things like roads. These are generated separately from OpenStreetMap data. To generate line features simply run the <code>genroads.py</code> command:

Usage: ./scripts/genroads.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--threads THREADS] [--cache-dir CACHE_DIR] [--output-dir OUTPUT_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--threads THREADS Number of parallel threads to run. Defaults to 1
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/cache/

For example, to generate roads for the area around Edinburgh:
./scripts/genroads.py --bbox 55 -4 56 -3

Inside the ./output/Terrain directory there should be a set of directories and, .STG files text files.

==Running FlightGear with the new WS3.0 Terrain==
To test the new terrain, simply include the output directory in your scenery path and run FlightGear with the <code>--prop:/scenery/use-vpb=true</code> to enable WS3.0.

== Advanced Techniques ==
The following sections describe more complex techniques to generate higher quality WS3.0 terrain. Almost all of them involve using different data sources to generate a more detailed landclass raster before running the final scenery generation processes described above. Generating a highly detailed landclass raster is where the magic happens.

Most techniques use gdal or grass to modify the raster/vector data, typically using the QGIS program.

=== Using a different elevation model ===
If you are using another elevation model other than NASAEM, then you may need to re-project it using QGIS/gdalwarp to the WGS84 CRS (aka EPSG:4326).

=== Landclass Data Requirements ===
For any landclass data we need to ensure the data is in the correct format. That means:

# Is a Raster (geotiff) rather than Vector data. This raster will become the texture on the terrain that the terrain shaders do their magic on.
# Uses the WGS84 Coordinate Reference System. The ensures that the terrain generation step is efficient.
# Has the correct landclass values for each terrain type. We use a set of values based on the CORINE raster set, defined in [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml].

Below is a quick table showing what steps you need to take for common landclass data sources.
{| class="wikitable"
|+
!Landclass Data
!Warp to WGS84 required?
!Landclass re-classification Required?
!Raster Simplification Required?
!Conversion to Raster Required?
|-
|CORINE Raster
|Yes
|No
|No
|No
|-
|CORINE Vector
|Yes
|Yes
|No
|Yes
|-
|NLCD
|No
|Yes
|Yes
|No
|-
|Sentinel-2
|Yes
|Yes
|No
|No
|}
Conversion to Raster must be done manually. Converting to WGS84 and the correct landclasses ''can'' be done by the genVPB.py script, but slows down scenery generation. Therefore if you are planning to generate scenery multiple times it is best to pre-process the files yourself.

The easiest way to do these operations is using QGIS, which is available for most platforms. If you are scripting a toolchain, the QGIS tools include command-line equivalents for all commands.

When using QGIS, set the Project CRS to WGS84 (aka EPSG:4326). You can then add layers of Raster or Vector data from files from the <code>Layer->Add Layer</code> menu. When performing any operations, <u>always</u> write out the data to a real file so you can go back to it later. Disk space is cheap :).

=== Warping Raster Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a raster layer to a different CRS using the Raster->Projections-Warp (Reproject) tool.

Select the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Resampling Method to Use - Nearest Neighbour. (Landclass data is not like normal images. You don't want to interpolate between values.)
* Nodata value for output bands - 0.0 (This means that any data at the edges will be Ocean, usually a reasonable default)
* Advanced Parameters - No Compression
* Output data type - Byte
* Reprojected - Choose a target filename

Alternatively you can do this step from the commandline.
gdalwarp -t_srs EPSG:4326 -dstnodata 0.0 -r near -ot Byte -of GTiff -co COMPRESS=NONE -co BIGTIFF=IF_NEEDED /home/stuart/FlightGear/VPB/data/CORINE/u2018_clc2018_v2020_20u1_raster100m/DATA/U2018_CLC2018_V2020_20u1.tif /home/stuart/FlightGear/VPB/data/scratch/corine_WGS84.tif

=== Warping Vector Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a vector layer using Vector->Data Management Tools->Reproject Layer.

Set the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Reprojected - Choose a target filename

=== Reclassifying Vector Layers ===
For CORINE vector data in particular, the attributes used in the vector data are not the same as those used by the CORINE Raster data. So we need to create a new attribute on the data.
[[File:Field Calculator.png|thumb|QGIS Field Calculator]]
To do this

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialog
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type "Whole Number (Integer)". This will create a new column which we will populate with the correct landclass data
* Click on the <code>Open Field Calculator</code> button (Ctrl + I). (If you get an error about only being able to create Virtual fields, go back to the Layer menu, export it and open the exported file).
* Select the following options:
** Update Existing Field
** Select the Landclass field you just created.
** Copy the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/corine_vector.txt into the Expression box (without the comment lines starting with <code>#</code>). This is just some simple code to set the attribute correctly. The code should be correct for CORINE vector data. If your data is from other sources you will need to work out how you want to map your source data landclasses to the CORINE ones. [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml] can be used as a guide.
* Select <code>OK</code>. You should see that your landclass column is now populated with the landclass data.
* Select <code>Layer->Save Layer Edits</code> to save you changes

=== Creating a Raster from a Vector Layer ===
To create a Raster from a Vector Layer select <code>Raster->Conversion->Rasterize (Vector to Raster)</code>.
[[File:QGIS Rasterize (Vector to Raster).png|thumb|Creating a Raster from a Vector Layer - QGIS Rasterize]]
Select the following options:

* Input Layer - correct layer, check CRS
* Field to use for burn-in value - select the <code>Landclass</code> column you created above.
* Output raster size units. This is going to set the resolution of your raster. You can work out the resolution in two different ways:
** Select "Georeferenced units" and determine how many degrees each pixel is in latitude and longitude.
** Select "Pixels" and determine the size of raster you want in pixels. [https://www.nhc.noaa.gov/gccalc.shtml This] is a good calculator to help. You input e.g. SE and SW coordinates and calculate to get the distance in Km. Then you multiply by thousand and devide by the number of metres per pixel (e.g. 5) -> resolution for width.
* Width/Horizontal Resolution. Enter the values you've calculated for the horizontal resolution (longitudinal), or the width of the raster
* Height/Vertical Resolution. Enter the values you've calculated for the vertical resolution (latitude or the height of the raster)
* Output extent - Select an option from the box on the right. You can edit the text afterwards (NB: East, West, South, North). Best practise is to create long thin strips of 1 degree latitude in height, as this makes subsequent processing much easier.
* Assign a specific nodata value to output bands - Select 0.0 for Ocean. CORINE vector data in particular has a lot of nodata for Oceans
* Advanced Parameters - No Compression
* Output data type - Byte
* Rasterized - Select a new filename

=== Simplifying a Raster Layer ===
Some Raster Landclass data (NLCD included) has too much noise - in particular large US highway systems are identified as Urban areas.

To smooth it out we can use the GRASS <code>n.neighbors</code> function from the Processing Toolbox in QGIS.

Select the following options:

* Input Layer - correct layer, check CRS
* Neighborhood operation - median. (This is not a normal image, so using an average will result in weird values)
* Neighborhood size - 5.
* Neighbors - Select a new filename.

=== Clipping a Raster Layer with OSM Data for Land (Corine) ===
The Corine dataset does not match OSM coastlines exactly. The following multi-stage process makes sure, that no Corine land-use is in the water as defined by OSM.

==== Download OSM Land Data ====

Download land polygons based on OSM data as a Shapefile from [https://osmdata.openstreetmap.de/data/land-polygons.html Land Polygons] and make sure to pick the WGS84 projected download with split polygons ("Large polygons are split, use for larger scales"). Once downloaded unzip the content into a directory.

==== Reclassifying the OSM Land Data Vector Layer ====
I QGIS make sure that only the layer for the raster for land data is selected (e.g. <code>land-polygons-split-4326</code>) -> in the map view you will see the whole earth. NB: typically you do this reclassify only once after download and can reuse the result for future processing.

Then:

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialogue
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type <code>Integer (32 bit)</code>. This will create a new column which we will populate with the correct land class data
* On top of the table on the left side choose "Landclass" in the drop-down menu, then input <code>2</code> into the field to the right and then press button "Update" all to the left of this field.
* Wait a bit and the close the dialogue.
* Select <code>Layer->Save Layer Edits</code> to save your changes (overwrite e.g. <code>land-polygons-split-4326</code>).

==== Convert the Land Data from Vector to Raster ====
Do the same as in chapter "Creating a Raster from a Vector Layer" above. The only difference is that the Input layer will be the land data polygons and you need to choose a different file name for the "Rasterized" (e.g. osm_land_scotland_5m.tif)

==== Remove Novalue Entries in the Land Data Raster ====
To do this:

* Select <code>Processing->Toolbox</code>. You should see a new box on the right side.
* Write "gdal_calc" in the search box and you should see an entry "Raster calculator". Double click on it and you will get a new dialogue window.
* In this dialogue:
** For "Input layer A" choose the raster from the previous chapter ((e.g. osm_land_scotland_5m.tif)
** In field "Calculation in gdalnumeric ..." write: <code>greater(A,0) * A</code>
** In field "Output raster type" choose <code>Byte</code>
** In field "Advanced Parameters" choose Profile <code>No compression</code>
** In field "Additional command-line parameters" write: <code>--hideNoData</code>
** In field "Calculated" choose a file (e.g. osm_land_scotland_allvalues_5m.tif)
** (In the "GDAL/OGR console call" it will have something similar to the follwing - just with different paths: <code>gdal_calc.py --overwrite --calc "greater(A ,0) * A" --format GTiff --type Byte -A /home/vanosten/custom-fg-scenery/data/osm_land_scotland_5m.tif --A_band 1 --co COMPRESS=NONE --co BIGTIFF=IF_NEEDED --hideNoData --outfile /home/vanosten/custom-fg-scenery/data/osm_land_scotland_allvalues_5m.tif</code>
** Press the "Run" button - and when complete close the dialogue.

You should now see a map only black and white. You can check for correctness by pressing <code>CTRL+SHIFT+I</code> to get a cursor with an arrow and an "i". First make sure the new raster is selected on the left side. Next click on the sea/ocean and then check in the "Identify Results" window on the right that the value is < 2. The click on the land and check that the value is 2.

==== Create the Final Clipped Corine Raster Against OSM Land Data =====
Do the following:

* In QGIS make sure that you have only the following two layers: the basis Corine raster (see chapter "Creating a Raster from a Vector Layer" - here e.g. corine_raster_scotland_5m.tif) and plus the raster from the previous step (e.g. osm_land_scotland_allvalues_5m.tif)
* Select <code>Raster->Raster Calculator ...</code> and a corresponding dialogue will open showing on the left hand side the two rasters.
* Choose a new "Output layer" (e.g. corine_raster_scotland_clipped_5m.tif).
* In the "Raster Calculator Expression" field input: <code>if ("osm_land_scotland_all_data_5m@1" < 2, 44, "corine_raster_scotland_5m@1")</code>
* Press button "OK" and wait a while (you will see a new dialogue with showing the progress.

Done. You have now a raster (e.g. corine_raster_scotland_clipped_5m.tif) which does not have land in areas, where OSM data has sea/ocean.

=== Reclassifying a Raster Layer ===
WS3.0 uses CORINE landclass values. If using data from other sources it needs to be reclassified to the correct values. genVPB.py has an option to do this, but you may wish to do so manually.

To do this select <code>GRASS->Raster->r.reclass</code> from the Processing Toolbox.

Select the following options:

* Input Raster Layer - correct layer, check CRS
* Reclass rules text - copy in the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/nlcd2019.txt. Or an appropriate mapping from your landclass data to CORINE. Note that you can also reference a file using the "File containing reclass rules" option. Note a mapping of 22 24 = 1 is the same as 22 and 24 = 1. For a range of 22 to 24 use 22 23 24 = 1.
* Reclassified - Select a new filename.

(If this doesn't work a similar function is available in the Processing Toolbox under <code>Raster analysis->Reclassify by table</code>. However this doesn't save your table once you close the dialog, and entries have to be manually entered individually which takes a lot of effort)

=== Processing NLCD for USA using the Raster Calculator and tools in QGIS ===

[[Processing_NLCD_for_USA_using_Raster_Calculator_and_tools_in_QGIS]]

=== Python script to process NLCD for the USA in the QGIS Python Editor ===

[[Python_script_to_process_NLCD_for_the_USA]]

=== Python script to process Sentinel-2 data ===

[[Python_script_to_process_Sentinel-2_data]]

=== Python script plus Grass to process NLCD data (also in batch) ===

[[Pure_Python_script_to_process_NLCD_for_the_USA_(does_not_require_using_QGIS_Python_Console)]]

===Generating the Terrain using osgdem===
Instead of using genVPB.py, you may wish to run osgdem directly.

In the Windows/Docker platform you can send the generate tile command directly to osgdem.exe, one tile at a time.

Using the NLCD raster processing convention from above, following is the the final step after creating the raster and entering bash shell with the windows version of "docker run..."

osgdem --TERRAIN --image-ext png --RGBA --no-interpolate-imagery --disable-error-diffusion --geocentric --no-mip-mapping -t ./data/California-Southern_4326-84-hd-corrected.tiff -d ./SRTM-3/N32W115.hgt -b -115 32 -114 33 --PagedLOD -l 7 --radius-to-max-visible-distance-ratio 3 -o ./output/vpb/w120n30/w115n32/ws_w115n32.osgb

Note: the --image-ext png --RGBA flags are critical to successfully building correctly placed landclasses in the final VPB generated scenery.

If you prefer to run the scenery generation manually, running the VPB osgdem process is described in more detail here: [[Virtual Planet Builder#Running VPB]].

After doing this you should have an output directory containing files of the form <code>output/vpb/w010n50/w004n50/ws_w004n50.osgb</code>, plus a host of sub-directories. Each one of these is a 1x1 tile of terrain.

to leave the container simply type <code>exit</code>.

===Packaging the Scenery===
Once you have the terrain and line features they should be packaged in a scenery directory in vpb and Terrain sub-directories respectively. E.g.
MyCoolScenery/Terrain
MyCoolScenery/vpb
It is good practise to document the data sources used in scenery generation. Some source licenses require attribution of the original data source for anything derived, published or distributed.

To assist in fulfilling these license obligations, you can create a source.xml file in the scenery directory which includes attribution information. This will then be available from within the simulator under Help->Scenery Sources, and <u>may</u> fulfil the attribution requirements of your license. '''Note that you are responsible for fulfilling any license requirements from the data, not FlightGear'''.

The format of the file is straightforward:
<?xml version="1.0"?>
<PropertyList>
<nowiki><source></nowiki>
<name>Corine Land Cover (CLC) 2018, Version 2020_20u1</name>
<nowiki><link></nowiki><nowiki>http://web.archive.org/web/20221112175615/https://land.copernicus.eu/pan-european/corine-land-cover/clc2018?tab=metadata%2A</nowiki><nowiki></link></nowiki>
<license>GMES Open License</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>NASADEM Merged DEM Global 1 arc second V001</name>
<nowiki><link></nowiki><nowiki>https://www.earthdata.nasa.gov/</nowiki><nowiki></link></nowiki>
<license>Public Domain</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>OpenStreetMap</name>
<nowiki><link></nowiki><nowiki>https://www.openstreetmap.org/copyright</nowiki><nowiki></link></nowiki>
<license>Open Data Commons Open Database License</license>
<nowiki></source></nowiki>
</PropertyList>

Python script to process NLCD for the USA

2026-05-20T17:14:47Z

Wlbragg: /* Batch script for multiple processes */

Pure Python script to process NLCD for the USA (does not require using QGIS Python Console)

2026-05-20T17:14:40Z

Wlbragg: Created page with "=== Pure Python script to process NLCD for the USA (does not require using QGIS Python Console) === This has been tested in Linux, it may or may not need modification to run under Windows OS. USAGE: python3 gen-scenery.py --part 89-86_29 --canopy 41 <syntaxhighlight lang="python"> #!/usr/bin/env python3 import os import subprocess import argparse import tempfile from pathlib import Path from osgeo import gdal # ----------------- CONFIG ----------------- BASE_PATH =..."

=== Pure Python script to process NLCD for the USA (does not require using QGIS Python Console) ===

This has been tested in Linux, it may or may not need modification to run under Windows OS.

USAGE: python3 gen-scenery.py --part 89-86_29 --canopy 41

<syntaxhighlight lang="python">
#!/usr/bin/env python3
import os
import subprocess
import argparse
import tempfile
from pathlib import Path
from osgeo import gdal

# ----------------- CONFIG -----------------

BASE_PATH = Path("/media/wayne/TOSHIBA-EXT/Scenery/ws3.0")
YEAR = "2023"
STATE = "Alabama"

# upsampling / smoothing
PERCENTAGE = 11.0
SIZE = 21

# GRASS binary
GRASS_BIN = "grass"

# ----------------- ARGUMENT PARSING -----------------

# USAGE: python3 gen-scenery.py --part 89-86_29 --canopy 41

#NLCD
# Choose the dominent canopy for the area being processed
# Areas not covered in the Tree Canopy layer will convert retain their original class
#41 = DeciduousForest
#42 = EvergreenForest
#43 = MixedForest

#FG equivalent
#22 = AgroForest
#23 = DeciduousBroadCover
#24 = EvergreenForest
#25 = MixedForest

parser = argparse.ArgumentParser()
parser.add_argument("--part", required=True, help="Tile part ID, e.g. 89-86_29")
parser.add_argument("--canopy", required=True, type=int, help="Tree canopy FG class")
args = parser.parse_args()

PART = args.part
CANOPY = args.canopy

# ----------------- HELPERS -----------------

def run(cmd, check=True, env=None):
print(">>", " ".join(str(c) for c in cmd))
subprocess.run(cmd, check=check, env=env)

def gdal_calc(args):
fixed = []
for a in args:
if a.startswith("--") and "=" in a:
key, val = a.split("=", 1)
fixed.append(key)
fixed.append(val)
else:
fixed.append(a)

cmd = ["gdal_calc.py"] + fixed + ["--overwrite"]
run(cmd)

def gdalwarp(input_path, output_path, t_srs="EPSG:4326",
resampling="near", dtype="Byte", extra=None):
cmd = [
"gdalwarp",
"-t_srs", t_srs,
"-r", resampling,
"-ot", dtype,
"-overwrite",
input_path,
output_path
]
if extra:
cmd.extend(extra)
run(cmd)

def gdal_translate(input_path, output_path,
nodata=0, dtype="Byte", compress="LZW"):
cmd = [
"gdal_translate",
"-a_nodata", str(nodata),
"-ot", dtype,
"-co", f"COMPRESS={compress}",
input_path,
output_path
]
run(cmd)

# ----------------- GRASS SESSION -----------------

# Create a temporary GRASS location with PERMANENT mapset
TMPDIR = tempfile.mkdtemp(prefix="grass_job_")
GRASS_LOCATION = os.path.join(TMPDIR, "location")

# Create the location
subprocess.run([
GRASS_BIN,
"-c", "EPSG:4326",
GRASS_LOCATION,
"--exec", "echo", "Location created"
], check=True)

# The active mapset is PERMANENT
GRASS_MAPSET = os.path.join(GRASS_LOCATION, "PERMANENT")

def grass_exec(args):
cmd = [GRASS_BIN, GRASS_MAPSET, "--exec"] + args
print(">>", " ".join(cmd))
subprocess.run(cmd, check=True)

def grass_exec(args):
cmd = [GRASS_BIN, GRASS_MAPSET, "--exec"] + args
print(">>", " ".join(cmd))
subprocess.run(cmd, check=True)

def grass_r_neighbors(input_raster, output_raster,
method="median", size=7):
in_name = "in_rast"
out_name = "out_rast"

grass_exec([
"r.in.gdal",
f"input={input_raster}",
f"output={in_name}",
"--overwrite"
])

grass_exec([
"g.region",
f"raster={in_name}"
])

grass_exec([
"r.neighbors",
f"input={in_name}",
f"output={out_name}",
f"method={method}",
f"size={size}",
"--overwrite"
])

grass_exec([
"r.out.gdal",
"-f",
f"input={out_name}",
f"output={output_raster}",
"format=GTiff",
"type=Byte",
"--overwrite"
])

def p(*parts):
return str(BASE_PATH.joinpath(STATE, *parts))

# ----------------- STEPS -----------------

def step1_tree_canopy_reclass():
src = p("data", "source", f"NLCD_{YEAR}_Tree_Canopy_{STATE}{PART}.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Trees-Combined.tiff")

expr = f"((A > 0) & (A < 255)) * {CANOPY} + (A <= 0) * A"
gdal_calc([
"-A", src,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 1: Trees-Combined")

def step2_warp_tree_canopy_4326():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Trees-Combined.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Canopy_4326.tiff")
gdalwarp(src, dst)
print("Step 2: Tree_Canopy_4326")

def step3_warp_land_cover_4326():
src = p("data", "source", f"NLCD_{YEAR}_Land_Cover_{STATE}{PART}.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Land_Cover_4326.tiff")
gdalwarp(src, dst)
print("Step 3: Land_Cover_4326")

def step4_combine_tree_land_4326():
a = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Canopy_4326.tiff")
b = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Land_Cover_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Land_Combined_4326.tiff")

expr = (
"(((B > 0) & (B < 255)) & (B != 41) & (B != 42) & (B != 43) & (A > 0)) * A + "
"((B == 41) | (B == 42) | (B == 43) | (A <= 0)) * B"
)
gdal_calc([
"-A", a,
"-B", b,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 4: Tree_Land_Combined_4326")

def step5_replace_urban_clutter_with_grass():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Land_Combined_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Grass-Only_4326.tiff")

expr = (
"(A == 0) * 44 + "
"(A == 11) * 41 + "
"(A == 12) * 34 + "
"(A == 21) * 26 + "
"(A == 22) * 26 + "
"(A == 23) * 26 + "
"(A == 24) * 26 + "
"(A == 31) * 27 + "
"(A == 41) * 23 + "
"(A == 42) * 24 + "
"(A == 43) * 25 + "
"(A == 51) * 30 + "
"(A == 52) * 29 + "
"(A == 71) * 26 + "
"(A == 72) * 32 + "
"(A == 73) * 31 + "
"(A == 74) * 31 + "
"(A == 75) * 32 + "
"(A == 81) * 18 + "
"(A == 82) * 19 + "
"(A == 90) * 25 + "
"(A == 95) * 35"
)
gdal_calc([
"-A", src,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 5: Grass-Only_4326")

def step6_reclass_urban():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Land_Combined_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Reclassed-Urban_4326.tiff")

expr = (
"(A == 21)*10 + "
"(A == 22)*1 + "
"(A == 23)*2 + "
"(A == 24)*3"
)
gdal_calc([
"-A", src,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 6: Reclassed-Urban_4326")

def step7_remove_clutter_roads_from_urban():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Reclassed-Urban_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Urban-Only_4326.tiff")

grass_r_neighbors(src, dst, method="median", size=7)
print("Step 7: Urban-Only_4326")

def step8_combine_grass_and_clean_urban():
a = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Urban-Only_4326.tiff")
b = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Grass-Only_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean_4326.tiff")

expr = "((A > 0) & (B > 0)) * A + ((A <= 0) | (B <= 0)) * B"
gdal_calc([
"-A", a,
"-B", b,
"--outfile", dst,
"--calc", expr,
"--NoDataValue", "0",
"--type", "Byte"
])
print("Step 8: Combined-Clean_4326")

def step9_upsample_to_hd():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean-HD_4326.tiff")

ds = gdal.Open(src)
if ds is None:
raise RuntimeError(f"Cannot open {src}")
gt = ds.GetGeoTransform()
original_xRes = gt[1]
original_yRes = abs(gt[5])

new_xRes = original_xRes / PERCENTAGE
new_yRes = original_yRes / PERCENTAGE

gdal.Warp(
dst,
src,
xRes=new_xRes,
yRes=new_yRes,
outputType=gdal.GDT_Byte
)
print("Step 9: Combined-Clean-HD_4326")

def step10_smooth_all_features():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean-HD_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Smoothed-HD_4326.tiff")

grass_r_neighbors(src, dst, method="median", size=SIZE)
print("Step 10: Smoothed-HD_4326")

def step11_convert_to_8bit_compressed():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Smoothed-HD_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Smoothed-HD-Compressed_4326.tiff")

gdal_translate(src, dst)
print("Step 11: Smoothed-HD-Compressed_4326")

# ----------------- MAIN -----------------

def main():
step1_tree_canopy_reclass()
step2_warp_tree_canopy_4326()
step3_warp_land_cover_4326()
step4_combine_tree_land_4326()
step5_replace_urban_clutter_with_grass()
step6_reclass_urban()
step7_remove_clutter_roads_from_urban()
step8_combine_grass_and_clean_urban()
step9_upsample_to_hd()
step10_smooth_all_features()
step11_convert_to_8bit_compressed()

if __name__ == "__main__":
main()
</syntaxhighlight>

== Batch script for multiple processes ==
<syntaxhighlight lang="python">
#!/bin/bash

python3 gen-scenery.py --part 89-86_29 --canopy 41 &
python3 gen-scenery.py --part 89-86_30 --canopy 41 &
python3 gen-scenery.py --part 89-86_31 --canopy 41 &
python3 gen-scenery.py --part 89-86_32 --canopy 41 &
python3 gen-scenery.py --part 89-86_33 --canopy 41 &
python3 gen-scenery.py --part 89-86_34 --canopy 41 &

wait
echo "All scenery jobs completed."
</syntaxhighlight>

Python script to process NLCD for the USA

2026-05-20T17:14:09Z

Wlbragg: /* Pure Python script to process NLCD for the USA (does not require using QGIS Python Console) */

Howto:Create WS3.0 terrain

2026-05-20T17:12:21Z

Wlbragg: /* Python script to process Sentinel-2 data */

{{WS30 Navbar}}
This article provides instructions on how to generate basic [[WS3.0]] terrain.

WS3.0 terrain consists of three parts:

# A terrain mesh consisting of a landclass texture draped over an elevation model.
# A high resolution water raster used to show water features such as rivers, lakes and coastline with more definition
# Line features such as roads and railways.

The terrain is generated by a set of tools that are packaged in a docker image for convenience.[[File:Diagram-export-21-12-2023-16 29 37.png|thumb|Basic WS3.0 Scenery Generation Process]]

== Prerequisites ==

=== Set up a Workspace ===
Create a directory with the following sub-directories:

* <code>cache</code>
* <code>data</code>
* <code>output/vpb</code>
* <code>output/Terrain</code>

=== Docker ===

# Install [https://docs.docker.com/get-started/ Docker] on your platform.
#Pull the docker image by running the following command

docker pull flightgear/ws30-vpb-generator:latest
Optionally, if you are hitting rate limits:
#Create an account on https://hub.docker.com/. (Note that you will need to click on an email verification link before you can log in for the first time)
#Run <code>docker login</code> before the '''docker pull''' command above

== Getting the base data ==
You need two pieces of data for the area of scenery you are generating:

# An elevation model (aka DEM). This indicates what altitude each point of the surface is.
# Landclass data showing what type of terrain is at each point of the surface. This is often either a Raster (effectively a texture), or vector data.

=== Elevation Model ===
Download the NASADEM elevation model for the area of scenery you wish to generate. This is available in 1x1 degree blocks from [https://lpdaac.usgs.gov/products/nasadem_hgtv001/ here], and with an interactive browser [https://search.earthdata.nasa.gov/search here].

Unzip the files into the <code>data</code> directory.

=== Landclass Raster ===
Download an landclass raster for the area of scenery you wish to generate.

* For Europe, use of [https://land.copernicus.eu/pan-european/corine-land-cover/clc2018 CORINE] is recommended.
* For the USA [https://www.mrlc.gov/viewer/ NLCD] is recommended
* Sentinel-2 data is available for the entire world via [https://livingatlas.arcgis.com/landcoverexplorer/ ESRI], but has limited set of landclasses.

Put these into the <code>data</code> directory.

More detailed terrain can be created by modifying the landclass raster, and/or generating a new raster from vector data. These processes are discussed below.

== Generating Terrain ==
To generate terrain you need to run the tools within the docker container we installed above. The docker image is like a small, independent virtual computing environment running within your system. This particular docker image has all the scenery generation tools already installed.

=== Running the docker container ===
Firstly, get the container running from the directory containing your <code>cache</code>, <code>data</code> and <code>output</code> directories:
docker run --rm --mount "type=bind,source=`pwd`/data,target=/home/flightgear/data,readonly" --mount "type=bind,source=`pwd`/output,target=/home/flightgear/output" --mount "type=bind,source=`pwd`/cache,target=/home/flightgear/cache" -it flightgear/ws30-vpb-generator:latest /bin/bash

You should now find yourself in a bash shell within your container. You should see data and output directories which are linked to the directories you created earlier:
flightgear@ddcac77f7d5e:~$ ls
cache data output bin scripts
In the Windows environment using Docker Desktop, if you need a path to a source of elevation data and a path to the OSM shoreline shapefiles, you can add the following:
docker run --rm --mount "type=bind,source=G:/Scenery/ws3.0/Alabama/data,target=/home/flightgear/data,readonly" --mount "type=bind,source=G:/Scenery/WS3.0-extra/vector/land-polygons-complete-4326,target=/home/flightgear/coastlines" --mount "type=bind,source=G:/Scenery/WS3.0-extra/SRTM-1,target=/home/flightgear/SRTM-3,readonly" --mount "type=bind,source=G:/Scenery/ws3.0/Alabama/output,target=/home/flightgear/output" --mount "type=bind,source=G:/Scenery/ws3.0/Alabama/output/cache,target=/home/flightgear/cache" -it flightgear/ws30-vpb-generator:latest /bin/bash

Note: the --mount "type=bind,source=G:/Scenery/WS3.0-extra/SRTM-1,target=/home/flightgear/SRTM-3,readonly", the genVPB.py script in the Docker container is expecting a location of /home/flightgear/SRTM-3 for the elevation data. In this example I am using SRTM-1 elevation data, but we still map it to the expected /home/flightgear/SRTM-3 Docker container location.
=== Building the terrain ===
To build the terrain mesh, use the <code>genVPB.py</code> tool from inside the docker container:

Usage: genVPB.py --raster <input-raster> [ option ... ]
Usage: genVPB.py --bbox <lat0> <lon0> <lat1> <lon1> --sentinel --reclass <reclass> [ option ... ]

Arguments:
--raster RASTER Input landclass raster.
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--sentinel Use Sentinel2 landclass tiles
--sentinel-dir SENTINEL_DIR Directory for Sentinel Data. Default /home/flightgear/data/Sentinel-2
--hgt-dir HGT_DIR Directory containing HGT DEM files. Default /home/flightgear/data/NASADEM
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/output
--download-sentinel Download Sentinel2 tiles if needed
--reclass RECLASS Reclassify raster using file <reclass>. See ./scripts/mappings/
--coastline COASTLINE Clip against coastline against polygon (.osm)
--shrink-water SHRINK_WATER Shrink water bodies (landclasses 40, 41) by <pixels> pixels
--generate-water-raster Generate a water raster from OSM data
--generate-line-features Generate a water raster from OSM data
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--nasadem-server NASADEM_SERVER Set server to download NASADEM data from. Default https://e4ftl01.cr.usgs.gov/MEASURES/NASADEM_HGT.001/2000.02.11/)
--nasadem-user NASADEM_USER NASA Earthdata username.
--nasadem-password NASADEM_PASSWORD NASA Earthdata password.
--debug Debug output

For example, to generate a piece of terrain around Edinburgh (latitude 55.5, longitude 3 degrees West):
./scripts/genVPB.py --bbox 55 -4 56 -3 --raster ./data/uk_wgs84_10m_N54.tif

Another example, to generate a coastal area with shorelines and lakes, like Alaska:
./scripts/genVPB.py --bbox 68 -167 69 -152 --raster ./data/NLCD_2016_Alaska167-153_68_Smoothed-HD-Compressed_4326.tiff --hgt-dir ./SRTM-3/ --generate-water-raster --shrink-water 4 --coastline ./coastlines/land_polygons.shp

Same thing with roads and rails (line features):
./scripts/genVPB.py --bbox 68 -167 69 -152 --raster ./data/NLCD_2016_Alaska167-153_68_Smoothed-HD-Compressed_4326.tiff --hgt-dir ./SRTM-3/ --generate-water-raster --shrink-water 4 --coastline ./coastlines/land_polygons.shp --generate-line-features

--coastline requires OSM data mask from here [https://osmdata.openstreetmap.de/data/land-polygons.html OSM Shapefiles] Make sure you download the shapefiles on this page and not the alternate "Water polygons or Coastlines". It is the land cover shapefiles that are used as the cutting mask, not the water line data.

If you are using anything other than a CORINE raster you will need to reclassify the data to match the landclasses used by FlightGear. Those classes are defined in [https://gitlab.com/flightgear/fgdata/-/tree/next/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml]. You can reclassify them using the files in the [https://gitlab.com/flightgear/fgmeta/-/tree/next/ws30/mappings/ scripts/mappings] directory. E.g. to reclassify NLCD2019 data you can use <code>--reclassify ./scripts/mappings/nlcd2019.txt</code>.

genVPB.py will output the data to the output/vpb directory, in which you should find a series of files and directories.

=== Adding water ===
'''Update 05/12/2026: Depreciated, it is now built into genVPB.py above.'''

'''Use genVPB.py ...... --generate-water-raster --shrink-water 4 --coastline [path_to_shapefile_mask]'''

The terrain mesh does not have highly detailed water features - as typically the source data has a resolution of 10-25m. Water features are generated from OpenStreetMap data. To generate water features simply run the <code>genwaterraster.py</code> command.

Usage: genwaterraster.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--output-dir OUTPUT_DIR] [--cache-dir CACHE_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--output-dir OUTPUT_DIR Directory to write files into. Default /home/flightgear/output
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache

For example, to generate water for the area around Edinburgh:
./scripts/genwaterraster.py --bbox 55 -4 56 -3

Inside the ./output/vpb directory there should be a set of directories and .png files.

=== Adding roads and railways ===
The terrain mesh does not have any line features - things like roads. These are generated separately from OpenStreetMap data. To generate line features simply run the <code>genroads.py</code> command:

Usage: ./scripts/genroads.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--threads THREADS] [--cache-dir CACHE_DIR] [--output-dir OUTPUT_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--threads THREADS Number of parallel threads to run. Defaults to 1
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/cache/

For example, to generate roads for the area around Edinburgh:
./scripts/genroads.py --bbox 55 -4 56 -3

Inside the ./output/Terrain directory there should be a set of directories and, .STG files text files.

==Running FlightGear with the new WS3.0 Terrain==
To test the new terrain, simply include the output directory in your scenery path and run FlightGear with the <code>--prop:/scenery/use-vpb=true</code> to enable WS3.0.

== Advanced Techniques ==
The following sections describe more complex techniques to generate higher quality WS3.0 terrain. Almost all of them involve using different data sources to generate a more detailed landclass raster before running the final scenery generation processes described above. Generating a highly detailed landclass raster is where the magic happens.

Most techniques use gdal or grass to modify the raster/vector data, typically using the QGIS program.

=== Using a different elevation model ===
If you are using another elevation model other than NASAEM, then you may need to re-project it using QGIS/gdalwarp to the WGS84 CRS (aka EPSG:4326).

=== Landclass Data Requirements ===
For any landclass data we need to ensure the data is in the correct format. That means:

# Is a Raster (geotiff) rather than Vector data. This raster will become the texture on the terrain that the terrain shaders do their magic on.
# Uses the WGS84 Coordinate Reference System. The ensures that the terrain generation step is efficient.
# Has the correct landclass values for each terrain type. We use a set of values based on the CORINE raster set, defined in [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml].

Below is a quick table showing what steps you need to take for common landclass data sources.
{| class="wikitable"
|+
!Landclass Data
!Warp to WGS84 required?
!Landclass re-classification Required?
!Raster Simplification Required?
!Conversion to Raster Required?
|-
|CORINE Raster
|Yes
|No
|No
|No
|-
|CORINE Vector
|Yes
|Yes
|No
|Yes
|-
|NLCD
|No
|Yes
|Yes
|No
|-
|Sentinel-2
|Yes
|Yes
|No
|No
|}
Conversion to Raster must be done manually. Converting to WGS84 and the correct landclasses ''can'' be done by the genVPB.py script, but slows down scenery generation. Therefore if you are planning to generate scenery multiple times it is best to pre-process the files yourself.

The easiest way to do these operations is using QGIS, which is available for most platforms. If you are scripting a toolchain, the QGIS tools include command-line equivalents for all commands.

When using QGIS, set the Project CRS to WGS84 (aka EPSG:4326). You can then add layers of Raster or Vector data from files from the <code>Layer->Add Layer</code> menu. When performing any operations, <u>always</u> write out the data to a real file so you can go back to it later. Disk space is cheap :).

=== Warping Raster Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a raster layer to a different CRS using the Raster->Projections-Warp (Reproject) tool.

Select the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Resampling Method to Use - Nearest Neighbour. (Landclass data is not like normal images. You don't want to interpolate between values.)
* Nodata value for output bands - 0.0 (This means that any data at the edges will be Ocean, usually a reasonable default)
* Advanced Parameters - No Compression
* Output data type - Byte
* Reprojected - Choose a target filename

Alternatively you can do this step from the commandline.
gdalwarp -t_srs EPSG:4326 -dstnodata 0.0 -r near -ot Byte -of GTiff -co COMPRESS=NONE -co BIGTIFF=IF_NEEDED /home/stuart/FlightGear/VPB/data/CORINE/u2018_clc2018_v2020_20u1_raster100m/DATA/U2018_CLC2018_V2020_20u1.tif /home/stuart/FlightGear/VPB/data/scratch/corine_WGS84.tif

=== Warping Vector Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a vector layer using Vector->Data Management Tools->Reproject Layer.

Set the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Reprojected - Choose a target filename

=== Reclassifying Vector Layers ===
For CORINE vector data in particular, the attributes used in the vector data are not the same as those used by the CORINE Raster data. So we need to create a new attribute on the data.
[[File:Field Calculator.png|thumb|QGIS Field Calculator]]
To do this

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialog
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type "Whole Number (Integer)". This will create a new column which we will populate with the correct landclass data
* Click on the <code>Open Field Calculator</code> button (Ctrl + I). (If you get an error about only being able to create Virtual fields, go back to the Layer menu, export it and open the exported file).
* Select the following options:
** Update Existing Field
** Select the Landclass field you just created.
** Copy the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/corine_vector.txt into the Expression box (without the comment lines starting with <code>#</code>). This is just some simple code to set the attribute correctly. The code should be correct for CORINE vector data. If your data is from other sources you will need to work out how you want to map your source data landclasses to the CORINE ones. [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml] can be used as a guide.
* Select <code>OK</code>. You should see that your landclass column is now populated with the landclass data.
* Select <code>Layer->Save Layer Edits</code> to save you changes

=== Creating a Raster from a Vector Layer ===
To create a Raster from a Vector Layer select <code>Raster->Conversion->Rasterize (Vector to Raster)</code>.
[[File:QGIS Rasterize (Vector to Raster).png|thumb|Creating a Raster from a Vector Layer - QGIS Rasterize]]
Select the following options:

* Input Layer - correct layer, check CRS
* Field to use for burn-in value - select the <code>Landclass</code> column you created above.
* Output raster size units. This is going to set the resolution of your raster. You can work out the resolution in two different ways:
** Select "Georeferenced units" and determine how many degrees each pixel is in latitude and longitude.
** Select "Pixels" and determine the size of raster you want in pixels. [https://www.nhc.noaa.gov/gccalc.shtml This] is a good calculator to help. You input e.g. SE and SW coordinates and calculate to get the distance in Km. Then you multiply by thousand and devide by the number of metres per pixel (e.g. 5) -> resolution for width.
* Width/Horizontal Resolution. Enter the values you've calculated for the horizontal resolution (longitudinal), or the width of the raster
* Height/Vertical Resolution. Enter the values you've calculated for the vertical resolution (latitude or the height of the raster)
* Output extent - Select an option from the box on the right. You can edit the text afterwards (NB: East, West, South, North). Best practise is to create long thin strips of 1 degree latitude in height, as this makes subsequent processing much easier.
* Assign a specific nodata value to output bands - Select 0.0 for Ocean. CORINE vector data in particular has a lot of nodata for Oceans
* Advanced Parameters - No Compression
* Output data type - Byte
* Rasterized - Select a new filename

=== Simplifying a Raster Layer ===
Some Raster Landclass data (NLCD included) has too much noise - in particular large US highway systems are identified as Urban areas.

To smooth it out we can use the GRASS <code>n.neighbors</code> function from the Processing Toolbox in QGIS.

Select the following options:

* Input Layer - correct layer, check CRS
* Neighborhood operation - median. (This is not a normal image, so using an average will result in weird values)
* Neighborhood size - 5.
* Neighbors - Select a new filename.

=== Clipping a Raster Layer with OSM Data for Land (Corine) ===
The Corine dataset does not match OSM coastlines exactly. The following multi-stage process makes sure, that no Corine land-use is in the water as defined by OSM.

==== Download OSM Land Data ====

Download land polygons based on OSM data as a Shapefile from [https://osmdata.openstreetmap.de/data/land-polygons.html Land Polygons] and make sure to pick the WGS84 projected download with split polygons ("Large polygons are split, use for larger scales"). Once downloaded unzip the content into a directory.

==== Reclassifying the OSM Land Data Vector Layer ====
I QGIS make sure that only the layer for the raster for land data is selected (e.g. <code>land-polygons-split-4326</code>) -> in the map view you will see the whole earth. NB: typically you do this reclassify only once after download and can reuse the result for future processing.

Then:

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialogue
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type <code>Integer (32 bit)</code>. This will create a new column which we will populate with the correct land class data
* On top of the table on the left side choose "Landclass" in the drop-down menu, then input <code>2</code> into the field to the right and then press button "Update" all to the left of this field.
* Wait a bit and the close the dialogue.
* Select <code>Layer->Save Layer Edits</code> to save your changes (overwrite e.g. <code>land-polygons-split-4326</code>).

==== Convert the Land Data from Vector to Raster ====
Do the same as in chapter "Creating a Raster from a Vector Layer" above. The only difference is that the Input layer will be the land data polygons and you need to choose a different file name for the "Rasterized" (e.g. osm_land_scotland_5m.tif)

==== Remove Novalue Entries in the Land Data Raster ====
To do this:

* Select <code>Processing->Toolbox</code>. You should see a new box on the right side.
* Write "gdal_calc" in the search box and you should see an entry "Raster calculator". Double click on it and you will get a new dialogue window.
* In this dialogue:
** For "Input layer A" choose the raster from the previous chapter ((e.g. osm_land_scotland_5m.tif)
** In field "Calculation in gdalnumeric ..." write: <code>greater(A,0) * A</code>
** In field "Output raster type" choose <code>Byte</code>
** In field "Advanced Parameters" choose Profile <code>No compression</code>
** In field "Additional command-line parameters" write: <code>--hideNoData</code>
** In field "Calculated" choose a file (e.g. osm_land_scotland_allvalues_5m.tif)
** (In the "GDAL/OGR console call" it will have something similar to the follwing - just with different paths: <code>gdal_calc.py --overwrite --calc "greater(A ,0) * A" --format GTiff --type Byte -A /home/vanosten/custom-fg-scenery/data/osm_land_scotland_5m.tif --A_band 1 --co COMPRESS=NONE --co BIGTIFF=IF_NEEDED --hideNoData --outfile /home/vanosten/custom-fg-scenery/data/osm_land_scotland_allvalues_5m.tif</code>
** Press the "Run" button - and when complete close the dialogue.

You should now see a map only black and white. You can check for correctness by pressing <code>CTRL+SHIFT+I</code> to get a cursor with an arrow and an "i". First make sure the new raster is selected on the left side. Next click on the sea/ocean and then check in the "Identify Results" window on the right that the value is < 2. The click on the land and check that the value is 2.

==== Create the Final Clipped Corine Raster Against OSM Land Data =====
Do the following:

* In QGIS make sure that you have only the following two layers: the basis Corine raster (see chapter "Creating a Raster from a Vector Layer" - here e.g. corine_raster_scotland_5m.tif) and plus the raster from the previous step (e.g. osm_land_scotland_allvalues_5m.tif)
* Select <code>Raster->Raster Calculator ...</code> and a corresponding dialogue will open showing on the left hand side the two rasters.
* Choose a new "Output layer" (e.g. corine_raster_scotland_clipped_5m.tif).
* In the "Raster Calculator Expression" field input: <code>if ("osm_land_scotland_all_data_5m@1" < 2, 44, "corine_raster_scotland_5m@1")</code>
* Press button "OK" and wait a while (you will see a new dialogue with showing the progress.

Done. You have now a raster (e.g. corine_raster_scotland_clipped_5m.tif) which does not have land in areas, where OSM data has sea/ocean.

=== Reclassifying a Raster Layer ===
WS3.0 uses CORINE landclass values. If using data from other sources it needs to be reclassified to the correct values. genVPB.py has an option to do this, but you may wish to do so manually.

To do this select <code>GRASS->Raster->r.reclass</code> from the Processing Toolbox.

Select the following options:

* Input Raster Layer - correct layer, check CRS
* Reclass rules text - copy in the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/nlcd2019.txt. Or an appropriate mapping from your landclass data to CORINE. Note that you can also reference a file using the "File containing reclass rules" option. Note a mapping of 22 24 = 1 is the same as 22 and 24 = 1. For a range of 22 to 24 use 22 23 24 = 1.
* Reclassified - Select a new filename.

(If this doesn't work a similar function is available in the Processing Toolbox under <code>Raster analysis->Reclassify by table</code>. However this doesn't save your table once you close the dialog, and entries have to be manually entered individually which takes a lot of effort)

=== Processing NLCD for USA using the Raster Calculator and tools in QGIS ===

[[Processing_NLCD_for_USA_using_Raster_Calculator_and_tools_in_QGIS]]

=== Python script to process NLCD for the USA ===

[[Python_script_to_process_NLCD_for_the_USA]]

=== Python script to process Sentinel-2 data ===

[[Python_script_to_process_Sentinel-2_data]]

=== Python script plus Grass to process NLCD data (also in batch) ===

[[Pure_Python_script_to_process_NLCD_for_the_USA_(does_not_require_using_QGIS_Python_Console)]]

===Generating the Terrain using osgdem===
Instead of using genVPB.py, you may wish to run osgdem directly.

In the Windows/Docker platform you can send the generate tile command directly to osgdem.exe, one tile at a time.

Using the NLCD raster processing convention from above, following is the the final step after creating the raster and entering bash shell with the windows version of "docker run..."

osgdem --TERRAIN --image-ext png --RGBA --no-interpolate-imagery --disable-error-diffusion --geocentric --no-mip-mapping -t ./data/California-Southern_4326-84-hd-corrected.tiff -d ./SRTM-3/N32W115.hgt -b -115 32 -114 33 --PagedLOD -l 7 --radius-to-max-visible-distance-ratio 3 -o ./output/vpb/w120n30/w115n32/ws_w115n32.osgb

Note: the --image-ext png --RGBA flags are critical to successfully building correctly placed landclasses in the final VPB generated scenery.

If you prefer to run the scenery generation manually, running the VPB osgdem process is described in more detail here: [[Virtual Planet Builder#Running VPB]].

After doing this you should have an output directory containing files of the form <code>output/vpb/w010n50/w004n50/ws_w004n50.osgb</code>, plus a host of sub-directories. Each one of these is a 1x1 tile of terrain.

to leave the container simply type <code>exit</code>.

===Packaging the Scenery===
Once you have the terrain and line features they should be packaged in a scenery directory in vpb and Terrain sub-directories respectively. E.g.
MyCoolScenery/Terrain
MyCoolScenery/vpb
It is good practise to document the data sources used in scenery generation. Some source licenses require attribution of the original data source for anything derived, published or distributed.

To assist in fulfilling these license obligations, you can create a source.xml file in the scenery directory which includes attribution information. This will then be available from within the simulator under Help->Scenery Sources, and <u>may</u> fulfil the attribution requirements of your license. '''Note that you are responsible for fulfilling any license requirements from the data, not FlightGear'''.

The format of the file is straightforward:
<?xml version="1.0"?>
<PropertyList>
<nowiki><source></nowiki>
<name>Corine Land Cover (CLC) 2018, Version 2020_20u1</name>
<nowiki><link></nowiki><nowiki>http://web.archive.org/web/20221112175615/https://land.copernicus.eu/pan-european/corine-land-cover/clc2018?tab=metadata%2A</nowiki><nowiki></link></nowiki>
<license>GMES Open License</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>NASADEM Merged DEM Global 1 arc second V001</name>
<nowiki><link></nowiki><nowiki>https://www.earthdata.nasa.gov/</nowiki><nowiki></link></nowiki>
<license>Public Domain</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>OpenStreetMap</name>
<nowiki><link></nowiki><nowiki>https://www.openstreetmap.org/copyright</nowiki><nowiki></link></nowiki>
<license>Open Data Commons Open Database License</license>
<nowiki></source></nowiki>
</PropertyList>

Python script to process NLCD for the USA

2026-05-20T17:02:34Z

Wlbragg: /* Pure Python script to process NLCD for the USA (does not require using QGIS Python Console) */

=== Python script to process NLCD for the USA in the QGIS Python Console ===
You can process the NLCD by loading this script in the python console of the QGIS Desktop program.
This python script method produces more refined data than by using the python calculator method above and it is more automated.
If you run this script outside the python console you will need to modify it to locate the data you are processing.
If you save the NLCD tiff's using the same consistent naming convention used in this example it is fairly simple to generate final WS3.0 tiff's to use to generate the scenery.

NOTE: the current genVPB.py script (osgdem) will not generate the final scenery water/land edge to this high of a resolution. It is set to a default tile size of 256x256, "--tile-image-size 256". This resolution is much higher than that. To achieve the same base resolution in the built scenery, osgdem needs a switch to "--tile-image-size 1024" to realize the higher resolution. However, when you apply the water mask flags --generate-water-raster --shrink-water 4 --coastline [path_to_coastal_shapefiles] using genVPB.py the cut mask will achieve the higher resolution.

You will start with an original tree layer and a land cover layer from the MRLC.gov site. See the section "Obtaining NLCD" in the above "Step By Step Procedure for Processing NLCD for the USA using the Raster Calculator" topic.

For example, to start with you will have a couple files named...

NLCD_2021_Tree_Canopy_Alaska141-140_60.tiff

NLCD_2021_Land_Cover_Alaska141-140_60.tiff

In the QGIS program the layer names you start with will be...

NLCD_2021_Tree_Canopy_Alaska141-140_60

NLCD_2021_Land_Cover_Alaska141-140_60

which will refer to the tiff files.

Running this script will generate a bunch of intermediate files including the last file, that will be the final finished file for running in the VPB script or VPB build environment Docker image.

The last file for this example for Alaska would be, NLCD_2021_Alaska141-140_60_Smoothed-HD-Compressed_4326.tiff

<syntaxhighlight lang="python">
from qgis.core import QgsApplication, QgsCoordinateTransform, QgsProject, QgsRasterLayer, QgsCoordinateReferenceSystem, QgsProcessingException, QgsRasterBlock, QgsRectangle
from qgis.analysis import QgsRasterCalculator, QgsRasterCalculatorEntry
from qgis import processing
from processing.core.Processing import Processing
from osgeo import gdal, osr, ogr
import os
import numpy
import numpy as np
import subprocess

# Define input layer names, change according to your file names
path = 'G:/Scenery/ws3.0/';
year = '2021';
state = 'Alaska';
part = '141-140_60';

# Ratio of upsampling to smoothing
percentage = 8
size = 11

################################## IMPORTANT ###############################
# Beginning filename of the NLCD from the source needs to be
# NLCD_' + year + '_Tree_Canopy_' + state + part + '.tiff'
# Also note that "/data/" is hardcoded into the path as well
# I needed the existing path structure to process it by state.
# For Alaska I used one lat and a few lon sections per chunck built.
# I will likely do the entire NLCD coverage area the same in future runs.
# Example beginning NLCD source:
# NLCD_2021_Tree_Canopy_Alaska141-140_60.tiff
# NLCD_2021_Land_Cover_Alaska141-140_60.tiff
# Full path and filename to source example is:
# G:/Scenery/ws3.0/Alaska/data/source/NLCD_2021_Tree_Canopy_Alaska141-140_60.tiff
# G:/Scenery/ws3.0/Alaska/data/source/NLCD_2021_Land_Cover_Alaska141-140_60.tiff
# Final output path to last processed file is:
# G:/Scenery/ws3.0/Alaska/data/NLCD_2021_Alaska141-140_60_Smoothed-HD-Compressed_4326
############################################################################

##################### Step 1: Reclass tree canopy to one landcover type 41, 42, or 43 #####################
#FG NLCD
#23 DeciduousBroadCover 41
#24 EvergreenForest 42
#25 MixedForest 43

# Define input and output paths
input_path = path + state + '/data/source/NLCD_' + year + '_Tree_Canopy_' + state + part + '.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Trees-Combined.tiff'

expression = (
'((A > 0) & (A < 255)) * 43 + '
'(A <= 0) * A'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows OS uses
#subprocess.run(command, shell=True)

print("Step 1: Calculate result_tree_canopy completed. (NLCD_" + year + "_" + state + part + "_Trees-Combined)")

##################### Step 2: Warp tree canopy to 4326 #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Trees-Combined.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Tree_Canopy_4326.tiff'

processing.run(
"gdal:warpreproject",
{
'INPUT':input_path,
'SOURCE_CRS':None,
'TARGET_CRS':QgsCoordinateReferenceSystem('EPSG:4326'),
'RESAMPLING':0,
'NODATA':None,
'TARGET_RESOLUTION':None,
'OPTIONS':'',
'DATA_TYPE':1, # GDAL GDT_Byte
'TARGET_EXTENT':None,
'TARGET_EXTENT_CRS':None,
'MULTITHREADING':False,
'EXTRA':'',
'OUTPUT':output_path
}
)

print("Step 2: Warp tree_canopy completed. (NLCD_" + year + "_" + state + part + "_Tree_Canopy_4326)")

##################### Step 3: Warp land cover 4326 #####################

input_path = path + state + '/data/source/NLCD_' + year + '_Land_Cover_' + state + part + '.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Land_Cover_4326.tiff'

processing.run(
"gdal:warpreproject",
{
'INPUT':input_path,
'SOURCE_CRS':None,
'TARGET_CRS':QgsCoordinateReferenceSystem('EPSG:4326'),
'RESAMPLING':0,
'NODATA':None,
'TARGET_RESOLUTION':None,
'OPTIONS':'',
'DATA_TYPE':1, # GDAL GDT_Byte
'TARGET_EXTENT':None,
'TARGET_EXTENT_CRS':None,
'MULTITHREADING':False,
'EXTRA':'',
'OUTPUT':output_path
}
)

print("Step 3: Warp land_cover completed. (NLCD_" + year + "_" + state + part + "_Land_Cover_4326)")

##################### Step 4: Combine land cover 4326 and tree canopy 4326 #####################

input_path_a = path + state + '/data/NLCD_' + year + '_' + state + part + '_Tree_Canopy_4326.tiff'
input_path_b = path + state + '/data/NLCD_' + year + '_' + state + part + '_Land_Cover_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Tree_Land_Combined_4326.tiff'

expression = (
'(((B > 0) & (B < 255)) & (B != 41) & (B != 42) & (B != 43) & (A > 0)) * A + '
'((B == 41) | (B == 42) | (B == 43) | (A <= 0)) * B'
)
command = [
'gdal_calc.py',
'-A', input_path_a,
'-B', input_path_b,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows OS uses
#subprocess.run(command, shell=True)

print("Step 4: Combine tree canopy and land cover completed. (NLCD_" + year + "_" + state + part + "_Tree_Land_Combined_4326)")

##################### Step 5: Replace urban and clutter with grass #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Tree_Land_Combined_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Grass-Only_4326.tiff'

expression = (
'(A == 0) * 44 + '
'(A == 11) * 41 + '
'(A == 12) * 34 + '
'(A == 21) * 26 + '
'(A == 22) * 26 + '
'(A == 23) * 26 + '
'(A == 24) * 26 + '
'(A == 31) * 27 + '
'(A == 41) * 23 + '
'(A == 42) * 24 + '
'(A == 43) * 25 + '
'(A == 51) * 30 + '
'(A == 52) * 29 + '
'(A == 71) * 26 + '
'(A == 72) * 32 + '
'(A == 73) * 31 + '
'(A == 74) * 31 + '
'(A == 75) * 32 + '
'(A == 81) * 18 + '
'(A == 82) * 19 + '
'(A == 90) * 25 + '
'(A == 95) * 35'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows OS uses
#subprocess.run(command, shell=True)

print("Step 5: Replace urban and clutter with grass completed. (NLCD_" + year + "_" + state + part + "_Grass-Only_4326)")

##################### Step 6: Reclass urban 21, 22, 23 or 24 #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Tree_Land_Combined_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Reclassed-Urban_4326.tiff'

expression = (
'(A == 21)*10 + '
'(A == 22)*1 + '
'(A == 23)*1 + '
'(A == 24)*2'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows OS uses
#subprocess.run(command, shell=True)

print("Step 6: Reclass urban completed. (NLCD_" + year + "_" + state + part + "_Reclassed-Urban_4326)")

##################### Step 7: Remove clutter and roads from urban #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Reclassed-Urban_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Urban-Only_4326.tiff'

processing.run(
"grass7:r.neighbors",
{
'input':input_path,
'selection':None,
'method':1, #1=median, 2=mode
'size':7,
'gauss':None,
'quantile':'',
'-c':False,
'-a':False,
'weight':'',
'output':output_path,
'GRASS_REGION_PARAMETER':None,
'GRASS_REGION_CELLSIZE_PARAMETER':0,
'GRASS_RASTER_FORMAT_OPT': 'TYPE=BYTE',
'GRASS_RASTER_FORMAT_META':''
}
)

print("Step 7: Remove clutter and roads from urban. (NLCD_" + year + "_" + state + part + "_Urban-Only_4326)")

##################### Step 8: Combine grass only and clean urban #####################

input_path_a = path + state + '/data/NLCD_' + year + '_' + state + part + '_Urban-Only_4326.tiff'
input_path_b = path + state + '/data/NLCD_' + year + '_' + state + part + '_Grass-Only_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Combined-Clean_4326.tiff'

expression = (
'((A > 0) & (B > 0)) * A + '
'((A <= 0) | (B <= 0)) * B'
)
command = [
'gdal_calc.py',
'-A', input_path_a,
'-B', input_path_b,
'--outfile', output_path,
'--calc', expression,
'--NoDataValue', '0',
'--type', 'Byte'
]
subprocess.run(command)
#Windows OS uses
#subprocess.run(command, shell=True)

print("Step 8: Combined and clean completed. (NLCD_" + year + "_" + state + part + "_Combined-Clean_4326)")

##################### Step 9: Upsample to HD #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Combined-Clean_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Combined-Clean-HD_4326.tiff'

# Open the original raster
ds = gdal.Open(input_path)
gt = ds.GetGeoTransform()

# Extract the original resolution
original_xRes = gt[1]
original_yRes = abs(gt[5])

# Define the percentage to resize by (e.g., 0.50 for 50%, 2.0 for 200%)
#defined at the beginning of the script
#percentage = 8.0

# Calculate the new resolution
new_xRes = original_xRes / percentage
new_yRes = original_yRes / percentage

# Perform the warp (resampling)
gdal.Warp(
output_path,
input_path,
xRes=new_xRes,
yRes=new_yRes,
outputType=gdal.GDT_Byte # Set the output type to uint8
)

print("Step 9: Upsample to. (NLCD_" + year + "_" + state + part + "_Combined-Clean-HD_4326)")

##################### Step 10: Smooth all features in original dataset #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Combined-Clean-HD_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Smoothed-HD_4326.tiff'

processing.run(
"grass7:r.neighbors",
{
'input':input_path,
'selection':None,
'method':3, #1=median, 3=mode
'size':size,
'gauss':None,
'quantile':'',
'-c':False,
'-a':False,
'weight':'',
'output':output_path,
'GRASS_REGION_CELLSIZE_PARAMETER':0,
'GRASS_RASTER_FORMAT_OPT': 'TYPE=BYTE',
'GRASS_RASTER_FORMAT_META':''
}
)

print("Step 10: Smooth all features in original dataset completed. (NLCD_" + year + "_" + state + part + "_Smoothed-HD_4326)")

##################### Step 11: Compress and insure 8Bit #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Smoothed-HD_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Smoothed-HD-Compressed_4326.tiff'

processing.run(
"gdal:translate",
{
'INPUT':input_path,
'TARGET_CRS':None,
'NODATA':0,
'COPY_SUBDATASETS':False,
'OPTIONS':'',
'EXTRA':'',
'DATA_TYPE':1,
'OUTPUT':output_path,
'OPTIONS': 'COMPRESS=LZW'
}
)

result_bit_conversion_layer = QgsRasterLayer(output_path, 'NLCD_' + year + '_' + state + part + '_Smoothed-HD-Compressed_4326')
QgsProject.instance().addMapLayer(result_bit_conversion_layer)

print("Step 11: Convert to Compressed. (NLCD_" + year + "_" + state + part + "_Smoothed-HD-Compressed_4326)")
</syntaxhighlight>

=== Pure Python script to process NLCD for the USA (does not require using QGIS Python Console) ===

This has been tested in Linux, it may or may not need modification to run under Windows OS.

USAGE: python3 gen-scenery.py --part 89-86_29 --canopy 41

<syntaxhighlight lang="python">
#!/usr/bin/env python3
import os
import subprocess
import argparse
import tempfile
from pathlib import Path
from osgeo import gdal

# ----------------- CONFIG -----------------

BASE_PATH = Path("/media/wayne/TOSHIBA-EXT/Scenery/ws3.0")
YEAR = "2023"
STATE = "Alabama"

# upsampling / smoothing
PERCENTAGE = 11.0
SIZE = 21

# GRASS binary
GRASS_BIN = "grass"

# ----------------- ARGUMENT PARSING -----------------

# USAGE: python3 gen-scenery.py --part 89-86_29 --canopy 41

#NLCD
# Choose the dominent canopy for the area being processed
# Areas not covered in the Tree Canopy layer will convert retain their original class
#41 = DeciduousForest
#42 = EvergreenForest
#43 = MixedForest

#FG equivalent
#22 = AgroForest
#23 = DeciduousBroadCover
#24 = EvergreenForest
#25 = MixedForest

parser = argparse.ArgumentParser()
parser.add_argument("--part", required=True, help="Tile part ID, e.g. 89-86_29")
parser.add_argument("--canopy", required=True, type=int, help="Tree canopy FG class")
args = parser.parse_args()

PART = args.part
CANOPY = args.canopy

# ----------------- HELPERS -----------------

def run(cmd, check=True, env=None):
print(">>", " ".join(str(c) for c in cmd))
subprocess.run(cmd, check=check, env=env)

def gdal_calc(args):
fixed = []
for a in args:
if a.startswith("--") and "=" in a:
key, val = a.split("=", 1)
fixed.append(key)
fixed.append(val)
else:
fixed.append(a)

cmd = ["gdal_calc.py"] + fixed + ["--overwrite"]
run(cmd)

def gdalwarp(input_path, output_path, t_srs="EPSG:4326",
resampling="near", dtype="Byte", extra=None):
cmd = [
"gdalwarp",
"-t_srs", t_srs,
"-r", resampling,
"-ot", dtype,
"-overwrite",
input_path,
output_path
]
if extra:
cmd.extend(extra)
run(cmd)

def gdal_translate(input_path, output_path,
nodata=0, dtype="Byte", compress="LZW"):
cmd = [
"gdal_translate",
"-a_nodata", str(nodata),
"-ot", dtype,
"-co", f"COMPRESS={compress}",
input_path,
output_path
]
run(cmd)

# ----------------- GRASS SESSION -----------------

# Create a temporary GRASS location with PERMANENT mapset
TMPDIR = tempfile.mkdtemp(prefix="grass_job_")
GRASS_LOCATION = os.path.join(TMPDIR, "location")

# Create the location
subprocess.run([
GRASS_BIN,
"-c", "EPSG:4326",
GRASS_LOCATION,
"--exec", "echo", "Location created"
], check=True)

# The active mapset is PERMANENT
GRASS_MAPSET = os.path.join(GRASS_LOCATION, "PERMANENT")

def grass_exec(args):
cmd = [GRASS_BIN, GRASS_MAPSET, "--exec"] + args
print(">>", " ".join(cmd))
subprocess.run(cmd, check=True)

def grass_exec(args):
cmd = [GRASS_BIN, GRASS_MAPSET, "--exec"] + args
print(">>", " ".join(cmd))
subprocess.run(cmd, check=True)

def grass_r_neighbors(input_raster, output_raster,
method="median", size=7):
in_name = "in_rast"
out_name = "out_rast"

grass_exec([
"r.in.gdal",
f"input={input_raster}",
f"output={in_name}",
"--overwrite"
])

grass_exec([
"g.region",
f"raster={in_name}"
])

grass_exec([
"r.neighbors",
f"input={in_name}",
f"output={out_name}",
f"method={method}",
f"size={size}",
"--overwrite"
])

grass_exec([
"r.out.gdal",
"-f",
f"input={out_name}",
f"output={output_raster}",
"format=GTiff",
"type=Byte",
"--overwrite"
])

def p(*parts):
return str(BASE_PATH.joinpath(STATE, *parts))

# ----------------- STEPS -----------------

def step1_tree_canopy_reclass():
src = p("data", "source", f"NLCD_{YEAR}_Tree_Canopy_{STATE}{PART}.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Trees-Combined.tiff")

expr = f"((A > 0) & (A < 255)) * {CANOPY} + (A <= 0) * A"
gdal_calc([
"-A", src,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 1: Trees-Combined")

def step2_warp_tree_canopy_4326():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Trees-Combined.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Canopy_4326.tiff")
gdalwarp(src, dst)
print("Step 2: Tree_Canopy_4326")

def step3_warp_land_cover_4326():
src = p("data", "source", f"NLCD_{YEAR}_Land_Cover_{STATE}{PART}.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Land_Cover_4326.tiff")
gdalwarp(src, dst)
print("Step 3: Land_Cover_4326")

def step4_combine_tree_land_4326():
a = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Canopy_4326.tiff")
b = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Land_Cover_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Land_Combined_4326.tiff")

expr = (
"(((B > 0) & (B < 255)) & (B != 41) & (B != 42) & (B != 43) & (A > 0)) * A + "
"((B == 41) | (B == 42) | (B == 43) | (A <= 0)) * B"
)
gdal_calc([
"-A", a,
"-B", b,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 4: Tree_Land_Combined_4326")

def step5_replace_urban_clutter_with_grass():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Land_Combined_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Grass-Only_4326.tiff")

expr = (
"(A == 0) * 44 + "
"(A == 11) * 41 + "
"(A == 12) * 34 + "
"(A == 21) * 26 + "
"(A == 22) * 26 + "
"(A == 23) * 26 + "
"(A == 24) * 26 + "
"(A == 31) * 27 + "
"(A == 41) * 23 + "
"(A == 42) * 24 + "
"(A == 43) * 25 + "
"(A == 51) * 30 + "
"(A == 52) * 29 + "
"(A == 71) * 26 + "
"(A == 72) * 32 + "
"(A == 73) * 31 + "
"(A == 74) * 31 + "
"(A == 75) * 32 + "
"(A == 81) * 18 + "
"(A == 82) * 19 + "
"(A == 90) * 25 + "
"(A == 95) * 35"
)
gdal_calc([
"-A", src,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 5: Grass-Only_4326")

def step6_reclass_urban():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Land_Combined_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Reclassed-Urban_4326.tiff")

expr = (
"(A == 21)*10 + "
"(A == 22)*1 + "
"(A == 23)*2 + "
"(A == 24)*3"
)
gdal_calc([
"-A", src,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 6: Reclassed-Urban_4326")

def step7_remove_clutter_roads_from_urban():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Reclassed-Urban_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Urban-Only_4326.tiff")

grass_r_neighbors(src, dst, method="median", size=7)
print("Step 7: Urban-Only_4326")

def step8_combine_grass_and_clean_urban():
a = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Urban-Only_4326.tiff")
b = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Grass-Only_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean_4326.tiff")

expr = "((A > 0) & (B > 0)) * A + ((A <= 0) | (B <= 0)) * B"
gdal_calc([
"-A", a,
"-B", b,
"--outfile", dst,
"--calc", expr,
"--NoDataValue", "0",
"--type", "Byte"
])
print("Step 8: Combined-Clean_4326")

def step9_upsample_to_hd():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean-HD_4326.tiff")

ds = gdal.Open(src)
if ds is None:
raise RuntimeError(f"Cannot open {src}")
gt = ds.GetGeoTransform()
original_xRes = gt[1]
original_yRes = abs(gt[5])

new_xRes = original_xRes / PERCENTAGE
new_yRes = original_yRes / PERCENTAGE

gdal.Warp(
dst,
src,
xRes=new_xRes,
yRes=new_yRes,
outputType=gdal.GDT_Byte
)
print("Step 9: Combined-Clean-HD_4326")

def step10_smooth_all_features():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean-HD_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Smoothed-HD_4326.tiff")

grass_r_neighbors(src, dst, method="median", size=SIZE)
print("Step 10: Smoothed-HD_4326")

def step11_convert_to_8bit_compressed():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Smoothed-HD_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Smoothed-HD-Compressed_4326.tiff")

gdal_translate(src, dst)
print("Step 11: Smoothed-HD-Compressed_4326")

# ----------------- MAIN -----------------

def main():
step1_tree_canopy_reclass()
step2_warp_tree_canopy_4326()
step3_warp_land_cover_4326()
step4_combine_tree_land_4326()
step5_replace_urban_clutter_with_grass()
step6_reclass_urban()
step7_remove_clutter_roads_from_urban()
step8_combine_grass_and_clean_urban()
step9_upsample_to_hd()
step10_smooth_all_features()
step11_convert_to_8bit_compressed()

if __name__ == "__main__":
main()
</syntaxhighlight>

== Batch script for multiple processes ==
<syntaxhighlight lang="python">
#!/bin/bash

python3 gen-scenery.py --part 89-86_29 --canopy 41 &
python3 gen-scenery.py --part 89-86_30 --canopy 41 &
python3 gen-scenery.py --part 89-86_31 --canopy 41 &
python3 gen-scenery.py --part 89-86_32 --canopy 41 &
python3 gen-scenery.py --part 89-86_33 --canopy 41 &
python3 gen-scenery.py --part 89-86_34 --canopy 41 &

wait
echo "All scenery jobs completed."
</syntaxhighlight>

Python script to process NLCD for the USA

2026-05-19T22:08:07Z

Wlbragg: /* Pure Python script to process NLCD for the USA (does not require using QGIS Python Console) */

=== Python script to process NLCD for the USA in the QGIS Python Console ===
You can process the NLCD by loading this script in the python console of the QGIS Desktop program.
This python script method produces more refined data than by using the python calculator method above and it is more automated.
If you run this script outside the python console you will need to modify it to locate the data you are processing.
If you save the NLCD tiff's using the same consistent naming convention used in this example it is fairly simple to generate final WS3.0 tiff's to use to generate the scenery.

NOTE: the current genVPB.py script (osgdem) will not generate the final scenery water/land edge to this high of a resolution. It is set to a default tile size of 256x256, "--tile-image-size 256". This resolution is much higher than that. To achieve the same base resolution in the built scenery, osgdem needs a switch to "--tile-image-size 1024" to realize the higher resolution. However, when you apply the water mask flags --generate-water-raster --shrink-water 4 --coastline [path_to_coastal_shapefiles] using genVPB.py the cut mask will achieve the higher resolution.

You will start with an original tree layer and a land cover layer from the MRLC.gov site. See the section "Obtaining NLCD" in the above "Step By Step Procedure for Processing NLCD for the USA using the Raster Calculator" topic.

For example, to start with you will have a couple files named...

NLCD_2021_Tree_Canopy_Alaska141-140_60.tiff

NLCD_2021_Land_Cover_Alaska141-140_60.tiff

In the QGIS program the layer names you start with will be...

NLCD_2021_Tree_Canopy_Alaska141-140_60

NLCD_2021_Land_Cover_Alaska141-140_60

which will refer to the tiff files.

Running this script will generate a bunch of intermediate files including the last file, that will be the final finished file for running in the VPB script or VPB build environment Docker image.

The last file for this example for Alaska would be, NLCD_2021_Alaska141-140_60_Smoothed-HD-Compressed_4326.tiff

<syntaxhighlight lang="python">
from qgis.core import QgsApplication, QgsCoordinateTransform, QgsProject, QgsRasterLayer, QgsCoordinateReferenceSystem, QgsProcessingException, QgsRasterBlock, QgsRectangle
from qgis.analysis import QgsRasterCalculator, QgsRasterCalculatorEntry
from qgis import processing
from processing.core.Processing import Processing
from osgeo import gdal, osr, ogr
import os
import numpy
import numpy as np
import subprocess

# Define input layer names, change according to your file names
path = 'G:/Scenery/ws3.0/';
year = '2021';
state = 'Alaska';
part = '141-140_60';

# Ratio of upsampling to smoothing
percentage = 8
size = 11

################################## IMPORTANT ###############################
# Beginning filename of the NLCD from the source needs to be
# NLCD_' + year + '_Tree_Canopy_' + state + part + '.tiff'
# Also note that "/data/" is hardcoded into the path as well
# I needed the existing path structure to process it by state.
# For Alaska I used one lat and a few lon sections per chunck built.
# I will likely do the entire NLCD coverage area the same in future runs.
# Example beginning NLCD source:
# NLCD_2021_Tree_Canopy_Alaska141-140_60.tiff
# NLCD_2021_Land_Cover_Alaska141-140_60.tiff
# Full path and filename to source example is:
# G:/Scenery/ws3.0/Alaska/data/source/NLCD_2021_Tree_Canopy_Alaska141-140_60.tiff
# G:/Scenery/ws3.0/Alaska/data/source/NLCD_2021_Land_Cover_Alaska141-140_60.tiff
# Final output path to last processed file is:
# G:/Scenery/ws3.0/Alaska/data/NLCD_2021_Alaska141-140_60_Smoothed-HD-Compressed_4326
############################################################################

##################### Step 1: Reclass tree canopy to one landcover type 41, 42, or 43 #####################
#FG NLCD
#23 DeciduousBroadCover 41
#24 EvergreenForest 42
#25 MixedForest 43

# Define input and output paths
input_path = path + state + '/data/source/NLCD_' + year + '_Tree_Canopy_' + state + part + '.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Trees-Combined.tiff'

expression = (
'((A > 0) & (A < 255)) * 43 + '
'(A <= 0) * A'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows OS uses
#subprocess.run(command, shell=True)

print("Step 1: Calculate result_tree_canopy completed. (NLCD_" + year + "_" + state + part + "_Trees-Combined)")

##################### Step 2: Warp tree canopy to 4326 #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Trees-Combined.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Tree_Canopy_4326.tiff'

processing.run(
"gdal:warpreproject",
{
'INPUT':input_path,
'SOURCE_CRS':None,
'TARGET_CRS':QgsCoordinateReferenceSystem('EPSG:4326'),
'RESAMPLING':0,
'NODATA':None,
'TARGET_RESOLUTION':None,
'OPTIONS':'',
'DATA_TYPE':1, # GDAL GDT_Byte
'TARGET_EXTENT':None,
'TARGET_EXTENT_CRS':None,
'MULTITHREADING':False,
'EXTRA':'',
'OUTPUT':output_path
}
)

print("Step 2: Warp tree_canopy completed. (NLCD_" + year + "_" + state + part + "_Tree_Canopy_4326)")

##################### Step 3: Warp land cover 4326 #####################

input_path = path + state + '/data/source/NLCD_' + year + '_Land_Cover_' + state + part + '.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Land_Cover_4326.tiff'

processing.run(
"gdal:warpreproject",
{
'INPUT':input_path,
'SOURCE_CRS':None,
'TARGET_CRS':QgsCoordinateReferenceSystem('EPSG:4326'),
'RESAMPLING':0,
'NODATA':None,
'TARGET_RESOLUTION':None,
'OPTIONS':'',
'DATA_TYPE':1, # GDAL GDT_Byte
'TARGET_EXTENT':None,
'TARGET_EXTENT_CRS':None,
'MULTITHREADING':False,
'EXTRA':'',
'OUTPUT':output_path
}
)

print("Step 3: Warp land_cover completed. (NLCD_" + year + "_" + state + part + "_Land_Cover_4326)")

##################### Step 4: Combine land cover 4326 and tree canopy 4326 #####################

input_path_a = path + state + '/data/NLCD_' + year + '_' + state + part + '_Tree_Canopy_4326.tiff'
input_path_b = path + state + '/data/NLCD_' + year + '_' + state + part + '_Land_Cover_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Tree_Land_Combined_4326.tiff'

expression = (
'(((B > 0) & (B < 255)) & (B != 41) & (B != 42) & (B != 43) & (A > 0)) * A + '
'((B == 41) | (B == 42) | (B == 43) | (A <= 0)) * B'
)
command = [
'gdal_calc.py',
'-A', input_path_a,
'-B', input_path_b,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows OS uses
#subprocess.run(command, shell=True)

print("Step 4: Combine tree canopy and land cover completed. (NLCD_" + year + "_" + state + part + "_Tree_Land_Combined_4326)")

##################### Step 5: Replace urban and clutter with grass #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Tree_Land_Combined_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Grass-Only_4326.tiff'

expression = (
'(A == 0) * 44 + '
'(A == 11) * 41 + '
'(A == 12) * 34 + '
'(A == 21) * 26 + '
'(A == 22) * 26 + '
'(A == 23) * 26 + '
'(A == 24) * 26 + '
'(A == 31) * 27 + '
'(A == 41) * 23 + '
'(A == 42) * 24 + '
'(A == 43) * 25 + '
'(A == 51) * 30 + '
'(A == 52) * 29 + '
'(A == 71) * 26 + '
'(A == 72) * 32 + '
'(A == 73) * 31 + '
'(A == 74) * 31 + '
'(A == 75) * 32 + '
'(A == 81) * 18 + '
'(A == 82) * 19 + '
'(A == 90) * 25 + '
'(A == 95) * 35'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows OS uses
#subprocess.run(command, shell=True)

print("Step 5: Replace urban and clutter with grass completed. (NLCD_" + year + "_" + state + part + "_Grass-Only_4326)")

##################### Step 6: Reclass urban 21, 22, 23 or 24 #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Tree_Land_Combined_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Reclassed-Urban_4326.tiff'

expression = (
'(A == 21)*10 + '
'(A == 22)*1 + '
'(A == 23)*1 + '
'(A == 24)*2'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows OS uses
#subprocess.run(command, shell=True)

print("Step 6: Reclass urban completed. (NLCD_" + year + "_" + state + part + "_Reclassed-Urban_4326)")

##################### Step 7: Remove clutter and roads from urban #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Reclassed-Urban_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Urban-Only_4326.tiff'

processing.run(
"grass7:r.neighbors",
{
'input':input_path,
'selection':None,
'method':1, #1=median, 2=mode
'size':7,
'gauss':None,
'quantile':'',
'-c':False,
'-a':False,
'weight':'',
'output':output_path,
'GRASS_REGION_PARAMETER':None,
'GRASS_REGION_CELLSIZE_PARAMETER':0,
'GRASS_RASTER_FORMAT_OPT': 'TYPE=BYTE',
'GRASS_RASTER_FORMAT_META':''
}
)

print("Step 7: Remove clutter and roads from urban. (NLCD_" + year + "_" + state + part + "_Urban-Only_4326)")

##################### Step 8: Combine grass only and clean urban #####################

input_path_a = path + state + '/data/NLCD_' + year + '_' + state + part + '_Urban-Only_4326.tiff'
input_path_b = path + state + '/data/NLCD_' + year + '_' + state + part + '_Grass-Only_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Combined-Clean_4326.tiff'

expression = (
'((A > 0) & (B > 0)) * A + '
'((A <= 0) | (B <= 0)) * B'
)
command = [
'gdal_calc.py',
'-A', input_path_a,
'-B', input_path_b,
'--outfile', output_path,
'--calc', expression,
'--NoDataValue', '0',
'--type', 'Byte'
]
subprocess.run(command)
#Windows OS uses
#subprocess.run(command, shell=True)

print("Step 8: Combined and clean completed. (NLCD_" + year + "_" + state + part + "_Combined-Clean_4326)")

##################### Step 9: Upsample to HD #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Combined-Clean_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Combined-Clean-HD_4326.tiff'

# Open the original raster
ds = gdal.Open(input_path)
gt = ds.GetGeoTransform()

# Extract the original resolution
original_xRes = gt[1]
original_yRes = abs(gt[5])

# Define the percentage to resize by (e.g., 0.50 for 50%, 2.0 for 200%)
#defined at the beginning of the script
#percentage = 8.0

# Calculate the new resolution
new_xRes = original_xRes / percentage
new_yRes = original_yRes / percentage

# Perform the warp (resampling)
gdal.Warp(
output_path,
input_path,
xRes=new_xRes,
yRes=new_yRes,
outputType=gdal.GDT_Byte # Set the output type to uint8
)

print("Step 9: Upsample to. (NLCD_" + year + "_" + state + part + "_Combined-Clean-HD_4326)")

##################### Step 10: Smooth all features in original dataset #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Combined-Clean-HD_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Smoothed-HD_4326.tiff'

processing.run(
"grass7:r.neighbors",
{
'input':input_path,
'selection':None,
'method':3, #1=median, 3=mode
'size':size,
'gauss':None,
'quantile':'',
'-c':False,
'-a':False,
'weight':'',
'output':output_path,
'GRASS_REGION_CELLSIZE_PARAMETER':0,
'GRASS_RASTER_FORMAT_OPT': 'TYPE=BYTE',
'GRASS_RASTER_FORMAT_META':''
}
)

print("Step 10: Smooth all features in original dataset completed. (NLCD_" + year + "_" + state + part + "_Smoothed-HD_4326)")

##################### Step 11: Compress and insure 8Bit #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Smoothed-HD_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Smoothed-HD-Compressed_4326.tiff'

processing.run(
"gdal:translate",
{
'INPUT':input_path,
'TARGET_CRS':None,
'NODATA':0,
'COPY_SUBDATASETS':False,
'OPTIONS':'',
'EXTRA':'',
'DATA_TYPE':1,
'OUTPUT':output_path,
'OPTIONS': 'COMPRESS=LZW'
}
)

result_bit_conversion_layer = QgsRasterLayer(output_path, 'NLCD_' + year + '_' + state + part + '_Smoothed-HD-Compressed_4326')
QgsProject.instance().addMapLayer(result_bit_conversion_layer)

print("Step 11: Convert to Compressed. (NLCD_" + year + "_" + state + part + "_Smoothed-HD-Compressed_4326)")
</syntaxhighlight>

=== Pure Python script to process NLCD for the USA (does not require using QGIS Python Console)===

This has been tested in Linux, it may or may not need modification to run under Windows OS.

<syntaxhighlight lang="python">
#!/usr/bin/env python3
import os
import subprocess
from pathlib import Path
from osgeo import gdal

# ----------------- CONFIG -----------------

BASE_PATH = Path("/media/wayne/TOSHIBA-EXT/Scenery/ws3.0")
YEAR = "2023"
STATE = "Alabama"
PART = "89-86_32"

# upsampling / smoothing
PERCENTAGE = 11.0
SIZE = 21

# GRASS config (adjust to your setup)
GRASS_BIN = "grass" # e.g. "grass", "grass82", or full path
GISDBASE = "/path/to/grassdata" # directory containing locations
LOCATION_NAME = "nlcd" # existing location name
MAPSET = "PERMANENT" # or a dedicated mapset

# ----------------- HELPERS -----------------

def run(cmd, check=True, env=None):
print(">>", " ".join(str(c) for c in cmd))
subprocess.run(cmd, check=check, env=env)

def gdal_calc(args):
"""
Fixes malformed args like '--type=Byte' and always appends --overwrite.
"""
fixed = []
for a in args:
if a.startswith("--") and "=" in a:
key, val = a.split("=", 1)
fixed.append(key)
fixed.append(val)
else:
fixed.append(a)

cmd = ["gdal_calc.py"] + fixed + ["--overwrite"]
run(cmd)

def gdalwarp(input_path, output_path, t_srs="EPSG:4326",
resampling="near", dtype="Byte", extra=None):
cmd = [
"gdalwarp",
"-t_srs", t_srs,
"-r", resampling,
"-ot", dtype,
"-overwrite",
input_path,
output_path
]
if extra:
cmd.extend(extra)
run(cmd)

def gdal_translate(input_path, output_path,
nodata=0, dtype="Byte", compress="LZW"):
cmd = [
"gdal_translate",
"-a_nodata", str(nodata),
"-ot", dtype,
"-co", f"COMPRESS={compress}",
"-overwrite",
input_path,
output_path
]
run(cmd)

def grass_env():
env = os.environ.copy()
env["GISDBASE"] = GISDBASE
env["LOCATION_NAME"] = LOCATION_NAME
env["MAPSET"] = MAPSET
return env

def grass_exec(args):
"""
FIXED: list-based wrapper that preserves argument order exactly.
"""
env = grass_env()
cmd = [GRASS_BIN, "--exec"] + args
print(">>", " ".join(cmd))
subprocess.run(cmd, check=True, env=env)

def grass_r_neighbors(input_raster, output_raster,
method="median", size=7):
"""
Import GeoTIFF -> set region -> r.neighbors -> export GeoTIFF.
Includes -f to allow DCELL->Byte export.
"""
in_name = "in_rast"
out_name = "out_rast"

# 1) import
grass_exec([
"r.in.gdal",
f"input={input_raster}",
f"output={in_name}",
"--overwrite"
])

# 2) set region to raster (fixes extent issues)
grass_exec([
"g.region",
f"raster={in_name}"
])

# 3) neighbors
grass_exec([
"r.neighbors",
f"input={in_name}",
f"output={out_name}",
f"method={method}",
f"size={size}",
"--overwrite"
])

# 4) export (with -f)
grass_exec([
"r.out.gdal",
"-f",
f"input={out_name}",
f"output={output_raster}",
"format=GTiff",
"type=Byte",
"--overwrite"
])

def p(*parts):
return str(BASE_PATH.joinpath(STATE, *parts))

# ----------------- STEPS -----------------

def step1_tree_canopy_reclass():
src = p("data", "source", f"NLCD_{YEAR}_Tree_Canopy_{STATE}{PART}.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Trees-Combined.tiff")

expr = "((A > 0) & (A < 255)) * 43 + (A <= 0) * A"
gdal_calc([
"-A", src,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 1: Trees-Combined")

def step2_warp_tree_canopy_4326():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Trees-Combined.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Canopy_4326.tiff")
gdalwarp(src, dst)
print("Step 2: Tree_Canopy_4326")

def step3_warp_land_cover_4326():
src = p("data", "source", f"NLCD_{YEAR}_Land_Cover_{STATE}{PART}.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Land_Cover_4326.tiff")
gdalwarp(src, dst)
print("Step 3: Land_Cover_4326")

def step4_combine_tree_land_4326():
a = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Canopy_4326.tiff")
b = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Land_Cover_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Land_Combined_4326.tiff")

expr = (
"(((B > 0) & (B < 255)) & (B != 41) & (B != 42) & (B != 43) & (A > 0)) * A + "
"((B == 41) | (B == 42) | (B == 43) | (A <= 0)) * B"
)
gdal_calc([
"-A", a,
"-B", b,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 4: Tree_Land_Combined_4326")

def step5_replace_urban_clutter_with_grass():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Land_Combined_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Grass-Only_4326.tiff")

expr = (
"(A == 0) * 44 + "
"(A == 11) * 41 + "
"(A == 12) * 34 + "
"(A == 21) * 26 + "
"(A == 22) * 26 + "
"(A == 23) * 26 + "
"(A == 24) * 26 + "
"(A == 31) * 27 + "
"(A == 41) * 23 + "
"(A == 42) * 24 + "
"(A == 43) * 25 + "
"(A == 51) * 30 + "
"(A == 52) * 29 + "
"(A == 71) * 26 + "
"(A == 72) * 32 + "
"(A == 73) * 31 + "
"(A == 74) * 31 + "
"(A == 75) * 32 + "
"(A == 81) * 18 + "
"(A == 82) * 19 + "
"(A == 90) * 25 + "
"(A == 95) * 35"
)
gdal_calc([
"-A", src,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 5: Grass-Only_4326")

def step6_reclass_urban():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Land_Combined_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Reclassed-Urban_4326.tiff")

expr = (
"(A == 21)*10 + "
"(A == 22)*1 + "
"(A == 23)*1 + "
"(A == 24)*2"
)
gdal_calc([
"-A", src,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 6: Reclassed-Urban_4326")

def step7_remove_clutter_roads_from_urban():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Reclassed-Urban_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Urban-Only_4326.tiff")

grass_r_neighbors(src, dst, method="median", size=7)
print("Step 7: Urban-Only_4326")

def step8_combine_grass_and_clean_urban():
a = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Urban-Only_4326.tiff")
b = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Grass-Only_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean_4326.tiff")

expr = "((A > 0) & (B > 0)) * A + ((A <= 0) | (B <= 0)) * B"
gdal_calc([
"-A", a,
"-B", b,
"--outfile", dst,
"--calc", expr,
"--NoDataValue", "0",
"--type", "Byte"
])
print("Step 8: Combined-Clean_4326")

def step9_upsample_to_hd():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean-HD_4326.tiff")

ds = gdal.Open(src)
if ds is None:
raise RuntimeError(f"Cannot open {src}")
gt = ds.GetGeoTransform()
original_xRes = gt[1]
original_yRes = abs(gt[5])

new_xRes = original_xRes / PERCENTAGE
new_yRes = original_yRes / PERCENTAGE

gdal.Warp(
dst,
src,
xRes=new_xRes,
yRes=new_yRes,
outputType=gdal.GDT_Byte
)
print("Step 9: Combined-Clean-HD_4326")

def step10_smooth_all_features():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean-HD_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Smoothed-HD_4326.tiff")

grass_r_neighbors(src, dst, method="median", size=SIZE)
print("Step 10: Smoothed-HD_4326")

def step11_convert_to_8bit_compressed():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Smoothed-HD_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Smoothed-HD-Compressed_4326.tiff")

gdal_translate(src, dst)
print("Step 11: Smoothed-HD-Compressed_4326")

# ----------------- MAIN -----------------

def main():
step1_tree_canopy_reclass()
step2_warp_tree_canopy_4326()
step3_warp_land_cover_4326()
step4_combine_tree_land_4326()
step5_replace_urban_clutter_with_grass()
step6_reclass_urban()
step7_remove_clutter_roads_from_urban()
step8_combine_grass_and_clean_urban()
step9_upsample_to_hd()
step10_smooth_all_features()
step11_convert_to_8bit_compressed()

if __name__ == "__main__":
main()
</syntaxhighlight>

Python script to process NLCD for the USA

2026-05-19T22:03:11Z

Wlbragg: /* Optional Python script to process NLCD for the USA */

=== Python script to process NLCD for the USA in the QGIS Python Console ===
You can process the NLCD by loading this script in the python console of the QGIS Desktop program.
This python script method produces more refined data than by using the python calculator method above and it is more automated.
If you run this script outside the python console you will need to modify it to locate the data you are processing.
If you save the NLCD tiff's using the same consistent naming convention used in this example it is fairly simple to generate final WS3.0 tiff's to use to generate the scenery.

NOTE: the current genVPB.py script (osgdem) will not generate the final scenery water/land edge to this high of a resolution. It is set to a default tile size of 256x256, "--tile-image-size 256". This resolution is much higher than that. To achieve the same base resolution in the built scenery, osgdem needs a switch to "--tile-image-size 1024" to realize the higher resolution. However, when you apply the water mask flags --generate-water-raster --shrink-water 4 --coastline [path_to_coastal_shapefiles] using genVPB.py the cut mask will achieve the higher resolution.

You will start with an original tree layer and a land cover layer from the MRLC.gov site. See the section "Obtaining NLCD" in the above "Step By Step Procedure for Processing NLCD for the USA using the Raster Calculator" topic.

For example, to start with you will have a couple files named...

NLCD_2021_Tree_Canopy_Alaska141-140_60.tiff

NLCD_2021_Land_Cover_Alaska141-140_60.tiff

In the QGIS program the layer names you start with will be...

NLCD_2021_Tree_Canopy_Alaska141-140_60

NLCD_2021_Land_Cover_Alaska141-140_60

which will refer to the tiff files.

Running this script will generate a bunch of intermediate files including the last file, that will be the final finished file for running in the VPB script or VPB build environment Docker image.

The last file for this example for Alaska would be, NLCD_2021_Alaska141-140_60_Smoothed-HD-Compressed_4326.tiff

<syntaxhighlight lang="python">
from qgis.core import QgsApplication, QgsCoordinateTransform, QgsProject, QgsRasterLayer, QgsCoordinateReferenceSystem, QgsProcessingException, QgsRasterBlock, QgsRectangle
from qgis.analysis import QgsRasterCalculator, QgsRasterCalculatorEntry
from qgis import processing
from processing.core.Processing import Processing
from osgeo import gdal, osr, ogr
import os
import numpy
import numpy as np
import subprocess

# Define input layer names, change according to your file names
path = 'G:/Scenery/ws3.0/';
year = '2021';
state = 'Alaska';
part = '141-140_60';

# Ratio of upsampling to smoothing
percentage = 8
size = 11

################################## IMPORTANT ###############################
# Beginning filename of the NLCD from the source needs to be
# NLCD_' + year + '_Tree_Canopy_' + state + part + '.tiff'
# Also note that "/data/" is hardcoded into the path as well
# I needed the existing path structure to process it by state.
# For Alaska I used one lat and a few lon sections per chunck built.
# I will likely do the entire NLCD coverage area the same in future runs.
# Example beginning NLCD source:
# NLCD_2021_Tree_Canopy_Alaska141-140_60.tiff
# NLCD_2021_Land_Cover_Alaska141-140_60.tiff
# Full path and filename to source example is:
# G:/Scenery/ws3.0/Alaska/data/source/NLCD_2021_Tree_Canopy_Alaska141-140_60.tiff
# G:/Scenery/ws3.0/Alaska/data/source/NLCD_2021_Land_Cover_Alaska141-140_60.tiff
# Final output path to last processed file is:
# G:/Scenery/ws3.0/Alaska/data/NLCD_2021_Alaska141-140_60_Smoothed-HD-Compressed_4326
############################################################################

##################### Step 1: Reclass tree canopy to one landcover type 41, 42, or 43 #####################
#FG NLCD
#23 DeciduousBroadCover 41
#24 EvergreenForest 42
#25 MixedForest 43

# Define input and output paths
input_path = path + state + '/data/source/NLCD_' + year + '_Tree_Canopy_' + state + part + '.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Trees-Combined.tiff'

expression = (
'((A > 0) & (A < 255)) * 43 + '
'(A <= 0) * A'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows OS uses
#subprocess.run(command, shell=True)

print("Step 1: Calculate result_tree_canopy completed. (NLCD_" + year + "_" + state + part + "_Trees-Combined)")

##################### Step 2: Warp tree canopy to 4326 #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Trees-Combined.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Tree_Canopy_4326.tiff'

processing.run(
"gdal:warpreproject",
{
'INPUT':input_path,
'SOURCE_CRS':None,
'TARGET_CRS':QgsCoordinateReferenceSystem('EPSG:4326'),
'RESAMPLING':0,
'NODATA':None,
'TARGET_RESOLUTION':None,
'OPTIONS':'',
'DATA_TYPE':1, # GDAL GDT_Byte
'TARGET_EXTENT':None,
'TARGET_EXTENT_CRS':None,
'MULTITHREADING':False,
'EXTRA':'',
'OUTPUT':output_path
}
)

print("Step 2: Warp tree_canopy completed. (NLCD_" + year + "_" + state + part + "_Tree_Canopy_4326)")

##################### Step 3: Warp land cover 4326 #####################

input_path = path + state + '/data/source/NLCD_' + year + '_Land_Cover_' + state + part + '.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Land_Cover_4326.tiff'

processing.run(
"gdal:warpreproject",
{
'INPUT':input_path,
'SOURCE_CRS':None,
'TARGET_CRS':QgsCoordinateReferenceSystem('EPSG:4326'),
'RESAMPLING':0,
'NODATA':None,
'TARGET_RESOLUTION':None,
'OPTIONS':'',
'DATA_TYPE':1, # GDAL GDT_Byte
'TARGET_EXTENT':None,
'TARGET_EXTENT_CRS':None,
'MULTITHREADING':False,
'EXTRA':'',
'OUTPUT':output_path
}
)

print("Step 3: Warp land_cover completed. (NLCD_" + year + "_" + state + part + "_Land_Cover_4326)")

##################### Step 4: Combine land cover 4326 and tree canopy 4326 #####################

input_path_a = path + state + '/data/NLCD_' + year + '_' + state + part + '_Tree_Canopy_4326.tiff'
input_path_b = path + state + '/data/NLCD_' + year + '_' + state + part + '_Land_Cover_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Tree_Land_Combined_4326.tiff'

expression = (
'(((B > 0) & (B < 255)) & (B != 41) & (B != 42) & (B != 43) & (A > 0)) * A + '
'((B == 41) | (B == 42) | (B == 43) | (A <= 0)) * B'
)
command = [
'gdal_calc.py',
'-A', input_path_a,
'-B', input_path_b,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows OS uses
#subprocess.run(command, shell=True)

print("Step 4: Combine tree canopy and land cover completed. (NLCD_" + year + "_" + state + part + "_Tree_Land_Combined_4326)")

##################### Step 5: Replace urban and clutter with grass #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Tree_Land_Combined_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Grass-Only_4326.tiff'

expression = (
'(A == 0) * 44 + '
'(A == 11) * 41 + '
'(A == 12) * 34 + '
'(A == 21) * 26 + '
'(A == 22) * 26 + '
'(A == 23) * 26 + '
'(A == 24) * 26 + '
'(A == 31) * 27 + '
'(A == 41) * 23 + '
'(A == 42) * 24 + '
'(A == 43) * 25 + '
'(A == 51) * 30 + '
'(A == 52) * 29 + '
'(A == 71) * 26 + '
'(A == 72) * 32 + '
'(A == 73) * 31 + '
'(A == 74) * 31 + '
'(A == 75) * 32 + '
'(A == 81) * 18 + '
'(A == 82) * 19 + '
'(A == 90) * 25 + '
'(A == 95) * 35'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows OS uses
#subprocess.run(command, shell=True)

print("Step 5: Replace urban and clutter with grass completed. (NLCD_" + year + "_" + state + part + "_Grass-Only_4326)")

##################### Step 6: Reclass urban 21, 22, 23 or 24 #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Tree_Land_Combined_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Reclassed-Urban_4326.tiff'

expression = (
'(A == 21)*10 + '
'(A == 22)*1 + '
'(A == 23)*1 + '
'(A == 24)*2'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows OS uses
#subprocess.run(command, shell=True)

print("Step 6: Reclass urban completed. (NLCD_" + year + "_" + state + part + "_Reclassed-Urban_4326)")

##################### Step 7: Remove clutter and roads from urban #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Reclassed-Urban_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Urban-Only_4326.tiff'

processing.run(
"grass7:r.neighbors",
{
'input':input_path,
'selection':None,
'method':1, #1=median, 2=mode
'size':7,
'gauss':None,
'quantile':'',
'-c':False,
'-a':False,
'weight':'',
'output':output_path,
'GRASS_REGION_PARAMETER':None,
'GRASS_REGION_CELLSIZE_PARAMETER':0,
'GRASS_RASTER_FORMAT_OPT': 'TYPE=BYTE',
'GRASS_RASTER_FORMAT_META':''
}
)

print("Step 7: Remove clutter and roads from urban. (NLCD_" + year + "_" + state + part + "_Urban-Only_4326)")

##################### Step 8: Combine grass only and clean urban #####################

input_path_a = path + state + '/data/NLCD_' + year + '_' + state + part + '_Urban-Only_4326.tiff'
input_path_b = path + state + '/data/NLCD_' + year + '_' + state + part + '_Grass-Only_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Combined-Clean_4326.tiff'

expression = (
'((A > 0) & (B > 0)) * A + '
'((A <= 0) | (B <= 0)) * B'
)
command = [
'gdal_calc.py',
'-A', input_path_a,
'-B', input_path_b,
'--outfile', output_path,
'--calc', expression,
'--NoDataValue', '0',
'--type', 'Byte'
]
subprocess.run(command)
#Windows OS uses
#subprocess.run(command, shell=True)

print("Step 8: Combined and clean completed. (NLCD_" + year + "_" + state + part + "_Combined-Clean_4326)")

##################### Step 9: Upsample to HD #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Combined-Clean_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Combined-Clean-HD_4326.tiff'

# Open the original raster
ds = gdal.Open(input_path)
gt = ds.GetGeoTransform()

# Extract the original resolution
original_xRes = gt[1]
original_yRes = abs(gt[5])

# Define the percentage to resize by (e.g., 0.50 for 50%, 2.0 for 200%)
#defined at the beginning of the script
#percentage = 8.0

# Calculate the new resolution
new_xRes = original_xRes / percentage
new_yRes = original_yRes / percentage

# Perform the warp (resampling)
gdal.Warp(
output_path,
input_path,
xRes=new_xRes,
yRes=new_yRes,
outputType=gdal.GDT_Byte # Set the output type to uint8
)

print("Step 9: Upsample to. (NLCD_" + year + "_" + state + part + "_Combined-Clean-HD_4326)")

##################### Step 10: Smooth all features in original dataset #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Combined-Clean-HD_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Smoothed-HD_4326.tiff'

processing.run(
"grass7:r.neighbors",
{
'input':input_path,
'selection':None,
'method':3, #1=median, 3=mode
'size':size,
'gauss':None,
'quantile':'',
'-c':False,
'-a':False,
'weight':'',
'output':output_path,
'GRASS_REGION_CELLSIZE_PARAMETER':0,
'GRASS_RASTER_FORMAT_OPT': 'TYPE=BYTE',
'GRASS_RASTER_FORMAT_META':''
}
)

print("Step 10: Smooth all features in original dataset completed. (NLCD_" + year + "_" + state + part + "_Smoothed-HD_4326)")

##################### Step 11: Compress and insure 8Bit #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Smoothed-HD_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Smoothed-HD-Compressed_4326.tiff'

processing.run(
"gdal:translate",
{
'INPUT':input_path,
'TARGET_CRS':None,
'NODATA':0,
'COPY_SUBDATASETS':False,
'OPTIONS':'',
'EXTRA':'',
'DATA_TYPE':1,
'OUTPUT':output_path,
'OPTIONS': 'COMPRESS=LZW'
}
)

result_bit_conversion_layer = QgsRasterLayer(output_path, 'NLCD_' + year + '_' + state + part + '_Smoothed-HD-Compressed_4326')
QgsProject.instance().addMapLayer(result_bit_conversion_layer)

print("Step 11: Convert to Compressed. (NLCD_" + year + "_" + state + part + "_Smoothed-HD-Compressed_4326)")
</syntaxhighlight>

=== Pure Python script to process NLCD for the USA (does not require using QGIS Python Console)===
<syntaxhighlight lang="python">
#!/usr/bin/env python3
import os
import subprocess
from pathlib import Path
from osgeo import gdal

# ----------------- CONFIG -----------------

BASE_PATH = Path("/media/wayne/TOSHIBA-EXT/Scenery/ws3.0")
YEAR = "2023"
STATE = "Alabama"
PART = "89-86_32"

# upsampling / smoothing
PERCENTAGE = 11.0
SIZE = 21

# GRASS config (adjust to your setup)
GRASS_BIN = "grass" # e.g. "grass", "grass82", or full path
GISDBASE = "/path/to/grassdata" # directory containing locations
LOCATION_NAME = "nlcd" # existing location name
MAPSET = "PERMANENT" # or a dedicated mapset

# ----------------- HELPERS -----------------

def run(cmd, check=True, env=None):
print(">>", " ".join(str(c) for c in cmd))
subprocess.run(cmd, check=check, env=env)

def gdal_calc(args):
"""
Fixes malformed args like '--type=Byte' and always appends --overwrite.
"""
fixed = []
for a in args:
if a.startswith("--") and "=" in a:
key, val = a.split("=", 1)
fixed.append(key)
fixed.append(val)
else:
fixed.append(a)

cmd = ["gdal_calc.py"] + fixed + ["--overwrite"]
run(cmd)

def gdalwarp(input_path, output_path, t_srs="EPSG:4326",
resampling="near", dtype="Byte", extra=None):
cmd = [
"gdalwarp",
"-t_srs", t_srs,
"-r", resampling,
"-ot", dtype,
"-overwrite",
input_path,
output_path
]
if extra:
cmd.extend(extra)
run(cmd)

def gdal_translate(input_path, output_path,
nodata=0, dtype="Byte", compress="LZW"):
cmd = [
"gdal_translate",
"-a_nodata", str(nodata),
"-ot", dtype,
"-co", f"COMPRESS={compress}",
"-overwrite",
input_path,
output_path
]
run(cmd)

def grass_env():
env = os.environ.copy()
env["GISDBASE"] = GISDBASE
env["LOCATION_NAME"] = LOCATION_NAME
env["MAPSET"] = MAPSET
return env

def grass_exec(args):
"""
FIXED: list-based wrapper that preserves argument order exactly.
"""
env = grass_env()
cmd = [GRASS_BIN, "--exec"] + args
print(">>", " ".join(cmd))
subprocess.run(cmd, check=True, env=env)

def grass_r_neighbors(input_raster, output_raster,
method="median", size=7):
"""
Import GeoTIFF -> set region -> r.neighbors -> export GeoTIFF.
Includes -f to allow DCELL->Byte export.
"""
in_name = "in_rast"
out_name = "out_rast"

# 1) import
grass_exec([
"r.in.gdal",
f"input={input_raster}",
f"output={in_name}",
"--overwrite"
])

# 2) set region to raster (fixes extent issues)
grass_exec([
"g.region",
f"raster={in_name}"
])

# 3) neighbors
grass_exec([
"r.neighbors",
f"input={in_name}",
f"output={out_name}",
f"method={method}",
f"size={size}",
"--overwrite"
])

# 4) export (with -f)
grass_exec([
"r.out.gdal",
"-f",
f"input={out_name}",
f"output={output_raster}",
"format=GTiff",
"type=Byte",
"--overwrite"
])

def p(*parts):
return str(BASE_PATH.joinpath(STATE, *parts))

# ----------------- STEPS -----------------

def step1_tree_canopy_reclass():
src = p("data", "source", f"NLCD_{YEAR}_Tree_Canopy_{STATE}{PART}.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Trees-Combined.tiff")

expr = "((A > 0) & (A < 255)) * 43 + (A <= 0) * A"
gdal_calc([
"-A", src,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 1: Trees-Combined")

def step2_warp_tree_canopy_4326():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Trees-Combined.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Canopy_4326.tiff")
gdalwarp(src, dst)
print("Step 2: Tree_Canopy_4326")

def step3_warp_land_cover_4326():
src = p("data", "source", f"NLCD_{YEAR}_Land_Cover_{STATE}{PART}.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Land_Cover_4326.tiff")
gdalwarp(src, dst)
print("Step 3: Land_Cover_4326")

def step4_combine_tree_land_4326():
a = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Canopy_4326.tiff")
b = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Land_Cover_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Land_Combined_4326.tiff")

expr = (
"(((B > 0) & (B < 255)) & (B != 41) & (B != 42) & (B != 43) & (A > 0)) * A + "
"((B == 41) | (B == 42) | (B == 43) | (A <= 0)) * B"
)
gdal_calc([
"-A", a,
"-B", b,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 4: Tree_Land_Combined_4326")

def step5_replace_urban_clutter_with_grass():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Land_Combined_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Grass-Only_4326.tiff")

expr = (
"(A == 0) * 44 + "
"(A == 11) * 41 + "
"(A == 12) * 34 + "
"(A == 21) * 26 + "
"(A == 22) * 26 + "
"(A == 23) * 26 + "
"(A == 24) * 26 + "
"(A == 31) * 27 + "
"(A == 41) * 23 + "
"(A == 42) * 24 + "
"(A == 43) * 25 + "
"(A == 51) * 30 + "
"(A == 52) * 29 + "
"(A == 71) * 26 + "
"(A == 72) * 32 + "
"(A == 73) * 31 + "
"(A == 74) * 31 + "
"(A == 75) * 32 + "
"(A == 81) * 18 + "
"(A == 82) * 19 + "
"(A == 90) * 25 + "
"(A == 95) * 35"
)
gdal_calc([
"-A", src,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 5: Grass-Only_4326")

def step6_reclass_urban():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Tree_Land_Combined_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Reclassed-Urban_4326.tiff")

expr = (
"(A == 21)*10 + "
"(A == 22)*1 + "
"(A == 23)*1 + "
"(A == 24)*2"
)
gdal_calc([
"-A", src,
"--outfile", dst,
"--calc", expr,
"--type", "Byte"
])
print("Step 6: Reclassed-Urban_4326")

def step7_remove_clutter_roads_from_urban():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Reclassed-Urban_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Urban-Only_4326.tiff")

grass_r_neighbors(src, dst, method="median", size=7)
print("Step 7: Urban-Only_4326")

def step8_combine_grass_and_clean_urban():
a = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Urban-Only_4326.tiff")
b = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Grass-Only_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean_4326.tiff")

expr = "((A > 0) & (B > 0)) * A + ((A <= 0) | (B <= 0)) * B"
gdal_calc([
"-A", a,
"-B", b,
"--outfile", dst,
"--calc", expr,
"--NoDataValue", "0",
"--type", "Byte"
])
print("Step 8: Combined-Clean_4326")

def step9_upsample_to_hd():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean-HD_4326.tiff")

ds = gdal.Open(src)
if ds is None:
raise RuntimeError(f"Cannot open {src}")
gt = ds.GetGeoTransform()
original_xRes = gt[1]
original_yRes = abs(gt[5])

new_xRes = original_xRes / PERCENTAGE
new_yRes = original_yRes / PERCENTAGE

gdal.Warp(
dst,
src,
xRes=new_xRes,
yRes=new_yRes,
outputType=gdal.GDT_Byte
)
print("Step 9: Combined-Clean-HD_4326")

def step10_smooth_all_features():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Combined-Clean-HD_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Smoothed-HD_4326.tiff")

grass_r_neighbors(src, dst, method="median", size=SIZE)
print("Step 10: Smoothed-HD_4326")

def step11_convert_to_8bit_compressed():
src = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Smoothed-HD_4326.tiff")
dst = p("data", f"NLCD_{YEAR}_{STATE}{PART}_Smoothed-HD-Compressed_4326.tiff")

gdal_translate(src, dst)
print("Step 11: Smoothed-HD-Compressed_4326")

# ----------------- MAIN -----------------

def main():
step1_tree_canopy_reclass()
step2_warp_tree_canopy_4326()
step3_warp_land_cover_4326()
step4_combine_tree_land_4326()
step5_replace_urban_clutter_with_grass()
step6_reclass_urban()
step7_remove_clutter_roads_from_urban()
step8_combine_grass_and_clean_urban()
step9_upsample_to_hd()
step10_smooth_all_features()
step11_convert_to_8bit_compressed()

if __name__ == "__main__":
main()
</syntaxhighlight>

Howto:Create WS3.0 terrain

2026-05-15T16:49:50Z

Wlbragg: /* Running the docker container */

{{WS30 Navbar}}
This article provides instructions on how to generate basic WS3.0 terrain.

WS3.0 terrain consists of three parts:

# A terrain mesh consisting of a landclass texture draped over an elevation model.
# A high resolution water raster used to show water features such as rivers, lakes and coastline with more definition
# Line features such as roads and railways.

The terrain is generated by a set of tools that are packaged in a docker image for convenience.[[File:Diagram-export-21-12-2023-16 29 37.png|thumb|Basic WS3.0 Scenery Generation Process]]

== Prerequisites ==

=== Set up a Workspace ===
Create a directory with the following sub-directories:

* <code>cache</code>
* <code>data</code>
* <code>output/vpb</code>
* <code>output/Terrain</code>

=== Docker ===

# Install [https://docs.docker.com/get-started/ Docker] on your platform.
#Pull the docker image by running the following command

docker pull flightgear/ws30-vpb-generator:latest
Optionally, if you are hitting rate limits:
#Create an account on https://hub.docker.com/. (Note that you will need to click on an email verification link before you can log in for the first time)
#Run <code>docker login</code> before the '''docker pull''' command above

== Getting the base data ==
You need two pieces of data for the area of scenery you are generating:

# An elevation model (aka DEM). This indicates what altitude each point of the surface is.
# Landclass data showing what type of terrain is at each point of the surface. This is often either a Raster (effectively a texture), or vector data.

=== Elevation Model ===
Download the NASADEM elevation model for the area of scenery you wish to generate. This is available in 1x1 degree blocks from [https://lpdaac.usgs.gov/products/nasadem_hgtv001/ here], and with an interactive browser [https://search.earthdata.nasa.gov/search here].

Unzip the files into the <code>data</code> directory.

=== Landclass Raster ===
Download an landclass raster for the area of scenery you wish to generate.

* For Europe, use of [https://land.copernicus.eu/pan-european/corine-land-cover/clc2018 CORINE] is recommended.
* For the USA [https://www.mrlc.gov/viewer/ NLCD] is recommended
* Sentinel-2 data is available for the entire world via [https://livingatlas.arcgis.com/landcoverexplorer/ ESRI], but has limited set of landclasses.

Put these into the <code>data</code> directory.

More detailed terrain can be created by modifying the landclass raster, and/or generating a new raster from vector data. These processes are discussed below.

== Generating Terrain ==
To generate terrain you need to run the tools within the docker container we installed above. The docker image is like a small, independent virtual computing environment running within your system. This particular docker image has all the scenery generation tools already installed.

=== Running the docker container ===
Firstly, get the container running from the directory containing your <code>cache</code>, <code>data</code> and <code>output</code> directories:
docker run --rm --mount "type=bind,source=`pwd`/data,target=/home/flightgear/data,readonly" --mount "type=bind,source=`pwd`/output,target=/home/flightgear/output" --mount "type=bind,source=`pwd`/cache,target=/home/flightgear/cache" -it flightgear/ws30-vpb-generator:latest /bin/bash

You should now find yourself in a bash shell within your container. You should see data and output directories which are linked to the directories you created earlier:
flightgear@ddcac77f7d5e:~$ ls
cache data output bin scripts
In the Windows environment using Docker Desktop, if you need a path to a source of elevation data and a path to the OSM shoreline shapefiles, you can add the following:
docker run --rm --mount "type=bind,source=G:/Scenery/ws3.0/Alabama/data,target=/home/flightgear/data,readonly" --mount "type=bind,source=G:/Scenery/WS3.0-extra/vector/land-polygons-complete-4326,target=/home/flightgear/coastlines" --mount "type=bind,source=G:/Scenery/WS3.0-extra/SRTM-1,target=/home/flightgear/SRTM-3,readonly" --mount "type=bind,source=G:/Scenery/ws3.0/Alabama/output,target=/home/flightgear/output" --mount "type=bind,source=G:/Scenery/ws3.0/Alabama/output/cache,target=/home/flightgear/cache" -it flightgear/ws30-vpb-generator:latest /bin/bash

Note: the --mount "type=bind,source=G:/Scenery/WS3.0-extra/SRTM-1,target=/home/flightgear/SRTM-3,readonly", the genVPB.py script in the Docker container is expecting a location of /home/flightgear/SRTM-3 for the elevation data. In this example I am using SRTM-1 elevation data, but we still map it to the expected /home/flightgear/SRTM-3 Docker container location.
=== Building the terrain ===
To build the terrain mesh, use the <code>genVPB.py</code> tool from inside the docker container:

Usage: genVPB.py --raster <input-raster> [ option ... ]
Usage: genVPB.py --bbox <lat0> <lon0> <lat1> <lon1> --sentinel --reclass <reclass> [ option ... ]

Arguments:
--raster RASTER Input landclass raster.
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--sentinel Use Sentinel2 landclass tiles
--sentinel-dir SENTINEL_DIR Directory for Sentinel Data. Default /home/flightgear/data/Sentinel-2
--hgt-dir HGT_DIR Directory containing HGT DEM files. Default /home/flightgear/data/NASADEM
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/output
--download-sentinel Download Sentinel2 tiles if needed
--reclass RECLASS Reclassify raster using file <reclass>. See ./scripts/mappings/
--coastline COASTLINE Clip against coastline against polygon (.osm)
--shrink-water SHRINK_WATER Shrink water bodies (landclasses 40, 41) by <pixels> pixels
--generate-water-raster Generate a water raster from OSM data
--generate-line-features Generate a water raster from OSM data
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--nasadem-server NASADEM_SERVER Set server to download NASADEM data from. Default https://e4ftl01.cr.usgs.gov/MEASURES/NASADEM_HGT.001/2000.02.11/)
--nasadem-user NASADEM_USER NASA Earthdata username.
--nasadem-password NASADEM_PASSWORD NASA Earthdata password.
--debug Debug output

For example, to generate a piece of terrain around Edinburgh (latitude 55.5, longitude 3 degrees West):
./scripts/genVPB.py --bbox 55 -4 56 -3 --raster ./data/uk_wgs84_10m_N54.tif

Another example, to generate a coastal area with shorelines and lakes, like Alaska:
./scripts/genVPB.py --bbox 68 -167 69 -152 --raster ./data/NLCD_2016_Alaska167-153_68_Smoothed-HD-Compressed_4326.tiff --hgt-dir ./SRTM-3/ --generate-water-raster --shrink-water 4 --coastline ./coastlines/land_polygons.shp

Same thing with roads and rails (line features):
./scripts/genVPB.py --bbox 68 -167 69 -152 --raster ./data/NLCD_2016_Alaska167-153_68_Smoothed-HD-Compressed_4326.tiff --hgt-dir ./SRTM-3/ --generate-water-raster --shrink-water 4 --coastline ./coastlines/land_polygons.shp --generate-line-features

--coastline requires OSM data mask from here [https://osmdata.openstreetmap.de/data/land-polygons.html OSM Shapefiles] Make sure you download the shapefiles on this page and not the alternate "Water polygons or Coastlines". It is the land cover shapefiles that are used as the cutting mask, not the water line data.

If you are using anything other than a CORINE raster you will need to reclassify the data to match the landclasses used by FlightGear. Those classes are defined in [https://gitlab.com/flightgear/fgdata/-/tree/next/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml]. You can reclassify them using the files in the [https://gitlab.com/flightgear/fgmeta/-/tree/next/ws30/mappings/ scripts/mappings] directory. E.g. to reclassify NLCD2019 data you can use <code>--reclassify ./scripts/mappings/nlcd2019.txt</code>.

genVPB.py will output the data to the output/vpb directory, in which you should find a series of files and directories.

=== Adding water ===
'''Update 05/12/2026: Depreciated, it is now built into genVPB.py above.'''

'''Use genVPB.py ...... --generate-water-raster --shrink-water 4 --coastline [path_to_shapefile_mask]'''

The terrain mesh does not have highly detailed water features - as typically the source data has a resolution of 10-25m. Water features are generated from OpenStreetMap data. To generate water features simply run the <code>genwaterraster.py</code> command.

Usage: genwaterraster.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--output-dir OUTPUT_DIR] [--cache-dir CACHE_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--output-dir OUTPUT_DIR Directory to write files into. Default /home/flightgear/output
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache

For example, to generate water for the area around Edinburgh:
./scripts/genwaterraster.py --bbox 55 -4 56 -3

Inside the ./output/vpb directory there should be a set of directories and .png files.

=== Adding roads and railways ===
The terrain mesh does not have any line features - things like roads. These are generated separately from OpenStreetMap data. To generate line features simply run the <code>genroads.py</code> command:

Usage: ./scripts/genroads.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--threads THREADS] [--cache-dir CACHE_DIR] [--output-dir OUTPUT_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--threads THREADS Number of parallel threads to run. Defaults to 1
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/cache/

For example, to generate roads for the area around Edinburgh:
./scripts/genroads.py --bbox 55 -4 56 -3

Inside the ./output/Terrain directory there should be a set of directories and, .STG files text files.

==Running FlightGear with the new WS3.0 Terrain==
To test the new terrain, simply include the output directory in your scenery path and run FlightGear with the <code>--prop:/scenery/use-vpb=true</code> to enable WS3.0.

== Advanced Techniques ==
The following sections describe more complex techniques to generate higher quality WS3.0 terrain. Almost all of them involve using different data sources to generate a more detailed landclass raster before running the final scenery generation processes described above. Generating a highly detailed landclass raster is where the magic happens.

Most techniques use gdal or grass to modify the raster/vector data, typically using the QGIS program.

=== Using a different elevation model ===
If you are using another elevation model other than NASAEM, then you may need to re-project it using QGIS/gdalwarp to the WGS84 CRS (aka EPSG:4326).

=== Landclass Data Requirements ===
For any landclass data we need to ensure the data is in the correct format. That means:

# Is a Raster (geotiff) rather than Vector data. This raster will become the texture on the terrain that the terrain shaders do their magic on.
# Uses the WGS84 Coordinate Reference System. The ensures that the terrain generation step is efficient.
# Has the correct landclass values for each terrain type. We use a set of values based on the CORINE raster set, defined in [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml].

Below is a quick table showing what steps you need to take for common landclass data sources.
{| class="wikitable"
|+
!Landclass Data
!Warp to WGS84 required?
!Landclass re-classification Required?
!Raster Simplification Required?
!Conversion to Raster Required?
|-
|CORINE Raster
|Yes
|No
|No
|No
|-
|CORINE Vector
|Yes
|Yes
|No
|Yes
|-
|NLCD
|No
|Yes
|Yes
|No
|-
|Sentinel-2
|Yes
|Yes
|No
|No
|}
Conversion to Raster must be done manually. Converting to WGS84 and the correct landclasses ''can'' be done by the genVPB.py script, but slows down scenery generation. Therefore if you are planning to generate scenery multiple times it is best to pre-process the files yourself.

The easiest way to do these operations is using QGIS, which is available for most platforms. If you are scripting a toolchain, the QGIS tools include command-line equivalents for all commands.

When using QGIS, set the Project CRS to WGS84 (aka EPSG:4326). You can then add layers of Raster or Vector data from files from the <code>Layer->Add Layer</code> menu. When performing any operations, <u>always</u> write out the data to a real file so you can go back to it later. Disk space is cheap :).

=== Warping Raster Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a raster layer to a different CRS using the Raster->Projections-Warp (Reproject) tool.

Select the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Resampling Method to Use - Nearest Neighbour. (Landclass data is not like normal images. You don't want to interpolate between values.)
* Nodata value for output bands - 0.0 (This means that any data at the edges will be Ocean, usually a reasonable default)
* Advanced Parameters - No Compression
* Output data type - Byte
* Reprojected - Choose a target filename

Alternatively you can do this step from the commandline.
gdalwarp -t_srs EPSG:4326 -dstnodata 0.0 -r near -ot Byte -of GTiff -co COMPRESS=NONE -co BIGTIFF=IF_NEEDED /home/stuart/FlightGear/VPB/data/CORINE/u2018_clc2018_v2020_20u1_raster100m/DATA/U2018_CLC2018_V2020_20u1.tif /home/stuart/FlightGear/VPB/data/scratch/corine_WGS84.tif

=== Warping Vector Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a vector layer using Vector->Data Management Tools->Reproject Layer.

Set the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Reprojected - Choose a target filename

=== Reclassifying Vector Layers ===
For CORINE vector data in particular, the attributes used in the vector data are not the same as those used by the CORINE Raster data. So we need to create a new attribute on the data.
[[File:Field Calculator.png|thumb|QGIS Field Calculator]]
To do this

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialog
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type "Whole Number (Integer)". This will create a new column which we will populate with the correct landclass data
* Click on the <code>Open Field Calculator</code> button (Ctrl + I). (If you get an error about only being able to create Virtual fields, go back to the Layer menu, export it and open the exported file).
* Select the following options:
** Update Existing Field
** Select the Landclass field you just created.
** Copy the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/corine_vector.txt into the Expression box (without the comment lines starting with <code>#</code>). This is just some simple code to set the attribute correctly. The code should be correct for CORINE vector data. If your data is from other sources you will need to work out how you want to map your source data landclasses to the CORINE ones. [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml] can be used as a guide.
* Select <code>OK</code>. You should see that your landclass column is now populated with the landclass data.
* Select <code>Layer->Save Layer Edits</code> to save you changes

=== Creating a Raster from a Vector Layer ===
To create a Raster from a Vector Layer select <code>Raster->Conversion->Rasterize (Vector to Raster)</code>.
[[File:QGIS Rasterize (Vector to Raster).png|thumb|Creating a Raster from a Vector Layer - QGIS Rasterize]]
Select the following options:

* Input Layer - correct layer, check CRS
* Field to use for burn-in value - select the <code>Landclass</code> column you created above.
* Output raster size units. This is going to set the resolution of your raster. You can work out the resolution in two different ways:
** Select "Georeferenced units" and determine how many degrees each pixel is in latitude and longitude.
** Select "Pixels" and determine the size of raster you want in pixels. [https://www.nhc.noaa.gov/gccalc.shtml This] is a good calculator to help. You input e.g. SE and SW coordinates and calculate to get the distance in Km. Then you multiply by thousand and devide by the number of metres per pixel (e.g. 5) -> resolution for width.
* Width/Horizontal Resolution. Enter the values you've calculated for the horizontal resolution (longitudinal), or the width of the raster
* Height/Vertical Resolution. Enter the values you've calculated for the vertical resolution (latitude or the height of the raster)
* Output extent - Select an option from the box on the right. You can edit the text afterwards (NB: East, West, South, North). Best practise is to create long thin strips of 1 degree latitude in height, as this makes subsequent processing much easier.
* Assign a specific nodata value to output bands - Select 0.0 for Ocean. CORINE vector data in particular has a lot of nodata for Oceans
* Advanced Parameters - No Compression
* Output data type - Byte
* Rasterized - Select a new filename

=== Simplifying a Raster Layer ===
Some Raster Landclass data (NLCD included) has too much noise - in particular large US highway systems are identified as Urban areas.

To smooth it out we can use the GRASS <code>n.neighbors</code> function from the Processing Toolbox in QGIS.

Select the following options:

* Input Layer - correct layer, check CRS
* Neighborhood operation - median. (This is not a normal image, so using an average will result in weird values)
* Neighborhood size - 5.
* Neighbors - Select a new filename.

=== Clipping a Raster Layer with OSM Data for Land (Corine) ===
The Corine dataset does not match OSM coastlines exactly. The following multi-stage process makes sure, that no Corine land-use is in the water as defined by OSM.

==== Download OSM Land Data ====

Download land polygons based on OSM data as a Shapefile from [https://osmdata.openstreetmap.de/data/land-polygons.html Land Polygons] and make sure to pick the WGS84 projected download with split polygons ("Large polygons are split, use for larger scales"). Once downloaded unzip the content into a directory.

==== Reclassifying the OSM Land Data Vector Layer ====
I QGIS make sure that only the layer for the raster for land data is selected (e.g. <code>land-polygons-split-4326</code>) -> in the map view you will see the whole earth. NB: typically you do this reclassify only once after download and can reuse the result for future processing.

Then:

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialogue
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type <code>Integer (32 bit)</code>. This will create a new column which we will populate with the correct land class data
* On top of the table on the left side choose "Landclass" in the drop-down menu, then input <code>2</code> into the field to the right and then press button "Update" all to the left of this field.
* Wait a bit and the close the dialogue.
* Select <code>Layer->Save Layer Edits</code> to save your changes (overwrite e.g. <code>land-polygons-split-4326</code>).

==== Convert the Land Data from Vector to Raster ====
Do the same as in chapter "Creating a Raster from a Vector Layer" above. The only difference is that the Input layer will be the land data polygons and you need to choose a different file name for the "Rasterized" (e.g. osm_land_scotland_5m.tif)

==== Remove Novalue Entries in the Land Data Raster ====
To do this:

* Select <code>Processing->Toolbox</code>. You should see a new box on the right side.
* Write "gdal_calc" in the search box and you should see an entry "Raster calculator". Double click on it and you will get a new dialogue window.
* In this dialogue:
** For "Input layer A" choose the raster from the previous chapter ((e.g. osm_land_scotland_5m.tif)
** In field "Calculation in gdalnumeric ..." write: <code>greater(A,0) * A</code>
** In field "Output raster type" choose <code>Byte</code>
** In field "Advanced Parameters" choose Profile <code>No compression</code>
** In field "Additional command-line parameters" write: <code>--hideNoData</code>
** In field "Calculated" choose a file (e.g. osm_land_scotland_allvalues_5m.tif)
** (In the "GDAL/OGR console call" it will have something similar to the follwing - just with different paths: <code>gdal_calc.py --overwrite --calc "greater(A ,0) * A" --format GTiff --type Byte -A /home/vanosten/custom-fg-scenery/data/osm_land_scotland_5m.tif --A_band 1 --co COMPRESS=NONE --co BIGTIFF=IF_NEEDED --hideNoData --outfile /home/vanosten/custom-fg-scenery/data/osm_land_scotland_allvalues_5m.tif</code>
** Press the "Run" button - and when complete close the dialogue.

You should now see a map only black and white. You can check for correctness by pressing <code>CTRL+SHIFT+I</code> to get a cursor with an arrow and an "i". First make sure the new raster is selected on the left side. Next click on the sea/ocean and then check in the "Identify Results" window on the right that the value is < 2. The click on the land and check that the value is 2.

==== Create the Final Clipped Corine Raster Against OSM Land Data =====
Do the following:

* In QGIS make sure that you have only the following two layers: the basis Corine raster (see chapter "Creating a Raster from a Vector Layer" - here e.g. corine_raster_scotland_5m.tif) and plus the raster from the previous step (e.g. osm_land_scotland_allvalues_5m.tif)
* Select <code>Raster->Raster Calculator ...</code> and a corresponding dialogue will open showing on the left hand side the two rasters.
* Choose a new "Output layer" (e.g. corine_raster_scotland_clipped_5m.tif).
* In the "Raster Calculator Expression" field input: <code>if ("osm_land_scotland_all_data_5m@1" < 2, 44, "corine_raster_scotland_5m@1")</code>
* Press button "OK" and wait a while (you will see a new dialogue with showing the progress.

Done. You have now a raster (e.g. corine_raster_scotland_clipped_5m.tif) which does not have land in areas, where OSM data has sea/ocean.

=== Reclassifying a Raster Layer ===
WS3.0 uses CORINE landclass values. If using data from other sources it needs to be reclassified to the correct values. genVPB.py has an option to do this, but you may wish to do so manually.

To do this select <code>GRASS->Raster->r.reclass</code> from the Processing Toolbox.

Select the following options:

* Input Raster Layer - correct layer, check CRS
* Reclass rules text - copy in the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/nlcd2019.txt. Or an appropriate mapping from your landclass data to CORINE. Note that you can also reference a file using the "File containing reclass rules" option. Note a mapping of 22 24 = 1 is the same as 22 and 24 = 1. For a range of 22 to 24 use 22 23 24 = 1.
* Reclassified - Select a new filename.

(If this doesn't work a similar function is available in the Processing Toolbox under <code>Raster analysis->Reclassify by table</code>. However this doesn't save your table once you close the dialog, and entries have to be manually entered individually which takes a lot of effort)

=== Processing NLCD for USA using the Raster Calculator and tools in QGIS ===

[[Processing_NLCD_for_USA_using_Raster_Calculator_and_tools_in_QGIS]]

=== Python script to process NLCD for the USA ===

[[Python_script_to_process_NLCD_for_the_USA]]

=== Python script to process Sentinel-2 data ===

[[Python_script_to_process_Sentinel-2_data]]

===Generating the Terrain using osgdem===
Instead of using genVPB.py, you may wish to run osgdem directly.

In the Windows/Docker platform you can send the generate tile command directly to osgdem.exe, one tile at a time.

Using the NLCD raster processing convention from above, following is the the final step after creating the raster and entering bash shell with the windows version of "docker run..."

osgdem --TERRAIN --image-ext png --RGBA --no-interpolate-imagery --disable-error-diffusion --geocentric --no-mip-mapping -t ./data/California-Southern_4326-84-hd-corrected.tiff -d ./SRTM-3/N32W115.hgt -b -115 32 -114 33 --PagedLOD -l 7 --radius-to-max-visible-distance-ratio 3 -o ./output/vpb/w120n30/w115n32/ws_w115n32.osgb

Note: the --image-ext png --RGBA flags are critical to successfully building correctly placed landclasses in the final VPB generated scenery.

If you prefer to run the scenery generation manually, running the VPB osgdem process is described in more detail here: [[Virtual Planet Builder#Running VPB]].

After doing this you should have an output directory containing files of the form <code>output/vpb/w010n50/w004n50/ws_w004n50.osgb</code>, plus a host of sub-directories. Each one of these is a 1x1 tile of terrain.

to leave the container simply type <code>exit</code>.

===Packaging the Scenery===
Once you have the terrain and line features they should be packaged in a scenery directory in vpb and Terrain sub-directories respectively. E.g.
MyCoolScenery/Terrain
MyCoolScenery/vpb
It is good practise to document the data sources used in scenery generation. Some source licenses require attribution of the original data source for anything derived, published or distributed.

To assist in fulfilling these license obligations, you can create a source.xml file in the scenery directory which includes attribution information. This will then be available from within the simulator under Help->Scenery Sources, and <u>may</u> fulfil the attribution requirements of your license. '''Note that you are responsible for fulfilling any license requirements from the data, not FlightGear'''.

The format of the file is straightforward:
<?xml version="1.0"?>
<PropertyList>
<nowiki><source></nowiki>
<name>Corine Land Cover (CLC) 2018, Version 2020_20u1</name>
<nowiki><link></nowiki><nowiki>http://web.archive.org/web/20221112175615/https://land.copernicus.eu/pan-european/corine-land-cover/clc2018?tab=metadata%2A</nowiki><nowiki></link></nowiki>
<license>GMES Open License</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>NASADEM Merged DEM Global 1 arc second V001</name>
<nowiki><link></nowiki><nowiki>https://www.earthdata.nasa.gov/</nowiki><nowiki></link></nowiki>
<license>Public Domain</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>OpenStreetMap</name>
<nowiki><link></nowiki><nowiki>https://www.openstreetmap.org/copyright</nowiki><nowiki></link></nowiki>
<license>Open Data Commons Open Database License</license>
<nowiki></source></nowiki>
</PropertyList>

Howto:Create WS3.0 terrain

2026-05-15T16:32:19Z

Wlbragg: /* Building the terrain */

{{WS30 Navbar}}
This article provides instructions on how to generate basic WS3.0 terrain.

WS3.0 terrain consists of three parts:

# A terrain mesh consisting of a landclass texture draped over an elevation model.
# A high resolution water raster used to show water features such as rivers, lakes and coastline with more definition
# Line features such as roads and railways.

The terrain is generated by a set of tools that are packaged in a docker image for convenience.[[File:Diagram-export-21-12-2023-16 29 37.png|thumb|Basic WS3.0 Scenery Generation Process]]

== Prerequisites ==

=== Set up a Workspace ===
Create a directory with the following sub-directories:

* <code>cache</code>
* <code>data</code>
* <code>output/vpb</code>
* <code>output/Terrain</code>

=== Docker ===

# Install [https://docs.docker.com/get-started/ Docker] on your platform.
#Pull the docker image by running the following command

docker pull flightgear/ws30-vpb-generator:latest
Optionally, if you are hitting rate limits:
#Create an account on https://hub.docker.com/. (Note that you will need to click on an email verification link before you can log in for the first time)
#Run <code>docker login</code> before the '''docker pull''' command above

== Getting the base data ==
You need two pieces of data for the area of scenery you are generating:

# An elevation model (aka DEM). This indicates what altitude each point of the surface is.
# Landclass data showing what type of terrain is at each point of the surface. This is often either a Raster (effectively a texture), or vector data.

=== Elevation Model ===
Download the NASADEM elevation model for the area of scenery you wish to generate. This is available in 1x1 degree blocks from [https://lpdaac.usgs.gov/products/nasadem_hgtv001/ here], and with an interactive browser [https://search.earthdata.nasa.gov/search here].

Unzip the files into the <code>data</code> directory.

=== Landclass Raster ===
Download an landclass raster for the area of scenery you wish to generate.

* For Europe, use of [https://land.copernicus.eu/pan-european/corine-land-cover/clc2018 CORINE] is recommended.
* For the USA [https://www.mrlc.gov/viewer/ NLCD] is recommended
* Sentinel-2 data is available for the entire world via [https://livingatlas.arcgis.com/landcoverexplorer/ ESRI], but has limited set of landclasses.

Put these into the <code>data</code> directory.

More detailed terrain can be created by modifying the landclass raster, and/or generating a new raster from vector data. These processes are discussed below.

== Generating Terrain ==
To generate terrain you need to run the tools within the docker container we installed above. The docker image is like a small, independent virtual computing environment running within your system. This particular docker image has all the scenery generation tools already installed.

=== Running the docker container ===
Firstly, get the container running from the directory containing your <code>cache</code>, <code>data</code> and <code>output</code> directories:
docker run --rm --mount "type=bind,source=`pwd`/data,target=/home/flightgear/data,readonly" --mount "type=bind,source=`pwd`/output,target=/home/flightgear/output" --mount "type=bind,source=`pwd`/cache,target=/home/flightgear/cache" -it flightgear/ws30-vpb-generator:latest /bin/bash

You should now find yourself in a bash shell within your container. You should see data and output directories which are linked to the directories you created earlier:
flightgear@ddcac77f7d5e:~$ ls
cache data output bin scripts
In the windows environment using Docker Desktop, if you need a path to a source of elevation data and a path to the OSM shoreline shapefiles, you can add the following:
docker run --rm --mount "type=bind,source=G:/Scenery/ws3.0/Alabama/data,target=/home/flightgear/data,readonly" --mount "type=bind,source=G:/Scenery/WS3.0-extra/vector/land-polygons-complete-4326,target=/home/flightgear/coastlines" --mount "type=bind,source=G:/Scenery/WS3.0-extra/SRTM-1,target=/home/flightgear/SRTM-3,readonly" --mount "type=bind,source=G:/Scenery/ws3.0/Alabama/output,target=/home/flightgear/output" --mount "type=bind,source=G:/Scenery/ws3.0/Alabama/output/cache,target=/home/flightgear/cache" -it flightgear/ws30-vpb-generator:latest /bin/bash

Note: the --mount "type=bind,source=G:/Scenery/WS3.0-extra/SRTM-1,target=/home/flightgear/SRTM-3,readonly", the genVPB.py script in the Docker container is expecting a location of /home/flightgear/SRTM-3 for the elevation data. In this example I am using SRTM-1 elevation data, but we still map it to the expected /home/flightgear/SRTM-3 Docker container location.
=== Building the terrain ===
To build the terrain mesh, use the <code>genVPB.py</code> tool from inside the docker container:

Usage: genVPB.py --raster <input-raster> [ option ... ]
Usage: genVPB.py --bbox <lat0> <lon0> <lat1> <lon1> --sentinel --reclass <reclass> [ option ... ]

Arguments:
--raster RASTER Input landclass raster.
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--sentinel Use Sentinel2 landclass tiles
--sentinel-dir SENTINEL_DIR Directory for Sentinel Data. Default /home/flightgear/data/Sentinel-2
--hgt-dir HGT_DIR Directory containing HGT DEM files. Default /home/flightgear/data/NASADEM
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/output
--download-sentinel Download Sentinel2 tiles if needed
--reclass RECLASS Reclassify raster using file <reclass>. See ./scripts/mappings/
--coastline COASTLINE Clip against coastline against polygon (.osm)
--shrink-water SHRINK_WATER Shrink water bodies (landclasses 40, 41) by <pixels> pixels
--generate-water-raster Generate a water raster from OSM data
--generate-line-features Generate a water raster from OSM data
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--nasadem-server NASADEM_SERVER Set server to download NASADEM data from. Default https://e4ftl01.cr.usgs.gov/MEASURES/NASADEM_HGT.001/2000.02.11/)
--nasadem-user NASADEM_USER NASA Earthdata username.
--nasadem-password NASADEM_PASSWORD NASA Earthdata password.
--debug Debug output

For example, to generate a piece of terrain around Edinburgh (latitude 55.5, longitude 3 degrees West):
./scripts/genVPB.py --bbox 55 -4 56 -3 --raster ./data/uk_wgs84_10m_N54.tif

Another example, to generate a coastal area with shorelines and lakes, like Alaska:
./scripts/genVPB.py --bbox 68 -167 69 -152 --raster ./data/NLCD_2016_Alaska167-153_68_Smoothed-HD-Compressed_4326.tiff --hgt-dir ./SRTM-3/ --generate-water-raster --shrink-water 4 --coastline ./coastlines/land_polygons.shp

Same thing with roads and rails (line features):
./scripts/genVPB.py --bbox 68 -167 69 -152 --raster ./data/NLCD_2016_Alaska167-153_68_Smoothed-HD-Compressed_4326.tiff --hgt-dir ./SRTM-3/ --generate-water-raster --shrink-water 4 --coastline ./coastlines/land_polygons.shp --generate-line-features

--coastline requires OSM data mask from here [https://osmdata.openstreetmap.de/data/land-polygons.html OSM Shapefiles] Make sure you download the shapefiles on this page and not the alternate "Water polygons or Coastlines". It is the land cover shapefiles that are used as the cutting mask, not the water line data.

If you are using anything other than a CORINE raster you will need to reclassify the data to match the landclasses used by FlightGear. Those classes are defined in [https://gitlab.com/flightgear/fgdata/-/tree/next/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml]. You can reclassify them using the files in the [https://gitlab.com/flightgear/fgmeta/-/tree/next/ws30/mappings/ scripts/mappings] directory. E.g. to reclassify NLCD2019 data you can use <code>--reclassify ./scripts/mappings/nlcd2019.txt</code>.

genVPB.py will output the data to the output/vpb directory, in which you should find a series of files and directories.

=== Adding water ===
'''Update 05/12/2026: Depreciated, it is now built into genVPB.py above.'''

'''Use genVPB.py ...... --generate-water-raster --shrink-water 4 --coastline [path_to_shapefile_mask]'''

The terrain mesh does not have highly detailed water features - as typically the source data has a resolution of 10-25m. Water features are generated from OpenStreetMap data. To generate water features simply run the <code>genwaterraster.py</code> command.

Usage: genwaterraster.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--output-dir OUTPUT_DIR] [--cache-dir CACHE_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--output-dir OUTPUT_DIR Directory to write files into. Default /home/flightgear/output
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache

For example, to generate water for the area around Edinburgh:
./scripts/genwaterraster.py --bbox 55 -4 56 -3

Inside the ./output/vpb directory there should be a set of directories and .png files.

=== Adding roads and railways ===
The terrain mesh does not have any line features - things like roads. These are generated separately from OpenStreetMap data. To generate line features simply run the <code>genroads.py</code> command:

Usage: ./scripts/genroads.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--threads THREADS] [--cache-dir CACHE_DIR] [--output-dir OUTPUT_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--threads THREADS Number of parallel threads to run. Defaults to 1
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/cache/

For example, to generate roads for the area around Edinburgh:
./scripts/genroads.py --bbox 55 -4 56 -3

Inside the ./output/Terrain directory there should be a set of directories and, .STG files text files.

==Running FlightGear with the new WS3.0 Terrain==
To test the new terrain, simply include the output directory in your scenery path and run FlightGear with the <code>--prop:/scenery/use-vpb=true</code> to enable WS3.0.

== Advanced Techniques ==
The following sections describe more complex techniques to generate higher quality WS3.0 terrain. Almost all of them involve using different data sources to generate a more detailed landclass raster before running the final scenery generation processes described above. Generating a highly detailed landclass raster is where the magic happens.

Most techniques use gdal or grass to modify the raster/vector data, typically using the QGIS program.

=== Using a different elevation model ===
If you are using another elevation model other than NASAEM, then you may need to re-project it using QGIS/gdalwarp to the WGS84 CRS (aka EPSG:4326).

=== Landclass Data Requirements ===
For any landclass data we need to ensure the data is in the correct format. That means:

# Is a Raster (geotiff) rather than Vector data. This raster will become the texture on the terrain that the terrain shaders do their magic on.
# Uses the WGS84 Coordinate Reference System. The ensures that the terrain generation step is efficient.
# Has the correct landclass values for each terrain type. We use a set of values based on the CORINE raster set, defined in [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml].

Below is a quick table showing what steps you need to take for common landclass data sources.
{| class="wikitable"
|+
!Landclass Data
!Warp to WGS84 required?
!Landclass re-classification Required?
!Raster Simplification Required?
!Conversion to Raster Required?
|-
|CORINE Raster
|Yes
|No
|No
|No
|-
|CORINE Vector
|Yes
|Yes
|No
|Yes
|-
|NLCD
|No
|Yes
|Yes
|No
|-
|Sentinel-2
|Yes
|Yes
|No
|No
|}
Conversion to Raster must be done manually. Converting to WGS84 and the correct landclasses ''can'' be done by the genVPB.py script, but slows down scenery generation. Therefore if you are planning to generate scenery multiple times it is best to pre-process the files yourself.

The easiest way to do these operations is using QGIS, which is available for most platforms. If you are scripting a toolchain, the QGIS tools include command-line equivalents for all commands.

When using QGIS, set the Project CRS to WGS84 (aka EPSG:4326). You can then add layers of Raster or Vector data from files from the <code>Layer->Add Layer</code> menu. When performing any operations, <u>always</u> write out the data to a real file so you can go back to it later. Disk space is cheap :).

=== Warping Raster Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a raster layer to a different CRS using the Raster->Projections-Warp (Reproject) tool.

Select the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Resampling Method to Use - Nearest Neighbour. (Landclass data is not like normal images. You don't want to interpolate between values.)
* Nodata value for output bands - 0.0 (This means that any data at the edges will be Ocean, usually a reasonable default)
* Advanced Parameters - No Compression
* Output data type - Byte
* Reprojected - Choose a target filename

Alternatively you can do this step from the commandline.
gdalwarp -t_srs EPSG:4326 -dstnodata 0.0 -r near -ot Byte -of GTiff -co COMPRESS=NONE -co BIGTIFF=IF_NEEDED /home/stuart/FlightGear/VPB/data/CORINE/u2018_clc2018_v2020_20u1_raster100m/DATA/U2018_CLC2018_V2020_20u1.tif /home/stuart/FlightGear/VPB/data/scratch/corine_WGS84.tif

=== Warping Vector Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a vector layer using Vector->Data Management Tools->Reproject Layer.

Set the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Reprojected - Choose a target filename

=== Reclassifying Vector Layers ===
For CORINE vector data in particular, the attributes used in the vector data are not the same as those used by the CORINE Raster data. So we need to create a new attribute on the data.
[[File:Field Calculator.png|thumb|QGIS Field Calculator]]
To do this

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialog
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type "Whole Number (Integer)". This will create a new column which we will populate with the correct landclass data
* Click on the <code>Open Field Calculator</code> button (Ctrl + I). (If you get an error about only being able to create Virtual fields, go back to the Layer menu, export it and open the exported file).
* Select the following options:
** Update Existing Field
** Select the Landclass field you just created.
** Copy the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/corine_vector.txt into the Expression box (without the comment lines starting with <code>#</code>). This is just some simple code to set the attribute correctly. The code should be correct for CORINE vector data. If your data is from other sources you will need to work out how you want to map your source data landclasses to the CORINE ones. [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml] can be used as a guide.
* Select <code>OK</code>. You should see that your landclass column is now populated with the landclass data.
* Select <code>Layer->Save Layer Edits</code> to save you changes

=== Creating a Raster from a Vector Layer ===
To create a Raster from a Vector Layer select <code>Raster->Conversion->Rasterize (Vector to Raster)</code>.
[[File:QGIS Rasterize (Vector to Raster).png|thumb|Creating a Raster from a Vector Layer - QGIS Rasterize]]
Select the following options:

* Input Layer - correct layer, check CRS
* Field to use for burn-in value - select the <code>Landclass</code> column you created above.
* Output raster size units. This is going to set the resolution of your raster. You can work out the resolution in two different ways:
** Select "Georeferenced units" and determine how many degrees each pixel is in latitude and longitude.
** Select "Pixels" and determine the size of raster you want in pixels. [https://www.nhc.noaa.gov/gccalc.shtml This] is a good calculator to help. You input e.g. SE and SW coordinates and calculate to get the distance in Km. Then you multiply by thousand and devide by the number of metres per pixel (e.g. 5) -> resolution for width.
* Width/Horizontal Resolution. Enter the values you've calculated for the horizontal resolution (longitudinal), or the width of the raster
* Height/Vertical Resolution. Enter the values you've calculated for the vertical resolution (latitude or the height of the raster)
* Output extent - Select an option from the box on the right. You can edit the text afterwards (NB: East, West, South, North). Best practise is to create long thin strips of 1 degree latitude in height, as this makes subsequent processing much easier.
* Assign a specific nodata value to output bands - Select 0.0 for Ocean. CORINE vector data in particular has a lot of nodata for Oceans
* Advanced Parameters - No Compression
* Output data type - Byte
* Rasterized - Select a new filename

=== Simplifying a Raster Layer ===
Some Raster Landclass data (NLCD included) has too much noise - in particular large US highway systems are identified as Urban areas.

To smooth it out we can use the GRASS <code>n.neighbors</code> function from the Processing Toolbox in QGIS.

Select the following options:

* Input Layer - correct layer, check CRS
* Neighborhood operation - median. (This is not a normal image, so using an average will result in weird values)
* Neighborhood size - 5.
* Neighbors - Select a new filename.

=== Clipping a Raster Layer with OSM Data for Land (Corine) ===
The Corine dataset does not match OSM coastlines exactly. The following multi-stage process makes sure, that no Corine land-use is in the water as defined by OSM.

==== Download OSM Land Data ====

Download land polygons based on OSM data as a Shapefile from [https://osmdata.openstreetmap.de/data/land-polygons.html Land Polygons] and make sure to pick the WGS84 projected download with split polygons ("Large polygons are split, use for larger scales"). Once downloaded unzip the content into a directory.

==== Reclassifying the OSM Land Data Vector Layer ====
I QGIS make sure that only the layer for the raster for land data is selected (e.g. <code>land-polygons-split-4326</code>) -> in the map view you will see the whole earth. NB: typically you do this reclassify only once after download and can reuse the result for future processing.

Then:

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialogue
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type <code>Integer (32 bit)</code>. This will create a new column which we will populate with the correct land class data
* On top of the table on the left side choose "Landclass" in the drop-down menu, then input <code>2</code> into the field to the right and then press button "Update" all to the left of this field.
* Wait a bit and the close the dialogue.
* Select <code>Layer->Save Layer Edits</code> to save your changes (overwrite e.g. <code>land-polygons-split-4326</code>).

==== Convert the Land Data from Vector to Raster ====
Do the same as in chapter "Creating a Raster from a Vector Layer" above. The only difference is that the Input layer will be the land data polygons and you need to choose a different file name for the "Rasterized" (e.g. osm_land_scotland_5m.tif)

==== Remove Novalue Entries in the Land Data Raster ====
To do this:

* Select <code>Processing->Toolbox</code>. You should see a new box on the right side.
* Write "gdal_calc" in the search box and you should see an entry "Raster calculator". Double click on it and you will get a new dialogue window.
* In this dialogue:
** For "Input layer A" choose the raster from the previous chapter ((e.g. osm_land_scotland_5m.tif)
** In field "Calculation in gdalnumeric ..." write: <code>greater(A,0) * A</code>
** In field "Output raster type" choose <code>Byte</code>
** In field "Advanced Parameters" choose Profile <code>No compression</code>
** In field "Additional command-line parameters" write: <code>--hideNoData</code>
** In field "Calculated" choose a file (e.g. osm_land_scotland_allvalues_5m.tif)
** (In the "GDAL/OGR console call" it will have something similar to the follwing - just with different paths: <code>gdal_calc.py --overwrite --calc "greater(A ,0) * A" --format GTiff --type Byte -A /home/vanosten/custom-fg-scenery/data/osm_land_scotland_5m.tif --A_band 1 --co COMPRESS=NONE --co BIGTIFF=IF_NEEDED --hideNoData --outfile /home/vanosten/custom-fg-scenery/data/osm_land_scotland_allvalues_5m.tif</code>
** Press the "Run" button - and when complete close the dialogue.

You should now see a map only black and white. You can check for correctness by pressing <code>CTRL+SHIFT+I</code> to get a cursor with an arrow and an "i". First make sure the new raster is selected on the left side. Next click on the sea/ocean and then check in the "Identify Results" window on the right that the value is < 2. The click on the land and check that the value is 2.

==== Create the Final Clipped Corine Raster Against OSM Land Data =====
Do the following:

* In QGIS make sure that you have only the following two layers: the basis Corine raster (see chapter "Creating a Raster from a Vector Layer" - here e.g. corine_raster_scotland_5m.tif) and plus the raster from the previous step (e.g. osm_land_scotland_allvalues_5m.tif)
* Select <code>Raster->Raster Calculator ...</code> and a corresponding dialogue will open showing on the left hand side the two rasters.
* Choose a new "Output layer" (e.g. corine_raster_scotland_clipped_5m.tif).
* In the "Raster Calculator Expression" field input: <code>if ("osm_land_scotland_all_data_5m@1" < 2, 44, "corine_raster_scotland_5m@1")</code>
* Press button "OK" and wait a while (you will see a new dialogue with showing the progress.

Done. You have now a raster (e.g. corine_raster_scotland_clipped_5m.tif) which does not have land in areas, where OSM data has sea/ocean.

=== Reclassifying a Raster Layer ===
WS3.0 uses CORINE landclass values. If using data from other sources it needs to be reclassified to the correct values. genVPB.py has an option to do this, but you may wish to do so manually.

To do this select <code>GRASS->Raster->r.reclass</code> from the Processing Toolbox.

Select the following options:

* Input Raster Layer - correct layer, check CRS
* Reclass rules text - copy in the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/nlcd2019.txt. Or an appropriate mapping from your landclass data to CORINE. Note that you can also reference a file using the "File containing reclass rules" option. Note a mapping of 22 24 = 1 is the same as 22 and 24 = 1. For a range of 22 to 24 use 22 23 24 = 1.
* Reclassified - Select a new filename.

(If this doesn't work a similar function is available in the Processing Toolbox under <code>Raster analysis->Reclassify by table</code>. However this doesn't save your table once you close the dialog, and entries have to be manually entered individually which takes a lot of effort)

=== Processing NLCD for USA using the Raster Calculator and tools in QGIS ===

[[Processing_NLCD_for_USA_using_Raster_Calculator_and_tools_in_QGIS]]

=== Python script to process NLCD for the USA ===

[[Python_script_to_process_NLCD_for_the_USA]]

=== Python script to process Sentinel-2 data ===

[[Python_script_to_process_Sentinel-2_data]]

===Generating the Terrain using osgdem===
Instead of using genVPB.py, you may wish to run osgdem directly.

In the Windows/Docker platform you can send the generate tile command directly to osgdem.exe, one tile at a time.

Using the NLCD raster processing convention from above, following is the the final step after creating the raster and entering bash shell with the windows version of "docker run..."

osgdem --TERRAIN --image-ext png --RGBA --no-interpolate-imagery --disable-error-diffusion --geocentric --no-mip-mapping -t ./data/California-Southern_4326-84-hd-corrected.tiff -d ./SRTM-3/N32W115.hgt -b -115 32 -114 33 --PagedLOD -l 7 --radius-to-max-visible-distance-ratio 3 -o ./output/vpb/w120n30/w115n32/ws_w115n32.osgb

Note: the --image-ext png --RGBA flags are critical to successfully building correctly placed landclasses in the final VPB generated scenery.

If you prefer to run the scenery generation manually, running the VPB osgdem process is described in more detail here: [[Virtual Planet Builder#Running VPB]].

After doing this you should have an output directory containing files of the form <code>output/vpb/w010n50/w004n50/ws_w004n50.osgb</code>, plus a host of sub-directories. Each one of these is a 1x1 tile of terrain.

to leave the container simply type <code>exit</code>.

===Packaging the Scenery===
Once you have the terrain and line features they should be packaged in a scenery directory in vpb and Terrain sub-directories respectively. E.g.
MyCoolScenery/Terrain
MyCoolScenery/vpb
It is good practise to document the data sources used in scenery generation. Some source licenses require attribution of the original data source for anything derived, published or distributed.

To assist in fulfilling these license obligations, you can create a source.xml file in the scenery directory which includes attribution information. This will then be available from within the simulator under Help->Scenery Sources, and <u>may</u> fulfil the attribution requirements of your license. '''Note that you are responsible for fulfilling any license requirements from the data, not FlightGear'''.

The format of the file is straightforward:
<?xml version="1.0"?>
<PropertyList>
<nowiki><source></nowiki>
<name>Corine Land Cover (CLC) 2018, Version 2020_20u1</name>
<nowiki><link></nowiki><nowiki>http://web.archive.org/web/20221112175615/https://land.copernicus.eu/pan-european/corine-land-cover/clc2018?tab=metadata%2A</nowiki><nowiki></link></nowiki>
<license>GMES Open License</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>NASADEM Merged DEM Global 1 arc second V001</name>
<nowiki><link></nowiki><nowiki>https://www.earthdata.nasa.gov/</nowiki><nowiki></link></nowiki>
<license>Public Domain</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>OpenStreetMap</name>
<nowiki><link></nowiki><nowiki>https://www.openstreetmap.org/copyright</nowiki><nowiki></link></nowiki>
<license>Open Data Commons Open Database License</license>
<nowiki></source></nowiki>
</PropertyList>

Howto:Create WS3.0 terrain

2026-05-15T16:23:46Z

Wlbragg: /* Generating Terrain */

{{WS30 Navbar}}
This article provides instructions on how to generate basic WS3.0 terrain.

WS3.0 terrain consists of three parts:

# A terrain mesh consisting of a landclass texture draped over an elevation model.
# A high resolution water raster used to show water features such as rivers, lakes and coastline with more definition
# Line features such as roads and railways.

The terrain is generated by a set of tools that are packaged in a docker image for convenience.[[File:Diagram-export-21-12-2023-16 29 37.png|thumb|Basic WS3.0 Scenery Generation Process]]

== Prerequisites ==

=== Set up a Workspace ===
Create a directory with the following sub-directories:

* <code>cache</code>
* <code>data</code>
* <code>output/vpb</code>
* <code>output/Terrain</code>

=== Docker ===

# Install [https://docs.docker.com/get-started/ Docker] on your platform.
#Pull the docker image by running the following command

docker pull flightgear/ws30-vpb-generator:latest
Optionally, if you are hitting rate limits:
#Create an account on https://hub.docker.com/. (Note that you will need to click on an email verification link before you can log in for the first time)
#Run <code>docker login</code> before the '''docker pull''' command above

== Getting the base data ==
You need two pieces of data for the area of scenery you are generating:

# An elevation model (aka DEM). This indicates what altitude each point of the surface is.
# Landclass data showing what type of terrain is at each point of the surface. This is often either a Raster (effectively a texture), or vector data.

=== Elevation Model ===
Download the NASADEM elevation model for the area of scenery you wish to generate. This is available in 1x1 degree blocks from [https://lpdaac.usgs.gov/products/nasadem_hgtv001/ here], and with an interactive browser [https://search.earthdata.nasa.gov/search here].

Unzip the files into the <code>data</code> directory.

=== Landclass Raster ===
Download an landclass raster for the area of scenery you wish to generate.

* For Europe, use of [https://land.copernicus.eu/pan-european/corine-land-cover/clc2018 CORINE] is recommended.
* For the USA [https://www.mrlc.gov/viewer/ NLCD] is recommended
* Sentinel-2 data is available for the entire world via [https://livingatlas.arcgis.com/landcoverexplorer/ ESRI], but has limited set of landclasses.

Put these into the <code>data</code> directory.

More detailed terrain can be created by modifying the landclass raster, and/or generating a new raster from vector data. These processes are discussed below.

== Generating Terrain ==
To generate terrain you need to run the tools within the docker container we installed above. The docker image is like a small, independent virtual computing environment running within your system. This particular docker image has all the scenery generation tools already installed.

=== Running the docker container ===
Firstly, get the container running from the directory containing your <code>cache</code>, <code>data</code> and <code>output</code> directories:
docker run --rm --mount "type=bind,source=`pwd`/data,target=/home/flightgear/data,readonly" --mount "type=bind,source=`pwd`/output,target=/home/flightgear/output" --mount "type=bind,source=`pwd`/cache,target=/home/flightgear/cache" -it flightgear/ws30-vpb-generator:latest /bin/bash

You should now find yourself in a bash shell within your container. You should see data and output directories which are linked to the directories you created earlier:
flightgear@ddcac77f7d5e:~$ ls
cache data output bin scripts
In the windows environment using Docker Desktop, if you need a path to a source of elevation data and a path to the OSM shoreline shapefiles, you can add the following:
docker run --rm --mount "type=bind,source=G:/Scenery/ws3.0/Alabama/data,target=/home/flightgear/data,readonly" --mount "type=bind,source=G:/Scenery/WS3.0-extra/vector/land-polygons-complete-4326,target=/home/flightgear/coastlines" --mount "type=bind,source=G:/Scenery/WS3.0-extra/SRTM-1,target=/home/flightgear/SRTM-3,readonly" --mount "type=bind,source=G:/Scenery/ws3.0/Alabama/output,target=/home/flightgear/output" --mount "type=bind,source=G:/Scenery/ws3.0/Alabama/output/cache,target=/home/flightgear/cache" -it flightgear/ws30-vpb-generator:latest /bin/bash

Note: the --mount "type=bind,source=G:/Scenery/WS3.0-extra/SRTM-1,target=/home/flightgear/SRTM-3,readonly", the genVPB.py script in the Docker container is expecting a location of /home/flightgear/SRTM-3 for the elevation data. In this example I am using SRTM-1 elevation data, but we still map it to the expected /home/flightgear/SRTM-3 Docker container location.
=== Building the terrain ===
To build the terrain mesh, use the <code>genVPB.py</code> tool from inside the docker container:

Usage: genVPB.py --raster <input-raster> [ option ... ]
Usage: genVPB.py --bbox <lat0> <lon0> <lat1> <lon1> --sentinel --reclass <reclass> [ option ... ]

Arguments:
--raster RASTER Input landclass raster.
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--sentinel Use Sentinel2 landclass tiles
--sentinel-dir SENTINEL_DIR Directory for Sentinel Data. Default /home/flightgear/data/Sentinel-2
--hgt-dir HGT_DIR Directory containing HGT DEM files. Default /home/flightgear/data/NASADEM
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/output
--download-sentinel Download Sentinel2 tiles if needed
--reclass RECLASS Reclassify raster using file <reclass>. See ./scripts/mappings/
--coastline COASTLINE Clip against coastline against polygon (.osm)
--shrink-water SHRINK_WATER Shrink water bodies (landclasses 40, 41) by <pixels> pixels
--generate-water-raster Generate a water raster from OSM data
--generate-line-features Generate a water raster from OSM data
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--nasadem-server NASADEM_SERVER Set server to download NASADEM data from. Default https://e4ftl01.cr.usgs.gov/MEASURES/NASADEM_HGT.001/2000.02.11/)
--nasadem-user NASADEM_USER NASA Earthdata username.
--nasadem-password NASADEM_PASSWORD NASA Earthdata password.
--debug Debug output

For example, to generate a piece of terrain around Edinburgh (latitude 55.5, longitude 3 degrees West):
./scripts/genVPB.py --bbox 55 -4 56 -3 --raster ./data/uk_wgs84_10m_N54.tif

Another example, to generate a coastal area with shorelines and lakes, like Alaska:
./scripts/genVPB.py --bbox 68 -167 69 -152 --raster ./data/NLCD_2016_Alaska167-153_68_Smoothed-HD-Compressed_4326.tiff --hgt-dir ./SRTM-3/ --generate-water-raster --shrink-water 4 --coastline ./coastlines/land_polygons.shp

Same thing with roads and rails (line features):
./scripts/genVPB.py --bbox 68 -167 69 -152 --raster ./data/NLCD_2016_Alaska167-153_68_Smoothed-HD-Compressed_4326.tiff --hgt-dir ./SRTM-3/ --generate-water-raster --shrink-water 4 --coastline ./coastlines/land_polygons.shp --generate-line-features

If you are using anything other than a CORINE raster you will need to reclassify the data to match the landclasses used by FlightGear. Those classes are defined in [https://gitlab.com/flightgear/fgdata/-/tree/next/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml]. You can reclassify them using the files in the [https://gitlab.com/flightgear/fgmeta/-/tree/next/ws30/mappings/ scripts/mappings] directory. E.g. to reclassify NLCD2019 data you can use <code>--reclassify ./scripts/mappings/nlcd2019.txt</code>.

genVPB.py will output the data to the output/vpb directory, in which you should find a series of files and directories.

=== Adding water ===
'''Update 05/12/2026: Depreciated, it is now built into genVPB.py above.'''

'''Use genVPB.py ...... --generate-water-raster --shrink-water 4 --coastline [path_to_shapefile_mask]'''

The terrain mesh does not have highly detailed water features - as typically the source data has a resolution of 10-25m. Water features are generated from OpenStreetMap data. To generate water features simply run the <code>genwaterraster.py</code> command.

Usage: genwaterraster.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--output-dir OUTPUT_DIR] [--cache-dir CACHE_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--output-dir OUTPUT_DIR Directory to write files into. Default /home/flightgear/output
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache

For example, to generate water for the area around Edinburgh:
./scripts/genwaterraster.py --bbox 55 -4 56 -3

Inside the ./output/vpb directory there should be a set of directories and .png files.

=== Adding roads and railways ===
The terrain mesh does not have any line features - things like roads. These are generated separately from OpenStreetMap data. To generate line features simply run the <code>genroads.py</code> command:

Usage: ./scripts/genroads.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--threads THREADS] [--cache-dir CACHE_DIR] [--output-dir OUTPUT_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--threads THREADS Number of parallel threads to run. Defaults to 1
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/cache/

For example, to generate roads for the area around Edinburgh:
./scripts/genroads.py --bbox 55 -4 56 -3

Inside the ./output/Terrain directory there should be a set of directories and, .STG files text files.

==Running FlightGear with the new WS3.0 Terrain==
To test the new terrain, simply include the output directory in your scenery path and run FlightGear with the <code>--prop:/scenery/use-vpb=true</code> to enable WS3.0.

== Advanced Techniques ==
The following sections describe more complex techniques to generate higher quality WS3.0 terrain. Almost all of them involve using different data sources to generate a more detailed landclass raster before running the final scenery generation processes described above. Generating a highly detailed landclass raster is where the magic happens.

Most techniques use gdal or grass to modify the raster/vector data, typically using the QGIS program.

=== Using a different elevation model ===
If you are using another elevation model other than NASAEM, then you may need to re-project it using QGIS/gdalwarp to the WGS84 CRS (aka EPSG:4326).

=== Landclass Data Requirements ===
For any landclass data we need to ensure the data is in the correct format. That means:

# Is a Raster (geotiff) rather than Vector data. This raster will become the texture on the terrain that the terrain shaders do their magic on.
# Uses the WGS84 Coordinate Reference System. The ensures that the terrain generation step is efficient.
# Has the correct landclass values for each terrain type. We use a set of values based on the CORINE raster set, defined in [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml].

Below is a quick table showing what steps you need to take for common landclass data sources.
{| class="wikitable"
|+
!Landclass Data
!Warp to WGS84 required?
!Landclass re-classification Required?
!Raster Simplification Required?
!Conversion to Raster Required?
|-
|CORINE Raster
|Yes
|No
|No
|No
|-
|CORINE Vector
|Yes
|Yes
|No
|Yes
|-
|NLCD
|No
|Yes
|Yes
|No
|-
|Sentinel-2
|Yes
|Yes
|No
|No
|}
Conversion to Raster must be done manually. Converting to WGS84 and the correct landclasses ''can'' be done by the genVPB.py script, but slows down scenery generation. Therefore if you are planning to generate scenery multiple times it is best to pre-process the files yourself.

The easiest way to do these operations is using QGIS, which is available for most platforms. If you are scripting a toolchain, the QGIS tools include command-line equivalents for all commands.

When using QGIS, set the Project CRS to WGS84 (aka EPSG:4326). You can then add layers of Raster or Vector data from files from the <code>Layer->Add Layer</code> menu. When performing any operations, <u>always</u> write out the data to a real file so you can go back to it later. Disk space is cheap :).

=== Warping Raster Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a raster layer to a different CRS using the Raster->Projections-Warp (Reproject) tool.

Select the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Resampling Method to Use - Nearest Neighbour. (Landclass data is not like normal images. You don't want to interpolate between values.)
* Nodata value for output bands - 0.0 (This means that any data at the edges will be Ocean, usually a reasonable default)
* Advanced Parameters - No Compression
* Output data type - Byte
* Reprojected - Choose a target filename

Alternatively you can do this step from the commandline.
gdalwarp -t_srs EPSG:4326 -dstnodata 0.0 -r near -ot Byte -of GTiff -co COMPRESS=NONE -co BIGTIFF=IF_NEEDED /home/stuart/FlightGear/VPB/data/CORINE/u2018_clc2018_v2020_20u1_raster100m/DATA/U2018_CLC2018_V2020_20u1.tif /home/stuart/FlightGear/VPB/data/scratch/corine_WGS84.tif

=== Warping Vector Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a vector layer using Vector->Data Management Tools->Reproject Layer.

Set the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Reprojected - Choose a target filename

=== Reclassifying Vector Layers ===
For CORINE vector data in particular, the attributes used in the vector data are not the same as those used by the CORINE Raster data. So we need to create a new attribute on the data.
[[File:Field Calculator.png|thumb|QGIS Field Calculator]]
To do this

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialog
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type "Whole Number (Integer)". This will create a new column which we will populate with the correct landclass data
* Click on the <code>Open Field Calculator</code> button (Ctrl + I). (If you get an error about only being able to create Virtual fields, go back to the Layer menu, export it and open the exported file).
* Select the following options:
** Update Existing Field
** Select the Landclass field you just created.
** Copy the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/corine_vector.txt into the Expression box (without the comment lines starting with <code>#</code>). This is just some simple code to set the attribute correctly. The code should be correct for CORINE vector data. If your data is from other sources you will need to work out how you want to map your source data landclasses to the CORINE ones. [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml] can be used as a guide.
* Select <code>OK</code>. You should see that your landclass column is now populated with the landclass data.
* Select <code>Layer->Save Layer Edits</code> to save you changes

=== Creating a Raster from a Vector Layer ===
To create a Raster from a Vector Layer select <code>Raster->Conversion->Rasterize (Vector to Raster)</code>.
[[File:QGIS Rasterize (Vector to Raster).png|thumb|Creating a Raster from a Vector Layer - QGIS Rasterize]]
Select the following options:

* Input Layer - correct layer, check CRS
* Field to use for burn-in value - select the <code>Landclass</code> column you created above.
* Output raster size units. This is going to set the resolution of your raster. You can work out the resolution in two different ways:
** Select "Georeferenced units" and determine how many degrees each pixel is in latitude and longitude.
** Select "Pixels" and determine the size of raster you want in pixels. [https://www.nhc.noaa.gov/gccalc.shtml This] is a good calculator to help. You input e.g. SE and SW coordinates and calculate to get the distance in Km. Then you multiply by thousand and devide by the number of metres per pixel (e.g. 5) -> resolution for width.
* Width/Horizontal Resolution. Enter the values you've calculated for the horizontal resolution (longitudinal), or the width of the raster
* Height/Vertical Resolution. Enter the values you've calculated for the vertical resolution (latitude or the height of the raster)
* Output extent - Select an option from the box on the right. You can edit the text afterwards (NB: East, West, South, North). Best practise is to create long thin strips of 1 degree latitude in height, as this makes subsequent processing much easier.
* Assign a specific nodata value to output bands - Select 0.0 for Ocean. CORINE vector data in particular has a lot of nodata for Oceans
* Advanced Parameters - No Compression
* Output data type - Byte
* Rasterized - Select a new filename

=== Simplifying a Raster Layer ===
Some Raster Landclass data (NLCD included) has too much noise - in particular large US highway systems are identified as Urban areas.

To smooth it out we can use the GRASS <code>n.neighbors</code> function from the Processing Toolbox in QGIS.

Select the following options:

* Input Layer - correct layer, check CRS
* Neighborhood operation - median. (This is not a normal image, so using an average will result in weird values)
* Neighborhood size - 5.
* Neighbors - Select a new filename.

=== Clipping a Raster Layer with OSM Data for Land (Corine) ===
The Corine dataset does not match OSM coastlines exactly. The following multi-stage process makes sure, that no Corine land-use is in the water as defined by OSM.

==== Download OSM Land Data ====

Download land polygons based on OSM data as a Shapefile from [https://osmdata.openstreetmap.de/data/land-polygons.html Land Polygons] and make sure to pick the WGS84 projected download with split polygons ("Large polygons are split, use for larger scales"). Once downloaded unzip the content into a directory.

==== Reclassifying the OSM Land Data Vector Layer ====
I QGIS make sure that only the layer for the raster for land data is selected (e.g. <code>land-polygons-split-4326</code>) -> in the map view you will see the whole earth. NB: typically you do this reclassify only once after download and can reuse the result for future processing.

Then:

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialogue
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type <code>Integer (32 bit)</code>. This will create a new column which we will populate with the correct land class data
* On top of the table on the left side choose "Landclass" in the drop-down menu, then input <code>2</code> into the field to the right and then press button "Update" all to the left of this field.
* Wait a bit and the close the dialogue.
* Select <code>Layer->Save Layer Edits</code> to save your changes (overwrite e.g. <code>land-polygons-split-4326</code>).

==== Convert the Land Data from Vector to Raster ====
Do the same as in chapter "Creating a Raster from a Vector Layer" above. The only difference is that the Input layer will be the land data polygons and you need to choose a different file name for the "Rasterized" (e.g. osm_land_scotland_5m.tif)

==== Remove Novalue Entries in the Land Data Raster ====
To do this:

* Select <code>Processing->Toolbox</code>. You should see a new box on the right side.
* Write "gdal_calc" in the search box and you should see an entry "Raster calculator". Double click on it and you will get a new dialogue window.
* In this dialogue:
** For "Input layer A" choose the raster from the previous chapter ((e.g. osm_land_scotland_5m.tif)
** In field "Calculation in gdalnumeric ..." write: <code>greater(A,0) * A</code>
** In field "Output raster type" choose <code>Byte</code>
** In field "Advanced Parameters" choose Profile <code>No compression</code>
** In field "Additional command-line parameters" write: <code>--hideNoData</code>
** In field "Calculated" choose a file (e.g. osm_land_scotland_allvalues_5m.tif)
** (In the "GDAL/OGR console call" it will have something similar to the follwing - just with different paths: <code>gdal_calc.py --overwrite --calc "greater(A ,0) * A" --format GTiff --type Byte -A /home/vanosten/custom-fg-scenery/data/osm_land_scotland_5m.tif --A_band 1 --co COMPRESS=NONE --co BIGTIFF=IF_NEEDED --hideNoData --outfile /home/vanosten/custom-fg-scenery/data/osm_land_scotland_allvalues_5m.tif</code>
** Press the "Run" button - and when complete close the dialogue.

You should now see a map only black and white. You can check for correctness by pressing <code>CTRL+SHIFT+I</code> to get a cursor with an arrow and an "i". First make sure the new raster is selected on the left side. Next click on the sea/ocean and then check in the "Identify Results" window on the right that the value is < 2. The click on the land and check that the value is 2.

==== Create the Final Clipped Corine Raster Against OSM Land Data =====
Do the following:

* In QGIS make sure that you have only the following two layers: the basis Corine raster (see chapter "Creating a Raster from a Vector Layer" - here e.g. corine_raster_scotland_5m.tif) and plus the raster from the previous step (e.g. osm_land_scotland_allvalues_5m.tif)
* Select <code>Raster->Raster Calculator ...</code> and a corresponding dialogue will open showing on the left hand side the two rasters.
* Choose a new "Output layer" (e.g. corine_raster_scotland_clipped_5m.tif).
* In the "Raster Calculator Expression" field input: <code>if ("osm_land_scotland_all_data_5m@1" < 2, 44, "corine_raster_scotland_5m@1")</code>
* Press button "OK" and wait a while (you will see a new dialogue with showing the progress.

Done. You have now a raster (e.g. corine_raster_scotland_clipped_5m.tif) which does not have land in areas, where OSM data has sea/ocean.

=== Reclassifying a Raster Layer ===
WS3.0 uses CORINE landclass values. If using data from other sources it needs to be reclassified to the correct values. genVPB.py has an option to do this, but you may wish to do so manually.

To do this select <code>GRASS->Raster->r.reclass</code> from the Processing Toolbox.

Select the following options:

* Input Raster Layer - correct layer, check CRS
* Reclass rules text - copy in the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/nlcd2019.txt. Or an appropriate mapping from your landclass data to CORINE. Note that you can also reference a file using the "File containing reclass rules" option. Note a mapping of 22 24 = 1 is the same as 22 and 24 = 1. For a range of 22 to 24 use 22 23 24 = 1.
* Reclassified - Select a new filename.

(If this doesn't work a similar function is available in the Processing Toolbox under <code>Raster analysis->Reclassify by table</code>. However this doesn't save your table once you close the dialog, and entries have to be manually entered individually which takes a lot of effort)

=== Processing NLCD for USA using the Raster Calculator and tools in QGIS ===

[[Processing_NLCD_for_USA_using_Raster_Calculator_and_tools_in_QGIS]]

=== Python script to process NLCD for the USA ===

[[Python_script_to_process_NLCD_for_the_USA]]

=== Python script to process Sentinel-2 data ===

[[Python_script_to_process_Sentinel-2_data]]

===Generating the Terrain using osgdem===
Instead of using genVPB.py, you may wish to run osgdem directly.

In the Windows/Docker platform you can send the generate tile command directly to osgdem.exe, one tile at a time.

Using the NLCD raster processing convention from above, following is the the final step after creating the raster and entering bash shell with the windows version of "docker run..."

osgdem --TERRAIN --image-ext png --RGBA --no-interpolate-imagery --disable-error-diffusion --geocentric --no-mip-mapping -t ./data/California-Southern_4326-84-hd-corrected.tiff -d ./SRTM-3/N32W115.hgt -b -115 32 -114 33 --PagedLOD -l 7 --radius-to-max-visible-distance-ratio 3 -o ./output/vpb/w120n30/w115n32/ws_w115n32.osgb

Note: the --image-ext png --RGBA flags are critical to successfully building correctly placed landclasses in the final VPB generated scenery.

If you prefer to run the scenery generation manually, running the VPB osgdem process is described in more detail here: [[Virtual Planet Builder#Running VPB]].

After doing this you should have an output directory containing files of the form <code>output/vpb/w010n50/w004n50/ws_w004n50.osgb</code>, plus a host of sub-directories. Each one of these is a 1x1 tile of terrain.

to leave the container simply type <code>exit</code>.

===Packaging the Scenery===
Once you have the terrain and line features they should be packaged in a scenery directory in vpb and Terrain sub-directories respectively. E.g.
MyCoolScenery/Terrain
MyCoolScenery/vpb
It is good practise to document the data sources used in scenery generation. Some source licenses require attribution of the original data source for anything derived, published or distributed.

To assist in fulfilling these license obligations, you can create a source.xml file in the scenery directory which includes attribution information. This will then be available from within the simulator under Help->Scenery Sources, and <u>may</u> fulfil the attribution requirements of your license. '''Note that you are responsible for fulfilling any license requirements from the data, not FlightGear'''.

The format of the file is straightforward:
<?xml version="1.0"?>
<PropertyList>
<nowiki><source></nowiki>
<name>Corine Land Cover (CLC) 2018, Version 2020_20u1</name>
<nowiki><link></nowiki><nowiki>http://web.archive.org/web/20221112175615/https://land.copernicus.eu/pan-european/corine-land-cover/clc2018?tab=metadata%2A</nowiki><nowiki></link></nowiki>
<license>GMES Open License</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>NASADEM Merged DEM Global 1 arc second V001</name>
<nowiki><link></nowiki><nowiki>https://www.earthdata.nasa.gov/</nowiki><nowiki></link></nowiki>
<license>Public Domain</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>OpenStreetMap</name>
<nowiki><link></nowiki><nowiki>https://www.openstreetmap.org/copyright</nowiki><nowiki></link></nowiki>
<license>Open Data Commons Open Database License</license>
<nowiki></source></nowiki>
</PropertyList>

World Scenery 3.0 coastlines

2026-05-15T16:22:44Z

Wlbragg:

'''NOTE: genVPB.py now includes a flag to process the coastline, --coastline [path_to_coastline_shapefile]'''

{{WS30 Navbar}}
World Scenery 3.0 uses a texture of landclass information, typically with 10-25m resolution. For coastlines in particular, this creates an obvious sharp edge with right angles.
[[File:Fgfs-20220208201349.jpg|thumb|WS3.0 coastline just using a 10m raster with no vector data, showing the coastline problem]]
[[File:Fgfs-20230219173559.jpg|thumb|WS3.0 coastline using OSM vector data. Note the artifacts where the data doesn't line up.]]
[[File:Fgfs-20230227220551.jpg|alt=|thumb|Current state-of-the-art coast rendering, using OSM data for both raster and coastline definition. Martinique]]

This page describes various techniques/experiments to find a better solution.

=== Current Rendering ===
The current "state of the art" is to is to create a second texture at much higher resolution and paint the coastline onto this. The fragment shader then mixes the standard resolution landclass and the much higher resolution coastline texture. This has the advantage of being able to mix the data together nicely.

We currently support both generating this higher resolution raster at scenery generation time and also at runtime. Both the generation of the texture and the shader are currently quite basic and would benefit from further development from anyone interested in this area.

The significant downside is the increased memory occupancy of the additional texture and the added complexity of the shader.

This still leaves an issue that the elevation mesh is completely regular, so where steep slopes meet the sea, the high water mark can be a half way up a slope! The shader creates cliffs and beaches instead of water depending on the steepness of the elevation mesh. We also force any vertex that is in the sea to 0 elevation.

=== OpenStreetMap or other vector coastline data ===
OpenStreetMap has line data for coastlines and water bodies. This is vector data, so can be rendered at higher apparent resolution than the landclass data. The gencoastline.py script in fgmeta/ws30 uses this to generate a series of lat/lon points that FlightGear can then use.

There is a problem where the OSM coastline (defined as the mean high water mark) doesn't exactly match the landclass raster due to projection discrepancies or simply because of state of the tide at the time that a satellite image was taken.

Ideally the coastline of the raster will match the OSM coastline as closely as possible, and perhaps overlap slightly.

To do this:

# Reclassify the Ocean as NODATA (0.0)
#* r.reclass using https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/remove_sea.txt. This reclassifies 44 (Sea) as NODATA

# Use the GDAL Fill nodata to fill out the edges for radius 10. You will now have a raster as if the sea level has dropped. Use one of the following
#*<code>gdal_fillnodata.py -md 10 -b 1 -of GTiff <original_file> <new_file></code>
#* r.fill.stats using the mode as the statistical method
# Get a shapefile of the coastline from OSM. The simplest way is to download the WGS84 split polygons from here: https://osmdata.openstreetmap.de/data/land-polygons.html. You may wish to pre-process these to clip to the rough extents of your scenery to reduce the size of the file.

# Load the OSM shapefile and Use Clip raster by mask layer this will cut out the landmass much more accurately than before.
#* gdalwarp -overwrite -of GTiff -tr 0.00015600000000000002 -9.000000000000003e-05 -tap -cutline <vector.osm> -cl multipolygons <input> <output>
# Use the GDAL Fill nodata to fill out the edges for radius 1. This ensures that there is "land" underneath the shoreline itself.
#* gdal_fillnodata.py -md 1 -b 1 -of GTiff <input> <output>
# Use the standard Fill NoData cells to fill the NoData with the correct Ocean landclass.
#* gdal_calc.py -A <input> --NoDataValue=44 --calc="A" --outfile <output>

The genVPB.py script performs these steps.

=== Experiments ===

==== Direct model generation ====
Initial experiments using the same approach as roads (overlaying an additional tri-strip for the coastline) did not blend well with the underlying landclass mesh.

'''Scenery-time generation of detailed coastline raster'''

fgmeta/ws30/gencoastlineraster.py generates a raster file that can be loaded by FG at runtime. This is quite effective and leverages python raster packages. The downside is the additional disk space.

=== Thought Experiments ===

==== Nearest Neighbour Encoding ====
The landclass texture currently has unused channels. It would be possible to use one of those channels to encode information about the neighbouring texels. This could be used for mixing coastline fragments better. For example, encoding whether the 8 surrounding texels are water or land could be done in 8 bits, conveniently 256 different values. A separate texture could be conceived that defined a different shape of coastline for each of the 256 combinations, probably with some perturbations to avoid obvious repetition.

Howto:Create WS3.0 terrain

2026-05-15T16:14:45Z

Wlbragg: /* Running the docker container */

{{WS30 Navbar}}
This article provides instructions on how to generate basic WS3.0 terrain.

WS3.0 terrain consists of three parts:

# A terrain mesh consisting of a landclass texture draped over an elevation model.
# A high resolution water raster used to show water features such as rivers, lakes and coastline with more definition
# Line features such as roads and railways.

The terrain is generated by a set of tools that are packaged in a docker image for convenience.[[File:Diagram-export-21-12-2023-16 29 37.png|thumb|Basic WS3.0 Scenery Generation Process]]

== Prerequisites ==

=== Set up a Workspace ===
Create a directory with the following sub-directories:

* <code>cache</code>
* <code>data</code>
* <code>output/vpb</code>
* <code>output/Terrain</code>

=== Docker ===

# Install [https://docs.docker.com/get-started/ Docker] on your platform.
#Pull the docker image by running the following command

docker pull flightgear/ws30-vpb-generator:latest
Optionally, if you are hitting rate limits:
#Create an account on https://hub.docker.com/. (Note that you will need to click on an email verification link before you can log in for the first time)
#Run <code>docker login</code> before the '''docker pull''' command above

== Getting the base data ==
You need two pieces of data for the area of scenery you are generating:

# An elevation model (aka DEM). This indicates what altitude each point of the surface is.
# Landclass data showing what type of terrain is at each point of the surface. This is often either a Raster (effectively a texture), or vector data.

=== Elevation Model ===
Download the NASADEM elevation model for the area of scenery you wish to generate. This is available in 1x1 degree blocks from [https://lpdaac.usgs.gov/products/nasadem_hgtv001/ here], and with an interactive browser [https://search.earthdata.nasa.gov/search here].

Unzip the files into the <code>data</code> directory.

=== Landclass Raster ===
Download an landclass raster for the area of scenery you wish to generate.

* For Europe, use of [https://land.copernicus.eu/pan-european/corine-land-cover/clc2018 CORINE] is recommended.
* For the USA [https://www.mrlc.gov/viewer/ NLCD] is recommended
* Sentinel-2 data is available for the entire world via [https://livingatlas.arcgis.com/landcoverexplorer/ ESRI], but has limited set of landclasses.

Put these into the <code>data</code> directory.

More detailed terrain can be created by modifying the landclass raster, and/or generating a new raster from vector data. These processes are discussed below.

== Generating Terrain ==
To generate terrain you need to run the tools within the docker container we installed above. The docker image is like a small, independent virtual computing environment running within your system. This particular docker image has all the scenery generation tools already installed.

=== Running the docker container ===
Firstly, get the container running from the directory containing your <code>cache</code>, <code>data</code> and <code>output</code> directories:
docker run --rm --mount "type=bind,source=`pwd`/data,target=/home/flightgear/data,readonly" --mount "type=bind,source=`pwd`/output,target=/home/flightgear/output" --mount "type=bind,source=`pwd`/cache,target=/home/flightgear/cache" -it flightgear/ws30-vpb-generator:latest /bin/bash

You should now find yourself in a bash shell within your container. You should see data and output directories which are linked to the directories you created earlier:
flightgear@ddcac77f7d5e:~$ ls
cache data output bin scripts
In the windows environment using Docker Desktop, if you need a path to a source of elevation data and a path to the OSM shoreline shapefiles, you can add the following:
docker run --rm --mount "type=bind,source=G:/Scenery/ws3.0/Alabama/data,target=/home/flightgear/data,readonly" --mount "type=bind,source=G:/Scenery/WS3.0-extra/vector/land-polygons-complete-4326,target=/home/flightgear/coastlines" --mount "type=bind,source=G:/Scenery/WS3.0-extra/SRTM-1,target=/home/flightgear/SRTM-3,readonly" --mount "type=bind,source=G:/Scenery/ws3.0/Alabama/output,target=/home/flightgear/output" --mount "type=bind,source=G:/Scenery/ws3.0/Alabama/output/cache,target=/home/flightgear/cache" -it flightgear/ws30-vpb-generator:latest /bin/bash

Note the --mount "type=bind,source=G:/Scenery/WS3.0-extra/SRTM-1,target=/home/flightgear/SRTM-3,readonly", the genVPB.py script in the Docker container is expecting a location of /home/flightgear/SRTM-3 for the elevation data. In this example I am using SRTM-1 elevation data, but we still map it to the expected /home/flightgear/SRTM-3 Docker container location.
=== Building the terrain ===
To build the terrain mesh, use the <code>genVPB.py</code> tool from inside the docker container:

Usage: genVPB.py --raster <input-raster> [ option ... ]
Usage: genVPB.py --bbox <lat0> <lon0> <lat1> <lon1> --sentinel --reclass <reclass> [ option ... ]

Arguments:
--raster RASTER Input landclass raster.
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--sentinel Use Sentinel2 landclass tiles
--sentinel-dir SENTINEL_DIR Directory for Sentinel Data. Default /home/flightgear/data/Sentinel-2
--hgt-dir HGT_DIR Directory containing HGT DEM files. Default /home/flightgear/data/NASADEM
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/output
--download-sentinel Download Sentinel2 tiles if needed
--reclass RECLASS Reclassify raster using file <reclass>. See ./scripts/mappings/
--coastline COASTLINE Clip against coastline against polygon (.osm)
--shrink-water SHRINK_WATER Shrink water bodies (landclasses 40, 41) by <pixels> pixels
--generate-water-raster Generate a water raster from OSM data
--generate-line-features Generate a water raster from OSM data
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--nasadem-server NASADEM_SERVER Set server to download NASADEM data from. Default https://e4ftl01.cr.usgs.gov/MEASURES/NASADEM_HGT.001/2000.02.11/)
--nasadem-user NASADEM_USER NASA Earthdata username.
--nasadem-password NASADEM_PASSWORD NASA Earthdata password.
--debug Debug output

For example, to generate a piece of terrain around Edinburgh (latitude 55.5, longitude 3 degrees West):
./scripts/genVPB.py --bbox 55 -4 56 -3 --raster ./data/uk_wgs84_10m_N54.tif

Another example, to generate a coastal area with shorelines and lakes, like Alaska:
./scripts/genVPB.py --bbox 68 -167 69 -152 --raster ./data/NLCD_2016_Alaska167-153_68_Smoothed-HD-Compressed_4326.tiff --hgt-dir ./SRTM-3/ --generate-water-raster --shrink-water 4 --coastline ./coastlines/land_polygons.shp

Same thing with roads and rails (line features):
./scripts/genVPB.py --bbox 68 -167 69 -152 --raster ./data/NLCD_2016_Alaska167-153_68_Smoothed-HD-Compressed_4326.tiff --hgt-dir ./SRTM-3/ --generate-water-raster --shrink-water 4 --coastline ./coastlines/land_polygons.shp --generate-line-features

If you are using anything other than a CORINE raster you will need to reclassify the data to match the landclasses used by FlightGear. Those classes are defined in [https://gitlab.com/flightgear/fgdata/-/tree/next/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml]. You can reclassify them using the files in the [https://gitlab.com/flightgear/fgmeta/-/tree/next/ws30/mappings/ scripts/mappings] directory. E.g. to reclassify NLCD2019 data you can use <code>--reclassify ./scripts/mappings/nlcd2019.txt</code>.

genVPB.py will output the data to the output/vpb directory, in which you should find a series of files and directories.

=== Adding water ===
'''Update 05/12/2026: Depreciated, it is now built into genVPB.py above.'''

'''Use genVPB.py ...... --generate-water-raster --shrink-water 4 --coastline [path_to_shapefile_mask]'''

The terrain mesh does not have highly detailed water features - as typically the source data has a resolution of 10-25m. Water features are generated from OpenStreetMap data. To generate water features simply run the <code>genwaterraster.py</code> command.

Usage: genwaterraster.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--output-dir OUTPUT_DIR] [--cache-dir CACHE_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--output-dir OUTPUT_DIR Directory to write files into. Default /home/flightgear/output
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache

For example, to generate water for the area around Edinburgh:
./scripts/genwaterraster.py --bbox 55 -4 56 -3

Inside the ./output/vpb directory there should be a set of directories and .png files.

=== Adding roads and railways ===
The terrain mesh does not have any line features - things like roads. These are generated separately from OpenStreetMap data. To generate line features simply run the <code>genroads.py</code> command:

Usage: ./scripts/genroads.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--threads THREADS] [--cache-dir CACHE_DIR] [--output-dir OUTPUT_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--threads THREADS Number of parallel threads to run. Defaults to 1
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/cache/

For example, to generate roads for the area around Edinburgh:
./scripts/genroads.py --bbox 55 -4 56 -3

Inside the ./output/Terrain directory there should be a set of directories and, .STG files text files.

==Running FlightGear with the new WS3.0 Terrain==
To test the new terrain, simply include the output directory in your scenery path and run FlightGear with the <code>--prop:/scenery/use-vpb=true</code> to enable WS3.0.

== Advanced Techniques ==
The following sections describe more complex techniques to generate higher quality WS3.0 terrain. Almost all of them involve using different data sources to generate a more detailed landclass raster before running the final scenery generation processes described above. Generating a highly detailed landclass raster is where the magic happens.

Most techniques use gdal or grass to modify the raster/vector data, typically using the QGIS program.

=== Using a different elevation model ===
If you are using another elevation model other than NASAEM, then you may need to re-project it using QGIS/gdalwarp to the WGS84 CRS (aka EPSG:4326).

=== Landclass Data Requirements ===
For any landclass data we need to ensure the data is in the correct format. That means:

# Is a Raster (geotiff) rather than Vector data. This raster will become the texture on the terrain that the terrain shaders do their magic on.
# Uses the WGS84 Coordinate Reference System. The ensures that the terrain generation step is efficient.
# Has the correct landclass values for each terrain type. We use a set of values based on the CORINE raster set, defined in [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml].

Below is a quick table showing what steps you need to take for common landclass data sources.
{| class="wikitable"
|+
!Landclass Data
!Warp to WGS84 required?
!Landclass re-classification Required?
!Raster Simplification Required?
!Conversion to Raster Required?
|-
|CORINE Raster
|Yes
|No
|No
|No
|-
|CORINE Vector
|Yes
|Yes
|No
|Yes
|-
|NLCD
|No
|Yes
|Yes
|No
|-
|Sentinel-2
|Yes
|Yes
|No
|No
|}
Conversion to Raster must be done manually. Converting to WGS84 and the correct landclasses ''can'' be done by the genVPB.py script, but slows down scenery generation. Therefore if you are planning to generate scenery multiple times it is best to pre-process the files yourself.

The easiest way to do these operations is using QGIS, which is available for most platforms. If you are scripting a toolchain, the QGIS tools include command-line equivalents for all commands.

When using QGIS, set the Project CRS to WGS84 (aka EPSG:4326). You can then add layers of Raster or Vector data from files from the <code>Layer->Add Layer</code> menu. When performing any operations, <u>always</u> write out the data to a real file so you can go back to it later. Disk space is cheap :).

=== Warping Raster Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a raster layer to a different CRS using the Raster->Projections-Warp (Reproject) tool.

Select the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Resampling Method to Use - Nearest Neighbour. (Landclass data is not like normal images. You don't want to interpolate between values.)
* Nodata value for output bands - 0.0 (This means that any data at the edges will be Ocean, usually a reasonable default)
* Advanced Parameters - No Compression
* Output data type - Byte
* Reprojected - Choose a target filename

Alternatively you can do this step from the commandline.
gdalwarp -t_srs EPSG:4326 -dstnodata 0.0 -r near -ot Byte -of GTiff -co COMPRESS=NONE -co BIGTIFF=IF_NEEDED /home/stuart/FlightGear/VPB/data/CORINE/u2018_clc2018_v2020_20u1_raster100m/DATA/U2018_CLC2018_V2020_20u1.tif /home/stuart/FlightGear/VPB/data/scratch/corine_WGS84.tif

=== Warping Vector Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a vector layer using Vector->Data Management Tools->Reproject Layer.

Set the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Reprojected - Choose a target filename

=== Reclassifying Vector Layers ===
For CORINE vector data in particular, the attributes used in the vector data are not the same as those used by the CORINE Raster data. So we need to create a new attribute on the data.
[[File:Field Calculator.png|thumb|QGIS Field Calculator]]
To do this

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialog
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type "Whole Number (Integer)". This will create a new column which we will populate with the correct landclass data
* Click on the <code>Open Field Calculator</code> button (Ctrl + I). (If you get an error about only being able to create Virtual fields, go back to the Layer menu, export it and open the exported file).
* Select the following options:
** Update Existing Field
** Select the Landclass field you just created.
** Copy the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/corine_vector.txt into the Expression box (without the comment lines starting with <code>#</code>). This is just some simple code to set the attribute correctly. The code should be correct for CORINE vector data. If your data is from other sources you will need to work out how you want to map your source data landclasses to the CORINE ones. [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml] can be used as a guide.
* Select <code>OK</code>. You should see that your landclass column is now populated with the landclass data.
* Select <code>Layer->Save Layer Edits</code> to save you changes

=== Creating a Raster from a Vector Layer ===
To create a Raster from a Vector Layer select <code>Raster->Conversion->Rasterize (Vector to Raster)</code>.
[[File:QGIS Rasterize (Vector to Raster).png|thumb|Creating a Raster from a Vector Layer - QGIS Rasterize]]
Select the following options:

* Input Layer - correct layer, check CRS
* Field to use for burn-in value - select the <code>Landclass</code> column you created above.
* Output raster size units. This is going to set the resolution of your raster. You can work out the resolution in two different ways:
** Select "Georeferenced units" and determine how many degrees each pixel is in latitude and longitude.
** Select "Pixels" and determine the size of raster you want in pixels. [https://www.nhc.noaa.gov/gccalc.shtml This] is a good calculator to help. You input e.g. SE and SW coordinates and calculate to get the distance in Km. Then you multiply by thousand and devide by the number of metres per pixel (e.g. 5) -> resolution for width.
* Width/Horizontal Resolution. Enter the values you've calculated for the horizontal resolution (longitudinal), or the width of the raster
* Height/Vertical Resolution. Enter the values you've calculated for the vertical resolution (latitude or the height of the raster)
* Output extent - Select an option from the box on the right. You can edit the text afterwards (NB: East, West, South, North). Best practise is to create long thin strips of 1 degree latitude in height, as this makes subsequent processing much easier.
* Assign a specific nodata value to output bands - Select 0.0 for Ocean. CORINE vector data in particular has a lot of nodata for Oceans
* Advanced Parameters - No Compression
* Output data type - Byte
* Rasterized - Select a new filename

=== Simplifying a Raster Layer ===
Some Raster Landclass data (NLCD included) has too much noise - in particular large US highway systems are identified as Urban areas.

To smooth it out we can use the GRASS <code>n.neighbors</code> function from the Processing Toolbox in QGIS.

Select the following options:

* Input Layer - correct layer, check CRS
* Neighborhood operation - median. (This is not a normal image, so using an average will result in weird values)
* Neighborhood size - 5.
* Neighbors - Select a new filename.

=== Clipping a Raster Layer with OSM Data for Land (Corine) ===
The Corine dataset does not match OSM coastlines exactly. The following multi-stage process makes sure, that no Corine land-use is in the water as defined by OSM.

==== Download OSM Land Data ====

Download land polygons based on OSM data as a Shapefile from [https://osmdata.openstreetmap.de/data/land-polygons.html Land Polygons] and make sure to pick the WGS84 projected download with split polygons ("Large polygons are split, use for larger scales"). Once downloaded unzip the content into a directory.

==== Reclassifying the OSM Land Data Vector Layer ====
I QGIS make sure that only the layer for the raster for land data is selected (e.g. <code>land-polygons-split-4326</code>) -> in the map view you will see the whole earth. NB: typically you do this reclassify only once after download and can reuse the result for future processing.

Then:

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialogue
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type <code>Integer (32 bit)</code>. This will create a new column which we will populate with the correct land class data
* On top of the table on the left side choose "Landclass" in the drop-down menu, then input <code>2</code> into the field to the right and then press button "Update" all to the left of this field.
* Wait a bit and the close the dialogue.
* Select <code>Layer->Save Layer Edits</code> to save your changes (overwrite e.g. <code>land-polygons-split-4326</code>).

==== Convert the Land Data from Vector to Raster ====
Do the same as in chapter "Creating a Raster from a Vector Layer" above. The only difference is that the Input layer will be the land data polygons and you need to choose a different file name for the "Rasterized" (e.g. osm_land_scotland_5m.tif)

==== Remove Novalue Entries in the Land Data Raster ====
To do this:

* Select <code>Processing->Toolbox</code>. You should see a new box on the right side.
* Write "gdal_calc" in the search box and you should see an entry "Raster calculator". Double click on it and you will get a new dialogue window.
* In this dialogue:
** For "Input layer A" choose the raster from the previous chapter ((e.g. osm_land_scotland_5m.tif)
** In field "Calculation in gdalnumeric ..." write: <code>greater(A,0) * A</code>
** In field "Output raster type" choose <code>Byte</code>
** In field "Advanced Parameters" choose Profile <code>No compression</code>
** In field "Additional command-line parameters" write: <code>--hideNoData</code>
** In field "Calculated" choose a file (e.g. osm_land_scotland_allvalues_5m.tif)
** (In the "GDAL/OGR console call" it will have something similar to the follwing - just with different paths: <code>gdal_calc.py --overwrite --calc "greater(A ,0) * A" --format GTiff --type Byte -A /home/vanosten/custom-fg-scenery/data/osm_land_scotland_5m.tif --A_band 1 --co COMPRESS=NONE --co BIGTIFF=IF_NEEDED --hideNoData --outfile /home/vanosten/custom-fg-scenery/data/osm_land_scotland_allvalues_5m.tif</code>
** Press the "Run" button - and when complete close the dialogue.

You should now see a map only black and white. You can check for correctness by pressing <code>CTRL+SHIFT+I</code> to get a cursor with an arrow and an "i". First make sure the new raster is selected on the left side. Next click on the sea/ocean and then check in the "Identify Results" window on the right that the value is < 2. The click on the land and check that the value is 2.

==== Create the Final Clipped Corine Raster Against OSM Land Data =====
Do the following:

* In QGIS make sure that you have only the following two layers: the basis Corine raster (see chapter "Creating a Raster from a Vector Layer" - here e.g. corine_raster_scotland_5m.tif) and plus the raster from the previous step (e.g. osm_land_scotland_allvalues_5m.tif)
* Select <code>Raster->Raster Calculator ...</code> and a corresponding dialogue will open showing on the left hand side the two rasters.
* Choose a new "Output layer" (e.g. corine_raster_scotland_clipped_5m.tif).
* In the "Raster Calculator Expression" field input: <code>if ("osm_land_scotland_all_data_5m@1" < 2, 44, "corine_raster_scotland_5m@1")</code>
* Press button "OK" and wait a while (you will see a new dialogue with showing the progress.

Done. You have now a raster (e.g. corine_raster_scotland_clipped_5m.tif) which does not have land in areas, where OSM data has sea/ocean.

=== Reclassifying a Raster Layer ===
WS3.0 uses CORINE landclass values. If using data from other sources it needs to be reclassified to the correct values. genVPB.py has an option to do this, but you may wish to do so manually.

To do this select <code>GRASS->Raster->r.reclass</code> from the Processing Toolbox.

Select the following options:

* Input Raster Layer - correct layer, check CRS
* Reclass rules text - copy in the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/nlcd2019.txt. Or an appropriate mapping from your landclass data to CORINE. Note that you can also reference a file using the "File containing reclass rules" option. Note a mapping of 22 24 = 1 is the same as 22 and 24 = 1. For a range of 22 to 24 use 22 23 24 = 1.
* Reclassified - Select a new filename.

(If this doesn't work a similar function is available in the Processing Toolbox under <code>Raster analysis->Reclassify by table</code>. However this doesn't save your table once you close the dialog, and entries have to be manually entered individually which takes a lot of effort)

=== Processing NLCD for USA using the Raster Calculator and tools in QGIS ===

[[Processing_NLCD_for_USA_using_Raster_Calculator_and_tools_in_QGIS]]

=== Python script to process NLCD for the USA ===

[[Python_script_to_process_NLCD_for_the_USA]]

=== Python script to process Sentinel-2 data ===

[[Python_script_to_process_Sentinel-2_data]]

===Generating the Terrain using osgdem===
Instead of using genVPB.py, you may wish to run osgdem directly.

In the Windows/Docker platform you can send the generate tile command directly to osgdem.exe, one tile at a time.

Using the NLCD raster processing convention from above, following is the the final step after creating the raster and entering bash shell with the windows version of "docker run..."

osgdem --TERRAIN --image-ext png --RGBA --no-interpolate-imagery --disable-error-diffusion --geocentric --no-mip-mapping -t ./data/California-Southern_4326-84-hd-corrected.tiff -d ./SRTM-3/N32W115.hgt -b -115 32 -114 33 --PagedLOD -l 7 --radius-to-max-visible-distance-ratio 3 -o ./output/vpb/w120n30/w115n32/ws_w115n32.osgb

Note: the --image-ext png --RGBA flags are critical to successfully building correctly placed landclasses in the final VPB generated scenery.

If you prefer to run the scenery generation manually, running the VPB osgdem process is described in more detail here: [[Virtual Planet Builder#Running VPB]].

After doing this you should have an output directory containing files of the form <code>output/vpb/w010n50/w004n50/ws_w004n50.osgb</code>, plus a host of sub-directories. Each one of these is a 1x1 tile of terrain.

to leave the container simply type <code>exit</code>.

===Packaging the Scenery===
Once you have the terrain and line features they should be packaged in a scenery directory in vpb and Terrain sub-directories respectively. E.g.
MyCoolScenery/Terrain
MyCoolScenery/vpb
It is good practise to document the data sources used in scenery generation. Some source licenses require attribution of the original data source for anything derived, published or distributed.

To assist in fulfilling these license obligations, you can create a source.xml file in the scenery directory which includes attribution information. This will then be available from within the simulator under Help->Scenery Sources, and <u>may</u> fulfil the attribution requirements of your license. '''Note that you are responsible for fulfilling any license requirements from the data, not FlightGear'''.

The format of the file is straightforward:
<?xml version="1.0"?>
<PropertyList>
<nowiki><source></nowiki>
<name>Corine Land Cover (CLC) 2018, Version 2020_20u1</name>
<nowiki><link></nowiki><nowiki>http://web.archive.org/web/20221112175615/https://land.copernicus.eu/pan-european/corine-land-cover/clc2018?tab=metadata%2A</nowiki><nowiki></link></nowiki>
<license>GMES Open License</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>NASADEM Merged DEM Global 1 arc second V001</name>
<nowiki><link></nowiki><nowiki>https://www.earthdata.nasa.gov/</nowiki><nowiki></link></nowiki>
<license>Public Domain</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>OpenStreetMap</name>
<nowiki><link></nowiki><nowiki>https://www.openstreetmap.org/copyright</nowiki><nowiki></link></nowiki>
<license>Open Data Commons Open Database License</license>
<nowiki></source></nowiki>
</PropertyList>

Howto:Create WS3.0 terrain

2026-05-15T16:14:15Z

Wlbragg: /* Running the docker container */

{{WS30 Navbar}}
This article provides instructions on how to generate basic WS3.0 terrain.

WS3.0 terrain consists of three parts:

# A terrain mesh consisting of a landclass texture draped over an elevation model.
# A high resolution water raster used to show water features such as rivers, lakes and coastline with more definition
# Line features such as roads and railways.

The terrain is generated by a set of tools that are packaged in a docker image for convenience.[[File:Diagram-export-21-12-2023-16 29 37.png|thumb|Basic WS3.0 Scenery Generation Process]]

== Prerequisites ==

=== Set up a Workspace ===
Create a directory with the following sub-directories:

* <code>cache</code>
* <code>data</code>
* <code>output/vpb</code>
* <code>output/Terrain</code>

=== Docker ===

# Install [https://docs.docker.com/get-started/ Docker] on your platform.
#Pull the docker image by running the following command

docker pull flightgear/ws30-vpb-generator:latest
Optionally, if you are hitting rate limits:
#Create an account on https://hub.docker.com/. (Note that you will need to click on an email verification link before you can log in for the first time)
#Run <code>docker login</code> before the '''docker pull''' command above

== Getting the base data ==
You need two pieces of data for the area of scenery you are generating:

# An elevation model (aka DEM). This indicates what altitude each point of the surface is.
# Landclass data showing what type of terrain is at each point of the surface. This is often either a Raster (effectively a texture), or vector data.

=== Elevation Model ===
Download the NASADEM elevation model for the area of scenery you wish to generate. This is available in 1x1 degree blocks from [https://lpdaac.usgs.gov/products/nasadem_hgtv001/ here], and with an interactive browser [https://search.earthdata.nasa.gov/search here].

Unzip the files into the <code>data</code> directory.

=== Landclass Raster ===
Download an landclass raster for the area of scenery you wish to generate.

* For Europe, use of [https://land.copernicus.eu/pan-european/corine-land-cover/clc2018 CORINE] is recommended.
* For the USA [https://www.mrlc.gov/viewer/ NLCD] is recommended
* Sentinel-2 data is available for the entire world via [https://livingatlas.arcgis.com/landcoverexplorer/ ESRI], but has limited set of landclasses.

Put these into the <code>data</code> directory.

More detailed terrain can be created by modifying the landclass raster, and/or generating a new raster from vector data. These processes are discussed below.

== Generating Terrain ==
To generate terrain you need to run the tools within the docker container we installed above. The docker image is like a small, independent virtual computing environment running within your system. This particular docker image has all the scenery generation tools already installed.

=== Running the docker container ===
Firstly, get the container running from the directory containing your <code>cache</code>, <code>data</code> and <code>output</code> directories:
docker run --rm --mount "type=bind,source=`pwd`/data,target=/home/flightgear/data,readonly" --mount "type=bind,source=`pwd`/output,target=/home/flightgear/output" --mount "type=bind,source=`pwd`/cache,target=/home/flightgear/cache" -it flightgear/ws30-vpb-generator:latest /bin/bash

You should now find yourself in a bash shell within your container. You should see data and output directories which are linked to the directories you created earlier:
flightgear@ddcac77f7d5e:~$ ls
cache data output bin scripts
In the windows environment using Docker Desktop, if you need a path to a source of elevation data and a path to the OSM shoreline shapefiles, you can od the following:
docker run --rm --mount "type=bind,source=G:/Scenery/ws3.0/Alabama/data,target=/home/flightgear/data,readonly" --mount "type=bind,source=G:/Scenery/WS3.0-extra/vector/land-polygons-complete-4326,target=/home/flightgear/coastlines" --mount "type=bind,source=G:/Scenery/WS3.0-extra/SRTM-1,target=/home/flightgear/SRTM-3,readonly" --mount "type=bind,source=G:/Scenery/ws3.0/Alabama/output,target=/home/flightgear/output" --mount "type=bind,source=G:/Scenery/ws3.0/Alabama/output/cache,target=/home/flightgear/cache" -it flightgear/ws30-vpb-generator:latest /bin/bash

Note the --mount "type=bind,source=G:/Scenery/WS3.0-extra/SRTM-1,target=/home/flightgear/SRTM-3,readonly", the genVPB.py script in the Docker container is expecting a location of /home/flightgear/SRTM-3 for the elevation data. In this example I am using SRTM-1 elevation data, but we still map it to the expected /home/flightgear/SRTM-3 Docker container location.
=== Building the terrain ===
To build the terrain mesh, use the <code>genVPB.py</code> tool from inside the docker container:

Usage: genVPB.py --raster <input-raster> [ option ... ]
Usage: genVPB.py --bbox <lat0> <lon0> <lat1> <lon1> --sentinel --reclass <reclass> [ option ... ]

Arguments:
--raster RASTER Input landclass raster.
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--sentinel Use Sentinel2 landclass tiles
--sentinel-dir SENTINEL_DIR Directory for Sentinel Data. Default /home/flightgear/data/Sentinel-2
--hgt-dir HGT_DIR Directory containing HGT DEM files. Default /home/flightgear/data/NASADEM
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/output
--download-sentinel Download Sentinel2 tiles if needed
--reclass RECLASS Reclassify raster using file <reclass>. See ./scripts/mappings/
--coastline COASTLINE Clip against coastline against polygon (.osm)
--shrink-water SHRINK_WATER Shrink water bodies (landclasses 40, 41) by <pixels> pixels
--generate-water-raster Generate a water raster from OSM data
--generate-line-features Generate a water raster from OSM data
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--nasadem-server NASADEM_SERVER Set server to download NASADEM data from. Default https://e4ftl01.cr.usgs.gov/MEASURES/NASADEM_HGT.001/2000.02.11/)
--nasadem-user NASADEM_USER NASA Earthdata username.
--nasadem-password NASADEM_PASSWORD NASA Earthdata password.
--debug Debug output

For example, to generate a piece of terrain around Edinburgh (latitude 55.5, longitude 3 degrees West):
./scripts/genVPB.py --bbox 55 -4 56 -3 --raster ./data/uk_wgs84_10m_N54.tif

Another example, to generate a coastal area with shorelines and lakes, like Alaska:
./scripts/genVPB.py --bbox 68 -167 69 -152 --raster ./data/NLCD_2016_Alaska167-153_68_Smoothed-HD-Compressed_4326.tiff --hgt-dir ./SRTM-3/ --generate-water-raster --shrink-water 4 --coastline ./coastlines/land_polygons.shp

Same thing with roads and rails (line features):
./scripts/genVPB.py --bbox 68 -167 69 -152 --raster ./data/NLCD_2016_Alaska167-153_68_Smoothed-HD-Compressed_4326.tiff --hgt-dir ./SRTM-3/ --generate-water-raster --shrink-water 4 --coastline ./coastlines/land_polygons.shp --generate-line-features

If you are using anything other than a CORINE raster you will need to reclassify the data to match the landclasses used by FlightGear. Those classes are defined in [https://gitlab.com/flightgear/fgdata/-/tree/next/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml]. You can reclassify them using the files in the [https://gitlab.com/flightgear/fgmeta/-/tree/next/ws30/mappings/ scripts/mappings] directory. E.g. to reclassify NLCD2019 data you can use <code>--reclassify ./scripts/mappings/nlcd2019.txt</code>.

genVPB.py will output the data to the output/vpb directory, in which you should find a series of files and directories.

=== Adding water ===
'''Update 05/12/2026: Depreciated, it is now built into genVPB.py above.'''

'''Use genVPB.py ...... --generate-water-raster --shrink-water 4 --coastline [path_to_shapefile_mask]'''

The terrain mesh does not have highly detailed water features - as typically the source data has a resolution of 10-25m. Water features are generated from OpenStreetMap data. To generate water features simply run the <code>genwaterraster.py</code> command.

Usage: genwaterraster.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--output-dir OUTPUT_DIR] [--cache-dir CACHE_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--output-dir OUTPUT_DIR Directory to write files into. Default /home/flightgear/output
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache

For example, to generate water for the area around Edinburgh:
./scripts/genwaterraster.py --bbox 55 -4 56 -3

Inside the ./output/vpb directory there should be a set of directories and .png files.

=== Adding roads and railways ===
The terrain mesh does not have any line features - things like roads. These are generated separately from OpenStreetMap data. To generate line features simply run the <code>genroads.py</code> command:

Usage: ./scripts/genroads.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--threads THREADS] [--cache-dir CACHE_DIR] [--output-dir OUTPUT_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--threads THREADS Number of parallel threads to run. Defaults to 1
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/cache/

For example, to generate roads for the area around Edinburgh:
./scripts/genroads.py --bbox 55 -4 56 -3

Inside the ./output/Terrain directory there should be a set of directories and, .STG files text files.

==Running FlightGear with the new WS3.0 Terrain==
To test the new terrain, simply include the output directory in your scenery path and run FlightGear with the <code>--prop:/scenery/use-vpb=true</code> to enable WS3.0.

== Advanced Techniques ==
The following sections describe more complex techniques to generate higher quality WS3.0 terrain. Almost all of them involve using different data sources to generate a more detailed landclass raster before running the final scenery generation processes described above. Generating a highly detailed landclass raster is where the magic happens.

Most techniques use gdal or grass to modify the raster/vector data, typically using the QGIS program.

=== Using a different elevation model ===
If you are using another elevation model other than NASAEM, then you may need to re-project it using QGIS/gdalwarp to the WGS84 CRS (aka EPSG:4326).

=== Landclass Data Requirements ===
For any landclass data we need to ensure the data is in the correct format. That means:

# Is a Raster (geotiff) rather than Vector data. This raster will become the texture on the terrain that the terrain shaders do their magic on.
# Uses the WGS84 Coordinate Reference System. The ensures that the terrain generation step is efficient.
# Has the correct landclass values for each terrain type. We use a set of values based on the CORINE raster set, defined in [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml].

Below is a quick table showing what steps you need to take for common landclass data sources.
{| class="wikitable"
|+
!Landclass Data
!Warp to WGS84 required?
!Landclass re-classification Required?
!Raster Simplification Required?
!Conversion to Raster Required?
|-
|CORINE Raster
|Yes
|No
|No
|No
|-
|CORINE Vector
|Yes
|Yes
|No
|Yes
|-
|NLCD
|No
|Yes
|Yes
|No
|-
|Sentinel-2
|Yes
|Yes
|No
|No
|}
Conversion to Raster must be done manually. Converting to WGS84 and the correct landclasses ''can'' be done by the genVPB.py script, but slows down scenery generation. Therefore if you are planning to generate scenery multiple times it is best to pre-process the files yourself.

The easiest way to do these operations is using QGIS, which is available for most platforms. If you are scripting a toolchain, the QGIS tools include command-line equivalents for all commands.

When using QGIS, set the Project CRS to WGS84 (aka EPSG:4326). You can then add layers of Raster or Vector data from files from the <code>Layer->Add Layer</code> menu. When performing any operations, <u>always</u> write out the data to a real file so you can go back to it later. Disk space is cheap :).

=== Warping Raster Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a raster layer to a different CRS using the Raster->Projections-Warp (Reproject) tool.

Select the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Resampling Method to Use - Nearest Neighbour. (Landclass data is not like normal images. You don't want to interpolate between values.)
* Nodata value for output bands - 0.0 (This means that any data at the edges will be Ocean, usually a reasonable default)
* Advanced Parameters - No Compression
* Output data type - Byte
* Reprojected - Choose a target filename

Alternatively you can do this step from the commandline.
gdalwarp -t_srs EPSG:4326 -dstnodata 0.0 -r near -ot Byte -of GTiff -co COMPRESS=NONE -co BIGTIFF=IF_NEEDED /home/stuart/FlightGear/VPB/data/CORINE/u2018_clc2018_v2020_20u1_raster100m/DATA/U2018_CLC2018_V2020_20u1.tif /home/stuart/FlightGear/VPB/data/scratch/corine_WGS84.tif

=== Warping Vector Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a vector layer using Vector->Data Management Tools->Reproject Layer.

Set the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Reprojected - Choose a target filename

=== Reclassifying Vector Layers ===
For CORINE vector data in particular, the attributes used in the vector data are not the same as those used by the CORINE Raster data. So we need to create a new attribute on the data.
[[File:Field Calculator.png|thumb|QGIS Field Calculator]]
To do this

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialog
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type "Whole Number (Integer)". This will create a new column which we will populate with the correct landclass data
* Click on the <code>Open Field Calculator</code> button (Ctrl + I). (If you get an error about only being able to create Virtual fields, go back to the Layer menu, export it and open the exported file).
* Select the following options:
** Update Existing Field
** Select the Landclass field you just created.
** Copy the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/corine_vector.txt into the Expression box (without the comment lines starting with <code>#</code>). This is just some simple code to set the attribute correctly. The code should be correct for CORINE vector data. If your data is from other sources you will need to work out how you want to map your source data landclasses to the CORINE ones. [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml] can be used as a guide.
* Select <code>OK</code>. You should see that your landclass column is now populated with the landclass data.
* Select <code>Layer->Save Layer Edits</code> to save you changes

=== Creating a Raster from a Vector Layer ===
To create a Raster from a Vector Layer select <code>Raster->Conversion->Rasterize (Vector to Raster)</code>.
[[File:QGIS Rasterize (Vector to Raster).png|thumb|Creating a Raster from a Vector Layer - QGIS Rasterize]]
Select the following options:

* Input Layer - correct layer, check CRS
* Field to use for burn-in value - select the <code>Landclass</code> column you created above.
* Output raster size units. This is going to set the resolution of your raster. You can work out the resolution in two different ways:
** Select "Georeferenced units" and determine how many degrees each pixel is in latitude and longitude.
** Select "Pixels" and determine the size of raster you want in pixels. [https://www.nhc.noaa.gov/gccalc.shtml This] is a good calculator to help. You input e.g. SE and SW coordinates and calculate to get the distance in Km. Then you multiply by thousand and devide by the number of metres per pixel (e.g. 5) -> resolution for width.
* Width/Horizontal Resolution. Enter the values you've calculated for the horizontal resolution (longitudinal), or the width of the raster
* Height/Vertical Resolution. Enter the values you've calculated for the vertical resolution (latitude or the height of the raster)
* Output extent - Select an option from the box on the right. You can edit the text afterwards (NB: East, West, South, North). Best practise is to create long thin strips of 1 degree latitude in height, as this makes subsequent processing much easier.
* Assign a specific nodata value to output bands - Select 0.0 for Ocean. CORINE vector data in particular has a lot of nodata for Oceans
* Advanced Parameters - No Compression
* Output data type - Byte
* Rasterized - Select a new filename

=== Simplifying a Raster Layer ===
Some Raster Landclass data (NLCD included) has too much noise - in particular large US highway systems are identified as Urban areas.

To smooth it out we can use the GRASS <code>n.neighbors</code> function from the Processing Toolbox in QGIS.

Select the following options:

* Input Layer - correct layer, check CRS
* Neighborhood operation - median. (This is not a normal image, so using an average will result in weird values)
* Neighborhood size - 5.
* Neighbors - Select a new filename.

=== Clipping a Raster Layer with OSM Data for Land (Corine) ===
The Corine dataset does not match OSM coastlines exactly. The following multi-stage process makes sure, that no Corine land-use is in the water as defined by OSM.

==== Download OSM Land Data ====

Download land polygons based on OSM data as a Shapefile from [https://osmdata.openstreetmap.de/data/land-polygons.html Land Polygons] and make sure to pick the WGS84 projected download with split polygons ("Large polygons are split, use for larger scales"). Once downloaded unzip the content into a directory.

==== Reclassifying the OSM Land Data Vector Layer ====
I QGIS make sure that only the layer for the raster for land data is selected (e.g. <code>land-polygons-split-4326</code>) -> in the map view you will see the whole earth. NB: typically you do this reclassify only once after download and can reuse the result for future processing.

Then:

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialogue
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type <code>Integer (32 bit)</code>. This will create a new column which we will populate with the correct land class data
* On top of the table on the left side choose "Landclass" in the drop-down menu, then input <code>2</code> into the field to the right and then press button "Update" all to the left of this field.
* Wait a bit and the close the dialogue.
* Select <code>Layer->Save Layer Edits</code> to save your changes (overwrite e.g. <code>land-polygons-split-4326</code>).

==== Convert the Land Data from Vector to Raster ====
Do the same as in chapter "Creating a Raster from a Vector Layer" above. The only difference is that the Input layer will be the land data polygons and you need to choose a different file name for the "Rasterized" (e.g. osm_land_scotland_5m.tif)

==== Remove Novalue Entries in the Land Data Raster ====
To do this:

* Select <code>Processing->Toolbox</code>. You should see a new box on the right side.
* Write "gdal_calc" in the search box and you should see an entry "Raster calculator". Double click on it and you will get a new dialogue window.
* In this dialogue:
** For "Input layer A" choose the raster from the previous chapter ((e.g. osm_land_scotland_5m.tif)
** In field "Calculation in gdalnumeric ..." write: <code>greater(A,0) * A</code>
** In field "Output raster type" choose <code>Byte</code>
** In field "Advanced Parameters" choose Profile <code>No compression</code>
** In field "Additional command-line parameters" write: <code>--hideNoData</code>
** In field "Calculated" choose a file (e.g. osm_land_scotland_allvalues_5m.tif)
** (In the "GDAL/OGR console call" it will have something similar to the follwing - just with different paths: <code>gdal_calc.py --overwrite --calc "greater(A ,0) * A" --format GTiff --type Byte -A /home/vanosten/custom-fg-scenery/data/osm_land_scotland_5m.tif --A_band 1 --co COMPRESS=NONE --co BIGTIFF=IF_NEEDED --hideNoData --outfile /home/vanosten/custom-fg-scenery/data/osm_land_scotland_allvalues_5m.tif</code>
** Press the "Run" button - and when complete close the dialogue.

You should now see a map only black and white. You can check for correctness by pressing <code>CTRL+SHIFT+I</code> to get a cursor with an arrow and an "i". First make sure the new raster is selected on the left side. Next click on the sea/ocean and then check in the "Identify Results" window on the right that the value is < 2. The click on the land and check that the value is 2.

==== Create the Final Clipped Corine Raster Against OSM Land Data =====
Do the following:

* In QGIS make sure that you have only the following two layers: the basis Corine raster (see chapter "Creating a Raster from a Vector Layer" - here e.g. corine_raster_scotland_5m.tif) and plus the raster from the previous step (e.g. osm_land_scotland_allvalues_5m.tif)
* Select <code>Raster->Raster Calculator ...</code> and a corresponding dialogue will open showing on the left hand side the two rasters.
* Choose a new "Output layer" (e.g. corine_raster_scotland_clipped_5m.tif).
* In the "Raster Calculator Expression" field input: <code>if ("osm_land_scotland_all_data_5m@1" < 2, 44, "corine_raster_scotland_5m@1")</code>
* Press button "OK" and wait a while (you will see a new dialogue with showing the progress.

Done. You have now a raster (e.g. corine_raster_scotland_clipped_5m.tif) which does not have land in areas, where OSM data has sea/ocean.

=== Reclassifying a Raster Layer ===
WS3.0 uses CORINE landclass values. If using data from other sources it needs to be reclassified to the correct values. genVPB.py has an option to do this, but you may wish to do so manually.

To do this select <code>GRASS->Raster->r.reclass</code> from the Processing Toolbox.

Select the following options:

* Input Raster Layer - correct layer, check CRS
* Reclass rules text - copy in the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/nlcd2019.txt. Or an appropriate mapping from your landclass data to CORINE. Note that you can also reference a file using the "File containing reclass rules" option. Note a mapping of 22 24 = 1 is the same as 22 and 24 = 1. For a range of 22 to 24 use 22 23 24 = 1.
* Reclassified - Select a new filename.

(If this doesn't work a similar function is available in the Processing Toolbox under <code>Raster analysis->Reclassify by table</code>. However this doesn't save your table once you close the dialog, and entries have to be manually entered individually which takes a lot of effort)

=== Processing NLCD for USA using the Raster Calculator and tools in QGIS ===

[[Processing_NLCD_for_USA_using_Raster_Calculator_and_tools_in_QGIS]]

=== Python script to process NLCD for the USA ===

[[Python_script_to_process_NLCD_for_the_USA]]

=== Python script to process Sentinel-2 data ===

[[Python_script_to_process_Sentinel-2_data]]

===Generating the Terrain using osgdem===
Instead of using genVPB.py, you may wish to run osgdem directly.

In the Windows/Docker platform you can send the generate tile command directly to osgdem.exe, one tile at a time.

Using the NLCD raster processing convention from above, following is the the final step after creating the raster and entering bash shell with the windows version of "docker run..."

osgdem --TERRAIN --image-ext png --RGBA --no-interpolate-imagery --disable-error-diffusion --geocentric --no-mip-mapping -t ./data/California-Southern_4326-84-hd-corrected.tiff -d ./SRTM-3/N32W115.hgt -b -115 32 -114 33 --PagedLOD -l 7 --radius-to-max-visible-distance-ratio 3 -o ./output/vpb/w120n30/w115n32/ws_w115n32.osgb

Note: the --image-ext png --RGBA flags are critical to successfully building correctly placed landclasses in the final VPB generated scenery.

If you prefer to run the scenery generation manually, running the VPB osgdem process is described in more detail here: [[Virtual Planet Builder#Running VPB]].

After doing this you should have an output directory containing files of the form <code>output/vpb/w010n50/w004n50/ws_w004n50.osgb</code>, plus a host of sub-directories. Each one of these is a 1x1 tile of terrain.

to leave the container simply type <code>exit</code>.

===Packaging the Scenery===
Once you have the terrain and line features they should be packaged in a scenery directory in vpb and Terrain sub-directories respectively. E.g.
MyCoolScenery/Terrain
MyCoolScenery/vpb
It is good practise to document the data sources used in scenery generation. Some source licenses require attribution of the original data source for anything derived, published or distributed.

To assist in fulfilling these license obligations, you can create a source.xml file in the scenery directory which includes attribution information. This will then be available from within the simulator under Help->Scenery Sources, and <u>may</u> fulfil the attribution requirements of your license. '''Note that you are responsible for fulfilling any license requirements from the data, not FlightGear'''.

The format of the file is straightforward:
<?xml version="1.0"?>
<PropertyList>
<nowiki><source></nowiki>
<name>Corine Land Cover (CLC) 2018, Version 2020_20u1</name>
<nowiki><link></nowiki><nowiki>http://web.archive.org/web/20221112175615/https://land.copernicus.eu/pan-european/corine-land-cover/clc2018?tab=metadata%2A</nowiki><nowiki></link></nowiki>
<license>GMES Open License</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>NASADEM Merged DEM Global 1 arc second V001</name>
<nowiki><link></nowiki><nowiki>https://www.earthdata.nasa.gov/</nowiki><nowiki></link></nowiki>
<license>Public Domain</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>OpenStreetMap</name>
<nowiki><link></nowiki><nowiki>https://www.openstreetmap.org/copyright</nowiki><nowiki></link></nowiki>
<license>Open Data Commons Open Database License</license>
<nowiki></source></nowiki>
</PropertyList>

Howto:Create WS3.0 terrain

2026-05-15T16:04:49Z

Wlbragg: /* Building the terrain */

{{WS30 Navbar}}
This article provides instructions on how to generate basic WS3.0 terrain.

WS3.0 terrain consists of three parts:

# A terrain mesh consisting of a landclass texture draped over an elevation model.
# A high resolution water raster used to show water features such as rivers, lakes and coastline with more definition
# Line features such as roads and railways.

The terrain is generated by a set of tools that are packaged in a docker image for convenience.[[File:Diagram-export-21-12-2023-16 29 37.png|thumb|Basic WS3.0 Scenery Generation Process]]

== Prerequisites ==

=== Set up a Workspace ===
Create a directory with the following sub-directories:

* <code>cache</code>
* <code>data</code>
* <code>output/vpb</code>
* <code>output/Terrain</code>

=== Docker ===

# Install [https://docs.docker.com/get-started/ Docker] on your platform.
#Pull the docker image by running the following command

docker pull flightgear/ws30-vpb-generator:latest
Optionally, if you are hitting rate limits:
#Create an account on https://hub.docker.com/. (Note that you will need to click on an email verification link before you can log in for the first time)
#Run <code>docker login</code> before the '''docker pull''' command above

== Getting the base data ==
You need two pieces of data for the area of scenery you are generating:

# An elevation model (aka DEM). This indicates what altitude each point of the surface is.
# Landclass data showing what type of terrain is at each point of the surface. This is often either a Raster (effectively a texture), or vector data.

=== Elevation Model ===
Download the NASADEM elevation model for the area of scenery you wish to generate. This is available in 1x1 degree blocks from [https://lpdaac.usgs.gov/products/nasadem_hgtv001/ here], and with an interactive browser [https://search.earthdata.nasa.gov/search here].

Unzip the files into the <code>data</code> directory.

=== Landclass Raster ===
Download an landclass raster for the area of scenery you wish to generate.

* For Europe, use of [https://land.copernicus.eu/pan-european/corine-land-cover/clc2018 CORINE] is recommended.
* For the USA [https://www.mrlc.gov/viewer/ NLCD] is recommended
* Sentinel-2 data is available for the entire world via [https://livingatlas.arcgis.com/landcoverexplorer/ ESRI], but has limited set of landclasses.

Put these into the <code>data</code> directory.

More detailed terrain can be created by modifying the landclass raster, and/or generating a new raster from vector data. These processes are discussed below.

== Generating Terrain ==
To generate terrain you need to run the tools within the docker container we installed above. The docker image is like a small, independent virtual computing environment running within your system. This particular docker image has all the scenery generation tools already installed.

=== Running the docker container ===
Firstly, get the container running from the directory containing your <code>cache</code>, <code>data</code> and <code>output</code> directories:
docker run --rm --mount "type=bind,source=`pwd`/data,target=/home/flightgear/data,readonly" --mount "type=bind,source=`pwd`/output,target=/home/flightgear/output" --mount "type=bind,source=`pwd`/cache,target=/home/flightgear/cache" -it flightgear/ws30-vpb-generator:latest /bin/bash

You should now find yourself in a bash shell within your container. You should see data and output directories which are linked to the directories you created earlier:
flightgear@ddcac77f7d5e:~$ ls
cache data output bin scripts

=== Building the terrain ===
To build the terrain mesh, use the <code>genVPB.py</code> tool from inside the docker container:

Usage: genVPB.py --raster <input-raster> [ option ... ]
Usage: genVPB.py --bbox <lat0> <lon0> <lat1> <lon1> --sentinel --reclass <reclass> [ option ... ]

Arguments:
--raster RASTER Input landclass raster.
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--sentinel Use Sentinel2 landclass tiles
--sentinel-dir SENTINEL_DIR Directory for Sentinel Data. Default /home/flightgear/data/Sentinel-2
--hgt-dir HGT_DIR Directory containing HGT DEM files. Default /home/flightgear/data/NASADEM
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/output
--download-sentinel Download Sentinel2 tiles if needed
--reclass RECLASS Reclassify raster using file <reclass>. See ./scripts/mappings/
--coastline COASTLINE Clip against coastline against polygon (.osm)
--shrink-water SHRINK_WATER Shrink water bodies (landclasses 40, 41) by <pixels> pixels
--generate-water-raster Generate a water raster from OSM data
--generate-line-features Generate a water raster from OSM data
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--nasadem-server NASADEM_SERVER Set server to download NASADEM data from. Default https://e4ftl01.cr.usgs.gov/MEASURES/NASADEM_HGT.001/2000.02.11/)
--nasadem-user NASADEM_USER NASA Earthdata username.
--nasadem-password NASADEM_PASSWORD NASA Earthdata password.
--debug Debug output

For example, to generate a piece of terrain around Edinburgh (latitude 55.5, longitude 3 degrees West):
./scripts/genVPB.py --bbox 55 -4 56 -3 --raster ./data/uk_wgs84_10m_N54.tif

Another example, to generate a coastal area with shorelines and lakes, like Alaska:
./scripts/genVPB.py --bbox 68 -167 69 -152 --raster ./data/NLCD_2016_Alaska167-153_68_Smoothed-HD-Compressed_4326.tiff --hgt-dir ./SRTM-3/ --generate-water-raster --shrink-water 4 --coastline ./coastlines/land_polygons.shp

Same thing with roads and rails (line features):
./scripts/genVPB.py --bbox 68 -167 69 -152 --raster ./data/NLCD_2016_Alaska167-153_68_Smoothed-HD-Compressed_4326.tiff --hgt-dir ./SRTM-3/ --generate-water-raster --shrink-water 4 --coastline ./coastlines/land_polygons.shp --generate-line-features

If you are using anything other than a CORINE raster you will need to reclassify the data to match the landclasses used by FlightGear. Those classes are defined in [https://gitlab.com/flightgear/fgdata/-/tree/next/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml]. You can reclassify them using the files in the [https://gitlab.com/flightgear/fgmeta/-/tree/next/ws30/mappings/ scripts/mappings] directory. E.g. to reclassify NLCD2019 data you can use <code>--reclassify ./scripts/mappings/nlcd2019.txt</code>.

genVPB.py will output the data to the output/vpb directory, in which you should find a series of files and directories.

=== Adding water ===
'''Update 05/12/2026: Depreciated, it is now built into genVPB.py above.'''

'''Use genVPB.py ...... --generate-water-raster --shrink-water 4 --coastline [path_to_shapefile_mask]'''

The terrain mesh does not have highly detailed water features - as typically the source data has a resolution of 10-25m. Water features are generated from OpenStreetMap data. To generate water features simply run the <code>genwaterraster.py</code> command.

Usage: genwaterraster.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--output-dir OUTPUT_DIR] [--cache-dir CACHE_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--output-dir OUTPUT_DIR Directory to write files into. Default /home/flightgear/output
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache

For example, to generate water for the area around Edinburgh:
./scripts/genwaterraster.py --bbox 55 -4 56 -3

Inside the ./output/vpb directory there should be a set of directories and .png files.

=== Adding roads and railways ===
The terrain mesh does not have any line features - things like roads. These are generated separately from OpenStreetMap data. To generate line features simply run the <code>genroads.py</code> command:

Usage: ./scripts/genroads.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--threads THREADS] [--cache-dir CACHE_DIR] [--output-dir OUTPUT_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--threads THREADS Number of parallel threads to run. Defaults to 1
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/cache/

For example, to generate roads for the area around Edinburgh:
./scripts/genroads.py --bbox 55 -4 56 -3

Inside the ./output/Terrain directory there should be a set of directories and, .STG files text files.

==Running FlightGear with the new WS3.0 Terrain==
To test the new terrain, simply include the output directory in your scenery path and run FlightGear with the <code>--prop:/scenery/use-vpb=true</code> to enable WS3.0.

== Advanced Techniques ==
The following sections describe more complex techniques to generate higher quality WS3.0 terrain. Almost all of them involve using different data sources to generate a more detailed landclass raster before running the final scenery generation processes described above. Generating a highly detailed landclass raster is where the magic happens.

Most techniques use gdal or grass to modify the raster/vector data, typically using the QGIS program.

=== Using a different elevation model ===
If you are using another elevation model other than NASAEM, then you may need to re-project it using QGIS/gdalwarp to the WGS84 CRS (aka EPSG:4326).

=== Landclass Data Requirements ===
For any landclass data we need to ensure the data is in the correct format. That means:

# Is a Raster (geotiff) rather than Vector data. This raster will become the texture on the terrain that the terrain shaders do their magic on.
# Uses the WGS84 Coordinate Reference System. The ensures that the terrain generation step is efficient.
# Has the correct landclass values for each terrain type. We use a set of values based on the CORINE raster set, defined in [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml].

Below is a quick table showing what steps you need to take for common landclass data sources.
{| class="wikitable"
|+
!Landclass Data
!Warp to WGS84 required?
!Landclass re-classification Required?
!Raster Simplification Required?
!Conversion to Raster Required?
|-
|CORINE Raster
|Yes
|No
|No
|No
|-
|CORINE Vector
|Yes
|Yes
|No
|Yes
|-
|NLCD
|No
|Yes
|Yes
|No
|-
|Sentinel-2
|Yes
|Yes
|No
|No
|}
Conversion to Raster must be done manually. Converting to WGS84 and the correct landclasses ''can'' be done by the genVPB.py script, but slows down scenery generation. Therefore if you are planning to generate scenery multiple times it is best to pre-process the files yourself.

The easiest way to do these operations is using QGIS, which is available for most platforms. If you are scripting a toolchain, the QGIS tools include command-line equivalents for all commands.

When using QGIS, set the Project CRS to WGS84 (aka EPSG:4326). You can then add layers of Raster or Vector data from files from the <code>Layer->Add Layer</code> menu. When performing any operations, <u>always</u> write out the data to a real file so you can go back to it later. Disk space is cheap :).

=== Warping Raster Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a raster layer to a different CRS using the Raster->Projections-Warp (Reproject) tool.

Select the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Resampling Method to Use - Nearest Neighbour. (Landclass data is not like normal images. You don't want to interpolate between values.)
* Nodata value for output bands - 0.0 (This means that any data at the edges will be Ocean, usually a reasonable default)
* Advanced Parameters - No Compression
* Output data type - Byte
* Reprojected - Choose a target filename

Alternatively you can do this step from the commandline.
gdalwarp -t_srs EPSG:4326 -dstnodata 0.0 -r near -ot Byte -of GTiff -co COMPRESS=NONE -co BIGTIFF=IF_NEEDED /home/stuart/FlightGear/VPB/data/CORINE/u2018_clc2018_v2020_20u1_raster100m/DATA/U2018_CLC2018_V2020_20u1.tif /home/stuart/FlightGear/VPB/data/scratch/corine_WGS84.tif

=== Warping Vector Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a vector layer using Vector->Data Management Tools->Reproject Layer.

Set the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Reprojected - Choose a target filename

=== Reclassifying Vector Layers ===
For CORINE vector data in particular, the attributes used in the vector data are not the same as those used by the CORINE Raster data. So we need to create a new attribute on the data.
[[File:Field Calculator.png|thumb|QGIS Field Calculator]]
To do this

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialog
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type "Whole Number (Integer)". This will create a new column which we will populate with the correct landclass data
* Click on the <code>Open Field Calculator</code> button (Ctrl + I). (If you get an error about only being able to create Virtual fields, go back to the Layer menu, export it and open the exported file).
* Select the following options:
** Update Existing Field
** Select the Landclass field you just created.
** Copy the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/corine_vector.txt into the Expression box (without the comment lines starting with <code>#</code>). This is just some simple code to set the attribute correctly. The code should be correct for CORINE vector data. If your data is from other sources you will need to work out how you want to map your source data landclasses to the CORINE ones. [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml] can be used as a guide.
* Select <code>OK</code>. You should see that your landclass column is now populated with the landclass data.
* Select <code>Layer->Save Layer Edits</code> to save you changes

=== Creating a Raster from a Vector Layer ===
To create a Raster from a Vector Layer select <code>Raster->Conversion->Rasterize (Vector to Raster)</code>.
[[File:QGIS Rasterize (Vector to Raster).png|thumb|Creating a Raster from a Vector Layer - QGIS Rasterize]]
Select the following options:

* Input Layer - correct layer, check CRS
* Field to use for burn-in value - select the <code>Landclass</code> column you created above.
* Output raster size units. This is going to set the resolution of your raster. You can work out the resolution in two different ways:
** Select "Georeferenced units" and determine how many degrees each pixel is in latitude and longitude.
** Select "Pixels" and determine the size of raster you want in pixels. [https://www.nhc.noaa.gov/gccalc.shtml This] is a good calculator to help. You input e.g. SE and SW coordinates and calculate to get the distance in Km. Then you multiply by thousand and devide by the number of metres per pixel (e.g. 5) -> resolution for width.
* Width/Horizontal Resolution. Enter the values you've calculated for the horizontal resolution (longitudinal), or the width of the raster
* Height/Vertical Resolution. Enter the values you've calculated for the vertical resolution (latitude or the height of the raster)
* Output extent - Select an option from the box on the right. You can edit the text afterwards (NB: East, West, South, North). Best practise is to create long thin strips of 1 degree latitude in height, as this makes subsequent processing much easier.
* Assign a specific nodata value to output bands - Select 0.0 for Ocean. CORINE vector data in particular has a lot of nodata for Oceans
* Advanced Parameters - No Compression
* Output data type - Byte
* Rasterized - Select a new filename

=== Simplifying a Raster Layer ===
Some Raster Landclass data (NLCD included) has too much noise - in particular large US highway systems are identified as Urban areas.

To smooth it out we can use the GRASS <code>n.neighbors</code> function from the Processing Toolbox in QGIS.

Select the following options:

* Input Layer - correct layer, check CRS
* Neighborhood operation - median. (This is not a normal image, so using an average will result in weird values)
* Neighborhood size - 5.
* Neighbors - Select a new filename.

=== Clipping a Raster Layer with OSM Data for Land (Corine) ===
The Corine dataset does not match OSM coastlines exactly. The following multi-stage process makes sure, that no Corine land-use is in the water as defined by OSM.

==== Download OSM Land Data ====

Download land polygons based on OSM data as a Shapefile from [https://osmdata.openstreetmap.de/data/land-polygons.html Land Polygons] and make sure to pick the WGS84 projected download with split polygons ("Large polygons are split, use for larger scales"). Once downloaded unzip the content into a directory.

==== Reclassifying the OSM Land Data Vector Layer ====
I QGIS make sure that only the layer for the raster for land data is selected (e.g. <code>land-polygons-split-4326</code>) -> in the map view you will see the whole earth. NB: typically you do this reclassify only once after download and can reuse the result for future processing.

Then:

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialogue
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type <code>Integer (32 bit)</code>. This will create a new column which we will populate with the correct land class data
* On top of the table on the left side choose "Landclass" in the drop-down menu, then input <code>2</code> into the field to the right and then press button "Update" all to the left of this field.
* Wait a bit and the close the dialogue.
* Select <code>Layer->Save Layer Edits</code> to save your changes (overwrite e.g. <code>land-polygons-split-4326</code>).

==== Convert the Land Data from Vector to Raster ====
Do the same as in chapter "Creating a Raster from a Vector Layer" above. The only difference is that the Input layer will be the land data polygons and you need to choose a different file name for the "Rasterized" (e.g. osm_land_scotland_5m.tif)

==== Remove Novalue Entries in the Land Data Raster ====
To do this:

* Select <code>Processing->Toolbox</code>. You should see a new box on the right side.
* Write "gdal_calc" in the search box and you should see an entry "Raster calculator". Double click on it and you will get a new dialogue window.
* In this dialogue:
** For "Input layer A" choose the raster from the previous chapter ((e.g. osm_land_scotland_5m.tif)
** In field "Calculation in gdalnumeric ..." write: <code>greater(A,0) * A</code>
** In field "Output raster type" choose <code>Byte</code>
** In field "Advanced Parameters" choose Profile <code>No compression</code>
** In field "Additional command-line parameters" write: <code>--hideNoData</code>
** In field "Calculated" choose a file (e.g. osm_land_scotland_allvalues_5m.tif)
** (In the "GDAL/OGR console call" it will have something similar to the follwing - just with different paths: <code>gdal_calc.py --overwrite --calc "greater(A ,0) * A" --format GTiff --type Byte -A /home/vanosten/custom-fg-scenery/data/osm_land_scotland_5m.tif --A_band 1 --co COMPRESS=NONE --co BIGTIFF=IF_NEEDED --hideNoData --outfile /home/vanosten/custom-fg-scenery/data/osm_land_scotland_allvalues_5m.tif</code>
** Press the "Run" button - and when complete close the dialogue.

You should now see a map only black and white. You can check for correctness by pressing <code>CTRL+SHIFT+I</code> to get a cursor with an arrow and an "i". First make sure the new raster is selected on the left side. Next click on the sea/ocean and then check in the "Identify Results" window on the right that the value is < 2. The click on the land and check that the value is 2.

==== Create the Final Clipped Corine Raster Against OSM Land Data =====
Do the following:

* In QGIS make sure that you have only the following two layers: the basis Corine raster (see chapter "Creating a Raster from a Vector Layer" - here e.g. corine_raster_scotland_5m.tif) and plus the raster from the previous step (e.g. osm_land_scotland_allvalues_5m.tif)
* Select <code>Raster->Raster Calculator ...</code> and a corresponding dialogue will open showing on the left hand side the two rasters.
* Choose a new "Output layer" (e.g. corine_raster_scotland_clipped_5m.tif).
* In the "Raster Calculator Expression" field input: <code>if ("osm_land_scotland_all_data_5m@1" < 2, 44, "corine_raster_scotland_5m@1")</code>
* Press button "OK" and wait a while (you will see a new dialogue with showing the progress.

Done. You have now a raster (e.g. corine_raster_scotland_clipped_5m.tif) which does not have land in areas, where OSM data has sea/ocean.

=== Reclassifying a Raster Layer ===
WS3.0 uses CORINE landclass values. If using data from other sources it needs to be reclassified to the correct values. genVPB.py has an option to do this, but you may wish to do so manually.

To do this select <code>GRASS->Raster->r.reclass</code> from the Processing Toolbox.

Select the following options:

* Input Raster Layer - correct layer, check CRS
* Reclass rules text - copy in the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/nlcd2019.txt. Or an appropriate mapping from your landclass data to CORINE. Note that you can also reference a file using the "File containing reclass rules" option. Note a mapping of 22 24 = 1 is the same as 22 and 24 = 1. For a range of 22 to 24 use 22 23 24 = 1.
* Reclassified - Select a new filename.

(If this doesn't work a similar function is available in the Processing Toolbox under <code>Raster analysis->Reclassify by table</code>. However this doesn't save your table once you close the dialog, and entries have to be manually entered individually which takes a lot of effort)

=== Processing NLCD for USA using the Raster Calculator and tools in QGIS ===

[[Processing_NLCD_for_USA_using_Raster_Calculator_and_tools_in_QGIS]]

=== Python script to process NLCD for the USA ===

[[Python_script_to_process_NLCD_for_the_USA]]

=== Python script to process Sentinel-2 data ===

[[Python_script_to_process_Sentinel-2_data]]

===Generating the Terrain using osgdem===
Instead of using genVPB.py, you may wish to run osgdem directly.

In the Windows/Docker platform you can send the generate tile command directly to osgdem.exe, one tile at a time.

Using the NLCD raster processing convention from above, following is the the final step after creating the raster and entering bash shell with the windows version of "docker run..."

osgdem --TERRAIN --image-ext png --RGBA --no-interpolate-imagery --disable-error-diffusion --geocentric --no-mip-mapping -t ./data/California-Southern_4326-84-hd-corrected.tiff -d ./SRTM-3/N32W115.hgt -b -115 32 -114 33 --PagedLOD -l 7 --radius-to-max-visible-distance-ratio 3 -o ./output/vpb/w120n30/w115n32/ws_w115n32.osgb

Note: the --image-ext png --RGBA flags are critical to successfully building correctly placed landclasses in the final VPB generated scenery.

If you prefer to run the scenery generation manually, running the VPB osgdem process is described in more detail here: [[Virtual Planet Builder#Running VPB]].

After doing this you should have an output directory containing files of the form <code>output/vpb/w010n50/w004n50/ws_w004n50.osgb</code>, plus a host of sub-directories. Each one of these is a 1x1 tile of terrain.

to leave the container simply type <code>exit</code>.

===Packaging the Scenery===
Once you have the terrain and line features they should be packaged in a scenery directory in vpb and Terrain sub-directories respectively. E.g.
MyCoolScenery/Terrain
MyCoolScenery/vpb
It is good practise to document the data sources used in scenery generation. Some source licenses require attribution of the original data source for anything derived, published or distributed.

To assist in fulfilling these license obligations, you can create a source.xml file in the scenery directory which includes attribution information. This will then be available from within the simulator under Help->Scenery Sources, and <u>may</u> fulfil the attribution requirements of your license. '''Note that you are responsible for fulfilling any license requirements from the data, not FlightGear'''.

The format of the file is straightforward:
<?xml version="1.0"?>
<PropertyList>
<nowiki><source></nowiki>
<name>Corine Land Cover (CLC) 2018, Version 2020_20u1</name>
<nowiki><link></nowiki><nowiki>http://web.archive.org/web/20221112175615/https://land.copernicus.eu/pan-european/corine-land-cover/clc2018?tab=metadata%2A</nowiki><nowiki></link></nowiki>
<license>GMES Open License</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>NASADEM Merged DEM Global 1 arc second V001</name>
<nowiki><link></nowiki><nowiki>https://www.earthdata.nasa.gov/</nowiki><nowiki></link></nowiki>
<license>Public Domain</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>OpenStreetMap</name>
<nowiki><link></nowiki><nowiki>https://www.openstreetmap.org/copyright</nowiki><nowiki></link></nowiki>
<license>Open Data Commons Open Database License</license>
<nowiki></source></nowiki>
</PropertyList>

Howto:Create WS3.0 terrain

2026-05-15T16:03:19Z

Wlbragg: /* Building the terrain */

{{WS30 Navbar}}
This article provides instructions on how to generate basic WS3.0 terrain.

WS3.0 terrain consists of three parts:

# A terrain mesh consisting of a landclass texture draped over an elevation model.
# A high resolution water raster used to show water features such as rivers, lakes and coastline with more definition
# Line features such as roads and railways.

The terrain is generated by a set of tools that are packaged in a docker image for convenience.[[File:Diagram-export-21-12-2023-16 29 37.png|thumb|Basic WS3.0 Scenery Generation Process]]

== Prerequisites ==

=== Set up a Workspace ===
Create a directory with the following sub-directories:

* <code>cache</code>
* <code>data</code>
* <code>output/vpb</code>
* <code>output/Terrain</code>

=== Docker ===

# Install [https://docs.docker.com/get-started/ Docker] on your platform.
#Pull the docker image by running the following command

docker pull flightgear/ws30-vpb-generator:latest
Optionally, if you are hitting rate limits:
#Create an account on https://hub.docker.com/. (Note that you will need to click on an email verification link before you can log in for the first time)
#Run <code>docker login</code> before the '''docker pull''' command above

== Getting the base data ==
You need two pieces of data for the area of scenery you are generating:

# An elevation model (aka DEM). This indicates what altitude each point of the surface is.
# Landclass data showing what type of terrain is at each point of the surface. This is often either a Raster (effectively a texture), or vector data.

=== Elevation Model ===
Download the NASADEM elevation model for the area of scenery you wish to generate. This is available in 1x1 degree blocks from [https://lpdaac.usgs.gov/products/nasadem_hgtv001/ here], and with an interactive browser [https://search.earthdata.nasa.gov/search here].

Unzip the files into the <code>data</code> directory.

=== Landclass Raster ===
Download an landclass raster for the area of scenery you wish to generate.

* For Europe, use of [https://land.copernicus.eu/pan-european/corine-land-cover/clc2018 CORINE] is recommended.
* For the USA [https://www.mrlc.gov/viewer/ NLCD] is recommended
* Sentinel-2 data is available for the entire world via [https://livingatlas.arcgis.com/landcoverexplorer/ ESRI], but has limited set of landclasses.

Put these into the <code>data</code> directory.

More detailed terrain can be created by modifying the landclass raster, and/or generating a new raster from vector data. These processes are discussed below.

== Generating Terrain ==
To generate terrain you need to run the tools within the docker container we installed above. The docker image is like a small, independent virtual computing environment running within your system. This particular docker image has all the scenery generation tools already installed.

=== Running the docker container ===
Firstly, get the container running from the directory containing your <code>cache</code>, <code>data</code> and <code>output</code> directories:
docker run --rm --mount "type=bind,source=`pwd`/data,target=/home/flightgear/data,readonly" --mount "type=bind,source=`pwd`/output,target=/home/flightgear/output" --mount "type=bind,source=`pwd`/cache,target=/home/flightgear/cache" -it flightgear/ws30-vpb-generator:latest /bin/bash

You should now find yourself in a bash shell within your container. You should see data and output directories which are linked to the directories you created earlier:
flightgear@ddcac77f7d5e:~$ ls
cache data output bin scripts

=== Building the terrain ===
To build the terrain mesh, use the <code>genVPB.py</code> tool from inside the docker container:

Usage: genVPB.py --raster <input-raster> [ option ... ]
Usage: genVPB.py --bbox <lat0> <lon0> <lat1> <lon1> --sentinel --reclass <reclass> [ option ... ]

Arguments:
--raster RASTER Input landclass raster.
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--sentinel Use Sentinel2 landclass tiles
--sentinel-dir SENTINEL_DIR Directory for Sentinel Data. Default /home/flightgear/data/Sentinel-2
--hgt-dir HGT_DIR Directory containing HGT DEM files. Default /home/flightgear/data/NASADEM
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/output
--download-sentinel Download Sentinel2 tiles if needed
--reclass RECLASS Reclassify raster using file <reclass>. See ./scripts/mappings/
--coastline COASTLINE Clip against coastline against polygon (.osm)
--shrink-water SHRINK_WATER Shrink water bodies (landclasses 40, 41) by <pixels> pixels
--generate-water-raster Generate a water raster from OSM data
--generate-line-features Generate a water raster from OSM data
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--nasadem-server NASADEM_SERVER Set server to download NASADEM data from. Default https://e4ftl01.cr.usgs.gov/MEASURES/NASADEM_HGT.001/2000.02.11/)
--nasadem-user NASADEM_USER NASA Earthdata username.
--nasadem-password NASADEM_PASSWORD NASA Earthdata password.
--debug Debug output

For example, to generate a piece of terrain around Edinburgh (latitude 55.5, longitude 3 degrees West):
./scripts/genVPB.py --bbox 55 -4 56 -3 --raster ./data/uk_wgs84_10m_N54.tif

Another example, to generate a coastal area with shorelines and lakes, like Alaska:

./scripts/genVPB.py --bbox 68 -167 69 -152 --raster ./data/NLCD_2016_Alaska167-153_68_Smoothed-HD-Compressed_4326.tiff --hgt-dir ./SRTM-3/ --generate-water-raster --shrink-water 4 --coastline ./coastlines/land_polygons.shp

Same thing with roads and rails (line features):

./scripts/genVPB.py --bbox 68 -167 69 -152 --raster ./data/NLCD_2016_Alaska167-153_68_Smoothed-HD-Compressed_4326.tiff --hgt-dir ./SRTM-3/ --generate-water-raster --shrink-water 4 --coastline ./coastlines/land_polygons.shp --generate-line-features

If you are using anything other than a CORINE raster you will need to reclassify the data to match the landclasses used by FlightGear. Those classes are defined in [https://gitlab.com/flightgear/fgdata/-/tree/next/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml]. You can reclassify them using the files in the [https://gitlab.com/flightgear/fgmeta/-/tree/next/ws30/mappings/ scripts/mappings] directory. E.g. to reclassify NLCD2019 data you can use <code>--reclassify ./scripts/mappings/nlcd2019.txt</code>.

genVPB.py will output the data to the output/vpb directory, in which you should find a series of files and directories.

=== Adding water ===
'''Update 05/12/2026: Depreciated, it is now built into genVPB.py above.'''

'''Use genVPB.py ...... --generate-water-raster --shrink-water 4 --coastline [path_to_shapefile_mask]'''

The terrain mesh does not have highly detailed water features - as typically the source data has a resolution of 10-25m. Water features are generated from OpenStreetMap data. To generate water features simply run the <code>genwaterraster.py</code> command.

Usage: genwaterraster.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--output-dir OUTPUT_DIR] [--cache-dir CACHE_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--output-dir OUTPUT_DIR Directory to write files into. Default /home/flightgear/output
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache

For example, to generate water for the area around Edinburgh:
./scripts/genwaterraster.py --bbox 55 -4 56 -3

Inside the ./output/vpb directory there should be a set of directories and .png files.

=== Adding roads and railways ===
The terrain mesh does not have any line features - things like roads. These are generated separately from OpenStreetMap data. To generate line features simply run the <code>genroads.py</code> command:

Usage: ./scripts/genroads.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--threads THREADS] [--cache-dir CACHE_DIR] [--output-dir OUTPUT_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--threads THREADS Number of parallel threads to run. Defaults to 1
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/cache/

For example, to generate roads for the area around Edinburgh:
./scripts/genroads.py --bbox 55 -4 56 -3

Inside the ./output/Terrain directory there should be a set of directories and, .STG files text files.

==Running FlightGear with the new WS3.0 Terrain==
To test the new terrain, simply include the output directory in your scenery path and run FlightGear with the <code>--prop:/scenery/use-vpb=true</code> to enable WS3.0.

== Advanced Techniques ==
The following sections describe more complex techniques to generate higher quality WS3.0 terrain. Almost all of them involve using different data sources to generate a more detailed landclass raster before running the final scenery generation processes described above. Generating a highly detailed landclass raster is where the magic happens.

Most techniques use gdal or grass to modify the raster/vector data, typically using the QGIS program.

=== Using a different elevation model ===
If you are using another elevation model other than NASAEM, then you may need to re-project it using QGIS/gdalwarp to the WGS84 CRS (aka EPSG:4326).

=== Landclass Data Requirements ===
For any landclass data we need to ensure the data is in the correct format. That means:

# Is a Raster (geotiff) rather than Vector data. This raster will become the texture on the terrain that the terrain shaders do their magic on.
# Uses the WGS84 Coordinate Reference System. The ensures that the terrain generation step is efficient.
# Has the correct landclass values for each terrain type. We use a set of values based on the CORINE raster set, defined in [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml].

Below is a quick table showing what steps you need to take for common landclass data sources.
{| class="wikitable"
|+
!Landclass Data
!Warp to WGS84 required?
!Landclass re-classification Required?
!Raster Simplification Required?
!Conversion to Raster Required?
|-
|CORINE Raster
|Yes
|No
|No
|No
|-
|CORINE Vector
|Yes
|Yes
|No
|Yes
|-
|NLCD
|No
|Yes
|Yes
|No
|-
|Sentinel-2
|Yes
|Yes
|No
|No
|}
Conversion to Raster must be done manually. Converting to WGS84 and the correct landclasses ''can'' be done by the genVPB.py script, but slows down scenery generation. Therefore if you are planning to generate scenery multiple times it is best to pre-process the files yourself.

The easiest way to do these operations is using QGIS, which is available for most platforms. If you are scripting a toolchain, the QGIS tools include command-line equivalents for all commands.

When using QGIS, set the Project CRS to WGS84 (aka EPSG:4326). You can then add layers of Raster or Vector data from files from the <code>Layer->Add Layer</code> menu. When performing any operations, <u>always</u> write out the data to a real file so you can go back to it later. Disk space is cheap :).

=== Warping Raster Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a raster layer to a different CRS using the Raster->Projections-Warp (Reproject) tool.

Select the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Resampling Method to Use - Nearest Neighbour. (Landclass data is not like normal images. You don't want to interpolate between values.)
* Nodata value for output bands - 0.0 (This means that any data at the edges will be Ocean, usually a reasonable default)
* Advanced Parameters - No Compression
* Output data type - Byte
* Reprojected - Choose a target filename

Alternatively you can do this step from the commandline.
gdalwarp -t_srs EPSG:4326 -dstnodata 0.0 -r near -ot Byte -of GTiff -co COMPRESS=NONE -co BIGTIFF=IF_NEEDED /home/stuart/FlightGear/VPB/data/CORINE/u2018_clc2018_v2020_20u1_raster100m/DATA/U2018_CLC2018_V2020_20u1.tif /home/stuart/FlightGear/VPB/data/scratch/corine_WGS84.tif

=== Warping Vector Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a vector layer using Vector->Data Management Tools->Reproject Layer.

Set the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Reprojected - Choose a target filename

=== Reclassifying Vector Layers ===
For CORINE vector data in particular, the attributes used in the vector data are not the same as those used by the CORINE Raster data. So we need to create a new attribute on the data.
[[File:Field Calculator.png|thumb|QGIS Field Calculator]]
To do this

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialog
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type "Whole Number (Integer)". This will create a new column which we will populate with the correct landclass data
* Click on the <code>Open Field Calculator</code> button (Ctrl + I). (If you get an error about only being able to create Virtual fields, go back to the Layer menu, export it and open the exported file).
* Select the following options:
** Update Existing Field
** Select the Landclass field you just created.
** Copy the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/corine_vector.txt into the Expression box (without the comment lines starting with <code>#</code>). This is just some simple code to set the attribute correctly. The code should be correct for CORINE vector data. If your data is from other sources you will need to work out how you want to map your source data landclasses to the CORINE ones. [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml] can be used as a guide.
* Select <code>OK</code>. You should see that your landclass column is now populated with the landclass data.
* Select <code>Layer->Save Layer Edits</code> to save you changes

=== Creating a Raster from a Vector Layer ===
To create a Raster from a Vector Layer select <code>Raster->Conversion->Rasterize (Vector to Raster)</code>.
[[File:QGIS Rasterize (Vector to Raster).png|thumb|Creating a Raster from a Vector Layer - QGIS Rasterize]]
Select the following options:

* Input Layer - correct layer, check CRS
* Field to use for burn-in value - select the <code>Landclass</code> column you created above.
* Output raster size units. This is going to set the resolution of your raster. You can work out the resolution in two different ways:
** Select "Georeferenced units" and determine how many degrees each pixel is in latitude and longitude.
** Select "Pixels" and determine the size of raster you want in pixels. [https://www.nhc.noaa.gov/gccalc.shtml This] is a good calculator to help. You input e.g. SE and SW coordinates and calculate to get the distance in Km. Then you multiply by thousand and devide by the number of metres per pixel (e.g. 5) -> resolution for width.
* Width/Horizontal Resolution. Enter the values you've calculated for the horizontal resolution (longitudinal), or the width of the raster
* Height/Vertical Resolution. Enter the values you've calculated for the vertical resolution (latitude or the height of the raster)
* Output extent - Select an option from the box on the right. You can edit the text afterwards (NB: East, West, South, North). Best practise is to create long thin strips of 1 degree latitude in height, as this makes subsequent processing much easier.
* Assign a specific nodata value to output bands - Select 0.0 for Ocean. CORINE vector data in particular has a lot of nodata for Oceans
* Advanced Parameters - No Compression
* Output data type - Byte
* Rasterized - Select a new filename

=== Simplifying a Raster Layer ===
Some Raster Landclass data (NLCD included) has too much noise - in particular large US highway systems are identified as Urban areas.

To smooth it out we can use the GRASS <code>n.neighbors</code> function from the Processing Toolbox in QGIS.

Select the following options:

* Input Layer - correct layer, check CRS
* Neighborhood operation - median. (This is not a normal image, so using an average will result in weird values)
* Neighborhood size - 5.
* Neighbors - Select a new filename.

=== Clipping a Raster Layer with OSM Data for Land (Corine) ===
The Corine dataset does not match OSM coastlines exactly. The following multi-stage process makes sure, that no Corine land-use is in the water as defined by OSM.

==== Download OSM Land Data ====

Download land polygons based on OSM data as a Shapefile from [https://osmdata.openstreetmap.de/data/land-polygons.html Land Polygons] and make sure to pick the WGS84 projected download with split polygons ("Large polygons are split, use for larger scales"). Once downloaded unzip the content into a directory.

==== Reclassifying the OSM Land Data Vector Layer ====
I QGIS make sure that only the layer for the raster for land data is selected (e.g. <code>land-polygons-split-4326</code>) -> in the map view you will see the whole earth. NB: typically you do this reclassify only once after download and can reuse the result for future processing.

Then:

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialogue
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type <code>Integer (32 bit)</code>. This will create a new column which we will populate with the correct land class data
* On top of the table on the left side choose "Landclass" in the drop-down menu, then input <code>2</code> into the field to the right and then press button "Update" all to the left of this field.
* Wait a bit and the close the dialogue.
* Select <code>Layer->Save Layer Edits</code> to save your changes (overwrite e.g. <code>land-polygons-split-4326</code>).

==== Convert the Land Data from Vector to Raster ====
Do the same as in chapter "Creating a Raster from a Vector Layer" above. The only difference is that the Input layer will be the land data polygons and you need to choose a different file name for the "Rasterized" (e.g. osm_land_scotland_5m.tif)

==== Remove Novalue Entries in the Land Data Raster ====
To do this:

* Select <code>Processing->Toolbox</code>. You should see a new box on the right side.
* Write "gdal_calc" in the search box and you should see an entry "Raster calculator". Double click on it and you will get a new dialogue window.
* In this dialogue:
** For "Input layer A" choose the raster from the previous chapter ((e.g. osm_land_scotland_5m.tif)
** In field "Calculation in gdalnumeric ..." write: <code>greater(A,0) * A</code>
** In field "Output raster type" choose <code>Byte</code>
** In field "Advanced Parameters" choose Profile <code>No compression</code>
** In field "Additional command-line parameters" write: <code>--hideNoData</code>
** In field "Calculated" choose a file (e.g. osm_land_scotland_allvalues_5m.tif)
** (In the "GDAL/OGR console call" it will have something similar to the follwing - just with different paths: <code>gdal_calc.py --overwrite --calc "greater(A ,0) * A" --format GTiff --type Byte -A /home/vanosten/custom-fg-scenery/data/osm_land_scotland_5m.tif --A_band 1 --co COMPRESS=NONE --co BIGTIFF=IF_NEEDED --hideNoData --outfile /home/vanosten/custom-fg-scenery/data/osm_land_scotland_allvalues_5m.tif</code>
** Press the "Run" button - and when complete close the dialogue.

You should now see a map only black and white. You can check for correctness by pressing <code>CTRL+SHIFT+I</code> to get a cursor with an arrow and an "i". First make sure the new raster is selected on the left side. Next click on the sea/ocean and then check in the "Identify Results" window on the right that the value is < 2. The click on the land and check that the value is 2.

==== Create the Final Clipped Corine Raster Against OSM Land Data =====
Do the following:

* In QGIS make sure that you have only the following two layers: the basis Corine raster (see chapter "Creating a Raster from a Vector Layer" - here e.g. corine_raster_scotland_5m.tif) and plus the raster from the previous step (e.g. osm_land_scotland_allvalues_5m.tif)
* Select <code>Raster->Raster Calculator ...</code> and a corresponding dialogue will open showing on the left hand side the two rasters.
* Choose a new "Output layer" (e.g. corine_raster_scotland_clipped_5m.tif).
* In the "Raster Calculator Expression" field input: <code>if ("osm_land_scotland_all_data_5m@1" < 2, 44, "corine_raster_scotland_5m@1")</code>
* Press button "OK" and wait a while (you will see a new dialogue with showing the progress.

Done. You have now a raster (e.g. corine_raster_scotland_clipped_5m.tif) which does not have land in areas, where OSM data has sea/ocean.

=== Reclassifying a Raster Layer ===
WS3.0 uses CORINE landclass values. If using data from other sources it needs to be reclassified to the correct values. genVPB.py has an option to do this, but you may wish to do so manually.

To do this select <code>GRASS->Raster->r.reclass</code> from the Processing Toolbox.

Select the following options:

* Input Raster Layer - correct layer, check CRS
* Reclass rules text - copy in the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/nlcd2019.txt. Or an appropriate mapping from your landclass data to CORINE. Note that you can also reference a file using the "File containing reclass rules" option. Note a mapping of 22 24 = 1 is the same as 22 and 24 = 1. For a range of 22 to 24 use 22 23 24 = 1.
* Reclassified - Select a new filename.

(If this doesn't work a similar function is available in the Processing Toolbox under <code>Raster analysis->Reclassify by table</code>. However this doesn't save your table once you close the dialog, and entries have to be manually entered individually which takes a lot of effort)

=== Processing NLCD for USA using the Raster Calculator and tools in QGIS ===

[[Processing_NLCD_for_USA_using_Raster_Calculator_and_tools_in_QGIS]]

=== Python script to process NLCD for the USA ===

[[Python_script_to_process_NLCD_for_the_USA]]

=== Python script to process Sentinel-2 data ===

[[Python_script_to_process_Sentinel-2_data]]

===Generating the Terrain using osgdem===
Instead of using genVPB.py, you may wish to run osgdem directly.

In the Windows/Docker platform you can send the generate tile command directly to osgdem.exe, one tile at a time.

Using the NLCD raster processing convention from above, following is the the final step after creating the raster and entering bash shell with the windows version of "docker run..."

osgdem --TERRAIN --image-ext png --RGBA --no-interpolate-imagery --disable-error-diffusion --geocentric --no-mip-mapping -t ./data/California-Southern_4326-84-hd-corrected.tiff -d ./SRTM-3/N32W115.hgt -b -115 32 -114 33 --PagedLOD -l 7 --radius-to-max-visible-distance-ratio 3 -o ./output/vpb/w120n30/w115n32/ws_w115n32.osgb

Note: the --image-ext png --RGBA flags are critical to successfully building correctly placed landclasses in the final VPB generated scenery.

If you prefer to run the scenery generation manually, running the VPB osgdem process is described in more detail here: [[Virtual Planet Builder#Running VPB]].

After doing this you should have an output directory containing files of the form <code>output/vpb/w010n50/w004n50/ws_w004n50.osgb</code>, plus a host of sub-directories. Each one of these is a 1x1 tile of terrain.

to leave the container simply type <code>exit</code>.

===Packaging the Scenery===
Once you have the terrain and line features they should be packaged in a scenery directory in vpb and Terrain sub-directories respectively. E.g.
MyCoolScenery/Terrain
MyCoolScenery/vpb
It is good practise to document the data sources used in scenery generation. Some source licenses require attribution of the original data source for anything derived, published or distributed.

To assist in fulfilling these license obligations, you can create a source.xml file in the scenery directory which includes attribution information. This will then be available from within the simulator under Help->Scenery Sources, and <u>may</u> fulfil the attribution requirements of your license. '''Note that you are responsible for fulfilling any license requirements from the data, not FlightGear'''.

The format of the file is straightforward:
<?xml version="1.0"?>
<PropertyList>
<nowiki><source></nowiki>
<name>Corine Land Cover (CLC) 2018, Version 2020_20u1</name>
<nowiki><link></nowiki><nowiki>http://web.archive.org/web/20221112175615/https://land.copernicus.eu/pan-european/corine-land-cover/clc2018?tab=metadata%2A</nowiki><nowiki></link></nowiki>
<license>GMES Open License</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>NASADEM Merged DEM Global 1 arc second V001</name>
<nowiki><link></nowiki><nowiki>https://www.earthdata.nasa.gov/</nowiki><nowiki></link></nowiki>
<license>Public Domain</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>OpenStreetMap</name>
<nowiki><link></nowiki><nowiki>https://www.openstreetmap.org/copyright</nowiki><nowiki></link></nowiki>
<license>Open Data Commons Open Database License</license>
<nowiki></source></nowiki>
</PropertyList>

Howto:Create WS3.0 terrain

2026-05-15T16:02:11Z

Wlbragg: /* Building the terrain */

{{WS30 Navbar}}
This article provides instructions on how to generate basic WS3.0 terrain.

WS3.0 terrain consists of three parts:

# A terrain mesh consisting of a landclass texture draped over an elevation model.
# A high resolution water raster used to show water features such as rivers, lakes and coastline with more definition
# Line features such as roads and railways.

The terrain is generated by a set of tools that are packaged in a docker image for convenience.[[File:Diagram-export-21-12-2023-16 29 37.png|thumb|Basic WS3.0 Scenery Generation Process]]

== Prerequisites ==

=== Set up a Workspace ===
Create a directory with the following sub-directories:

* <code>cache</code>
* <code>data</code>
* <code>output/vpb</code>
* <code>output/Terrain</code>

=== Docker ===

# Install [https://docs.docker.com/get-started/ Docker] on your platform.
#Pull the docker image by running the following command

docker pull flightgear/ws30-vpb-generator:latest
Optionally, if you are hitting rate limits:
#Create an account on https://hub.docker.com/. (Note that you will need to click on an email verification link before you can log in for the first time)
#Run <code>docker login</code> before the '''docker pull''' command above

== Getting the base data ==
You need two pieces of data for the area of scenery you are generating:

# An elevation model (aka DEM). This indicates what altitude each point of the surface is.
# Landclass data showing what type of terrain is at each point of the surface. This is often either a Raster (effectively a texture), or vector data.

=== Elevation Model ===
Download the NASADEM elevation model for the area of scenery you wish to generate. This is available in 1x1 degree blocks from [https://lpdaac.usgs.gov/products/nasadem_hgtv001/ here], and with an interactive browser [https://search.earthdata.nasa.gov/search here].

Unzip the files into the <code>data</code> directory.

=== Landclass Raster ===
Download an landclass raster for the area of scenery you wish to generate.

* For Europe, use of [https://land.copernicus.eu/pan-european/corine-land-cover/clc2018 CORINE] is recommended.
* For the USA [https://www.mrlc.gov/viewer/ NLCD] is recommended
* Sentinel-2 data is available for the entire world via [https://livingatlas.arcgis.com/landcoverexplorer/ ESRI], but has limited set of landclasses.

Put these into the <code>data</code> directory.

More detailed terrain can be created by modifying the landclass raster, and/or generating a new raster from vector data. These processes are discussed below.

== Generating Terrain ==
To generate terrain you need to run the tools within the docker container we installed above. The docker image is like a small, independent virtual computing environment running within your system. This particular docker image has all the scenery generation tools already installed.

=== Running the docker container ===
Firstly, get the container running from the directory containing your <code>cache</code>, <code>data</code> and <code>output</code> directories:
docker run --rm --mount "type=bind,source=`pwd`/data,target=/home/flightgear/data,readonly" --mount "type=bind,source=`pwd`/output,target=/home/flightgear/output" --mount "type=bind,source=`pwd`/cache,target=/home/flightgear/cache" -it flightgear/ws30-vpb-generator:latest /bin/bash

You should now find yourself in a bash shell within your container. You should see data and output directories which are linked to the directories you created earlier:
flightgear@ddcac77f7d5e:~$ ls
cache data output bin scripts

=== Building the terrain ===
To build the terrain mesh, use the <code>genVPB.py</code> tool from inside the docker container:

Usage: genVPB.py --raster <input-raster> [ option ... ]
Usage: genVPB.py --bbox <lat0> <lon0> <lat1> <lon1> --sentinel --reclass <reclass> [ option ... ]

Arguments:
--raster RASTER Input landclass raster.
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--sentinel Use Sentinel2 landclass tiles
--sentinel-dir SENTINEL_DIR Directory for Sentinel Data. Default /home/flightgear/data/Sentinel-2
--hgt-dir HGT_DIR Directory containing HGT DEM files. Default /home/flightgear/data/NASADEM
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/output
--download-sentinel Download Sentinel2 tiles if needed
--reclass RECLASS Reclassify raster using file <reclass>. See ./scripts/mappings/
--coastline COASTLINE Clip against coastline against polygon (.osm)
--shrink-water SHRINK_WATER Shrink water bodies (landclasses 40, 41) by <pixels> pixels
--generate-water-raster Generate a water raster from OSM data
--generate-line-features Generate a water raster from OSM data
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--nasadem-server NASADEM_SERVER Set server to download NASADEM data from. Default https://e4ftl01.cr.usgs.gov/MEASURES/NASADEM_HGT.001/2000.02.11/)
--nasadem-user NASADEM_USER NASA Earthdata username.
--nasadem-password NASADEM_PASSWORD NASA Earthdata password.
--debug Debug output

For example, to generate a piece of terrain around Edinburgh (latitude 55.5, longitude 3 degrees West):
./scripts/genVPB.py --bbox 55 -4 56 -3 --raster ./data/uk_wgs84_10m_N54.tif

Another example, to generate a coastal area with shorelines and lakes, like Alaska:
./scripts/genVPB.py --bbox 68 -167 69 -152 --raster ./data/NLCD_2016_Alaska167-153_68_Smoothed-HD-Compressed_4326.tiff --hgt-dir ./SRTM-3/ --generate-water-raster --shrink-water 4 --coastline ./coastlines/land_polygons.shp

Same thing with roads and rails (line features):
./scripts/genVPB.py --bbox 68 -167 69 -152 --raster ./data/NLCD_2016_Alaska167-153_68_Smoothed-HD-Compressed_4326.tiff --hgt-dir ./SRTM-3/ --generate-water-raster --shrink-water 4 --coastline ./coastlines/land_polygons.shp --generate-line-features

If you are using anything other than a CORINE raster you will need to reclassify the data to match the landclasses used by FlightGear. Those classes are defined in [https://gitlab.com/flightgear/fgdata/-/tree/next/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml]. You can reclassify them using the files in the [https://gitlab.com/flightgear/fgmeta/-/tree/next/ws30/mappings/ scripts/mappings] directory. E.g. to reclassify NLCD2019 data you can use <code>--reclassify ./scripts/mappings/nlcd2019.txt</code>.

genVPB.py will output the data to the output/vpb directory, in which you should find a series of files and directories.

=== Adding water ===
'''Update 05/12/2026: Depreciated, it is now built into genVPB.py above.'''

'''Use genVPB.py ...... --generate-water-raster --shrink-water 4 --coastline [path_to_shapefile_mask]'''

The terrain mesh does not have highly detailed water features - as typically the source data has a resolution of 10-25m. Water features are generated from OpenStreetMap data. To generate water features simply run the <code>genwaterraster.py</code> command.

Usage: genwaterraster.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--output-dir OUTPUT_DIR] [--cache-dir CACHE_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--output-dir OUTPUT_DIR Directory to write files into. Default /home/flightgear/output
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache

For example, to generate water for the area around Edinburgh:
./scripts/genwaterraster.py --bbox 55 -4 56 -3

Inside the ./output/vpb directory there should be a set of directories and .png files.

=== Adding roads and railways ===
The terrain mesh does not have any line features - things like roads. These are generated separately from OpenStreetMap data. To generate line features simply run the <code>genroads.py</code> command:

Usage: ./scripts/genroads.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--threads THREADS] [--cache-dir CACHE_DIR] [--output-dir OUTPUT_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--threads THREADS Number of parallel threads to run. Defaults to 1
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/cache/

For example, to generate roads for the area around Edinburgh:
./scripts/genroads.py --bbox 55 -4 56 -3

Inside the ./output/Terrain directory there should be a set of directories and, .STG files text files.

==Running FlightGear with the new WS3.0 Terrain==
To test the new terrain, simply include the output directory in your scenery path and run FlightGear with the <code>--prop:/scenery/use-vpb=true</code> to enable WS3.0.

== Advanced Techniques ==
The following sections describe more complex techniques to generate higher quality WS3.0 terrain. Almost all of them involve using different data sources to generate a more detailed landclass raster before running the final scenery generation processes described above. Generating a highly detailed landclass raster is where the magic happens.

Most techniques use gdal or grass to modify the raster/vector data, typically using the QGIS program.

=== Using a different elevation model ===
If you are using another elevation model other than NASAEM, then you may need to re-project it using QGIS/gdalwarp to the WGS84 CRS (aka EPSG:4326).

=== Landclass Data Requirements ===
For any landclass data we need to ensure the data is in the correct format. That means:

# Is a Raster (geotiff) rather than Vector data. This raster will become the texture on the terrain that the terrain shaders do their magic on.
# Uses the WGS84 Coordinate Reference System. The ensures that the terrain generation step is efficient.
# Has the correct landclass values for each terrain type. We use a set of values based on the CORINE raster set, defined in [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml].

Below is a quick table showing what steps you need to take for common landclass data sources.
{| class="wikitable"
|+
!Landclass Data
!Warp to WGS84 required?
!Landclass re-classification Required?
!Raster Simplification Required?
!Conversion to Raster Required?
|-
|CORINE Raster
|Yes
|No
|No
|No
|-
|CORINE Vector
|Yes
|Yes
|No
|Yes
|-
|NLCD
|No
|Yes
|Yes
|No
|-
|Sentinel-2
|Yes
|Yes
|No
|No
|}
Conversion to Raster must be done manually. Converting to WGS84 and the correct landclasses ''can'' be done by the genVPB.py script, but slows down scenery generation. Therefore if you are planning to generate scenery multiple times it is best to pre-process the files yourself.

The easiest way to do these operations is using QGIS, which is available for most platforms. If you are scripting a toolchain, the QGIS tools include command-line equivalents for all commands.

When using QGIS, set the Project CRS to WGS84 (aka EPSG:4326). You can then add layers of Raster or Vector data from files from the <code>Layer->Add Layer</code> menu. When performing any operations, <u>always</u> write out the data to a real file so you can go back to it later. Disk space is cheap :).

=== Warping Raster Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a raster layer to a different CRS using the Raster->Projections-Warp (Reproject) tool.

Select the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Resampling Method to Use - Nearest Neighbour. (Landclass data is not like normal images. You don't want to interpolate between values.)
* Nodata value for output bands - 0.0 (This means that any data at the edges will be Ocean, usually a reasonable default)
* Advanced Parameters - No Compression
* Output data type - Byte
* Reprojected - Choose a target filename

Alternatively you can do this step from the commandline.
gdalwarp -t_srs EPSG:4326 -dstnodata 0.0 -r near -ot Byte -of GTiff -co COMPRESS=NONE -co BIGTIFF=IF_NEEDED /home/stuart/FlightGear/VPB/data/CORINE/u2018_clc2018_v2020_20u1_raster100m/DATA/U2018_CLC2018_V2020_20u1.tif /home/stuart/FlightGear/VPB/data/scratch/corine_WGS84.tif

=== Warping Vector Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a vector layer using Vector->Data Management Tools->Reproject Layer.

Set the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Reprojected - Choose a target filename

=== Reclassifying Vector Layers ===
For CORINE vector data in particular, the attributes used in the vector data are not the same as those used by the CORINE Raster data. So we need to create a new attribute on the data.
[[File:Field Calculator.png|thumb|QGIS Field Calculator]]
To do this

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialog
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type "Whole Number (Integer)". This will create a new column which we will populate with the correct landclass data
* Click on the <code>Open Field Calculator</code> button (Ctrl + I). (If you get an error about only being able to create Virtual fields, go back to the Layer menu, export it and open the exported file).
* Select the following options:
** Update Existing Field
** Select the Landclass field you just created.
** Copy the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/corine_vector.txt into the Expression box (without the comment lines starting with <code>#</code>). This is just some simple code to set the attribute correctly. The code should be correct for CORINE vector data. If your data is from other sources you will need to work out how you want to map your source data landclasses to the CORINE ones. [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml] can be used as a guide.
* Select <code>OK</code>. You should see that your landclass column is now populated with the landclass data.
* Select <code>Layer->Save Layer Edits</code> to save you changes

=== Creating a Raster from a Vector Layer ===
To create a Raster from a Vector Layer select <code>Raster->Conversion->Rasterize (Vector to Raster)</code>.
[[File:QGIS Rasterize (Vector to Raster).png|thumb|Creating a Raster from a Vector Layer - QGIS Rasterize]]
Select the following options:

* Input Layer - correct layer, check CRS
* Field to use for burn-in value - select the <code>Landclass</code> column you created above.
* Output raster size units. This is going to set the resolution of your raster. You can work out the resolution in two different ways:
** Select "Georeferenced units" and determine how many degrees each pixel is in latitude and longitude.
** Select "Pixels" and determine the size of raster you want in pixels. [https://www.nhc.noaa.gov/gccalc.shtml This] is a good calculator to help. You input e.g. SE and SW coordinates and calculate to get the distance in Km. Then you multiply by thousand and devide by the number of metres per pixel (e.g. 5) -> resolution for width.
* Width/Horizontal Resolution. Enter the values you've calculated for the horizontal resolution (longitudinal), or the width of the raster
* Height/Vertical Resolution. Enter the values you've calculated for the vertical resolution (latitude or the height of the raster)
* Output extent - Select an option from the box on the right. You can edit the text afterwards (NB: East, West, South, North). Best practise is to create long thin strips of 1 degree latitude in height, as this makes subsequent processing much easier.
* Assign a specific nodata value to output bands - Select 0.0 for Ocean. CORINE vector data in particular has a lot of nodata for Oceans
* Advanced Parameters - No Compression
* Output data type - Byte
* Rasterized - Select a new filename

=== Simplifying a Raster Layer ===
Some Raster Landclass data (NLCD included) has too much noise - in particular large US highway systems are identified as Urban areas.

To smooth it out we can use the GRASS <code>n.neighbors</code> function from the Processing Toolbox in QGIS.

Select the following options:

* Input Layer - correct layer, check CRS
* Neighborhood operation - median. (This is not a normal image, so using an average will result in weird values)
* Neighborhood size - 5.
* Neighbors - Select a new filename.

=== Clipping a Raster Layer with OSM Data for Land (Corine) ===
The Corine dataset does not match OSM coastlines exactly. The following multi-stage process makes sure, that no Corine land-use is in the water as defined by OSM.

==== Download OSM Land Data ====

Download land polygons based on OSM data as a Shapefile from [https://osmdata.openstreetmap.de/data/land-polygons.html Land Polygons] and make sure to pick the WGS84 projected download with split polygons ("Large polygons are split, use for larger scales"). Once downloaded unzip the content into a directory.

==== Reclassifying the OSM Land Data Vector Layer ====
I QGIS make sure that only the layer for the raster for land data is selected (e.g. <code>land-polygons-split-4326</code>) -> in the map view you will see the whole earth. NB: typically you do this reclassify only once after download and can reuse the result for future processing.

Then:

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialogue
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type <code>Integer (32 bit)</code>. This will create a new column which we will populate with the correct land class data
* On top of the table on the left side choose "Landclass" in the drop-down menu, then input <code>2</code> into the field to the right and then press button "Update" all to the left of this field.
* Wait a bit and the close the dialogue.
* Select <code>Layer->Save Layer Edits</code> to save your changes (overwrite e.g. <code>land-polygons-split-4326</code>).

==== Convert the Land Data from Vector to Raster ====
Do the same as in chapter "Creating a Raster from a Vector Layer" above. The only difference is that the Input layer will be the land data polygons and you need to choose a different file name for the "Rasterized" (e.g. osm_land_scotland_5m.tif)

==== Remove Novalue Entries in the Land Data Raster ====
To do this:

* Select <code>Processing->Toolbox</code>. You should see a new box on the right side.
* Write "gdal_calc" in the search box and you should see an entry "Raster calculator". Double click on it and you will get a new dialogue window.
* In this dialogue:
** For "Input layer A" choose the raster from the previous chapter ((e.g. osm_land_scotland_5m.tif)
** In field "Calculation in gdalnumeric ..." write: <code>greater(A,0) * A</code>
** In field "Output raster type" choose <code>Byte</code>
** In field "Advanced Parameters" choose Profile <code>No compression</code>
** In field "Additional command-line parameters" write: <code>--hideNoData</code>
** In field "Calculated" choose a file (e.g. osm_land_scotland_allvalues_5m.tif)
** (In the "GDAL/OGR console call" it will have something similar to the follwing - just with different paths: <code>gdal_calc.py --overwrite --calc "greater(A ,0) * A" --format GTiff --type Byte -A /home/vanosten/custom-fg-scenery/data/osm_land_scotland_5m.tif --A_band 1 --co COMPRESS=NONE --co BIGTIFF=IF_NEEDED --hideNoData --outfile /home/vanosten/custom-fg-scenery/data/osm_land_scotland_allvalues_5m.tif</code>
** Press the "Run" button - and when complete close the dialogue.

You should now see a map only black and white. You can check for correctness by pressing <code>CTRL+SHIFT+I</code> to get a cursor with an arrow and an "i". First make sure the new raster is selected on the left side. Next click on the sea/ocean and then check in the "Identify Results" window on the right that the value is < 2. The click on the land and check that the value is 2.

==== Create the Final Clipped Corine Raster Against OSM Land Data =====
Do the following:

* In QGIS make sure that you have only the following two layers: the basis Corine raster (see chapter "Creating a Raster from a Vector Layer" - here e.g. corine_raster_scotland_5m.tif) and plus the raster from the previous step (e.g. osm_land_scotland_allvalues_5m.tif)
* Select <code>Raster->Raster Calculator ...</code> and a corresponding dialogue will open showing on the left hand side the two rasters.
* Choose a new "Output layer" (e.g. corine_raster_scotland_clipped_5m.tif).
* In the "Raster Calculator Expression" field input: <code>if ("osm_land_scotland_all_data_5m@1" < 2, 44, "corine_raster_scotland_5m@1")</code>
* Press button "OK" and wait a while (you will see a new dialogue with showing the progress.

Done. You have now a raster (e.g. corine_raster_scotland_clipped_5m.tif) which does not have land in areas, where OSM data has sea/ocean.

=== Reclassifying a Raster Layer ===
WS3.0 uses CORINE landclass values. If using data from other sources it needs to be reclassified to the correct values. genVPB.py has an option to do this, but you may wish to do so manually.

To do this select <code>GRASS->Raster->r.reclass</code> from the Processing Toolbox.

Select the following options:

* Input Raster Layer - correct layer, check CRS
* Reclass rules text - copy in the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/nlcd2019.txt. Or an appropriate mapping from your landclass data to CORINE. Note that you can also reference a file using the "File containing reclass rules" option. Note a mapping of 22 24 = 1 is the same as 22 and 24 = 1. For a range of 22 to 24 use 22 23 24 = 1.
* Reclassified - Select a new filename.

(If this doesn't work a similar function is available in the Processing Toolbox under <code>Raster analysis->Reclassify by table</code>. However this doesn't save your table once you close the dialog, and entries have to be manually entered individually which takes a lot of effort)

=== Processing NLCD for USA using the Raster Calculator and tools in QGIS ===

[[Processing_NLCD_for_USA_using_Raster_Calculator_and_tools_in_QGIS]]

=== Python script to process NLCD for the USA ===

[[Python_script_to_process_NLCD_for_the_USA]]

=== Python script to process Sentinel-2 data ===

[[Python_script_to_process_Sentinel-2_data]]

===Generating the Terrain using osgdem===
Instead of using genVPB.py, you may wish to run osgdem directly.

In the Windows/Docker platform you can send the generate tile command directly to osgdem.exe, one tile at a time.

Using the NLCD raster processing convention from above, following is the the final step after creating the raster and entering bash shell with the windows version of "docker run..."

osgdem --TERRAIN --image-ext png --RGBA --no-interpolate-imagery --disable-error-diffusion --geocentric --no-mip-mapping -t ./data/California-Southern_4326-84-hd-corrected.tiff -d ./SRTM-3/N32W115.hgt -b -115 32 -114 33 --PagedLOD -l 7 --radius-to-max-visible-distance-ratio 3 -o ./output/vpb/w120n30/w115n32/ws_w115n32.osgb

Note: the --image-ext png --RGBA flags are critical to successfully building correctly placed landclasses in the final VPB generated scenery.

If you prefer to run the scenery generation manually, running the VPB osgdem process is described in more detail here: [[Virtual Planet Builder#Running VPB]].

After doing this you should have an output directory containing files of the form <code>output/vpb/w010n50/w004n50/ws_w004n50.osgb</code>, plus a host of sub-directories. Each one of these is a 1x1 tile of terrain.

to leave the container simply type <code>exit</code>.

===Packaging the Scenery===
Once you have the terrain and line features they should be packaged in a scenery directory in vpb and Terrain sub-directories respectively. E.g.
MyCoolScenery/Terrain
MyCoolScenery/vpb
It is good practise to document the data sources used in scenery generation. Some source licenses require attribution of the original data source for anything derived, published or distributed.

To assist in fulfilling these license obligations, you can create a source.xml file in the scenery directory which includes attribution information. This will then be available from within the simulator under Help->Scenery Sources, and <u>may</u> fulfil the attribution requirements of your license. '''Note that you are responsible for fulfilling any license requirements from the data, not FlightGear'''.

The format of the file is straightforward:
<?xml version="1.0"?>
<PropertyList>
<nowiki><source></nowiki>
<name>Corine Land Cover (CLC) 2018, Version 2020_20u1</name>
<nowiki><link></nowiki><nowiki>http://web.archive.org/web/20221112175615/https://land.copernicus.eu/pan-european/corine-land-cover/clc2018?tab=metadata%2A</nowiki><nowiki></link></nowiki>
<license>GMES Open License</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>NASADEM Merged DEM Global 1 arc second V001</name>
<nowiki><link></nowiki><nowiki>https://www.earthdata.nasa.gov/</nowiki><nowiki></link></nowiki>
<license>Public Domain</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>OpenStreetMap</name>
<nowiki><link></nowiki><nowiki>https://www.openstreetmap.org/copyright</nowiki><nowiki></link></nowiki>
<license>Open Data Commons Open Database License</license>
<nowiki></source></nowiki>
</PropertyList>

Howto:Create WS3.0 terrain

2026-05-15T16:01:35Z

Wlbragg: /* Building the terrain */

{{WS30 Navbar}}
This article provides instructions on how to generate basic WS3.0 terrain.

WS3.0 terrain consists of three parts:

# A terrain mesh consisting of a landclass texture draped over an elevation model.
# A high resolution water raster used to show water features such as rivers, lakes and coastline with more definition
# Line features such as roads and railways.

The terrain is generated by a set of tools that are packaged in a docker image for convenience.[[File:Diagram-export-21-12-2023-16 29 37.png|thumb|Basic WS3.0 Scenery Generation Process]]

== Prerequisites ==

=== Set up a Workspace ===
Create a directory with the following sub-directories:

* <code>cache</code>
* <code>data</code>
* <code>output/vpb</code>
* <code>output/Terrain</code>

=== Docker ===

# Install [https://docs.docker.com/get-started/ Docker] on your platform.
#Pull the docker image by running the following command

docker pull flightgear/ws30-vpb-generator:latest
Optionally, if you are hitting rate limits:
#Create an account on https://hub.docker.com/. (Note that you will need to click on an email verification link before you can log in for the first time)
#Run <code>docker login</code> before the '''docker pull''' command above

== Getting the base data ==
You need two pieces of data for the area of scenery you are generating:

# An elevation model (aka DEM). This indicates what altitude each point of the surface is.
# Landclass data showing what type of terrain is at each point of the surface. This is often either a Raster (effectively a texture), or vector data.

=== Elevation Model ===
Download the NASADEM elevation model for the area of scenery you wish to generate. This is available in 1x1 degree blocks from [https://lpdaac.usgs.gov/products/nasadem_hgtv001/ here], and with an interactive browser [https://search.earthdata.nasa.gov/search here].

Unzip the files into the <code>data</code> directory.

=== Landclass Raster ===
Download an landclass raster for the area of scenery you wish to generate.

* For Europe, use of [https://land.copernicus.eu/pan-european/corine-land-cover/clc2018 CORINE] is recommended.
* For the USA [https://www.mrlc.gov/viewer/ NLCD] is recommended
* Sentinel-2 data is available for the entire world via [https://livingatlas.arcgis.com/landcoverexplorer/ ESRI], but has limited set of landclasses.

Put these into the <code>data</code> directory.

More detailed terrain can be created by modifying the landclass raster, and/or generating a new raster from vector data. These processes are discussed below.

== Generating Terrain ==
To generate terrain you need to run the tools within the docker container we installed above. The docker image is like a small, independent virtual computing environment running within your system. This particular docker image has all the scenery generation tools already installed.

=== Running the docker container ===
Firstly, get the container running from the directory containing your <code>cache</code>, <code>data</code> and <code>output</code> directories:
docker run --rm --mount "type=bind,source=`pwd`/data,target=/home/flightgear/data,readonly" --mount "type=bind,source=`pwd`/output,target=/home/flightgear/output" --mount "type=bind,source=`pwd`/cache,target=/home/flightgear/cache" -it flightgear/ws30-vpb-generator:latest /bin/bash

You should now find yourself in a bash shell within your container. You should see data and output directories which are linked to the directories you created earlier:
flightgear@ddcac77f7d5e:~$ ls
cache data output bin scripts

=== Building the terrain ===
To build the terrain mesh, use the <code>genVPB.py</code> tool from inside the docker container:

Usage: genVPB.py --raster <input-raster> [ option ... ]
Usage: genVPB.py --bbox <lat0> <lon0> <lat1> <lon1> --sentinel --reclass <reclass> [ option ... ]

Arguments:
--raster RASTER Input landclass raster.
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--sentinel Use Sentinel2 landclass tiles
--sentinel-dir SENTINEL_DIR Directory for Sentinel Data. Default /home/flightgear/data/Sentinel-2
--hgt-dir HGT_DIR Directory containing HGT DEM files. Default /home/flightgear/data/NASADEM
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/output
--download-sentinel Download Sentinel2 tiles if needed
--reclass RECLASS Reclassify raster using file <reclass>. See ./scripts/mappings/
--coastline COASTLINE Clip against coastline against polygon (.osm)
--shrink-water SHRINK_WATER Shrink water bodies (landclasses 40, 41) by <pixels> pixels
--generate-water-raster Generate a water raster from OSM data
--generate-line-features Generate a water raster from OSM data
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--nasadem-server NASADEM_SERVER Set server to download NASADEM data from. Default https://e4ftl01.cr.usgs.gov/MEASURES/NASADEM_HGT.001/2000.02.11/)
--nasadem-user NASADEM_USER NASA Earthdata username.
--nasadem-password NASADEM_PASSWORD NASA Earthdata password.
--debug Debug output

For example, to generate a piece of terrain around Edinburgh (latitude 55.5, longitude 3 degrees West):
./scripts/genVPB.py --bbox 55 -4 56 -3 --raster ./data/uk_wgs84_10m_N54.tif

Another example, to generate a coastal area with shorelines and lakes, like Alaska
./scripts/genVPB.py --bbox 68 -167 69 -152 --raster ./data/NLCD_2016_Alaska167-153_68_Smoothed-HD-Compressed_4326.tiff --hgt-dir ./SRTM-3/ --generate-water-raster --shrink-water 4 --coastline ./coastlines/land_polygons.shp

Same thing with roads and rails (line features)
./scripts/genVPB.py --bbox 68 -167 69 -152 --raster ./data/NLCD_2016_Alaska167-153_68_Smoothed-HD-Compressed_4326.tiff --hgt-dir ./SRTM-3/ --generate-water-raster --shrink-water 4 --coastline ./coastlines/land_polygons.shp --generate-line-features

If you are using anything other than a CORINE raster you will need to reclassify the data to match the landclasses used by FlightGear. Those classes are defined in [https://gitlab.com/flightgear/fgdata/-/tree/next/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml]. You can reclassify them using the files in the [https://gitlab.com/flightgear/fgmeta/-/tree/next/ws30/mappings/ scripts/mappings] directory. E.g. to reclassify NLCD2019 data you can use <code>--reclassify ./scripts/mappings/nlcd2019.txt</code>.

genVPB.py will output the data to the output/vpb directory, in which you should find a series of files and directories.

=== Adding water ===
'''Update 05/12/2026: Depreciated, it is now built into genVPB.py above.'''

'''Use genVPB.py ...... --generate-water-raster --shrink-water 4 --coastline [path_to_shapefile_mask]'''

The terrain mesh does not have highly detailed water features - as typically the source data has a resolution of 10-25m. Water features are generated from OpenStreetMap data. To generate water features simply run the <code>genwaterraster.py</code> command.

Usage: genwaterraster.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--output-dir OUTPUT_DIR] [--cache-dir CACHE_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--output-dir OUTPUT_DIR Directory to write files into. Default /home/flightgear/output
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache

For example, to generate water for the area around Edinburgh:
./scripts/genwaterraster.py --bbox 55 -4 56 -3

Inside the ./output/vpb directory there should be a set of directories and .png files.

=== Adding roads and railways ===
The terrain mesh does not have any line features - things like roads. These are generated separately from OpenStreetMap data. To generate line features simply run the <code>genroads.py</code> command:

Usage: ./scripts/genroads.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--threads THREADS] [--cache-dir CACHE_DIR] [--output-dir OUTPUT_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--threads THREADS Number of parallel threads to run. Defaults to 1
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/cache/

For example, to generate roads for the area around Edinburgh:
./scripts/genroads.py --bbox 55 -4 56 -3

Inside the ./output/Terrain directory there should be a set of directories and, .STG files text files.

==Running FlightGear with the new WS3.0 Terrain==
To test the new terrain, simply include the output directory in your scenery path and run FlightGear with the <code>--prop:/scenery/use-vpb=true</code> to enable WS3.0.

== Advanced Techniques ==
The following sections describe more complex techniques to generate higher quality WS3.0 terrain. Almost all of them involve using different data sources to generate a more detailed landclass raster before running the final scenery generation processes described above. Generating a highly detailed landclass raster is where the magic happens.

Most techniques use gdal or grass to modify the raster/vector data, typically using the QGIS program.

=== Using a different elevation model ===
If you are using another elevation model other than NASAEM, then you may need to re-project it using QGIS/gdalwarp to the WGS84 CRS (aka EPSG:4326).

=== Landclass Data Requirements ===
For any landclass data we need to ensure the data is in the correct format. That means:

# Is a Raster (geotiff) rather than Vector data. This raster will become the texture on the terrain that the terrain shaders do their magic on.
# Uses the WGS84 Coordinate Reference System. The ensures that the terrain generation step is efficient.
# Has the correct landclass values for each terrain type. We use a set of values based on the CORINE raster set, defined in [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml].

Below is a quick table showing what steps you need to take for common landclass data sources.
{| class="wikitable"
|+
!Landclass Data
!Warp to WGS84 required?
!Landclass re-classification Required?
!Raster Simplification Required?
!Conversion to Raster Required?
|-
|CORINE Raster
|Yes
|No
|No
|No
|-
|CORINE Vector
|Yes
|Yes
|No
|Yes
|-
|NLCD
|No
|Yes
|Yes
|No
|-
|Sentinel-2
|Yes
|Yes
|No
|No
|}
Conversion to Raster must be done manually. Converting to WGS84 and the correct landclasses ''can'' be done by the genVPB.py script, but slows down scenery generation. Therefore if you are planning to generate scenery multiple times it is best to pre-process the files yourself.

The easiest way to do these operations is using QGIS, which is available for most platforms. If you are scripting a toolchain, the QGIS tools include command-line equivalents for all commands.

When using QGIS, set the Project CRS to WGS84 (aka EPSG:4326). You can then add layers of Raster or Vector data from files from the <code>Layer->Add Layer</code> menu. When performing any operations, <u>always</u> write out the data to a real file so you can go back to it later. Disk space is cheap :).

=== Warping Raster Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a raster layer to a different CRS using the Raster->Projections-Warp (Reproject) tool.

Select the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Resampling Method to Use - Nearest Neighbour. (Landclass data is not like normal images. You don't want to interpolate between values.)
* Nodata value for output bands - 0.0 (This means that any data at the edges will be Ocean, usually a reasonable default)
* Advanced Parameters - No Compression
* Output data type - Byte
* Reprojected - Choose a target filename

Alternatively you can do this step from the commandline.
gdalwarp -t_srs EPSG:4326 -dstnodata 0.0 -r near -ot Byte -of GTiff -co COMPRESS=NONE -co BIGTIFF=IF_NEEDED /home/stuart/FlightGear/VPB/data/CORINE/u2018_clc2018_v2020_20u1_raster100m/DATA/U2018_CLC2018_V2020_20u1.tif /home/stuart/FlightGear/VPB/data/scratch/corine_WGS84.tif

=== Warping Vector Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a vector layer using Vector->Data Management Tools->Reproject Layer.

Set the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Reprojected - Choose a target filename

=== Reclassifying Vector Layers ===
For CORINE vector data in particular, the attributes used in the vector data are not the same as those used by the CORINE Raster data. So we need to create a new attribute on the data.
[[File:Field Calculator.png|thumb|QGIS Field Calculator]]
To do this

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialog
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type "Whole Number (Integer)". This will create a new column which we will populate with the correct landclass data
* Click on the <code>Open Field Calculator</code> button (Ctrl + I). (If you get an error about only being able to create Virtual fields, go back to the Layer menu, export it and open the exported file).
* Select the following options:
** Update Existing Field
** Select the Landclass field you just created.
** Copy the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/corine_vector.txt into the Expression box (without the comment lines starting with <code>#</code>). This is just some simple code to set the attribute correctly. The code should be correct for CORINE vector data. If your data is from other sources you will need to work out how you want to map your source data landclasses to the CORINE ones. [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml] can be used as a guide.
* Select <code>OK</code>. You should see that your landclass column is now populated with the landclass data.
* Select <code>Layer->Save Layer Edits</code> to save you changes

=== Creating a Raster from a Vector Layer ===
To create a Raster from a Vector Layer select <code>Raster->Conversion->Rasterize (Vector to Raster)</code>.
[[File:QGIS Rasterize (Vector to Raster).png|thumb|Creating a Raster from a Vector Layer - QGIS Rasterize]]
Select the following options:

* Input Layer - correct layer, check CRS
* Field to use for burn-in value - select the <code>Landclass</code> column you created above.
* Output raster size units. This is going to set the resolution of your raster. You can work out the resolution in two different ways:
** Select "Georeferenced units" and determine how many degrees each pixel is in latitude and longitude.
** Select "Pixels" and determine the size of raster you want in pixels. [https://www.nhc.noaa.gov/gccalc.shtml This] is a good calculator to help. You input e.g. SE and SW coordinates and calculate to get the distance in Km. Then you multiply by thousand and devide by the number of metres per pixel (e.g. 5) -> resolution for width.
* Width/Horizontal Resolution. Enter the values you've calculated for the horizontal resolution (longitudinal), or the width of the raster
* Height/Vertical Resolution. Enter the values you've calculated for the vertical resolution (latitude or the height of the raster)
* Output extent - Select an option from the box on the right. You can edit the text afterwards (NB: East, West, South, North). Best practise is to create long thin strips of 1 degree latitude in height, as this makes subsequent processing much easier.
* Assign a specific nodata value to output bands - Select 0.0 for Ocean. CORINE vector data in particular has a lot of nodata for Oceans
* Advanced Parameters - No Compression
* Output data type - Byte
* Rasterized - Select a new filename

=== Simplifying a Raster Layer ===
Some Raster Landclass data (NLCD included) has too much noise - in particular large US highway systems are identified as Urban areas.

To smooth it out we can use the GRASS <code>n.neighbors</code> function from the Processing Toolbox in QGIS.

Select the following options:

* Input Layer - correct layer, check CRS
* Neighborhood operation - median. (This is not a normal image, so using an average will result in weird values)
* Neighborhood size - 5.
* Neighbors - Select a new filename.

=== Clipping a Raster Layer with OSM Data for Land (Corine) ===
The Corine dataset does not match OSM coastlines exactly. The following multi-stage process makes sure, that no Corine land-use is in the water as defined by OSM.

==== Download OSM Land Data ====

Download land polygons based on OSM data as a Shapefile from [https://osmdata.openstreetmap.de/data/land-polygons.html Land Polygons] and make sure to pick the WGS84 projected download with split polygons ("Large polygons are split, use for larger scales"). Once downloaded unzip the content into a directory.

==== Reclassifying the OSM Land Data Vector Layer ====
I QGIS make sure that only the layer for the raster for land data is selected (e.g. <code>land-polygons-split-4326</code>) -> in the map view you will see the whole earth. NB: typically you do this reclassify only once after download and can reuse the result for future processing.

Then:

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialogue
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type <code>Integer (32 bit)</code>. This will create a new column which we will populate with the correct land class data
* On top of the table on the left side choose "Landclass" in the drop-down menu, then input <code>2</code> into the field to the right and then press button "Update" all to the left of this field.
* Wait a bit and the close the dialogue.
* Select <code>Layer->Save Layer Edits</code> to save your changes (overwrite e.g. <code>land-polygons-split-4326</code>).

==== Convert the Land Data from Vector to Raster ====
Do the same as in chapter "Creating a Raster from a Vector Layer" above. The only difference is that the Input layer will be the land data polygons and you need to choose a different file name for the "Rasterized" (e.g. osm_land_scotland_5m.tif)

==== Remove Novalue Entries in the Land Data Raster ====
To do this:

* Select <code>Processing->Toolbox</code>. You should see a new box on the right side.
* Write "gdal_calc" in the search box and you should see an entry "Raster calculator". Double click on it and you will get a new dialogue window.
* In this dialogue:
** For "Input layer A" choose the raster from the previous chapter ((e.g. osm_land_scotland_5m.tif)
** In field "Calculation in gdalnumeric ..." write: <code>greater(A,0) * A</code>
** In field "Output raster type" choose <code>Byte</code>
** In field "Advanced Parameters" choose Profile <code>No compression</code>
** In field "Additional command-line parameters" write: <code>--hideNoData</code>
** In field "Calculated" choose a file (e.g. osm_land_scotland_allvalues_5m.tif)
** (In the "GDAL/OGR console call" it will have something similar to the follwing - just with different paths: <code>gdal_calc.py --overwrite --calc "greater(A ,0) * A" --format GTiff --type Byte -A /home/vanosten/custom-fg-scenery/data/osm_land_scotland_5m.tif --A_band 1 --co COMPRESS=NONE --co BIGTIFF=IF_NEEDED --hideNoData --outfile /home/vanosten/custom-fg-scenery/data/osm_land_scotland_allvalues_5m.tif</code>
** Press the "Run" button - and when complete close the dialogue.

You should now see a map only black and white. You can check for correctness by pressing <code>CTRL+SHIFT+I</code> to get a cursor with an arrow and an "i". First make sure the new raster is selected on the left side. Next click on the sea/ocean and then check in the "Identify Results" window on the right that the value is < 2. The click on the land and check that the value is 2.

==== Create the Final Clipped Corine Raster Against OSM Land Data =====
Do the following:

* In QGIS make sure that you have only the following two layers: the basis Corine raster (see chapter "Creating a Raster from a Vector Layer" - here e.g. corine_raster_scotland_5m.tif) and plus the raster from the previous step (e.g. osm_land_scotland_allvalues_5m.tif)
* Select <code>Raster->Raster Calculator ...</code> and a corresponding dialogue will open showing on the left hand side the two rasters.
* Choose a new "Output layer" (e.g. corine_raster_scotland_clipped_5m.tif).
* In the "Raster Calculator Expression" field input: <code>if ("osm_land_scotland_all_data_5m@1" < 2, 44, "corine_raster_scotland_5m@1")</code>
* Press button "OK" and wait a while (you will see a new dialogue with showing the progress.

Done. You have now a raster (e.g. corine_raster_scotland_clipped_5m.tif) which does not have land in areas, where OSM data has sea/ocean.

=== Reclassifying a Raster Layer ===
WS3.0 uses CORINE landclass values. If using data from other sources it needs to be reclassified to the correct values. genVPB.py has an option to do this, but you may wish to do so manually.

To do this select <code>GRASS->Raster->r.reclass</code> from the Processing Toolbox.

Select the following options:

* Input Raster Layer - correct layer, check CRS
* Reclass rules text - copy in the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/nlcd2019.txt. Or an appropriate mapping from your landclass data to CORINE. Note that you can also reference a file using the "File containing reclass rules" option. Note a mapping of 22 24 = 1 is the same as 22 and 24 = 1. For a range of 22 to 24 use 22 23 24 = 1.
* Reclassified - Select a new filename.

(If this doesn't work a similar function is available in the Processing Toolbox under <code>Raster analysis->Reclassify by table</code>. However this doesn't save your table once you close the dialog, and entries have to be manually entered individually which takes a lot of effort)

=== Processing NLCD for USA using the Raster Calculator and tools in QGIS ===

[[Processing_NLCD_for_USA_using_Raster_Calculator_and_tools_in_QGIS]]

=== Python script to process NLCD for the USA ===

[[Python_script_to_process_NLCD_for_the_USA]]

=== Python script to process Sentinel-2 data ===

[[Python_script_to_process_Sentinel-2_data]]

===Generating the Terrain using osgdem===
Instead of using genVPB.py, you may wish to run osgdem directly.

In the Windows/Docker platform you can send the generate tile command directly to osgdem.exe, one tile at a time.

Using the NLCD raster processing convention from above, following is the the final step after creating the raster and entering bash shell with the windows version of "docker run..."

osgdem --TERRAIN --image-ext png --RGBA --no-interpolate-imagery --disable-error-diffusion --geocentric --no-mip-mapping -t ./data/California-Southern_4326-84-hd-corrected.tiff -d ./SRTM-3/N32W115.hgt -b -115 32 -114 33 --PagedLOD -l 7 --radius-to-max-visible-distance-ratio 3 -o ./output/vpb/w120n30/w115n32/ws_w115n32.osgb

Note: the --image-ext png --RGBA flags are critical to successfully building correctly placed landclasses in the final VPB generated scenery.

If you prefer to run the scenery generation manually, running the VPB osgdem process is described in more detail here: [[Virtual Planet Builder#Running VPB]].

After doing this you should have an output directory containing files of the form <code>output/vpb/w010n50/w004n50/ws_w004n50.osgb</code>, plus a host of sub-directories. Each one of these is a 1x1 tile of terrain.

to leave the container simply type <code>exit</code>.

===Packaging the Scenery===
Once you have the terrain and line features they should be packaged in a scenery directory in vpb and Terrain sub-directories respectively. E.g.
MyCoolScenery/Terrain
MyCoolScenery/vpb
It is good practise to document the data sources used in scenery generation. Some source licenses require attribution of the original data source for anything derived, published or distributed.

To assist in fulfilling these license obligations, you can create a source.xml file in the scenery directory which includes attribution information. This will then be available from within the simulator under Help->Scenery Sources, and <u>may</u> fulfil the attribution requirements of your license. '''Note that you are responsible for fulfilling any license requirements from the data, not FlightGear'''.

The format of the file is straightforward:
<?xml version="1.0"?>
<PropertyList>
<nowiki><source></nowiki>
<name>Corine Land Cover (CLC) 2018, Version 2020_20u1</name>
<nowiki><link></nowiki><nowiki>http://web.archive.org/web/20221112175615/https://land.copernicus.eu/pan-european/corine-land-cover/clc2018?tab=metadata%2A</nowiki><nowiki></link></nowiki>
<license>GMES Open License</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>NASADEM Merged DEM Global 1 arc second V001</name>
<nowiki><link></nowiki><nowiki>https://www.earthdata.nasa.gov/</nowiki><nowiki></link></nowiki>
<license>Public Domain</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>OpenStreetMap</name>
<nowiki><link></nowiki><nowiki>https://www.openstreetmap.org/copyright</nowiki><nowiki></link></nowiki>
<license>Open Data Commons Open Database License</license>
<nowiki></source></nowiki>
</PropertyList>

Howto:Create WS3.0 terrain

2026-05-15T15:56:50Z

Wlbragg: /* Adding water */

{{WS30 Navbar}}
This article provides instructions on how to generate basic WS3.0 terrain.

WS3.0 terrain consists of three parts:

# A terrain mesh consisting of a landclass texture draped over an elevation model.
# A high resolution water raster used to show water features such as rivers, lakes and coastline with more definition
# Line features such as roads and railways.

The terrain is generated by a set of tools that are packaged in a docker image for convenience.[[File:Diagram-export-21-12-2023-16 29 37.png|thumb|Basic WS3.0 Scenery Generation Process]]

== Prerequisites ==

=== Set up a Workspace ===
Create a directory with the following sub-directories:

* <code>cache</code>
* <code>data</code>
* <code>output/vpb</code>
* <code>output/Terrain</code>

=== Docker ===

# Install [https://docs.docker.com/get-started/ Docker] on your platform.
#Pull the docker image by running the following command

docker pull flightgear/ws30-vpb-generator:latest
Optionally, if you are hitting rate limits:
#Create an account on https://hub.docker.com/. (Note that you will need to click on an email verification link before you can log in for the first time)
#Run <code>docker login</code> before the '''docker pull''' command above

== Getting the base data ==
You need two pieces of data for the area of scenery you are generating:

# An elevation model (aka DEM). This indicates what altitude each point of the surface is.
# Landclass data showing what type of terrain is at each point of the surface. This is often either a Raster (effectively a texture), or vector data.

=== Elevation Model ===
Download the NASADEM elevation model for the area of scenery you wish to generate. This is available in 1x1 degree blocks from [https://lpdaac.usgs.gov/products/nasadem_hgtv001/ here], and with an interactive browser [https://search.earthdata.nasa.gov/search here].

Unzip the files into the <code>data</code> directory.

=== Landclass Raster ===
Download an landclass raster for the area of scenery you wish to generate.

* For Europe, use of [https://land.copernicus.eu/pan-european/corine-land-cover/clc2018 CORINE] is recommended.
* For the USA [https://www.mrlc.gov/viewer/ NLCD] is recommended
* Sentinel-2 data is available for the entire world via [https://livingatlas.arcgis.com/landcoverexplorer/ ESRI], but has limited set of landclasses.

Put these into the <code>data</code> directory.

More detailed terrain can be created by modifying the landclass raster, and/or generating a new raster from vector data. These processes are discussed below.

== Generating Terrain ==
To generate terrain you need to run the tools within the docker container we installed above. The docker image is like a small, independent virtual computing environment running within your system. This particular docker image has all the scenery generation tools already installed.

=== Running the docker container ===
Firstly, get the container running from the directory containing your <code>cache</code>, <code>data</code> and <code>output</code> directories:
docker run --rm --mount "type=bind,source=`pwd`/data,target=/home/flightgear/data,readonly" --mount "type=bind,source=`pwd`/output,target=/home/flightgear/output" --mount "type=bind,source=`pwd`/cache,target=/home/flightgear/cache" -it flightgear/ws30-vpb-generator:latest /bin/bash

You should now find yourself in a bash shell within your container. You should see data and output directories which are linked to the directories you created earlier:
flightgear@ddcac77f7d5e:~$ ls
cache data output bin scripts

=== Building the terrain ===
To build the terrain mesh, use the <code>genVPB.py</code> tool from inside the docker container:

Usage: genVPB.py --raster <input-raster> [ option ... ]
Usage: genVPB.py --bbox <lat0> <lon0> <lat1> <lon1> --sentinel --reclass <reclass> [ option ... ]

Arguments:
--raster RASTER Input landclass raster.
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--sentinel Use Sentinel2 landclass tiles
--sentinel-dir SENTINEL_DIR Directory for Sentinel Data. Default /home/flightgear/data/Sentinel-2
--hgt-dir HGT_DIR Directory containing HGT DEM files. Default /home/flightgear/data/NASADEM
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/output
--download-sentinel Download Sentinel2 tiles if needed
--reclass RECLASS Reclassify raster using file <reclass>. See ./scripts/mappings/
--coastline COASTLINE Clip against coastline against polygon (.osm)
--shrink-water SHRINK_WATER Shrink water bodies (landclasses 40, 41) by <pixels> pixels
--generate-water-raster Generate a water raster from OSM data
--generate-line-features Generate a water raster from OSM data
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--nasadem-server NASADEM_SERVER Set server to download NASADEM data from. Default https://e4ftl01.cr.usgs.gov/MEASURES/NASADEM_HGT.001/2000.02.11/)
--nasadem-user NASADEM_USER NASA Earthdata username.
--nasadem-password NASADEM_PASSWORD NASA Earthdata password.
--debug Debug output

For example, to generate a piece of terrain around Edinburgh (latitude 55.5, longitude 3 degrees West):
./scripts/genVPB.py --bbox 55 -4 56 -3 --raster ./data/uk_wgs84_10m_N54.tif

If you are using anything other than a CORINE raster you will need to reclassify the data to match the landclasses used by FlightGear. Those classes are defined in [https://gitlab.com/flightgear/fgdata/-/tree/next/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml]. You can reclassify them using the files in the [https://gitlab.com/flightgear/fgmeta/-/tree/next/ws30/mappings/ scripts/mappings] directory. E.g. to reclassify NLCD2019 data you can use <code>--reclassify ./scripts/mappings/nlcd2019.txt</code>.

genVPB.py will output the data to the output/vpb directory, in which you should find a series of files and directories.

=== Adding water ===
'''Update 05/12/2026: Depreciated, it is now built into genVPB.py above.'''

'''Use genVPB.py ...... --generate-water-raster --shrink-water 4 --coastline [path_to_shapefile_mask]'''

The terrain mesh does not have highly detailed water features - as typically the source data has a resolution of 10-25m. Water features are generated from OpenStreetMap data. To generate water features simply run the <code>genwaterraster.py</code> command.

Usage: genwaterraster.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--output-dir OUTPUT_DIR] [--cache-dir CACHE_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--output-dir OUTPUT_DIR Directory to write files into. Default /home/flightgear/output
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache

For example, to generate water for the area around Edinburgh:
./scripts/genwaterraster.py --bbox 55 -4 56 -3

Inside the ./output/vpb directory there should be a set of directories and .png files.

=== Adding roads and railways ===
The terrain mesh does not have any line features - things like roads. These are generated separately from OpenStreetMap data. To generate line features simply run the <code>genroads.py</code> command:

Usage: ./scripts/genroads.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--threads THREADS] [--cache-dir CACHE_DIR] [--output-dir OUTPUT_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--threads THREADS Number of parallel threads to run. Defaults to 1
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/cache/

For example, to generate roads for the area around Edinburgh:
./scripts/genroads.py --bbox 55 -4 56 -3

Inside the ./output/Terrain directory there should be a set of directories and, .STG files text files.

==Running FlightGear with the new WS3.0 Terrain==
To test the new terrain, simply include the output directory in your scenery path and run FlightGear with the <code>--prop:/scenery/use-vpb=true</code> to enable WS3.0.

== Advanced Techniques ==
The following sections describe more complex techniques to generate higher quality WS3.0 terrain. Almost all of them involve using different data sources to generate a more detailed landclass raster before running the final scenery generation processes described above. Generating a highly detailed landclass raster is where the magic happens.

Most techniques use gdal or grass to modify the raster/vector data, typically using the QGIS program.

=== Using a different elevation model ===
If you are using another elevation model other than NASAEM, then you may need to re-project it using QGIS/gdalwarp to the WGS84 CRS (aka EPSG:4326).

=== Landclass Data Requirements ===
For any landclass data we need to ensure the data is in the correct format. That means:

# Is a Raster (geotiff) rather than Vector data. This raster will become the texture on the terrain that the terrain shaders do their magic on.
# Uses the WGS84 Coordinate Reference System. The ensures that the terrain generation step is efficient.
# Has the correct landclass values for each terrain type. We use a set of values based on the CORINE raster set, defined in [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml].

Below is a quick table showing what steps you need to take for common landclass data sources.
{| class="wikitable"
|+
!Landclass Data
!Warp to WGS84 required?
!Landclass re-classification Required?
!Raster Simplification Required?
!Conversion to Raster Required?
|-
|CORINE Raster
|Yes
|No
|No
|No
|-
|CORINE Vector
|Yes
|Yes
|No
|Yes
|-
|NLCD
|No
|Yes
|Yes
|No
|-
|Sentinel-2
|Yes
|Yes
|No
|No
|}
Conversion to Raster must be done manually. Converting to WGS84 and the correct landclasses ''can'' be done by the genVPB.py script, but slows down scenery generation. Therefore if you are planning to generate scenery multiple times it is best to pre-process the files yourself.

The easiest way to do these operations is using QGIS, which is available for most platforms. If you are scripting a toolchain, the QGIS tools include command-line equivalents for all commands.

When using QGIS, set the Project CRS to WGS84 (aka EPSG:4326). You can then add layers of Raster or Vector data from files from the <code>Layer->Add Layer</code> menu. When performing any operations, <u>always</u> write out the data to a real file so you can go back to it later. Disk space is cheap :).

=== Warping Raster Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a raster layer to a different CRS using the Raster->Projections-Warp (Reproject) tool.

Select the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Resampling Method to Use - Nearest Neighbour. (Landclass data is not like normal images. You don't want to interpolate between values.)
* Nodata value for output bands - 0.0 (This means that any data at the edges will be Ocean, usually a reasonable default)
* Advanced Parameters - No Compression
* Output data type - Byte
* Reprojected - Choose a target filename

Alternatively you can do this step from the commandline.
gdalwarp -t_srs EPSG:4326 -dstnodata 0.0 -r near -ot Byte -of GTiff -co COMPRESS=NONE -co BIGTIFF=IF_NEEDED /home/stuart/FlightGear/VPB/data/CORINE/u2018_clc2018_v2020_20u1_raster100m/DATA/U2018_CLC2018_V2020_20u1.tif /home/stuart/FlightGear/VPB/data/scratch/corine_WGS84.tif

=== Warping Vector Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a vector layer using Vector->Data Management Tools->Reproject Layer.

Set the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Reprojected - Choose a target filename

=== Reclassifying Vector Layers ===
For CORINE vector data in particular, the attributes used in the vector data are not the same as those used by the CORINE Raster data. So we need to create a new attribute on the data.
[[File:Field Calculator.png|thumb|QGIS Field Calculator]]
To do this

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialog
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type "Whole Number (Integer)". This will create a new column which we will populate with the correct landclass data
* Click on the <code>Open Field Calculator</code> button (Ctrl + I). (If you get an error about only being able to create Virtual fields, go back to the Layer menu, export it and open the exported file).
* Select the following options:
** Update Existing Field
** Select the Landclass field you just created.
** Copy the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/corine_vector.txt into the Expression box (without the comment lines starting with <code>#</code>). This is just some simple code to set the attribute correctly. The code should be correct for CORINE vector data. If your data is from other sources you will need to work out how you want to map your source data landclasses to the CORINE ones. [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml] can be used as a guide.
* Select <code>OK</code>. You should see that your landclass column is now populated with the landclass data.
* Select <code>Layer->Save Layer Edits</code> to save you changes

=== Creating a Raster from a Vector Layer ===
To create a Raster from a Vector Layer select <code>Raster->Conversion->Rasterize (Vector to Raster)</code>.
[[File:QGIS Rasterize (Vector to Raster).png|thumb|Creating a Raster from a Vector Layer - QGIS Rasterize]]
Select the following options:

* Input Layer - correct layer, check CRS
* Field to use for burn-in value - select the <code>Landclass</code> column you created above.
* Output raster size units. This is going to set the resolution of your raster. You can work out the resolution in two different ways:
** Select "Georeferenced units" and determine how many degrees each pixel is in latitude and longitude.
** Select "Pixels" and determine the size of raster you want in pixels. [https://www.nhc.noaa.gov/gccalc.shtml This] is a good calculator to help. You input e.g. SE and SW coordinates and calculate to get the distance in Km. Then you multiply by thousand and devide by the number of metres per pixel (e.g. 5) -> resolution for width.
* Width/Horizontal Resolution. Enter the values you've calculated for the horizontal resolution (longitudinal), or the width of the raster
* Height/Vertical Resolution. Enter the values you've calculated for the vertical resolution (latitude or the height of the raster)
* Output extent - Select an option from the box on the right. You can edit the text afterwards (NB: East, West, South, North). Best practise is to create long thin strips of 1 degree latitude in height, as this makes subsequent processing much easier.
* Assign a specific nodata value to output bands - Select 0.0 for Ocean. CORINE vector data in particular has a lot of nodata for Oceans
* Advanced Parameters - No Compression
* Output data type - Byte
* Rasterized - Select a new filename

=== Simplifying a Raster Layer ===
Some Raster Landclass data (NLCD included) has too much noise - in particular large US highway systems are identified as Urban areas.

To smooth it out we can use the GRASS <code>n.neighbors</code> function from the Processing Toolbox in QGIS.

Select the following options:

* Input Layer - correct layer, check CRS
* Neighborhood operation - median. (This is not a normal image, so using an average will result in weird values)
* Neighborhood size - 5.
* Neighbors - Select a new filename.

=== Clipping a Raster Layer with OSM Data for Land (Corine) ===
The Corine dataset does not match OSM coastlines exactly. The following multi-stage process makes sure, that no Corine land-use is in the water as defined by OSM.

==== Download OSM Land Data ====

Download land polygons based on OSM data as a Shapefile from [https://osmdata.openstreetmap.de/data/land-polygons.html Land Polygons] and make sure to pick the WGS84 projected download with split polygons ("Large polygons are split, use for larger scales"). Once downloaded unzip the content into a directory.

==== Reclassifying the OSM Land Data Vector Layer ====
I QGIS make sure that only the layer for the raster for land data is selected (e.g. <code>land-polygons-split-4326</code>) -> in the map view you will see the whole earth. NB: typically you do this reclassify only once after download and can reuse the result for future processing.

Then:

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialogue
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type <code>Integer (32 bit)</code>. This will create a new column which we will populate with the correct land class data
* On top of the table on the left side choose "Landclass" in the drop-down menu, then input <code>2</code> into the field to the right and then press button "Update" all to the left of this field.
* Wait a bit and the close the dialogue.
* Select <code>Layer->Save Layer Edits</code> to save your changes (overwrite e.g. <code>land-polygons-split-4326</code>).

==== Convert the Land Data from Vector to Raster ====
Do the same as in chapter "Creating a Raster from a Vector Layer" above. The only difference is that the Input layer will be the land data polygons and you need to choose a different file name for the "Rasterized" (e.g. osm_land_scotland_5m.tif)

==== Remove Novalue Entries in the Land Data Raster ====
To do this:

* Select <code>Processing->Toolbox</code>. You should see a new box on the right side.
* Write "gdal_calc" in the search box and you should see an entry "Raster calculator". Double click on it and you will get a new dialogue window.
* In this dialogue:
** For "Input layer A" choose the raster from the previous chapter ((e.g. osm_land_scotland_5m.tif)
** In field "Calculation in gdalnumeric ..." write: <code>greater(A,0) * A</code>
** In field "Output raster type" choose <code>Byte</code>
** In field "Advanced Parameters" choose Profile <code>No compression</code>
** In field "Additional command-line parameters" write: <code>--hideNoData</code>
** In field "Calculated" choose a file (e.g. osm_land_scotland_allvalues_5m.tif)
** (In the "GDAL/OGR console call" it will have something similar to the follwing - just with different paths: <code>gdal_calc.py --overwrite --calc "greater(A ,0) * A" --format GTiff --type Byte -A /home/vanosten/custom-fg-scenery/data/osm_land_scotland_5m.tif --A_band 1 --co COMPRESS=NONE --co BIGTIFF=IF_NEEDED --hideNoData --outfile /home/vanosten/custom-fg-scenery/data/osm_land_scotland_allvalues_5m.tif</code>
** Press the "Run" button - and when complete close the dialogue.

You should now see a map only black and white. You can check for correctness by pressing <code>CTRL+SHIFT+I</code> to get a cursor with an arrow and an "i". First make sure the new raster is selected on the left side. Next click on the sea/ocean and then check in the "Identify Results" window on the right that the value is < 2. The click on the land and check that the value is 2.

==== Create the Final Clipped Corine Raster Against OSM Land Data =====
Do the following:

* In QGIS make sure that you have only the following two layers: the basis Corine raster (see chapter "Creating a Raster from a Vector Layer" - here e.g. corine_raster_scotland_5m.tif) and plus the raster from the previous step (e.g. osm_land_scotland_allvalues_5m.tif)
* Select <code>Raster->Raster Calculator ...</code> and a corresponding dialogue will open showing on the left hand side the two rasters.
* Choose a new "Output layer" (e.g. corine_raster_scotland_clipped_5m.tif).
* In the "Raster Calculator Expression" field input: <code>if ("osm_land_scotland_all_data_5m@1" < 2, 44, "corine_raster_scotland_5m@1")</code>
* Press button "OK" and wait a while (you will see a new dialogue with showing the progress.

Done. You have now a raster (e.g. corine_raster_scotland_clipped_5m.tif) which does not have land in areas, where OSM data has sea/ocean.

=== Reclassifying a Raster Layer ===
WS3.0 uses CORINE landclass values. If using data from other sources it needs to be reclassified to the correct values. genVPB.py has an option to do this, but you may wish to do so manually.

To do this select <code>GRASS->Raster->r.reclass</code> from the Processing Toolbox.

Select the following options:

* Input Raster Layer - correct layer, check CRS
* Reclass rules text - copy in the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/nlcd2019.txt. Or an appropriate mapping from your landclass data to CORINE. Note that you can also reference a file using the "File containing reclass rules" option. Note a mapping of 22 24 = 1 is the same as 22 and 24 = 1. For a range of 22 to 24 use 22 23 24 = 1.
* Reclassified - Select a new filename.

(If this doesn't work a similar function is available in the Processing Toolbox under <code>Raster analysis->Reclassify by table</code>. However this doesn't save your table once you close the dialog, and entries have to be manually entered individually which takes a lot of effort)

=== Processing NLCD for USA using the Raster Calculator and tools in QGIS ===

[[Processing_NLCD_for_USA_using_Raster_Calculator_and_tools_in_QGIS]]

=== Python script to process NLCD for the USA ===

[[Python_script_to_process_NLCD_for_the_USA]]

=== Python script to process Sentinel-2 data ===

[[Python_script_to_process_Sentinel-2_data]]

===Generating the Terrain using osgdem===
Instead of using genVPB.py, you may wish to run osgdem directly.

In the Windows/Docker platform you can send the generate tile command directly to osgdem.exe, one tile at a time.

Using the NLCD raster processing convention from above, following is the the final step after creating the raster and entering bash shell with the windows version of "docker run..."

osgdem --TERRAIN --image-ext png --RGBA --no-interpolate-imagery --disable-error-diffusion --geocentric --no-mip-mapping -t ./data/California-Southern_4326-84-hd-corrected.tiff -d ./SRTM-3/N32W115.hgt -b -115 32 -114 33 --PagedLOD -l 7 --radius-to-max-visible-distance-ratio 3 -o ./output/vpb/w120n30/w115n32/ws_w115n32.osgb

Note: the --image-ext png --RGBA flags are critical to successfully building correctly placed landclasses in the final VPB generated scenery.

If you prefer to run the scenery generation manually, running the VPB osgdem process is described in more detail here: [[Virtual Planet Builder#Running VPB]].

After doing this you should have an output directory containing files of the form <code>output/vpb/w010n50/w004n50/ws_w004n50.osgb</code>, plus a host of sub-directories. Each one of these is a 1x1 tile of terrain.

to leave the container simply type <code>exit</code>.

===Packaging the Scenery===
Once you have the terrain and line features they should be packaged in a scenery directory in vpb and Terrain sub-directories respectively. E.g.
MyCoolScenery/Terrain
MyCoolScenery/vpb
It is good practise to document the data sources used in scenery generation. Some source licenses require attribution of the original data source for anything derived, published or distributed.

To assist in fulfilling these license obligations, you can create a source.xml file in the scenery directory which includes attribution information. This will then be available from within the simulator under Help->Scenery Sources, and <u>may</u> fulfil the attribution requirements of your license. '''Note that you are responsible for fulfilling any license requirements from the data, not FlightGear'''.

The format of the file is straightforward:
<?xml version="1.0"?>
<PropertyList>
<nowiki><source></nowiki>
<name>Corine Land Cover (CLC) 2018, Version 2020_20u1</name>
<nowiki><link></nowiki><nowiki>http://web.archive.org/web/20221112175615/https://land.copernicus.eu/pan-european/corine-land-cover/clc2018?tab=metadata%2A</nowiki><nowiki></link></nowiki>
<license>GMES Open License</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>NASADEM Merged DEM Global 1 arc second V001</name>
<nowiki><link></nowiki><nowiki>https://www.earthdata.nasa.gov/</nowiki><nowiki></link></nowiki>
<license>Public Domain</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>OpenStreetMap</name>
<nowiki><link></nowiki><nowiki>https://www.openstreetmap.org/copyright</nowiki><nowiki></link></nowiki>
<license>Open Data Commons Open Database License</license>
<nowiki></source></nowiki>
</PropertyList>

Howto:Create WS3.0 terrain

2026-05-15T15:56:30Z

Wlbragg: /* Adding water */

{{WS30 Navbar}}
This article provides instructions on how to generate basic WS3.0 terrain.

WS3.0 terrain consists of three parts:

# A terrain mesh consisting of a landclass texture draped over an elevation model.
# A high resolution water raster used to show water features such as rivers, lakes and coastline with more definition
# Line features such as roads and railways.

The terrain is generated by a set of tools that are packaged in a docker image for convenience.[[File:Diagram-export-21-12-2023-16 29 37.png|thumb|Basic WS3.0 Scenery Generation Process]]

== Prerequisites ==

=== Set up a Workspace ===
Create a directory with the following sub-directories:

* <code>cache</code>
* <code>data</code>
* <code>output/vpb</code>
* <code>output/Terrain</code>

=== Docker ===

# Install [https://docs.docker.com/get-started/ Docker] on your platform.
#Pull the docker image by running the following command

docker pull flightgear/ws30-vpb-generator:latest
Optionally, if you are hitting rate limits:
#Create an account on https://hub.docker.com/. (Note that you will need to click on an email verification link before you can log in for the first time)
#Run <code>docker login</code> before the '''docker pull''' command above

== Getting the base data ==
You need two pieces of data for the area of scenery you are generating:

# An elevation model (aka DEM). This indicates what altitude each point of the surface is.
# Landclass data showing what type of terrain is at each point of the surface. This is often either a Raster (effectively a texture), or vector data.

=== Elevation Model ===
Download the NASADEM elevation model for the area of scenery you wish to generate. This is available in 1x1 degree blocks from [https://lpdaac.usgs.gov/products/nasadem_hgtv001/ here], and with an interactive browser [https://search.earthdata.nasa.gov/search here].

Unzip the files into the <code>data</code> directory.

=== Landclass Raster ===
Download an landclass raster for the area of scenery you wish to generate.

* For Europe, use of [https://land.copernicus.eu/pan-european/corine-land-cover/clc2018 CORINE] is recommended.
* For the USA [https://www.mrlc.gov/viewer/ NLCD] is recommended
* Sentinel-2 data is available for the entire world via [https://livingatlas.arcgis.com/landcoverexplorer/ ESRI], but has limited set of landclasses.

Put these into the <code>data</code> directory.

More detailed terrain can be created by modifying the landclass raster, and/or generating a new raster from vector data. These processes are discussed below.

== Generating Terrain ==
To generate terrain you need to run the tools within the docker container we installed above. The docker image is like a small, independent virtual computing environment running within your system. This particular docker image has all the scenery generation tools already installed.

=== Running the docker container ===
Firstly, get the container running from the directory containing your <code>cache</code>, <code>data</code> and <code>output</code> directories:
docker run --rm --mount "type=bind,source=`pwd`/data,target=/home/flightgear/data,readonly" --mount "type=bind,source=`pwd`/output,target=/home/flightgear/output" --mount "type=bind,source=`pwd`/cache,target=/home/flightgear/cache" -it flightgear/ws30-vpb-generator:latest /bin/bash

You should now find yourself in a bash shell within your container. You should see data and output directories which are linked to the directories you created earlier:
flightgear@ddcac77f7d5e:~$ ls
cache data output bin scripts

=== Building the terrain ===
To build the terrain mesh, use the <code>genVPB.py</code> tool from inside the docker container:

Usage: genVPB.py --raster <input-raster> [ option ... ]
Usage: genVPB.py --bbox <lat0> <lon0> <lat1> <lon1> --sentinel --reclass <reclass> [ option ... ]

Arguments:
--raster RASTER Input landclass raster.
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--sentinel Use Sentinel2 landclass tiles
--sentinel-dir SENTINEL_DIR Directory for Sentinel Data. Default /home/flightgear/data/Sentinel-2
--hgt-dir HGT_DIR Directory containing HGT DEM files. Default /home/flightgear/data/NASADEM
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/output
--download-sentinel Download Sentinel2 tiles if needed
--reclass RECLASS Reclassify raster using file <reclass>. See ./scripts/mappings/
--coastline COASTLINE Clip against coastline against polygon (.osm)
--shrink-water SHRINK_WATER Shrink water bodies (landclasses 40, 41) by <pixels> pixels
--generate-water-raster Generate a water raster from OSM data
--generate-line-features Generate a water raster from OSM data
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--nasadem-server NASADEM_SERVER Set server to download NASADEM data from. Default https://e4ftl01.cr.usgs.gov/MEASURES/NASADEM_HGT.001/2000.02.11/)
--nasadem-user NASADEM_USER NASA Earthdata username.
--nasadem-password NASADEM_PASSWORD NASA Earthdata password.
--debug Debug output

For example, to generate a piece of terrain around Edinburgh (latitude 55.5, longitude 3 degrees West):
./scripts/genVPB.py --bbox 55 -4 56 -3 --raster ./data/uk_wgs84_10m_N54.tif

If you are using anything other than a CORINE raster you will need to reclassify the data to match the landclasses used by FlightGear. Those classes are defined in [https://gitlab.com/flightgear/fgdata/-/tree/next/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml]. You can reclassify them using the files in the [https://gitlab.com/flightgear/fgmeta/-/tree/next/ws30/mappings/ scripts/mappings] directory. E.g. to reclassify NLCD2019 data you can use <code>--reclassify ./scripts/mappings/nlcd2019.txt</code>.

genVPB.py will output the data to the output/vpb directory, in which you should find a series of files and directories.

=== Adding water ===
'''Update 05/12/2026: Depreciated, it is now built into genVPB.py above.'''

'''Use genVPG.py ...... --generate-water-raster --shrink-water 4 --coastline [path_to_shapefile_mask]'''

The terrain mesh does not have highly detailed water features - as typically the source data has a resolution of 10-25m. Water features are generated from OpenStreetMap data. To generate water features simply run the <code>genwaterraster.py</code> command.

Usage: genwaterraster.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--output-dir OUTPUT_DIR] [--cache-dir CACHE_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--output-dir OUTPUT_DIR Directory to write files into. Default /home/flightgear/output
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache

For example, to generate water for the area around Edinburgh:
./scripts/genwaterraster.py --bbox 55 -4 56 -3

Inside the ./output/vpb directory there should be a set of directories and .png files.

=== Adding roads and railways ===
The terrain mesh does not have any line features - things like roads. These are generated separately from OpenStreetMap data. To generate line features simply run the <code>genroads.py</code> command:

Usage: ./scripts/genroads.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--threads THREADS] [--cache-dir CACHE_DIR] [--output-dir OUTPUT_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--threads THREADS Number of parallel threads to run. Defaults to 1
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/cache/

For example, to generate roads for the area around Edinburgh:
./scripts/genroads.py --bbox 55 -4 56 -3

Inside the ./output/Terrain directory there should be a set of directories and, .STG files text files.

==Running FlightGear with the new WS3.0 Terrain==
To test the new terrain, simply include the output directory in your scenery path and run FlightGear with the <code>--prop:/scenery/use-vpb=true</code> to enable WS3.0.

== Advanced Techniques ==
The following sections describe more complex techniques to generate higher quality WS3.0 terrain. Almost all of them involve using different data sources to generate a more detailed landclass raster before running the final scenery generation processes described above. Generating a highly detailed landclass raster is where the magic happens.

Most techniques use gdal or grass to modify the raster/vector data, typically using the QGIS program.

=== Using a different elevation model ===
If you are using another elevation model other than NASAEM, then you may need to re-project it using QGIS/gdalwarp to the WGS84 CRS (aka EPSG:4326).

=== Landclass Data Requirements ===
For any landclass data we need to ensure the data is in the correct format. That means:

# Is a Raster (geotiff) rather than Vector data. This raster will become the texture on the terrain that the terrain shaders do their magic on.
# Uses the WGS84 Coordinate Reference System. The ensures that the terrain generation step is efficient.
# Has the correct landclass values for each terrain type. We use a set of values based on the CORINE raster set, defined in [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml].

Below is a quick table showing what steps you need to take for common landclass data sources.
{| class="wikitable"
|+
!Landclass Data
!Warp to WGS84 required?
!Landclass re-classification Required?
!Raster Simplification Required?
!Conversion to Raster Required?
|-
|CORINE Raster
|Yes
|No
|No
|No
|-
|CORINE Vector
|Yes
|Yes
|No
|Yes
|-
|NLCD
|No
|Yes
|Yes
|No
|-
|Sentinel-2
|Yes
|Yes
|No
|No
|}
Conversion to Raster must be done manually. Converting to WGS84 and the correct landclasses ''can'' be done by the genVPB.py script, but slows down scenery generation. Therefore if you are planning to generate scenery multiple times it is best to pre-process the files yourself.

The easiest way to do these operations is using QGIS, which is available for most platforms. If you are scripting a toolchain, the QGIS tools include command-line equivalents for all commands.

When using QGIS, set the Project CRS to WGS84 (aka EPSG:4326). You can then add layers of Raster or Vector data from files from the <code>Layer->Add Layer</code> menu. When performing any operations, <u>always</u> write out the data to a real file so you can go back to it later. Disk space is cheap :).

=== Warping Raster Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a raster layer to a different CRS using the Raster->Projections-Warp (Reproject) tool.

Select the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Resampling Method to Use - Nearest Neighbour. (Landclass data is not like normal images. You don't want to interpolate between values.)
* Nodata value for output bands - 0.0 (This means that any data at the edges will be Ocean, usually a reasonable default)
* Advanced Parameters - No Compression
* Output data type - Byte
* Reprojected - Choose a target filename

Alternatively you can do this step from the commandline.
gdalwarp -t_srs EPSG:4326 -dstnodata 0.0 -r near -ot Byte -of GTiff -co COMPRESS=NONE -co BIGTIFF=IF_NEEDED /home/stuart/FlightGear/VPB/data/CORINE/u2018_clc2018_v2020_20u1_raster100m/DATA/U2018_CLC2018_V2020_20u1.tif /home/stuart/FlightGear/VPB/data/scratch/corine_WGS84.tif

=== Warping Vector Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a vector layer using Vector->Data Management Tools->Reproject Layer.

Set the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Reprojected - Choose a target filename

=== Reclassifying Vector Layers ===
For CORINE vector data in particular, the attributes used in the vector data are not the same as those used by the CORINE Raster data. So we need to create a new attribute on the data.
[[File:Field Calculator.png|thumb|QGIS Field Calculator]]
To do this

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialog
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type "Whole Number (Integer)". This will create a new column which we will populate with the correct landclass data
* Click on the <code>Open Field Calculator</code> button (Ctrl + I). (If you get an error about only being able to create Virtual fields, go back to the Layer menu, export it and open the exported file).
* Select the following options:
** Update Existing Field
** Select the Landclass field you just created.
** Copy the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/corine_vector.txt into the Expression box (without the comment lines starting with <code>#</code>). This is just some simple code to set the attribute correctly. The code should be correct for CORINE vector data. If your data is from other sources you will need to work out how you want to map your source data landclasses to the CORINE ones. [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml] can be used as a guide.
* Select <code>OK</code>. You should see that your landclass column is now populated with the landclass data.
* Select <code>Layer->Save Layer Edits</code> to save you changes

=== Creating a Raster from a Vector Layer ===
To create a Raster from a Vector Layer select <code>Raster->Conversion->Rasterize (Vector to Raster)</code>.
[[File:QGIS Rasterize (Vector to Raster).png|thumb|Creating a Raster from a Vector Layer - QGIS Rasterize]]
Select the following options:

* Input Layer - correct layer, check CRS
* Field to use for burn-in value - select the <code>Landclass</code> column you created above.
* Output raster size units. This is going to set the resolution of your raster. You can work out the resolution in two different ways:
** Select "Georeferenced units" and determine how many degrees each pixel is in latitude and longitude.
** Select "Pixels" and determine the size of raster you want in pixels. [https://www.nhc.noaa.gov/gccalc.shtml This] is a good calculator to help. You input e.g. SE and SW coordinates and calculate to get the distance in Km. Then you multiply by thousand and devide by the number of metres per pixel (e.g. 5) -> resolution for width.
* Width/Horizontal Resolution. Enter the values you've calculated for the horizontal resolution (longitudinal), or the width of the raster
* Height/Vertical Resolution. Enter the values you've calculated for the vertical resolution (latitude or the height of the raster)
* Output extent - Select an option from the box on the right. You can edit the text afterwards (NB: East, West, South, North). Best practise is to create long thin strips of 1 degree latitude in height, as this makes subsequent processing much easier.
* Assign a specific nodata value to output bands - Select 0.0 for Ocean. CORINE vector data in particular has a lot of nodata for Oceans
* Advanced Parameters - No Compression
* Output data type - Byte
* Rasterized - Select a new filename

=== Simplifying a Raster Layer ===
Some Raster Landclass data (NLCD included) has too much noise - in particular large US highway systems are identified as Urban areas.

To smooth it out we can use the GRASS <code>n.neighbors</code> function from the Processing Toolbox in QGIS.

Select the following options:

* Input Layer - correct layer, check CRS
* Neighborhood operation - median. (This is not a normal image, so using an average will result in weird values)
* Neighborhood size - 5.
* Neighbors - Select a new filename.

=== Clipping a Raster Layer with OSM Data for Land (Corine) ===
The Corine dataset does not match OSM coastlines exactly. The following multi-stage process makes sure, that no Corine land-use is in the water as defined by OSM.

==== Download OSM Land Data ====

Download land polygons based on OSM data as a Shapefile from [https://osmdata.openstreetmap.de/data/land-polygons.html Land Polygons] and make sure to pick the WGS84 projected download with split polygons ("Large polygons are split, use for larger scales"). Once downloaded unzip the content into a directory.

==== Reclassifying the OSM Land Data Vector Layer ====
I QGIS make sure that only the layer for the raster for land data is selected (e.g. <code>land-polygons-split-4326</code>) -> in the map view you will see the whole earth. NB: typically you do this reclassify only once after download and can reuse the result for future processing.

Then:

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialogue
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type <code>Integer (32 bit)</code>. This will create a new column which we will populate with the correct land class data
* On top of the table on the left side choose "Landclass" in the drop-down menu, then input <code>2</code> into the field to the right and then press button "Update" all to the left of this field.
* Wait a bit and the close the dialogue.
* Select <code>Layer->Save Layer Edits</code> to save your changes (overwrite e.g. <code>land-polygons-split-4326</code>).

==== Convert the Land Data from Vector to Raster ====
Do the same as in chapter "Creating a Raster from a Vector Layer" above. The only difference is that the Input layer will be the land data polygons and you need to choose a different file name for the "Rasterized" (e.g. osm_land_scotland_5m.tif)

==== Remove Novalue Entries in the Land Data Raster ====
To do this:

* Select <code>Processing->Toolbox</code>. You should see a new box on the right side.
* Write "gdal_calc" in the search box and you should see an entry "Raster calculator". Double click on it and you will get a new dialogue window.
* In this dialogue:
** For "Input layer A" choose the raster from the previous chapter ((e.g. osm_land_scotland_5m.tif)
** In field "Calculation in gdalnumeric ..." write: <code>greater(A,0) * A</code>
** In field "Output raster type" choose <code>Byte</code>
** In field "Advanced Parameters" choose Profile <code>No compression</code>
** In field "Additional command-line parameters" write: <code>--hideNoData</code>
** In field "Calculated" choose a file (e.g. osm_land_scotland_allvalues_5m.tif)
** (In the "GDAL/OGR console call" it will have something similar to the follwing - just with different paths: <code>gdal_calc.py --overwrite --calc "greater(A ,0) * A" --format GTiff --type Byte -A /home/vanosten/custom-fg-scenery/data/osm_land_scotland_5m.tif --A_band 1 --co COMPRESS=NONE --co BIGTIFF=IF_NEEDED --hideNoData --outfile /home/vanosten/custom-fg-scenery/data/osm_land_scotland_allvalues_5m.tif</code>
** Press the "Run" button - and when complete close the dialogue.

You should now see a map only black and white. You can check for correctness by pressing <code>CTRL+SHIFT+I</code> to get a cursor with an arrow and an "i". First make sure the new raster is selected on the left side. Next click on the sea/ocean and then check in the "Identify Results" window on the right that the value is < 2. The click on the land and check that the value is 2.

==== Create the Final Clipped Corine Raster Against OSM Land Data =====
Do the following:

* In QGIS make sure that you have only the following two layers: the basis Corine raster (see chapter "Creating a Raster from a Vector Layer" - here e.g. corine_raster_scotland_5m.tif) and plus the raster from the previous step (e.g. osm_land_scotland_allvalues_5m.tif)
* Select <code>Raster->Raster Calculator ...</code> and a corresponding dialogue will open showing on the left hand side the two rasters.
* Choose a new "Output layer" (e.g. corine_raster_scotland_clipped_5m.tif).
* In the "Raster Calculator Expression" field input: <code>if ("osm_land_scotland_all_data_5m@1" < 2, 44, "corine_raster_scotland_5m@1")</code>
* Press button "OK" and wait a while (you will see a new dialogue with showing the progress.

Done. You have now a raster (e.g. corine_raster_scotland_clipped_5m.tif) which does not have land in areas, where OSM data has sea/ocean.

=== Reclassifying a Raster Layer ===
WS3.0 uses CORINE landclass values. If using data from other sources it needs to be reclassified to the correct values. genVPB.py has an option to do this, but you may wish to do so manually.

To do this select <code>GRASS->Raster->r.reclass</code> from the Processing Toolbox.

Select the following options:

* Input Raster Layer - correct layer, check CRS
* Reclass rules text - copy in the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/nlcd2019.txt. Or an appropriate mapping from your landclass data to CORINE. Note that you can also reference a file using the "File containing reclass rules" option. Note a mapping of 22 24 = 1 is the same as 22 and 24 = 1. For a range of 22 to 24 use 22 23 24 = 1.
* Reclassified - Select a new filename.

(If this doesn't work a similar function is available in the Processing Toolbox under <code>Raster analysis->Reclassify by table</code>. However this doesn't save your table once you close the dialog, and entries have to be manually entered individually which takes a lot of effort)

=== Processing NLCD for USA using the Raster Calculator and tools in QGIS ===

[[Processing_NLCD_for_USA_using_Raster_Calculator_and_tools_in_QGIS]]

=== Python script to process NLCD for the USA ===

[[Python_script_to_process_NLCD_for_the_USA]]

=== Python script to process Sentinel-2 data ===

[[Python_script_to_process_Sentinel-2_data]]

===Generating the Terrain using osgdem===
Instead of using genVPB.py, you may wish to run osgdem directly.

In the Windows/Docker platform you can send the generate tile command directly to osgdem.exe, one tile at a time.

Using the NLCD raster processing convention from above, following is the the final step after creating the raster and entering bash shell with the windows version of "docker run..."

osgdem --TERRAIN --image-ext png --RGBA --no-interpolate-imagery --disable-error-diffusion --geocentric --no-mip-mapping -t ./data/California-Southern_4326-84-hd-corrected.tiff -d ./SRTM-3/N32W115.hgt -b -115 32 -114 33 --PagedLOD -l 7 --radius-to-max-visible-distance-ratio 3 -o ./output/vpb/w120n30/w115n32/ws_w115n32.osgb

Note: the --image-ext png --RGBA flags are critical to successfully building correctly placed landclasses in the final VPB generated scenery.

If you prefer to run the scenery generation manually, running the VPB osgdem process is described in more detail here: [[Virtual Planet Builder#Running VPB]].

After doing this you should have an output directory containing files of the form <code>output/vpb/w010n50/w004n50/ws_w004n50.osgb</code>, plus a host of sub-directories. Each one of these is a 1x1 tile of terrain.

to leave the container simply type <code>exit</code>.

===Packaging the Scenery===
Once you have the terrain and line features they should be packaged in a scenery directory in vpb and Terrain sub-directories respectively. E.g.
MyCoolScenery/Terrain
MyCoolScenery/vpb
It is good practise to document the data sources used in scenery generation. Some source licenses require attribution of the original data source for anything derived, published or distributed.

To assist in fulfilling these license obligations, you can create a source.xml file in the scenery directory which includes attribution information. This will then be available from within the simulator under Help->Scenery Sources, and <u>may</u> fulfil the attribution requirements of your license. '''Note that you are responsible for fulfilling any license requirements from the data, not FlightGear'''.

The format of the file is straightforward:
<?xml version="1.0"?>
<PropertyList>
<nowiki><source></nowiki>
<name>Corine Land Cover (CLC) 2018, Version 2020_20u1</name>
<nowiki><link></nowiki><nowiki>http://web.archive.org/web/20221112175615/https://land.copernicus.eu/pan-european/corine-land-cover/clc2018?tab=metadata%2A</nowiki><nowiki></link></nowiki>
<license>GMES Open License</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>NASADEM Merged DEM Global 1 arc second V001</name>
<nowiki><link></nowiki><nowiki>https://www.earthdata.nasa.gov/</nowiki><nowiki></link></nowiki>
<license>Public Domain</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>OpenStreetMap</name>
<nowiki><link></nowiki><nowiki>https://www.openstreetmap.org/copyright</nowiki><nowiki></link></nowiki>
<license>Open Data Commons Open Database License</license>
<nowiki></source></nowiki>
</PropertyList>

Howto:Create WS3.0 terrain

2026-05-15T15:55:46Z

Wlbragg: /* Adding water */

{{WS30 Navbar}}
This article provides instructions on how to generate basic WS3.0 terrain.

WS3.0 terrain consists of three parts:

# A terrain mesh consisting of a landclass texture draped over an elevation model.
# A high resolution water raster used to show water features such as rivers, lakes and coastline with more definition
# Line features such as roads and railways.

The terrain is generated by a set of tools that are packaged in a docker image for convenience.[[File:Diagram-export-21-12-2023-16 29 37.png|thumb|Basic WS3.0 Scenery Generation Process]]

== Prerequisites ==

=== Set up a Workspace ===
Create a directory with the following sub-directories:

* <code>cache</code>
* <code>data</code>
* <code>output/vpb</code>
* <code>output/Terrain</code>

=== Docker ===

# Install [https://docs.docker.com/get-started/ Docker] on your platform.
#Pull the docker image by running the following command

docker pull flightgear/ws30-vpb-generator:latest
Optionally, if you are hitting rate limits:
#Create an account on https://hub.docker.com/. (Note that you will need to click on an email verification link before you can log in for the first time)
#Run <code>docker login</code> before the '''docker pull''' command above

== Getting the base data ==
You need two pieces of data for the area of scenery you are generating:

# An elevation model (aka DEM). This indicates what altitude each point of the surface is.
# Landclass data showing what type of terrain is at each point of the surface. This is often either a Raster (effectively a texture), or vector data.

=== Elevation Model ===
Download the NASADEM elevation model for the area of scenery you wish to generate. This is available in 1x1 degree blocks from [https://lpdaac.usgs.gov/products/nasadem_hgtv001/ here], and with an interactive browser [https://search.earthdata.nasa.gov/search here].

Unzip the files into the <code>data</code> directory.

=== Landclass Raster ===
Download an landclass raster for the area of scenery you wish to generate.

* For Europe, use of [https://land.copernicus.eu/pan-european/corine-land-cover/clc2018 CORINE] is recommended.
* For the USA [https://www.mrlc.gov/viewer/ NLCD] is recommended
* Sentinel-2 data is available for the entire world via [https://livingatlas.arcgis.com/landcoverexplorer/ ESRI], but has limited set of landclasses.

Put these into the <code>data</code> directory.

More detailed terrain can be created by modifying the landclass raster, and/or generating a new raster from vector data. These processes are discussed below.

== Generating Terrain ==
To generate terrain you need to run the tools within the docker container we installed above. The docker image is like a small, independent virtual computing environment running within your system. This particular docker image has all the scenery generation tools already installed.

=== Running the docker container ===
Firstly, get the container running from the directory containing your <code>cache</code>, <code>data</code> and <code>output</code> directories:
docker run --rm --mount "type=bind,source=`pwd`/data,target=/home/flightgear/data,readonly" --mount "type=bind,source=`pwd`/output,target=/home/flightgear/output" --mount "type=bind,source=`pwd`/cache,target=/home/flightgear/cache" -it flightgear/ws30-vpb-generator:latest /bin/bash

You should now find yourself in a bash shell within your container. You should see data and output directories which are linked to the directories you created earlier:
flightgear@ddcac77f7d5e:~$ ls
cache data output bin scripts

=== Building the terrain ===
To build the terrain mesh, use the <code>genVPB.py</code> tool from inside the docker container:

Usage: genVPB.py --raster <input-raster> [ option ... ]
Usage: genVPB.py --bbox <lat0> <lon0> <lat1> <lon1> --sentinel --reclass <reclass> [ option ... ]

Arguments:
--raster RASTER Input landclass raster.
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--sentinel Use Sentinel2 landclass tiles
--sentinel-dir SENTINEL_DIR Directory for Sentinel Data. Default /home/flightgear/data/Sentinel-2
--hgt-dir HGT_DIR Directory containing HGT DEM files. Default /home/flightgear/data/NASADEM
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/output
--download-sentinel Download Sentinel2 tiles if needed
--reclass RECLASS Reclassify raster using file <reclass>. See ./scripts/mappings/
--coastline COASTLINE Clip against coastline against polygon (.osm)
--shrink-water SHRINK_WATER Shrink water bodies (landclasses 40, 41) by <pixels> pixels
--generate-water-raster Generate a water raster from OSM data
--generate-line-features Generate a water raster from OSM data
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--nasadem-server NASADEM_SERVER Set server to download NASADEM data from. Default https://e4ftl01.cr.usgs.gov/MEASURES/NASADEM_HGT.001/2000.02.11/)
--nasadem-user NASADEM_USER NASA Earthdata username.
--nasadem-password NASADEM_PASSWORD NASA Earthdata password.
--debug Debug output

For example, to generate a piece of terrain around Edinburgh (latitude 55.5, longitude 3 degrees West):
./scripts/genVPB.py --bbox 55 -4 56 -3 --raster ./data/uk_wgs84_10m_N54.tif

If you are using anything other than a CORINE raster you will need to reclassify the data to match the landclasses used by FlightGear. Those classes are defined in [https://gitlab.com/flightgear/fgdata/-/tree/next/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml]. You can reclassify them using the files in the [https://gitlab.com/flightgear/fgmeta/-/tree/next/ws30/mappings/ scripts/mappings] directory. E.g. to reclassify NLCD2019 data you can use <code>--reclassify ./scripts/mappings/nlcd2019.txt</code>.

genVPB.py will output the data to the output/vpb directory, in which you should find a series of files and directories.

=== Adding water ===
'''Update 05/12/2026: Depreciated, it is now built into genVPB.py above.'''

'''Use --generate-water-raster --shrink-water 4 --coastline [path_to_shapefile_mask'''

The terrain mesh does not have highly detailed water features - as typically the source data has a resolution of 10-25m. Water features are generated from OpenStreetMap data. To generate water features simply run the <code>genwaterraster.py</code> command.

Usage: genwaterraster.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--output-dir OUTPUT_DIR] [--cache-dir CACHE_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--output-dir OUTPUT_DIR Directory to write files into. Default /home/flightgear/output
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache

For example, to generate water for the area around Edinburgh:
./scripts/genwaterraster.py --bbox 55 -4 56 -3

Inside the ./output/vpb directory there should be a set of directories and .png files.

=== Adding roads and railways ===
The terrain mesh does not have any line features - things like roads. These are generated separately from OpenStreetMap data. To generate line features simply run the <code>genroads.py</code> command:

Usage: ./scripts/genroads.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--threads THREADS] [--cache-dir CACHE_DIR] [--output-dir OUTPUT_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--threads THREADS Number of parallel threads to run. Defaults to 1
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/cache/

For example, to generate roads for the area around Edinburgh:
./scripts/genroads.py --bbox 55 -4 56 -3

Inside the ./output/Terrain directory there should be a set of directories and, .STG files text files.

==Running FlightGear with the new WS3.0 Terrain==
To test the new terrain, simply include the output directory in your scenery path and run FlightGear with the <code>--prop:/scenery/use-vpb=true</code> to enable WS3.0.

== Advanced Techniques ==
The following sections describe more complex techniques to generate higher quality WS3.0 terrain. Almost all of them involve using different data sources to generate a more detailed landclass raster before running the final scenery generation processes described above. Generating a highly detailed landclass raster is where the magic happens.

Most techniques use gdal or grass to modify the raster/vector data, typically using the QGIS program.

=== Using a different elevation model ===
If you are using another elevation model other than NASAEM, then you may need to re-project it using QGIS/gdalwarp to the WGS84 CRS (aka EPSG:4326).

=== Landclass Data Requirements ===
For any landclass data we need to ensure the data is in the correct format. That means:

# Is a Raster (geotiff) rather than Vector data. This raster will become the texture on the terrain that the terrain shaders do their magic on.
# Uses the WGS84 Coordinate Reference System. The ensures that the terrain generation step is efficient.
# Has the correct landclass values for each terrain type. We use a set of values based on the CORINE raster set, defined in [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml].

Below is a quick table showing what steps you need to take for common landclass data sources.
{| class="wikitable"
|+
!Landclass Data
!Warp to WGS84 required?
!Landclass re-classification Required?
!Raster Simplification Required?
!Conversion to Raster Required?
|-
|CORINE Raster
|Yes
|No
|No
|No
|-
|CORINE Vector
|Yes
|Yes
|No
|Yes
|-
|NLCD
|No
|Yes
|Yes
|No
|-
|Sentinel-2
|Yes
|Yes
|No
|No
|}
Conversion to Raster must be done manually. Converting to WGS84 and the correct landclasses ''can'' be done by the genVPB.py script, but slows down scenery generation. Therefore if you are planning to generate scenery multiple times it is best to pre-process the files yourself.

The easiest way to do these operations is using QGIS, which is available for most platforms. If you are scripting a toolchain, the QGIS tools include command-line equivalents for all commands.

When using QGIS, set the Project CRS to WGS84 (aka EPSG:4326). You can then add layers of Raster or Vector data from files from the <code>Layer->Add Layer</code> menu. When performing any operations, <u>always</u> write out the data to a real file so you can go back to it later. Disk space is cheap :).

=== Warping Raster Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a raster layer to a different CRS using the Raster->Projections-Warp (Reproject) tool.

Select the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Resampling Method to Use - Nearest Neighbour. (Landclass data is not like normal images. You don't want to interpolate between values.)
* Nodata value for output bands - 0.0 (This means that any data at the edges will be Ocean, usually a reasonable default)
* Advanced Parameters - No Compression
* Output data type - Byte
* Reprojected - Choose a target filename

Alternatively you can do this step from the commandline.
gdalwarp -t_srs EPSG:4326 -dstnodata 0.0 -r near -ot Byte -of GTiff -co COMPRESS=NONE -co BIGTIFF=IF_NEEDED /home/stuart/FlightGear/VPB/data/CORINE/u2018_clc2018_v2020_20u1_raster100m/DATA/U2018_CLC2018_V2020_20u1.tif /home/stuart/FlightGear/VPB/data/scratch/corine_WGS84.tif

=== Warping Vector Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a vector layer using Vector->Data Management Tools->Reproject Layer.

Set the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Reprojected - Choose a target filename

=== Reclassifying Vector Layers ===
For CORINE vector data in particular, the attributes used in the vector data are not the same as those used by the CORINE Raster data. So we need to create a new attribute on the data.
[[File:Field Calculator.png|thumb|QGIS Field Calculator]]
To do this

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialog
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type "Whole Number (Integer)". This will create a new column which we will populate with the correct landclass data
* Click on the <code>Open Field Calculator</code> button (Ctrl + I). (If you get an error about only being able to create Virtual fields, go back to the Layer menu, export it and open the exported file).
* Select the following options:
** Update Existing Field
** Select the Landclass field you just created.
** Copy the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/corine_vector.txt into the Expression box (without the comment lines starting with <code>#</code>). This is just some simple code to set the attribute correctly. The code should be correct for CORINE vector data. If your data is from other sources you will need to work out how you want to map your source data landclasses to the CORINE ones. [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml] can be used as a guide.
* Select <code>OK</code>. You should see that your landclass column is now populated with the landclass data.
* Select <code>Layer->Save Layer Edits</code> to save you changes

=== Creating a Raster from a Vector Layer ===
To create a Raster from a Vector Layer select <code>Raster->Conversion->Rasterize (Vector to Raster)</code>.
[[File:QGIS Rasterize (Vector to Raster).png|thumb|Creating a Raster from a Vector Layer - QGIS Rasterize]]
Select the following options:

* Input Layer - correct layer, check CRS
* Field to use for burn-in value - select the <code>Landclass</code> column you created above.
* Output raster size units. This is going to set the resolution of your raster. You can work out the resolution in two different ways:
** Select "Georeferenced units" and determine how many degrees each pixel is in latitude and longitude.
** Select "Pixels" and determine the size of raster you want in pixels. [https://www.nhc.noaa.gov/gccalc.shtml This] is a good calculator to help. You input e.g. SE and SW coordinates and calculate to get the distance in Km. Then you multiply by thousand and devide by the number of metres per pixel (e.g. 5) -> resolution for width.
* Width/Horizontal Resolution. Enter the values you've calculated for the horizontal resolution (longitudinal), or the width of the raster
* Height/Vertical Resolution. Enter the values you've calculated for the vertical resolution (latitude or the height of the raster)
* Output extent - Select an option from the box on the right. You can edit the text afterwards (NB: East, West, South, North). Best practise is to create long thin strips of 1 degree latitude in height, as this makes subsequent processing much easier.
* Assign a specific nodata value to output bands - Select 0.0 for Ocean. CORINE vector data in particular has a lot of nodata for Oceans
* Advanced Parameters - No Compression
* Output data type - Byte
* Rasterized - Select a new filename

=== Simplifying a Raster Layer ===
Some Raster Landclass data (NLCD included) has too much noise - in particular large US highway systems are identified as Urban areas.

To smooth it out we can use the GRASS <code>n.neighbors</code> function from the Processing Toolbox in QGIS.

Select the following options:

* Input Layer - correct layer, check CRS
* Neighborhood operation - median. (This is not a normal image, so using an average will result in weird values)
* Neighborhood size - 5.
* Neighbors - Select a new filename.

=== Clipping a Raster Layer with OSM Data for Land (Corine) ===
The Corine dataset does not match OSM coastlines exactly. The following multi-stage process makes sure, that no Corine land-use is in the water as defined by OSM.

==== Download OSM Land Data ====

Download land polygons based on OSM data as a Shapefile from [https://osmdata.openstreetmap.de/data/land-polygons.html Land Polygons] and make sure to pick the WGS84 projected download with split polygons ("Large polygons are split, use for larger scales"). Once downloaded unzip the content into a directory.

==== Reclassifying the OSM Land Data Vector Layer ====
I QGIS make sure that only the layer for the raster for land data is selected (e.g. <code>land-polygons-split-4326</code>) -> in the map view you will see the whole earth. NB: typically you do this reclassify only once after download and can reuse the result for future processing.

Then:

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialogue
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type <code>Integer (32 bit)</code>. This will create a new column which we will populate with the correct land class data
* On top of the table on the left side choose "Landclass" in the drop-down menu, then input <code>2</code> into the field to the right and then press button "Update" all to the left of this field.
* Wait a bit and the close the dialogue.
* Select <code>Layer->Save Layer Edits</code> to save your changes (overwrite e.g. <code>land-polygons-split-4326</code>).

==== Convert the Land Data from Vector to Raster ====
Do the same as in chapter "Creating a Raster from a Vector Layer" above. The only difference is that the Input layer will be the land data polygons and you need to choose a different file name for the "Rasterized" (e.g. osm_land_scotland_5m.tif)

==== Remove Novalue Entries in the Land Data Raster ====
To do this:

* Select <code>Processing->Toolbox</code>. You should see a new box on the right side.
* Write "gdal_calc" in the search box and you should see an entry "Raster calculator". Double click on it and you will get a new dialogue window.
* In this dialogue:
** For "Input layer A" choose the raster from the previous chapter ((e.g. osm_land_scotland_5m.tif)
** In field "Calculation in gdalnumeric ..." write: <code>greater(A,0) * A</code>
** In field "Output raster type" choose <code>Byte</code>
** In field "Advanced Parameters" choose Profile <code>No compression</code>
** In field "Additional command-line parameters" write: <code>--hideNoData</code>
** In field "Calculated" choose a file (e.g. osm_land_scotland_allvalues_5m.tif)
** (In the "GDAL/OGR console call" it will have something similar to the follwing - just with different paths: <code>gdal_calc.py --overwrite --calc "greater(A ,0) * A" --format GTiff --type Byte -A /home/vanosten/custom-fg-scenery/data/osm_land_scotland_5m.tif --A_band 1 --co COMPRESS=NONE --co BIGTIFF=IF_NEEDED --hideNoData --outfile /home/vanosten/custom-fg-scenery/data/osm_land_scotland_allvalues_5m.tif</code>
** Press the "Run" button - and when complete close the dialogue.

You should now see a map only black and white. You can check for correctness by pressing <code>CTRL+SHIFT+I</code> to get a cursor with an arrow and an "i". First make sure the new raster is selected on the left side. Next click on the sea/ocean and then check in the "Identify Results" window on the right that the value is < 2. The click on the land and check that the value is 2.

==== Create the Final Clipped Corine Raster Against OSM Land Data =====
Do the following:

* In QGIS make sure that you have only the following two layers: the basis Corine raster (see chapter "Creating a Raster from a Vector Layer" - here e.g. corine_raster_scotland_5m.tif) and plus the raster from the previous step (e.g. osm_land_scotland_allvalues_5m.tif)
* Select <code>Raster->Raster Calculator ...</code> and a corresponding dialogue will open showing on the left hand side the two rasters.
* Choose a new "Output layer" (e.g. corine_raster_scotland_clipped_5m.tif).
* In the "Raster Calculator Expression" field input: <code>if ("osm_land_scotland_all_data_5m@1" < 2, 44, "corine_raster_scotland_5m@1")</code>
* Press button "OK" and wait a while (you will see a new dialogue with showing the progress.

Done. You have now a raster (e.g. corine_raster_scotland_clipped_5m.tif) which does not have land in areas, where OSM data has sea/ocean.

=== Reclassifying a Raster Layer ===
WS3.0 uses CORINE landclass values. If using data from other sources it needs to be reclassified to the correct values. genVPB.py has an option to do this, but you may wish to do so manually.

To do this select <code>GRASS->Raster->r.reclass</code> from the Processing Toolbox.

Select the following options:

* Input Raster Layer - correct layer, check CRS
* Reclass rules text - copy in the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/nlcd2019.txt. Or an appropriate mapping from your landclass data to CORINE. Note that you can also reference a file using the "File containing reclass rules" option. Note a mapping of 22 24 = 1 is the same as 22 and 24 = 1. For a range of 22 to 24 use 22 23 24 = 1.
* Reclassified - Select a new filename.

(If this doesn't work a similar function is available in the Processing Toolbox under <code>Raster analysis->Reclassify by table</code>. However this doesn't save your table once you close the dialog, and entries have to be manually entered individually which takes a lot of effort)

=== Processing NLCD for USA using the Raster Calculator and tools in QGIS ===

[[Processing_NLCD_for_USA_using_Raster_Calculator_and_tools_in_QGIS]]

=== Python script to process NLCD for the USA ===

[[Python_script_to_process_NLCD_for_the_USA]]

=== Python script to process Sentinel-2 data ===

[[Python_script_to_process_Sentinel-2_data]]

===Generating the Terrain using osgdem===
Instead of using genVPB.py, you may wish to run osgdem directly.

In the Windows/Docker platform you can send the generate tile command directly to osgdem.exe, one tile at a time.

Using the NLCD raster processing convention from above, following is the the final step after creating the raster and entering bash shell with the windows version of "docker run..."

osgdem --TERRAIN --image-ext png --RGBA --no-interpolate-imagery --disable-error-diffusion --geocentric --no-mip-mapping -t ./data/California-Southern_4326-84-hd-corrected.tiff -d ./SRTM-3/N32W115.hgt -b -115 32 -114 33 --PagedLOD -l 7 --radius-to-max-visible-distance-ratio 3 -o ./output/vpb/w120n30/w115n32/ws_w115n32.osgb

Note: the --image-ext png --RGBA flags are critical to successfully building correctly placed landclasses in the final VPB generated scenery.

If you prefer to run the scenery generation manually, running the VPB osgdem process is described in more detail here: [[Virtual Planet Builder#Running VPB]].

After doing this you should have an output directory containing files of the form <code>output/vpb/w010n50/w004n50/ws_w004n50.osgb</code>, plus a host of sub-directories. Each one of these is a 1x1 tile of terrain.

to leave the container simply type <code>exit</code>.

===Packaging the Scenery===
Once you have the terrain and line features they should be packaged in a scenery directory in vpb and Terrain sub-directories respectively. E.g.
MyCoolScenery/Terrain
MyCoolScenery/vpb
It is good practise to document the data sources used in scenery generation. Some source licenses require attribution of the original data source for anything derived, published or distributed.

To assist in fulfilling these license obligations, you can create a source.xml file in the scenery directory which includes attribution information. This will then be available from within the simulator under Help->Scenery Sources, and <u>may</u> fulfil the attribution requirements of your license. '''Note that you are responsible for fulfilling any license requirements from the data, not FlightGear'''.

The format of the file is straightforward:
<?xml version="1.0"?>
<PropertyList>
<nowiki><source></nowiki>
<name>Corine Land Cover (CLC) 2018, Version 2020_20u1</name>
<nowiki><link></nowiki><nowiki>http://web.archive.org/web/20221112175615/https://land.copernicus.eu/pan-european/corine-land-cover/clc2018?tab=metadata%2A</nowiki><nowiki></link></nowiki>
<license>GMES Open License</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>NASADEM Merged DEM Global 1 arc second V001</name>
<nowiki><link></nowiki><nowiki>https://www.earthdata.nasa.gov/</nowiki><nowiki></link></nowiki>
<license>Public Domain</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>OpenStreetMap</name>
<nowiki><link></nowiki><nowiki>https://www.openstreetmap.org/copyright</nowiki><nowiki></link></nowiki>
<license>Open Data Commons Open Database License</license>
<nowiki></source></nowiki>
</PropertyList>

Howto:Create WS3.0 terrain

2026-05-15T15:55:30Z

Wlbragg: /* Adding water */

{{WS30 Navbar}}
This article provides instructions on how to generate basic WS3.0 terrain.

WS3.0 terrain consists of three parts:

# A terrain mesh consisting of a landclass texture draped over an elevation model.
# A high resolution water raster used to show water features such as rivers, lakes and coastline with more definition
# Line features such as roads and railways.

The terrain is generated by a set of tools that are packaged in a docker image for convenience.[[File:Diagram-export-21-12-2023-16 29 37.png|thumb|Basic WS3.0 Scenery Generation Process]]

== Prerequisites ==

=== Set up a Workspace ===
Create a directory with the following sub-directories:

* <code>cache</code>
* <code>data</code>
* <code>output/vpb</code>
* <code>output/Terrain</code>

=== Docker ===

# Install [https://docs.docker.com/get-started/ Docker] on your platform.
#Pull the docker image by running the following command

docker pull flightgear/ws30-vpb-generator:latest
Optionally, if you are hitting rate limits:
#Create an account on https://hub.docker.com/. (Note that you will need to click on an email verification link before you can log in for the first time)
#Run <code>docker login</code> before the '''docker pull''' command above

== Getting the base data ==
You need two pieces of data for the area of scenery you are generating:

# An elevation model (aka DEM). This indicates what altitude each point of the surface is.
# Landclass data showing what type of terrain is at each point of the surface. This is often either a Raster (effectively a texture), or vector data.

=== Elevation Model ===
Download the NASADEM elevation model for the area of scenery you wish to generate. This is available in 1x1 degree blocks from [https://lpdaac.usgs.gov/products/nasadem_hgtv001/ here], and with an interactive browser [https://search.earthdata.nasa.gov/search here].

Unzip the files into the <code>data</code> directory.

=== Landclass Raster ===
Download an landclass raster for the area of scenery you wish to generate.

* For Europe, use of [https://land.copernicus.eu/pan-european/corine-land-cover/clc2018 CORINE] is recommended.
* For the USA [https://www.mrlc.gov/viewer/ NLCD] is recommended
* Sentinel-2 data is available for the entire world via [https://livingatlas.arcgis.com/landcoverexplorer/ ESRI], but has limited set of landclasses.

Put these into the <code>data</code> directory.

More detailed terrain can be created by modifying the landclass raster, and/or generating a new raster from vector data. These processes are discussed below.

== Generating Terrain ==
To generate terrain you need to run the tools within the docker container we installed above. The docker image is like a small, independent virtual computing environment running within your system. This particular docker image has all the scenery generation tools already installed.

=== Running the docker container ===
Firstly, get the container running from the directory containing your <code>cache</code>, <code>data</code> and <code>output</code> directories:
docker run --rm --mount "type=bind,source=`pwd`/data,target=/home/flightgear/data,readonly" --mount "type=bind,source=`pwd`/output,target=/home/flightgear/output" --mount "type=bind,source=`pwd`/cache,target=/home/flightgear/cache" -it flightgear/ws30-vpb-generator:latest /bin/bash

You should now find yourself in a bash shell within your container. You should see data and output directories which are linked to the directories you created earlier:
flightgear@ddcac77f7d5e:~$ ls
cache data output bin scripts

=== Building the terrain ===
To build the terrain mesh, use the <code>genVPB.py</code> tool from inside the docker container:

Usage: genVPB.py --raster <input-raster> [ option ... ]
Usage: genVPB.py --bbox <lat0> <lon0> <lat1> <lon1> --sentinel --reclass <reclass> [ option ... ]

Arguments:
--raster RASTER Input landclass raster.
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--sentinel Use Sentinel2 landclass tiles
--sentinel-dir SENTINEL_DIR Directory for Sentinel Data. Default /home/flightgear/data/Sentinel-2
--hgt-dir HGT_DIR Directory containing HGT DEM files. Default /home/flightgear/data/NASADEM
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/output
--download-sentinel Download Sentinel2 tiles if needed
--reclass RECLASS Reclassify raster using file <reclass>. See ./scripts/mappings/
--coastline COASTLINE Clip against coastline against polygon (.osm)
--shrink-water SHRINK_WATER Shrink water bodies (landclasses 40, 41) by <pixels> pixels
--generate-water-raster Generate a water raster from OSM data
--generate-line-features Generate a water raster from OSM data
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--nasadem-server NASADEM_SERVER Set server to download NASADEM data from. Default https://e4ftl01.cr.usgs.gov/MEASURES/NASADEM_HGT.001/2000.02.11/)
--nasadem-user NASADEM_USER NASA Earthdata username.
--nasadem-password NASADEM_PASSWORD NASA Earthdata password.
--debug Debug output

For example, to generate a piece of terrain around Edinburgh (latitude 55.5, longitude 3 degrees West):
./scripts/genVPB.py --bbox 55 -4 56 -3 --raster ./data/uk_wgs84_10m_N54.tif

If you are using anything other than a CORINE raster you will need to reclassify the data to match the landclasses used by FlightGear. Those classes are defined in [https://gitlab.com/flightgear/fgdata/-/tree/next/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml]. You can reclassify them using the files in the [https://gitlab.com/flightgear/fgmeta/-/tree/next/ws30/mappings/ scripts/mappings] directory. E.g. to reclassify NLCD2019 data you can use <code>--reclassify ./scripts/mappings/nlcd2019.txt</code>.

genVPB.py will output the data to the output/vpb directory, in which you should find a series of files and directories.

=== Adding water ===
'''Update 05/12/2026: Depreciated, it is now built into genVPB.py above.'''
'''Use --generate-water-raster --shrink-water 4 --coastline [path_to_shapefile_mask'''

The terrain mesh does not have highly detailed water features - as typically the source data has a resolution of 10-25m. Water features are generated from OpenStreetMap data. To generate water features simply run the <code>genwaterraster.py</code> command.

Usage: genwaterraster.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--output-dir OUTPUT_DIR] [--cache-dir CACHE_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--output-dir OUTPUT_DIR Directory to write files into. Default /home/flightgear/output
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache

For example, to generate water for the area around Edinburgh:
./scripts/genwaterraster.py --bbox 55 -4 56 -3

Inside the ./output/vpb directory there should be a set of directories and .png files.

=== Adding roads and railways ===
The terrain mesh does not have any line features - things like roads. These are generated separately from OpenStreetMap data. To generate line features simply run the <code>genroads.py</code> command:

Usage: ./scripts/genroads.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--threads THREADS] [--cache-dir CACHE_DIR] [--output-dir OUTPUT_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--threads THREADS Number of parallel threads to run. Defaults to 1
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/cache/

For example, to generate roads for the area around Edinburgh:
./scripts/genroads.py --bbox 55 -4 56 -3

Inside the ./output/Terrain directory there should be a set of directories and, .STG files text files.

==Running FlightGear with the new WS3.0 Terrain==
To test the new terrain, simply include the output directory in your scenery path and run FlightGear with the <code>--prop:/scenery/use-vpb=true</code> to enable WS3.0.

== Advanced Techniques ==
The following sections describe more complex techniques to generate higher quality WS3.0 terrain. Almost all of them involve using different data sources to generate a more detailed landclass raster before running the final scenery generation processes described above. Generating a highly detailed landclass raster is where the magic happens.

Most techniques use gdal or grass to modify the raster/vector data, typically using the QGIS program.

=== Using a different elevation model ===
If you are using another elevation model other than NASAEM, then you may need to re-project it using QGIS/gdalwarp to the WGS84 CRS (aka EPSG:4326).

=== Landclass Data Requirements ===
For any landclass data we need to ensure the data is in the correct format. That means:

# Is a Raster (geotiff) rather than Vector data. This raster will become the texture on the terrain that the terrain shaders do their magic on.
# Uses the WGS84 Coordinate Reference System. The ensures that the terrain generation step is efficient.
# Has the correct landclass values for each terrain type. We use a set of values based on the CORINE raster set, defined in [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml].

Below is a quick table showing what steps you need to take for common landclass data sources.
{| class="wikitable"
|+
!Landclass Data
!Warp to WGS84 required?
!Landclass re-classification Required?
!Raster Simplification Required?
!Conversion to Raster Required?
|-
|CORINE Raster
|Yes
|No
|No
|No
|-
|CORINE Vector
|Yes
|Yes
|No
|Yes
|-
|NLCD
|No
|Yes
|Yes
|No
|-
|Sentinel-2
|Yes
|Yes
|No
|No
|}
Conversion to Raster must be done manually. Converting to WGS84 and the correct landclasses ''can'' be done by the genVPB.py script, but slows down scenery generation. Therefore if you are planning to generate scenery multiple times it is best to pre-process the files yourself.

The easiest way to do these operations is using QGIS, which is available for most platforms. If you are scripting a toolchain, the QGIS tools include command-line equivalents for all commands.

When using QGIS, set the Project CRS to WGS84 (aka EPSG:4326). You can then add layers of Raster or Vector data from files from the <code>Layer->Add Layer</code> menu. When performing any operations, <u>always</u> write out the data to a real file so you can go back to it later. Disk space is cheap :).

=== Warping Raster Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a raster layer to a different CRS using the Raster->Projections-Warp (Reproject) tool.

Select the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Resampling Method to Use - Nearest Neighbour. (Landclass data is not like normal images. You don't want to interpolate between values.)
* Nodata value for output bands - 0.0 (This means that any data at the edges will be Ocean, usually a reasonable default)
* Advanced Parameters - No Compression
* Output data type - Byte
* Reprojected - Choose a target filename

Alternatively you can do this step from the commandline.
gdalwarp -t_srs EPSG:4326 -dstnodata 0.0 -r near -ot Byte -of GTiff -co COMPRESS=NONE -co BIGTIFF=IF_NEEDED /home/stuart/FlightGear/VPB/data/CORINE/u2018_clc2018_v2020_20u1_raster100m/DATA/U2018_CLC2018_V2020_20u1.tif /home/stuart/FlightGear/VPB/data/scratch/corine_WGS84.tif

=== Warping Vector Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a vector layer using Vector->Data Management Tools->Reproject Layer.

Set the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Reprojected - Choose a target filename

=== Reclassifying Vector Layers ===
For CORINE vector data in particular, the attributes used in the vector data are not the same as those used by the CORINE Raster data. So we need to create a new attribute on the data.
[[File:Field Calculator.png|thumb|QGIS Field Calculator]]
To do this

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialog
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type "Whole Number (Integer)". This will create a new column which we will populate with the correct landclass data
* Click on the <code>Open Field Calculator</code> button (Ctrl + I). (If you get an error about only being able to create Virtual fields, go back to the Layer menu, export it and open the exported file).
* Select the following options:
** Update Existing Field
** Select the Landclass field you just created.
** Copy the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/corine_vector.txt into the Expression box (without the comment lines starting with <code>#</code>). This is just some simple code to set the attribute correctly. The code should be correct for CORINE vector data. If your data is from other sources you will need to work out how you want to map your source data landclasses to the CORINE ones. [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml] can be used as a guide.
* Select <code>OK</code>. You should see that your landclass column is now populated with the landclass data.
* Select <code>Layer->Save Layer Edits</code> to save you changes

=== Creating a Raster from a Vector Layer ===
To create a Raster from a Vector Layer select <code>Raster->Conversion->Rasterize (Vector to Raster)</code>.
[[File:QGIS Rasterize (Vector to Raster).png|thumb|Creating a Raster from a Vector Layer - QGIS Rasterize]]
Select the following options:

* Input Layer - correct layer, check CRS
* Field to use for burn-in value - select the <code>Landclass</code> column you created above.
* Output raster size units. This is going to set the resolution of your raster. You can work out the resolution in two different ways:
** Select "Georeferenced units" and determine how many degrees each pixel is in latitude and longitude.
** Select "Pixels" and determine the size of raster you want in pixels. [https://www.nhc.noaa.gov/gccalc.shtml This] is a good calculator to help. You input e.g. SE and SW coordinates and calculate to get the distance in Km. Then you multiply by thousand and devide by the number of metres per pixel (e.g. 5) -> resolution for width.
* Width/Horizontal Resolution. Enter the values you've calculated for the horizontal resolution (longitudinal), or the width of the raster
* Height/Vertical Resolution. Enter the values you've calculated for the vertical resolution (latitude or the height of the raster)
* Output extent - Select an option from the box on the right. You can edit the text afterwards (NB: East, West, South, North). Best practise is to create long thin strips of 1 degree latitude in height, as this makes subsequent processing much easier.
* Assign a specific nodata value to output bands - Select 0.0 for Ocean. CORINE vector data in particular has a lot of nodata for Oceans
* Advanced Parameters - No Compression
* Output data type - Byte
* Rasterized - Select a new filename

=== Simplifying a Raster Layer ===
Some Raster Landclass data (NLCD included) has too much noise - in particular large US highway systems are identified as Urban areas.

To smooth it out we can use the GRASS <code>n.neighbors</code> function from the Processing Toolbox in QGIS.

Select the following options:

* Input Layer - correct layer, check CRS
* Neighborhood operation - median. (This is not a normal image, so using an average will result in weird values)
* Neighborhood size - 5.
* Neighbors - Select a new filename.

=== Clipping a Raster Layer with OSM Data for Land (Corine) ===
The Corine dataset does not match OSM coastlines exactly. The following multi-stage process makes sure, that no Corine land-use is in the water as defined by OSM.

==== Download OSM Land Data ====

Download land polygons based on OSM data as a Shapefile from [https://osmdata.openstreetmap.de/data/land-polygons.html Land Polygons] and make sure to pick the WGS84 projected download with split polygons ("Large polygons are split, use for larger scales"). Once downloaded unzip the content into a directory.

==== Reclassifying the OSM Land Data Vector Layer ====
I QGIS make sure that only the layer for the raster for land data is selected (e.g. <code>land-polygons-split-4326</code>) -> in the map view you will see the whole earth. NB: typically you do this reclassify only once after download and can reuse the result for future processing.

Then:

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialogue
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type <code>Integer (32 bit)</code>. This will create a new column which we will populate with the correct land class data
* On top of the table on the left side choose "Landclass" in the drop-down menu, then input <code>2</code> into the field to the right and then press button "Update" all to the left of this field.
* Wait a bit and the close the dialogue.
* Select <code>Layer->Save Layer Edits</code> to save your changes (overwrite e.g. <code>land-polygons-split-4326</code>).

==== Convert the Land Data from Vector to Raster ====
Do the same as in chapter "Creating a Raster from a Vector Layer" above. The only difference is that the Input layer will be the land data polygons and you need to choose a different file name for the "Rasterized" (e.g. osm_land_scotland_5m.tif)

==== Remove Novalue Entries in the Land Data Raster ====
To do this:

* Select <code>Processing->Toolbox</code>. You should see a new box on the right side.
* Write "gdal_calc" in the search box and you should see an entry "Raster calculator". Double click on it and you will get a new dialogue window.
* In this dialogue:
** For "Input layer A" choose the raster from the previous chapter ((e.g. osm_land_scotland_5m.tif)
** In field "Calculation in gdalnumeric ..." write: <code>greater(A,0) * A</code>
** In field "Output raster type" choose <code>Byte</code>
** In field "Advanced Parameters" choose Profile <code>No compression</code>
** In field "Additional command-line parameters" write: <code>--hideNoData</code>
** In field "Calculated" choose a file (e.g. osm_land_scotland_allvalues_5m.tif)
** (In the "GDAL/OGR console call" it will have something similar to the follwing - just with different paths: <code>gdal_calc.py --overwrite --calc "greater(A ,0) * A" --format GTiff --type Byte -A /home/vanosten/custom-fg-scenery/data/osm_land_scotland_5m.tif --A_band 1 --co COMPRESS=NONE --co BIGTIFF=IF_NEEDED --hideNoData --outfile /home/vanosten/custom-fg-scenery/data/osm_land_scotland_allvalues_5m.tif</code>
** Press the "Run" button - and when complete close the dialogue.

You should now see a map only black and white. You can check for correctness by pressing <code>CTRL+SHIFT+I</code> to get a cursor with an arrow and an "i". First make sure the new raster is selected on the left side. Next click on the sea/ocean and then check in the "Identify Results" window on the right that the value is < 2. The click on the land and check that the value is 2.

==== Create the Final Clipped Corine Raster Against OSM Land Data =====
Do the following:

* In QGIS make sure that you have only the following two layers: the basis Corine raster (see chapter "Creating a Raster from a Vector Layer" - here e.g. corine_raster_scotland_5m.tif) and plus the raster from the previous step (e.g. osm_land_scotland_allvalues_5m.tif)
* Select <code>Raster->Raster Calculator ...</code> and a corresponding dialogue will open showing on the left hand side the two rasters.
* Choose a new "Output layer" (e.g. corine_raster_scotland_clipped_5m.tif).
* In the "Raster Calculator Expression" field input: <code>if ("osm_land_scotland_all_data_5m@1" < 2, 44, "corine_raster_scotland_5m@1")</code>
* Press button "OK" and wait a while (you will see a new dialogue with showing the progress.

Done. You have now a raster (e.g. corine_raster_scotland_clipped_5m.tif) which does not have land in areas, where OSM data has sea/ocean.

=== Reclassifying a Raster Layer ===
WS3.0 uses CORINE landclass values. If using data from other sources it needs to be reclassified to the correct values. genVPB.py has an option to do this, but you may wish to do so manually.

To do this select <code>GRASS->Raster->r.reclass</code> from the Processing Toolbox.

Select the following options:

* Input Raster Layer - correct layer, check CRS
* Reclass rules text - copy in the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/nlcd2019.txt. Or an appropriate mapping from your landclass data to CORINE. Note that you can also reference a file using the "File containing reclass rules" option. Note a mapping of 22 24 = 1 is the same as 22 and 24 = 1. For a range of 22 to 24 use 22 23 24 = 1.
* Reclassified - Select a new filename.

(If this doesn't work a similar function is available in the Processing Toolbox under <code>Raster analysis->Reclassify by table</code>. However this doesn't save your table once you close the dialog, and entries have to be manually entered individually which takes a lot of effort)

=== Processing NLCD for USA using the Raster Calculator and tools in QGIS ===

[[Processing_NLCD_for_USA_using_Raster_Calculator_and_tools_in_QGIS]]

=== Python script to process NLCD for the USA ===

[[Python_script_to_process_NLCD_for_the_USA]]

=== Python script to process Sentinel-2 data ===

[[Python_script_to_process_Sentinel-2_data]]

===Generating the Terrain using osgdem===
Instead of using genVPB.py, you may wish to run osgdem directly.

In the Windows/Docker platform you can send the generate tile command directly to osgdem.exe, one tile at a time.

Using the NLCD raster processing convention from above, following is the the final step after creating the raster and entering bash shell with the windows version of "docker run..."

osgdem --TERRAIN --image-ext png --RGBA --no-interpolate-imagery --disable-error-diffusion --geocentric --no-mip-mapping -t ./data/California-Southern_4326-84-hd-corrected.tiff -d ./SRTM-3/N32W115.hgt -b -115 32 -114 33 --PagedLOD -l 7 --radius-to-max-visible-distance-ratio 3 -o ./output/vpb/w120n30/w115n32/ws_w115n32.osgb

Note: the --image-ext png --RGBA flags are critical to successfully building correctly placed landclasses in the final VPB generated scenery.

If you prefer to run the scenery generation manually, running the VPB osgdem process is described in more detail here: [[Virtual Planet Builder#Running VPB]].

After doing this you should have an output directory containing files of the form <code>output/vpb/w010n50/w004n50/ws_w004n50.osgb</code>, plus a host of sub-directories. Each one of these is a 1x1 tile of terrain.

to leave the container simply type <code>exit</code>.

===Packaging the Scenery===
Once you have the terrain and line features they should be packaged in a scenery directory in vpb and Terrain sub-directories respectively. E.g.
MyCoolScenery/Terrain
MyCoolScenery/vpb
It is good practise to document the data sources used in scenery generation. Some source licenses require attribution of the original data source for anything derived, published or distributed.

To assist in fulfilling these license obligations, you can create a source.xml file in the scenery directory which includes attribution information. This will then be available from within the simulator under Help->Scenery Sources, and <u>may</u> fulfil the attribution requirements of your license. '''Note that you are responsible for fulfilling any license requirements from the data, not FlightGear'''.

The format of the file is straightforward:
<?xml version="1.0"?>
<PropertyList>
<nowiki><source></nowiki>
<name>Corine Land Cover (CLC) 2018, Version 2020_20u1</name>
<nowiki><link></nowiki><nowiki>http://web.archive.org/web/20221112175615/https://land.copernicus.eu/pan-european/corine-land-cover/clc2018?tab=metadata%2A</nowiki><nowiki></link></nowiki>
<license>GMES Open License</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>NASADEM Merged DEM Global 1 arc second V001</name>
<nowiki><link></nowiki><nowiki>https://www.earthdata.nasa.gov/</nowiki><nowiki></link></nowiki>
<license>Public Domain</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>OpenStreetMap</name>
<nowiki><link></nowiki><nowiki>https://www.openstreetmap.org/copyright</nowiki><nowiki></link></nowiki>
<license>Open Data Commons Open Database License</license>
<nowiki></source></nowiki>
</PropertyList>

Howto:Create WS3.0 terrain

2026-05-15T15:55:13Z

Wlbragg: /* Adding water */

{{WS30 Navbar}}
This article provides instructions on how to generate basic WS3.0 terrain.

WS3.0 terrain consists of three parts:

# A terrain mesh consisting of a landclass texture draped over an elevation model.
# A high resolution water raster used to show water features such as rivers, lakes and coastline with more definition
# Line features such as roads and railways.

The terrain is generated by a set of tools that are packaged in a docker image for convenience.[[File:Diagram-export-21-12-2023-16 29 37.png|thumb|Basic WS3.0 Scenery Generation Process]]

== Prerequisites ==

=== Set up a Workspace ===
Create a directory with the following sub-directories:

* <code>cache</code>
* <code>data</code>
* <code>output/vpb</code>
* <code>output/Terrain</code>

=== Docker ===

# Install [https://docs.docker.com/get-started/ Docker] on your platform.
#Pull the docker image by running the following command

docker pull flightgear/ws30-vpb-generator:latest
Optionally, if you are hitting rate limits:
#Create an account on https://hub.docker.com/. (Note that you will need to click on an email verification link before you can log in for the first time)
#Run <code>docker login</code> before the '''docker pull''' command above

== Getting the base data ==
You need two pieces of data for the area of scenery you are generating:

# An elevation model (aka DEM). This indicates what altitude each point of the surface is.
# Landclass data showing what type of terrain is at each point of the surface. This is often either a Raster (effectively a texture), or vector data.

=== Elevation Model ===
Download the NASADEM elevation model for the area of scenery you wish to generate. This is available in 1x1 degree blocks from [https://lpdaac.usgs.gov/products/nasadem_hgtv001/ here], and with an interactive browser [https://search.earthdata.nasa.gov/search here].

Unzip the files into the <code>data</code> directory.

=== Landclass Raster ===
Download an landclass raster for the area of scenery you wish to generate.

* For Europe, use of [https://land.copernicus.eu/pan-european/corine-land-cover/clc2018 CORINE] is recommended.
* For the USA [https://www.mrlc.gov/viewer/ NLCD] is recommended
* Sentinel-2 data is available for the entire world via [https://livingatlas.arcgis.com/landcoverexplorer/ ESRI], but has limited set of landclasses.

Put these into the <code>data</code> directory.

More detailed terrain can be created by modifying the landclass raster, and/or generating a new raster from vector data. These processes are discussed below.

== Generating Terrain ==
To generate terrain you need to run the tools within the docker container we installed above. The docker image is like a small, independent virtual computing environment running within your system. This particular docker image has all the scenery generation tools already installed.

=== Running the docker container ===
Firstly, get the container running from the directory containing your <code>cache</code>, <code>data</code> and <code>output</code> directories:
docker run --rm --mount "type=bind,source=`pwd`/data,target=/home/flightgear/data,readonly" --mount "type=bind,source=`pwd`/output,target=/home/flightgear/output" --mount "type=bind,source=`pwd`/cache,target=/home/flightgear/cache" -it flightgear/ws30-vpb-generator:latest /bin/bash

You should now find yourself in a bash shell within your container. You should see data and output directories which are linked to the directories you created earlier:
flightgear@ddcac77f7d5e:~$ ls
cache data output bin scripts

=== Building the terrain ===
To build the terrain mesh, use the <code>genVPB.py</code> tool from inside the docker container:

Usage: genVPB.py --raster <input-raster> [ option ... ]
Usage: genVPB.py --bbox <lat0> <lon0> <lat1> <lon1> --sentinel --reclass <reclass> [ option ... ]

Arguments:
--raster RASTER Input landclass raster.
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--sentinel Use Sentinel2 landclass tiles
--sentinel-dir SENTINEL_DIR Directory for Sentinel Data. Default /home/flightgear/data/Sentinel-2
--hgt-dir HGT_DIR Directory containing HGT DEM files. Default /home/flightgear/data/NASADEM
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/output
--download-sentinel Download Sentinel2 tiles if needed
--reclass RECLASS Reclassify raster using file <reclass>. See ./scripts/mappings/
--coastline COASTLINE Clip against coastline against polygon (.osm)
--shrink-water SHRINK_WATER Shrink water bodies (landclasses 40, 41) by <pixels> pixels
--generate-water-raster Generate a water raster from OSM data
--generate-line-features Generate a water raster from OSM data
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--nasadem-server NASADEM_SERVER Set server to download NASADEM data from. Default https://e4ftl01.cr.usgs.gov/MEASURES/NASADEM_HGT.001/2000.02.11/)
--nasadem-user NASADEM_USER NASA Earthdata username.
--nasadem-password NASADEM_PASSWORD NASA Earthdata password.
--debug Debug output

For example, to generate a piece of terrain around Edinburgh (latitude 55.5, longitude 3 degrees West):
./scripts/genVPB.py --bbox 55 -4 56 -3 --raster ./data/uk_wgs84_10m_N54.tif

If you are using anything other than a CORINE raster you will need to reclassify the data to match the landclasses used by FlightGear. Those classes are defined in [https://gitlab.com/flightgear/fgdata/-/tree/next/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml]. You can reclassify them using the files in the [https://gitlab.com/flightgear/fgmeta/-/tree/next/ws30/mappings/ scripts/mappings] directory. E.g. to reclassify NLCD2019 data you can use <code>--reclassify ./scripts/mappings/nlcd2019.txt</code>.

genVPB.py will output the data to the output/vpb directory, in which you should find a series of files and directories.

=== Adding water ===
'''Update 05/12/2026: Depreciated, it is now built into genVPB.py above.
use --generate-water-raster --shrink-water 4 --coastline [path_to_shapefile_mask'''

The terrain mesh does not have highly detailed water features - as typically the source data has a resolution of 10-25m. Water features are generated from OpenStreetMap data. To generate water features simply run the <code>genwaterraster.py</code> command.

Usage: genwaterraster.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--output-dir OUTPUT_DIR] [--cache-dir CACHE_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--output-dir OUTPUT_DIR Directory to write files into. Default /home/flightgear/output
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache

For example, to generate water for the area around Edinburgh:
./scripts/genwaterraster.py --bbox 55 -4 56 -3

Inside the ./output/vpb directory there should be a set of directories and .png files.

=== Adding roads and railways ===
The terrain mesh does not have any line features - things like roads. These are generated separately from OpenStreetMap data. To generate line features simply run the <code>genroads.py</code> command:

Usage: ./scripts/genroads.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--threads THREADS] [--cache-dir CACHE_DIR] [--output-dir OUTPUT_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--threads THREADS Number of parallel threads to run. Defaults to 1
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/cache/

For example, to generate roads for the area around Edinburgh:
./scripts/genroads.py --bbox 55 -4 56 -3

Inside the ./output/Terrain directory there should be a set of directories and, .STG files text files.

==Running FlightGear with the new WS3.0 Terrain==
To test the new terrain, simply include the output directory in your scenery path and run FlightGear with the <code>--prop:/scenery/use-vpb=true</code> to enable WS3.0.

== Advanced Techniques ==
The following sections describe more complex techniques to generate higher quality WS3.0 terrain. Almost all of them involve using different data sources to generate a more detailed landclass raster before running the final scenery generation processes described above. Generating a highly detailed landclass raster is where the magic happens.

Most techniques use gdal or grass to modify the raster/vector data, typically using the QGIS program.

=== Using a different elevation model ===
If you are using another elevation model other than NASAEM, then you may need to re-project it using QGIS/gdalwarp to the WGS84 CRS (aka EPSG:4326).

=== Landclass Data Requirements ===
For any landclass data we need to ensure the data is in the correct format. That means:

# Is a Raster (geotiff) rather than Vector data. This raster will become the texture on the terrain that the terrain shaders do their magic on.
# Uses the WGS84 Coordinate Reference System. The ensures that the terrain generation step is efficient.
# Has the correct landclass values for each terrain type. We use a set of values based on the CORINE raster set, defined in [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml].

Below is a quick table showing what steps you need to take for common landclass data sources.
{| class="wikitable"
|+
!Landclass Data
!Warp to WGS84 required?
!Landclass re-classification Required?
!Raster Simplification Required?
!Conversion to Raster Required?
|-
|CORINE Raster
|Yes
|No
|No
|No
|-
|CORINE Vector
|Yes
|Yes
|No
|Yes
|-
|NLCD
|No
|Yes
|Yes
|No
|-
|Sentinel-2
|Yes
|Yes
|No
|No
|}
Conversion to Raster must be done manually. Converting to WGS84 and the correct landclasses ''can'' be done by the genVPB.py script, but slows down scenery generation. Therefore if you are planning to generate scenery multiple times it is best to pre-process the files yourself.

The easiest way to do these operations is using QGIS, which is available for most platforms. If you are scripting a toolchain, the QGIS tools include command-line equivalents for all commands.

When using QGIS, set the Project CRS to WGS84 (aka EPSG:4326). You can then add layers of Raster or Vector data from files from the <code>Layer->Add Layer</code> menu. When performing any operations, <u>always</u> write out the data to a real file so you can go back to it later. Disk space is cheap :).

=== Warping Raster Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a raster layer to a different CRS using the Raster->Projections-Warp (Reproject) tool.

Select the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Resampling Method to Use - Nearest Neighbour. (Landclass data is not like normal images. You don't want to interpolate between values.)
* Nodata value for output bands - 0.0 (This means that any data at the edges will be Ocean, usually a reasonable default)
* Advanced Parameters - No Compression
* Output data type - Byte
* Reprojected - Choose a target filename

Alternatively you can do this step from the commandline.
gdalwarp -t_srs EPSG:4326 -dstnodata 0.0 -r near -ot Byte -of GTiff -co COMPRESS=NONE -co BIGTIFF=IF_NEEDED /home/stuart/FlightGear/VPB/data/CORINE/u2018_clc2018_v2020_20u1_raster100m/DATA/U2018_CLC2018_V2020_20u1.tif /home/stuart/FlightGear/VPB/data/scratch/corine_WGS84.tif

=== Warping Vector Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a vector layer using Vector->Data Management Tools->Reproject Layer.

Set the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Reprojected - Choose a target filename

=== Reclassifying Vector Layers ===
For CORINE vector data in particular, the attributes used in the vector data are not the same as those used by the CORINE Raster data. So we need to create a new attribute on the data.
[[File:Field Calculator.png|thumb|QGIS Field Calculator]]
To do this

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialog
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type "Whole Number (Integer)". This will create a new column which we will populate with the correct landclass data
* Click on the <code>Open Field Calculator</code> button (Ctrl + I). (If you get an error about only being able to create Virtual fields, go back to the Layer menu, export it and open the exported file).
* Select the following options:
** Update Existing Field
** Select the Landclass field you just created.
** Copy the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/corine_vector.txt into the Expression box (without the comment lines starting with <code>#</code>). This is just some simple code to set the attribute correctly. The code should be correct for CORINE vector data. If your data is from other sources you will need to work out how you want to map your source data landclasses to the CORINE ones. [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml] can be used as a guide.
* Select <code>OK</code>. You should see that your landclass column is now populated with the landclass data.
* Select <code>Layer->Save Layer Edits</code> to save you changes

=== Creating a Raster from a Vector Layer ===
To create a Raster from a Vector Layer select <code>Raster->Conversion->Rasterize (Vector to Raster)</code>.
[[File:QGIS Rasterize (Vector to Raster).png|thumb|Creating a Raster from a Vector Layer - QGIS Rasterize]]
Select the following options:

* Input Layer - correct layer, check CRS
* Field to use for burn-in value - select the <code>Landclass</code> column you created above.
* Output raster size units. This is going to set the resolution of your raster. You can work out the resolution in two different ways:
** Select "Georeferenced units" and determine how many degrees each pixel is in latitude and longitude.
** Select "Pixels" and determine the size of raster you want in pixels. [https://www.nhc.noaa.gov/gccalc.shtml This] is a good calculator to help. You input e.g. SE and SW coordinates and calculate to get the distance in Km. Then you multiply by thousand and devide by the number of metres per pixel (e.g. 5) -> resolution for width.
* Width/Horizontal Resolution. Enter the values you've calculated for the horizontal resolution (longitudinal), or the width of the raster
* Height/Vertical Resolution. Enter the values you've calculated for the vertical resolution (latitude or the height of the raster)
* Output extent - Select an option from the box on the right. You can edit the text afterwards (NB: East, West, South, North). Best practise is to create long thin strips of 1 degree latitude in height, as this makes subsequent processing much easier.
* Assign a specific nodata value to output bands - Select 0.0 for Ocean. CORINE vector data in particular has a lot of nodata for Oceans
* Advanced Parameters - No Compression
* Output data type - Byte
* Rasterized - Select a new filename

=== Simplifying a Raster Layer ===
Some Raster Landclass data (NLCD included) has too much noise - in particular large US highway systems are identified as Urban areas.

To smooth it out we can use the GRASS <code>n.neighbors</code> function from the Processing Toolbox in QGIS.

Select the following options:

* Input Layer - correct layer, check CRS
* Neighborhood operation - median. (This is not a normal image, so using an average will result in weird values)
* Neighborhood size - 5.
* Neighbors - Select a new filename.

=== Clipping a Raster Layer with OSM Data for Land (Corine) ===
The Corine dataset does not match OSM coastlines exactly. The following multi-stage process makes sure, that no Corine land-use is in the water as defined by OSM.

==== Download OSM Land Data ====

Download land polygons based on OSM data as a Shapefile from [https://osmdata.openstreetmap.de/data/land-polygons.html Land Polygons] and make sure to pick the WGS84 projected download with split polygons ("Large polygons are split, use for larger scales"). Once downloaded unzip the content into a directory.

==== Reclassifying the OSM Land Data Vector Layer ====
I QGIS make sure that only the layer for the raster for land data is selected (e.g. <code>land-polygons-split-4326</code>) -> in the map view you will see the whole earth. NB: typically you do this reclassify only once after download and can reuse the result for future processing.

Then:

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialogue
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type <code>Integer (32 bit)</code>. This will create a new column which we will populate with the correct land class data
* On top of the table on the left side choose "Landclass" in the drop-down menu, then input <code>2</code> into the field to the right and then press button "Update" all to the left of this field.
* Wait a bit and the close the dialogue.
* Select <code>Layer->Save Layer Edits</code> to save your changes (overwrite e.g. <code>land-polygons-split-4326</code>).

==== Convert the Land Data from Vector to Raster ====
Do the same as in chapter "Creating a Raster from a Vector Layer" above. The only difference is that the Input layer will be the land data polygons and you need to choose a different file name for the "Rasterized" (e.g. osm_land_scotland_5m.tif)

==== Remove Novalue Entries in the Land Data Raster ====
To do this:

* Select <code>Processing->Toolbox</code>. You should see a new box on the right side.
* Write "gdal_calc" in the search box and you should see an entry "Raster calculator". Double click on it and you will get a new dialogue window.
* In this dialogue:
** For "Input layer A" choose the raster from the previous chapter ((e.g. osm_land_scotland_5m.tif)
** In field "Calculation in gdalnumeric ..." write: <code>greater(A,0) * A</code>
** In field "Output raster type" choose <code>Byte</code>
** In field "Advanced Parameters" choose Profile <code>No compression</code>
** In field "Additional command-line parameters" write: <code>--hideNoData</code>
** In field "Calculated" choose a file (e.g. osm_land_scotland_allvalues_5m.tif)
** (In the "GDAL/OGR console call" it will have something similar to the follwing - just with different paths: <code>gdal_calc.py --overwrite --calc "greater(A ,0) * A" --format GTiff --type Byte -A /home/vanosten/custom-fg-scenery/data/osm_land_scotland_5m.tif --A_band 1 --co COMPRESS=NONE --co BIGTIFF=IF_NEEDED --hideNoData --outfile /home/vanosten/custom-fg-scenery/data/osm_land_scotland_allvalues_5m.tif</code>
** Press the "Run" button - and when complete close the dialogue.

You should now see a map only black and white. You can check for correctness by pressing <code>CTRL+SHIFT+I</code> to get a cursor with an arrow and an "i". First make sure the new raster is selected on the left side. Next click on the sea/ocean and then check in the "Identify Results" window on the right that the value is < 2. The click on the land and check that the value is 2.

==== Create the Final Clipped Corine Raster Against OSM Land Data =====
Do the following:

* In QGIS make sure that you have only the following two layers: the basis Corine raster (see chapter "Creating a Raster from a Vector Layer" - here e.g. corine_raster_scotland_5m.tif) and plus the raster from the previous step (e.g. osm_land_scotland_allvalues_5m.tif)
* Select <code>Raster->Raster Calculator ...</code> and a corresponding dialogue will open showing on the left hand side the two rasters.
* Choose a new "Output layer" (e.g. corine_raster_scotland_clipped_5m.tif).
* In the "Raster Calculator Expression" field input: <code>if ("osm_land_scotland_all_data_5m@1" < 2, 44, "corine_raster_scotland_5m@1")</code>
* Press button "OK" and wait a while (you will see a new dialogue with showing the progress.

Done. You have now a raster (e.g. corine_raster_scotland_clipped_5m.tif) which does not have land in areas, where OSM data has sea/ocean.

=== Reclassifying a Raster Layer ===
WS3.0 uses CORINE landclass values. If using data from other sources it needs to be reclassified to the correct values. genVPB.py has an option to do this, but you may wish to do so manually.

To do this select <code>GRASS->Raster->r.reclass</code> from the Processing Toolbox.

Select the following options:

* Input Raster Layer - correct layer, check CRS
* Reclass rules text - copy in the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/nlcd2019.txt. Or an appropriate mapping from your landclass data to CORINE. Note that you can also reference a file using the "File containing reclass rules" option. Note a mapping of 22 24 = 1 is the same as 22 and 24 = 1. For a range of 22 to 24 use 22 23 24 = 1.
* Reclassified - Select a new filename.

(If this doesn't work a similar function is available in the Processing Toolbox under <code>Raster analysis->Reclassify by table</code>. However this doesn't save your table once you close the dialog, and entries have to be manually entered individually which takes a lot of effort)

=== Processing NLCD for USA using the Raster Calculator and tools in QGIS ===

[[Processing_NLCD_for_USA_using_Raster_Calculator_and_tools_in_QGIS]]

=== Python script to process NLCD for the USA ===

[[Python_script_to_process_NLCD_for_the_USA]]

=== Python script to process Sentinel-2 data ===

[[Python_script_to_process_Sentinel-2_data]]

===Generating the Terrain using osgdem===
Instead of using genVPB.py, you may wish to run osgdem directly.

In the Windows/Docker platform you can send the generate tile command directly to osgdem.exe, one tile at a time.

Using the NLCD raster processing convention from above, following is the the final step after creating the raster and entering bash shell with the windows version of "docker run..."

osgdem --TERRAIN --image-ext png --RGBA --no-interpolate-imagery --disable-error-diffusion --geocentric --no-mip-mapping -t ./data/California-Southern_4326-84-hd-corrected.tiff -d ./SRTM-3/N32W115.hgt -b -115 32 -114 33 --PagedLOD -l 7 --radius-to-max-visible-distance-ratio 3 -o ./output/vpb/w120n30/w115n32/ws_w115n32.osgb

Note: the --image-ext png --RGBA flags are critical to successfully building correctly placed landclasses in the final VPB generated scenery.

If you prefer to run the scenery generation manually, running the VPB osgdem process is described in more detail here: [[Virtual Planet Builder#Running VPB]].

After doing this you should have an output directory containing files of the form <code>output/vpb/w010n50/w004n50/ws_w004n50.osgb</code>, plus a host of sub-directories. Each one of these is a 1x1 tile of terrain.

to leave the container simply type <code>exit</code>.

===Packaging the Scenery===
Once you have the terrain and line features they should be packaged in a scenery directory in vpb and Terrain sub-directories respectively. E.g.
MyCoolScenery/Terrain
MyCoolScenery/vpb
It is good practise to document the data sources used in scenery generation. Some source licenses require attribution of the original data source for anything derived, published or distributed.

To assist in fulfilling these license obligations, you can create a source.xml file in the scenery directory which includes attribution information. This will then be available from within the simulator under Help->Scenery Sources, and <u>may</u> fulfil the attribution requirements of your license. '''Note that you are responsible for fulfilling any license requirements from the data, not FlightGear'''.

The format of the file is straightforward:
<?xml version="1.0"?>
<PropertyList>
<nowiki><source></nowiki>
<name>Corine Land Cover (CLC) 2018, Version 2020_20u1</name>
<nowiki><link></nowiki><nowiki>http://web.archive.org/web/20221112175615/https://land.copernicus.eu/pan-european/corine-land-cover/clc2018?tab=metadata%2A</nowiki><nowiki></link></nowiki>
<license>GMES Open License</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>NASADEM Merged DEM Global 1 arc second V001</name>
<nowiki><link></nowiki><nowiki>https://www.earthdata.nasa.gov/</nowiki><nowiki></link></nowiki>
<license>Public Domain</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>OpenStreetMap</name>
<nowiki><link></nowiki><nowiki>https://www.openstreetmap.org/copyright</nowiki><nowiki></link></nowiki>
<license>Open Data Commons Open Database License</license>
<nowiki></source></nowiki>
</PropertyList>

Howto:Create WS3.0 terrain

2026-05-15T15:53:44Z

Wlbragg: /* Adding water */

{{WS30 Navbar}}
This article provides instructions on how to generate basic WS3.0 terrain.

WS3.0 terrain consists of three parts:

# A terrain mesh consisting of a landclass texture draped over an elevation model.
# A high resolution water raster used to show water features such as rivers, lakes and coastline with more definition
# Line features such as roads and railways.

The terrain is generated by a set of tools that are packaged in a docker image for convenience.[[File:Diagram-export-21-12-2023-16 29 37.png|thumb|Basic WS3.0 Scenery Generation Process]]

== Prerequisites ==

=== Set up a Workspace ===
Create a directory with the following sub-directories:

* <code>cache</code>
* <code>data</code>
* <code>output/vpb</code>
* <code>output/Terrain</code>

=== Docker ===

# Install [https://docs.docker.com/get-started/ Docker] on your platform.
#Pull the docker image by running the following command

docker pull flightgear/ws30-vpb-generator:latest
Optionally, if you are hitting rate limits:
#Create an account on https://hub.docker.com/. (Note that you will need to click on an email verification link before you can log in for the first time)
#Run <code>docker login</code> before the '''docker pull''' command above

== Getting the base data ==
You need two pieces of data for the area of scenery you are generating:

# An elevation model (aka DEM). This indicates what altitude each point of the surface is.
# Landclass data showing what type of terrain is at each point of the surface. This is often either a Raster (effectively a texture), or vector data.

=== Elevation Model ===
Download the NASADEM elevation model for the area of scenery you wish to generate. This is available in 1x1 degree blocks from [https://lpdaac.usgs.gov/products/nasadem_hgtv001/ here], and with an interactive browser [https://search.earthdata.nasa.gov/search here].

Unzip the files into the <code>data</code> directory.

=== Landclass Raster ===
Download an landclass raster for the area of scenery you wish to generate.

* For Europe, use of [https://land.copernicus.eu/pan-european/corine-land-cover/clc2018 CORINE] is recommended.
* For the USA [https://www.mrlc.gov/viewer/ NLCD] is recommended
* Sentinel-2 data is available for the entire world via [https://livingatlas.arcgis.com/landcoverexplorer/ ESRI], but has limited set of landclasses.

Put these into the <code>data</code> directory.

More detailed terrain can be created by modifying the landclass raster, and/or generating a new raster from vector data. These processes are discussed below.

== Generating Terrain ==
To generate terrain you need to run the tools within the docker container we installed above. The docker image is like a small, independent virtual computing environment running within your system. This particular docker image has all the scenery generation tools already installed.

=== Running the docker container ===
Firstly, get the container running from the directory containing your <code>cache</code>, <code>data</code> and <code>output</code> directories:
docker run --rm --mount "type=bind,source=`pwd`/data,target=/home/flightgear/data,readonly" --mount "type=bind,source=`pwd`/output,target=/home/flightgear/output" --mount "type=bind,source=`pwd`/cache,target=/home/flightgear/cache" -it flightgear/ws30-vpb-generator:latest /bin/bash

You should now find yourself in a bash shell within your container. You should see data and output directories which are linked to the directories you created earlier:
flightgear@ddcac77f7d5e:~$ ls
cache data output bin scripts

=== Building the terrain ===
To build the terrain mesh, use the <code>genVPB.py</code> tool from inside the docker container:

Usage: genVPB.py --raster <input-raster> [ option ... ]
Usage: genVPB.py --bbox <lat0> <lon0> <lat1> <lon1> --sentinel --reclass <reclass> [ option ... ]

Arguments:
--raster RASTER Input landclass raster.
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--sentinel Use Sentinel2 landclass tiles
--sentinel-dir SENTINEL_DIR Directory for Sentinel Data. Default /home/flightgear/data/Sentinel-2
--hgt-dir HGT_DIR Directory containing HGT DEM files. Default /home/flightgear/data/NASADEM
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/output
--download-sentinel Download Sentinel2 tiles if needed
--reclass RECLASS Reclassify raster using file <reclass>. See ./scripts/mappings/
--coastline COASTLINE Clip against coastline against polygon (.osm)
--shrink-water SHRINK_WATER Shrink water bodies (landclasses 40, 41) by <pixels> pixels
--generate-water-raster Generate a water raster from OSM data
--generate-line-features Generate a water raster from OSM data
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--nasadem-server NASADEM_SERVER Set server to download NASADEM data from. Default https://e4ftl01.cr.usgs.gov/MEASURES/NASADEM_HGT.001/2000.02.11/)
--nasadem-user NASADEM_USER NASA Earthdata username.
--nasadem-password NASADEM_PASSWORD NASA Earthdata password.
--debug Debug output

For example, to generate a piece of terrain around Edinburgh (latitude 55.5, longitude 3 degrees West):
./scripts/genVPB.py --bbox 55 -4 56 -3 --raster ./data/uk_wgs84_10m_N54.tif

If you are using anything other than a CORINE raster you will need to reclassify the data to match the landclasses used by FlightGear. Those classes are defined in [https://gitlab.com/flightgear/fgdata/-/tree/next/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml]. You can reclassify them using the files in the [https://gitlab.com/flightgear/fgmeta/-/tree/next/ws30/mappings/ scripts/mappings] directory. E.g. to reclassify NLCD2019 data you can use <code>--reclassify ./scripts/mappings/nlcd2019.txt</code>.

genVPB.py will output the data to the output/vpb directory, in which you should find a series of files and directories.

=== Adding water ===
'''Update 05/12/2026: Depreciated, it is now built into genVPB.py above.'''

The terrain mesh does not have highly detailed water features - as typically the source data has a resolution of 10-25m. Water features are generated from OpenStreetMap data. To generate water features simply run the <code>genwaterraster.py</code> command.

Usage: genwaterraster.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--output-dir OUTPUT_DIR] [--cache-dir CACHE_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--output-dir OUTPUT_DIR Directory to write files into. Default /home/flightgear/output
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache

For example, to generate water for the area around Edinburgh:
./scripts/genwaterraster.py --bbox 55 -4 56 -3

Inside the ./output/vpb directory there should be a set of directories and .png files.

=== Adding roads and railways ===
The terrain mesh does not have any line features - things like roads. These are generated separately from OpenStreetMap data. To generate line features simply run the <code>genroads.py</code> command:

Usage: ./scripts/genroads.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--threads THREADS] [--cache-dir CACHE_DIR] [--output-dir OUTPUT_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--threads THREADS Number of parallel threads to run. Defaults to 1
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/cache/

For example, to generate roads for the area around Edinburgh:
./scripts/genroads.py --bbox 55 -4 56 -3

Inside the ./output/Terrain directory there should be a set of directories and, .STG files text files.

==Running FlightGear with the new WS3.0 Terrain==
To test the new terrain, simply include the output directory in your scenery path and run FlightGear with the <code>--prop:/scenery/use-vpb=true</code> to enable WS3.0.

== Advanced Techniques ==
The following sections describe more complex techniques to generate higher quality WS3.0 terrain. Almost all of them involve using different data sources to generate a more detailed landclass raster before running the final scenery generation processes described above. Generating a highly detailed landclass raster is where the magic happens.

Most techniques use gdal or grass to modify the raster/vector data, typically using the QGIS program.

=== Using a different elevation model ===
If you are using another elevation model other than NASAEM, then you may need to re-project it using QGIS/gdalwarp to the WGS84 CRS (aka EPSG:4326).

=== Landclass Data Requirements ===
For any landclass data we need to ensure the data is in the correct format. That means:

# Is a Raster (geotiff) rather than Vector data. This raster will become the texture on the terrain that the terrain shaders do their magic on.
# Uses the WGS84 Coordinate Reference System. The ensures that the terrain generation step is efficient.
# Has the correct landclass values for each terrain type. We use a set of values based on the CORINE raster set, defined in [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml].

Below is a quick table showing what steps you need to take for common landclass data sources.
{| class="wikitable"
|+
!Landclass Data
!Warp to WGS84 required?
!Landclass re-classification Required?
!Raster Simplification Required?
!Conversion to Raster Required?
|-
|CORINE Raster
|Yes
|No
|No
|No
|-
|CORINE Vector
|Yes
|Yes
|No
|Yes
|-
|NLCD
|No
|Yes
|Yes
|No
|-
|Sentinel-2
|Yes
|Yes
|No
|No
|}
Conversion to Raster must be done manually. Converting to WGS84 and the correct landclasses ''can'' be done by the genVPB.py script, but slows down scenery generation. Therefore if you are planning to generate scenery multiple times it is best to pre-process the files yourself.

The easiest way to do these operations is using QGIS, which is available for most platforms. If you are scripting a toolchain, the QGIS tools include command-line equivalents for all commands.

When using QGIS, set the Project CRS to WGS84 (aka EPSG:4326). You can then add layers of Raster or Vector data from files from the <code>Layer->Add Layer</code> menu. When performing any operations, <u>always</u> write out the data to a real file so you can go back to it later. Disk space is cheap :).

=== Warping Raster Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a raster layer to a different CRS using the Raster->Projections-Warp (Reproject) tool.

Select the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Resampling Method to Use - Nearest Neighbour. (Landclass data is not like normal images. You don't want to interpolate between values.)
* Nodata value for output bands - 0.0 (This means that any data at the edges will be Ocean, usually a reasonable default)
* Advanced Parameters - No Compression
* Output data type - Byte
* Reprojected - Choose a target filename

Alternatively you can do this step from the commandline.
gdalwarp -t_srs EPSG:4326 -dstnodata 0.0 -r near -ot Byte -of GTiff -co COMPRESS=NONE -co BIGTIFF=IF_NEEDED /home/stuart/FlightGear/VPB/data/CORINE/u2018_clc2018_v2020_20u1_raster100m/DATA/U2018_CLC2018_V2020_20u1.tif /home/stuart/FlightGear/VPB/data/scratch/corine_WGS84.tif

=== Warping Vector Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a vector layer using Vector->Data Management Tools->Reproject Layer.

Set the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Reprojected - Choose a target filename

=== Reclassifying Vector Layers ===
For CORINE vector data in particular, the attributes used in the vector data are not the same as those used by the CORINE Raster data. So we need to create a new attribute on the data.
[[File:Field Calculator.png|thumb|QGIS Field Calculator]]
To do this

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialog
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type "Whole Number (Integer)". This will create a new column which we will populate with the correct landclass data
* Click on the <code>Open Field Calculator</code> button (Ctrl + I). (If you get an error about only being able to create Virtual fields, go back to the Layer menu, export it and open the exported file).
* Select the following options:
** Update Existing Field
** Select the Landclass field you just created.
** Copy the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/corine_vector.txt into the Expression box (without the comment lines starting with <code>#</code>). This is just some simple code to set the attribute correctly. The code should be correct for CORINE vector data. If your data is from other sources you will need to work out how you want to map your source data landclasses to the CORINE ones. [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml] can be used as a guide.
* Select <code>OK</code>. You should see that your landclass column is now populated with the landclass data.
* Select <code>Layer->Save Layer Edits</code> to save you changes

=== Creating a Raster from a Vector Layer ===
To create a Raster from a Vector Layer select <code>Raster->Conversion->Rasterize (Vector to Raster)</code>.
[[File:QGIS Rasterize (Vector to Raster).png|thumb|Creating a Raster from a Vector Layer - QGIS Rasterize]]
Select the following options:

* Input Layer - correct layer, check CRS
* Field to use for burn-in value - select the <code>Landclass</code> column you created above.
* Output raster size units. This is going to set the resolution of your raster. You can work out the resolution in two different ways:
** Select "Georeferenced units" and determine how many degrees each pixel is in latitude and longitude.
** Select "Pixels" and determine the size of raster you want in pixels. [https://www.nhc.noaa.gov/gccalc.shtml This] is a good calculator to help. You input e.g. SE and SW coordinates and calculate to get the distance in Km. Then you multiply by thousand and devide by the number of metres per pixel (e.g. 5) -> resolution for width.
* Width/Horizontal Resolution. Enter the values you've calculated for the horizontal resolution (longitudinal), or the width of the raster
* Height/Vertical Resolution. Enter the values you've calculated for the vertical resolution (latitude or the height of the raster)
* Output extent - Select an option from the box on the right. You can edit the text afterwards (NB: East, West, South, North). Best practise is to create long thin strips of 1 degree latitude in height, as this makes subsequent processing much easier.
* Assign a specific nodata value to output bands - Select 0.0 for Ocean. CORINE vector data in particular has a lot of nodata for Oceans
* Advanced Parameters - No Compression
* Output data type - Byte
* Rasterized - Select a new filename

=== Simplifying a Raster Layer ===
Some Raster Landclass data (NLCD included) has too much noise - in particular large US highway systems are identified as Urban areas.

To smooth it out we can use the GRASS <code>n.neighbors</code> function from the Processing Toolbox in QGIS.

Select the following options:

* Input Layer - correct layer, check CRS
* Neighborhood operation - median. (This is not a normal image, so using an average will result in weird values)
* Neighborhood size - 5.
* Neighbors - Select a new filename.

=== Clipping a Raster Layer with OSM Data for Land (Corine) ===
The Corine dataset does not match OSM coastlines exactly. The following multi-stage process makes sure, that no Corine land-use is in the water as defined by OSM.

==== Download OSM Land Data ====

Download land polygons based on OSM data as a Shapefile from [https://osmdata.openstreetmap.de/data/land-polygons.html Land Polygons] and make sure to pick the WGS84 projected download with split polygons ("Large polygons are split, use for larger scales"). Once downloaded unzip the content into a directory.

==== Reclassifying the OSM Land Data Vector Layer ====
I QGIS make sure that only the layer for the raster for land data is selected (e.g. <code>land-polygons-split-4326</code>) -> in the map view you will see the whole earth. NB: typically you do this reclassify only once after download and can reuse the result for future processing.

Then:

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialogue
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type <code>Integer (32 bit)</code>. This will create a new column which we will populate with the correct land class data
* On top of the table on the left side choose "Landclass" in the drop-down menu, then input <code>2</code> into the field to the right and then press button "Update" all to the left of this field.
* Wait a bit and the close the dialogue.
* Select <code>Layer->Save Layer Edits</code> to save your changes (overwrite e.g. <code>land-polygons-split-4326</code>).

==== Convert the Land Data from Vector to Raster ====
Do the same as in chapter "Creating a Raster from a Vector Layer" above. The only difference is that the Input layer will be the land data polygons and you need to choose a different file name for the "Rasterized" (e.g. osm_land_scotland_5m.tif)

==== Remove Novalue Entries in the Land Data Raster ====
To do this:

* Select <code>Processing->Toolbox</code>. You should see a new box on the right side.
* Write "gdal_calc" in the search box and you should see an entry "Raster calculator". Double click on it and you will get a new dialogue window.
* In this dialogue:
** For "Input layer A" choose the raster from the previous chapter ((e.g. osm_land_scotland_5m.tif)
** In field "Calculation in gdalnumeric ..." write: <code>greater(A,0) * A</code>
** In field "Output raster type" choose <code>Byte</code>
** In field "Advanced Parameters" choose Profile <code>No compression</code>
** In field "Additional command-line parameters" write: <code>--hideNoData</code>
** In field "Calculated" choose a file (e.g. osm_land_scotland_allvalues_5m.tif)
** (In the "GDAL/OGR console call" it will have something similar to the follwing - just with different paths: <code>gdal_calc.py --overwrite --calc "greater(A ,0) * A" --format GTiff --type Byte -A /home/vanosten/custom-fg-scenery/data/osm_land_scotland_5m.tif --A_band 1 --co COMPRESS=NONE --co BIGTIFF=IF_NEEDED --hideNoData --outfile /home/vanosten/custom-fg-scenery/data/osm_land_scotland_allvalues_5m.tif</code>
** Press the "Run" button - and when complete close the dialogue.

You should now see a map only black and white. You can check for correctness by pressing <code>CTRL+SHIFT+I</code> to get a cursor with an arrow and an "i". First make sure the new raster is selected on the left side. Next click on the sea/ocean and then check in the "Identify Results" window on the right that the value is < 2. The click on the land and check that the value is 2.

==== Create the Final Clipped Corine Raster Against OSM Land Data =====
Do the following:

* In QGIS make sure that you have only the following two layers: the basis Corine raster (see chapter "Creating a Raster from a Vector Layer" - here e.g. corine_raster_scotland_5m.tif) and plus the raster from the previous step (e.g. osm_land_scotland_allvalues_5m.tif)
* Select <code>Raster->Raster Calculator ...</code> and a corresponding dialogue will open showing on the left hand side the two rasters.
* Choose a new "Output layer" (e.g. corine_raster_scotland_clipped_5m.tif).
* In the "Raster Calculator Expression" field input: <code>if ("osm_land_scotland_all_data_5m@1" < 2, 44, "corine_raster_scotland_5m@1")</code>
* Press button "OK" and wait a while (you will see a new dialogue with showing the progress.

Done. You have now a raster (e.g. corine_raster_scotland_clipped_5m.tif) which does not have land in areas, where OSM data has sea/ocean.

=== Reclassifying a Raster Layer ===
WS3.0 uses CORINE landclass values. If using data from other sources it needs to be reclassified to the correct values. genVPB.py has an option to do this, but you may wish to do so manually.

To do this select <code>GRASS->Raster->r.reclass</code> from the Processing Toolbox.

Select the following options:

* Input Raster Layer - correct layer, check CRS
* Reclass rules text - copy in the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/nlcd2019.txt. Or an appropriate mapping from your landclass data to CORINE. Note that you can also reference a file using the "File containing reclass rules" option. Note a mapping of 22 24 = 1 is the same as 22 and 24 = 1. For a range of 22 to 24 use 22 23 24 = 1.
* Reclassified - Select a new filename.

(If this doesn't work a similar function is available in the Processing Toolbox under <code>Raster analysis->Reclassify by table</code>. However this doesn't save your table once you close the dialog, and entries have to be manually entered individually which takes a lot of effort)

=== Processing NLCD for USA using the Raster Calculator and tools in QGIS ===

[[Processing_NLCD_for_USA_using_Raster_Calculator_and_tools_in_QGIS]]

=== Python script to process NLCD for the USA ===

[[Python_script_to_process_NLCD_for_the_USA]]

=== Python script to process Sentinel-2 data ===

[[Python_script_to_process_Sentinel-2_data]]

===Generating the Terrain using osgdem===
Instead of using genVPB.py, you may wish to run osgdem directly.

In the Windows/Docker platform you can send the generate tile command directly to osgdem.exe, one tile at a time.

Using the NLCD raster processing convention from above, following is the the final step after creating the raster and entering bash shell with the windows version of "docker run..."

osgdem --TERRAIN --image-ext png --RGBA --no-interpolate-imagery --disable-error-diffusion --geocentric --no-mip-mapping -t ./data/California-Southern_4326-84-hd-corrected.tiff -d ./SRTM-3/N32W115.hgt -b -115 32 -114 33 --PagedLOD -l 7 --radius-to-max-visible-distance-ratio 3 -o ./output/vpb/w120n30/w115n32/ws_w115n32.osgb

Note: the --image-ext png --RGBA flags are critical to successfully building correctly placed landclasses in the final VPB generated scenery.

If you prefer to run the scenery generation manually, running the VPB osgdem process is described in more detail here: [[Virtual Planet Builder#Running VPB]].

After doing this you should have an output directory containing files of the form <code>output/vpb/w010n50/w004n50/ws_w004n50.osgb</code>, plus a host of sub-directories. Each one of these is a 1x1 tile of terrain.

to leave the container simply type <code>exit</code>.

===Packaging the Scenery===
Once you have the terrain and line features they should be packaged in a scenery directory in vpb and Terrain sub-directories respectively. E.g.
MyCoolScenery/Terrain
MyCoolScenery/vpb
It is good practise to document the data sources used in scenery generation. Some source licenses require attribution of the original data source for anything derived, published or distributed.

To assist in fulfilling these license obligations, you can create a source.xml file in the scenery directory which includes attribution information. This will then be available from within the simulator under Help->Scenery Sources, and <u>may</u> fulfil the attribution requirements of your license. '''Note that you are responsible for fulfilling any license requirements from the data, not FlightGear'''.

The format of the file is straightforward:
<?xml version="1.0"?>
<PropertyList>
<nowiki><source></nowiki>
<name>Corine Land Cover (CLC) 2018, Version 2020_20u1</name>
<nowiki><link></nowiki><nowiki>http://web.archive.org/web/20221112175615/https://land.copernicus.eu/pan-european/corine-land-cover/clc2018?tab=metadata%2A</nowiki><nowiki></link></nowiki>
<license>GMES Open License</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>NASADEM Merged DEM Global 1 arc second V001</name>
<nowiki><link></nowiki><nowiki>https://www.earthdata.nasa.gov/</nowiki><nowiki></link></nowiki>
<license>Public Domain</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>OpenStreetMap</name>
<nowiki><link></nowiki><nowiki>https://www.openstreetmap.org/copyright</nowiki><nowiki></link></nowiki>
<license>Open Data Commons Open Database License</license>
<nowiki></source></nowiki>
</PropertyList>

Howto:Create WS3.0 terrain

2026-05-15T15:52:58Z

Wlbragg: /* Adding water */

{{WS30 Navbar}}
This article provides instructions on how to generate basic WS3.0 terrain.

WS3.0 terrain consists of three parts:

# A terrain mesh consisting of a landclass texture draped over an elevation model.
# A high resolution water raster used to show water features such as rivers, lakes and coastline with more definition
# Line features such as roads and railways.

The terrain is generated by a set of tools that are packaged in a docker image for convenience.[[File:Diagram-export-21-12-2023-16 29 37.png|thumb|Basic WS3.0 Scenery Generation Process]]

== Prerequisites ==

=== Set up a Workspace ===
Create a directory with the following sub-directories:

* <code>cache</code>
* <code>data</code>
* <code>output/vpb</code>
* <code>output/Terrain</code>

=== Docker ===

# Install [https://docs.docker.com/get-started/ Docker] on your platform.
#Pull the docker image by running the following command

docker pull flightgear/ws30-vpb-generator:latest
Optionally, if you are hitting rate limits:
#Create an account on https://hub.docker.com/. (Note that you will need to click on an email verification link before you can log in for the first time)
#Run <code>docker login</code> before the '''docker pull''' command above

== Getting the base data ==
You need two pieces of data for the area of scenery you are generating:

# An elevation model (aka DEM). This indicates what altitude each point of the surface is.
# Landclass data showing what type of terrain is at each point of the surface. This is often either a Raster (effectively a texture), or vector data.

=== Elevation Model ===
Download the NASADEM elevation model for the area of scenery you wish to generate. This is available in 1x1 degree blocks from [https://lpdaac.usgs.gov/products/nasadem_hgtv001/ here], and with an interactive browser [https://search.earthdata.nasa.gov/search here].

Unzip the files into the <code>data</code> directory.

=== Landclass Raster ===
Download an landclass raster for the area of scenery you wish to generate.

* For Europe, use of [https://land.copernicus.eu/pan-european/corine-land-cover/clc2018 CORINE] is recommended.
* For the USA [https://www.mrlc.gov/viewer/ NLCD] is recommended
* Sentinel-2 data is available for the entire world via [https://livingatlas.arcgis.com/landcoverexplorer/ ESRI], but has limited set of landclasses.

Put these into the <code>data</code> directory.

More detailed terrain can be created by modifying the landclass raster, and/or generating a new raster from vector data. These processes are discussed below.

== Generating Terrain ==
To generate terrain you need to run the tools within the docker container we installed above. The docker image is like a small, independent virtual computing environment running within your system. This particular docker image has all the scenery generation tools already installed.

=== Running the docker container ===
Firstly, get the container running from the directory containing your <code>cache</code>, <code>data</code> and <code>output</code> directories:
docker run --rm --mount "type=bind,source=`pwd`/data,target=/home/flightgear/data,readonly" --mount "type=bind,source=`pwd`/output,target=/home/flightgear/output" --mount "type=bind,source=`pwd`/cache,target=/home/flightgear/cache" -it flightgear/ws30-vpb-generator:latest /bin/bash

You should now find yourself in a bash shell within your container. You should see data and output directories which are linked to the directories you created earlier:
flightgear@ddcac77f7d5e:~$ ls
cache data output bin scripts

=== Building the terrain ===
To build the terrain mesh, use the <code>genVPB.py</code> tool from inside the docker container:

Usage: genVPB.py --raster <input-raster> [ option ... ]
Usage: genVPB.py --bbox <lat0> <lon0> <lat1> <lon1> --sentinel --reclass <reclass> [ option ... ]

Arguments:
--raster RASTER Input landclass raster.
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--sentinel Use Sentinel2 landclass tiles
--sentinel-dir SENTINEL_DIR Directory for Sentinel Data. Default /home/flightgear/data/Sentinel-2
--hgt-dir HGT_DIR Directory containing HGT DEM files. Default /home/flightgear/data/NASADEM
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/output
--download-sentinel Download Sentinel2 tiles if needed
--reclass RECLASS Reclassify raster using file <reclass>. See ./scripts/mappings/
--coastline COASTLINE Clip against coastline against polygon (.osm)
--shrink-water SHRINK_WATER Shrink water bodies (landclasses 40, 41) by <pixels> pixels
--generate-water-raster Generate a water raster from OSM data
--generate-line-features Generate a water raster from OSM data
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--nasadem-server NASADEM_SERVER Set server to download NASADEM data from. Default https://e4ftl01.cr.usgs.gov/MEASURES/NASADEM_HGT.001/2000.02.11/)
--nasadem-user NASADEM_USER NASA Earthdata username.
--nasadem-password NASADEM_PASSWORD NASA Earthdata password.
--debug Debug output

For example, to generate a piece of terrain around Edinburgh (latitude 55.5, longitude 3 degrees West):
./scripts/genVPB.py --bbox 55 -4 56 -3 --raster ./data/uk_wgs84_10m_N54.tif

If you are using anything other than a CORINE raster you will need to reclassify the data to match the landclasses used by FlightGear. Those classes are defined in [https://gitlab.com/flightgear/fgdata/-/tree/next/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml]. You can reclassify them using the files in the [https://gitlab.com/flightgear/fgmeta/-/tree/next/ws30/mappings/ scripts/mappings] directory. E.g. to reclassify NLCD2019 data you can use <code>--reclassify ./scripts/mappings/nlcd2019.txt</code>.

genVPB.py will output the data to the output/vpb directory, in which you should find a series of files and directories.

=== Adding water ===
'''Update 05/12/2026: Depreciated, it is now built into genVPB.py above.'''
The terrain mesh does not have highly detailed water features - as typically the source data has a resolution of 10-25m. Water features are generated from OpenStreetMap data. To generate water features simply run the <code>genwaterraster.py</code> command.

Usage: genwaterraster.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--output-dir OUTPUT_DIR] [--cache-dir CACHE_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--output-dir OUTPUT_DIR Directory to write files into. Default /home/flightgear/output
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache

For example, to generate water for the area around Edinburgh:
./scripts/genwaterraster.py --bbox 55 -4 56 -3

Inside the ./output/vpb directory there should be a set of directories and .png files.

=== Adding roads and railways ===
The terrain mesh does not have any line features - things like roads. These are generated separately from OpenStreetMap data. To generate line features simply run the <code>genroads.py</code> command:

Usage: ./scripts/genroads.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--threads THREADS] [--cache-dir CACHE_DIR] [--output-dir OUTPUT_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--threads THREADS Number of parallel threads to run. Defaults to 1
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/cache/

For example, to generate roads for the area around Edinburgh:
./scripts/genroads.py --bbox 55 -4 56 -3

Inside the ./output/Terrain directory there should be a set of directories and, .STG files text files.

==Running FlightGear with the new WS3.0 Terrain==
To test the new terrain, simply include the output directory in your scenery path and run FlightGear with the <code>--prop:/scenery/use-vpb=true</code> to enable WS3.0.

== Advanced Techniques ==
The following sections describe more complex techniques to generate higher quality WS3.0 terrain. Almost all of them involve using different data sources to generate a more detailed landclass raster before running the final scenery generation processes described above. Generating a highly detailed landclass raster is where the magic happens.

Most techniques use gdal or grass to modify the raster/vector data, typically using the QGIS program.

=== Using a different elevation model ===
If you are using another elevation model other than NASAEM, then you may need to re-project it using QGIS/gdalwarp to the WGS84 CRS (aka EPSG:4326).

=== Landclass Data Requirements ===
For any landclass data we need to ensure the data is in the correct format. That means:

# Is a Raster (geotiff) rather than Vector data. This raster will become the texture on the terrain that the terrain shaders do their magic on.
# Uses the WGS84 Coordinate Reference System. The ensures that the terrain generation step is efficient.
# Has the correct landclass values for each terrain type. We use a set of values based on the CORINE raster set, defined in [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml].

Below is a quick table showing what steps you need to take for common landclass data sources.
{| class="wikitable"
|+
!Landclass Data
!Warp to WGS84 required?
!Landclass re-classification Required?
!Raster Simplification Required?
!Conversion to Raster Required?
|-
|CORINE Raster
|Yes
|No
|No
|No
|-
|CORINE Vector
|Yes
|Yes
|No
|Yes
|-
|NLCD
|No
|Yes
|Yes
|No
|-
|Sentinel-2
|Yes
|Yes
|No
|No
|}
Conversion to Raster must be done manually. Converting to WGS84 and the correct landclasses ''can'' be done by the genVPB.py script, but slows down scenery generation. Therefore if you are planning to generate scenery multiple times it is best to pre-process the files yourself.

The easiest way to do these operations is using QGIS, which is available for most platforms. If you are scripting a toolchain, the QGIS tools include command-line equivalents for all commands.

When using QGIS, set the Project CRS to WGS84 (aka EPSG:4326). You can then add layers of Raster or Vector data from files from the <code>Layer->Add Layer</code> menu. When performing any operations, <u>always</u> write out the data to a real file so you can go back to it later. Disk space is cheap :).

=== Warping Raster Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a raster layer to a different CRS using the Raster->Projections-Warp (Reproject) tool.

Select the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Resampling Method to Use - Nearest Neighbour. (Landclass data is not like normal images. You don't want to interpolate between values.)
* Nodata value for output bands - 0.0 (This means that any data at the edges will be Ocean, usually a reasonable default)
* Advanced Parameters - No Compression
* Output data type - Byte
* Reprojected - Choose a target filename

Alternatively you can do this step from the commandline.
gdalwarp -t_srs EPSG:4326 -dstnodata 0.0 -r near -ot Byte -of GTiff -co COMPRESS=NONE -co BIGTIFF=IF_NEEDED /home/stuart/FlightGear/VPB/data/CORINE/u2018_clc2018_v2020_20u1_raster100m/DATA/U2018_CLC2018_V2020_20u1.tif /home/stuart/FlightGear/VPB/data/scratch/corine_WGS84.tif

=== Warping Vector Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a vector layer using Vector->Data Management Tools->Reproject Layer.

Set the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Reprojected - Choose a target filename

=== Reclassifying Vector Layers ===
For CORINE vector data in particular, the attributes used in the vector data are not the same as those used by the CORINE Raster data. So we need to create a new attribute on the data.
[[File:Field Calculator.png|thumb|QGIS Field Calculator]]
To do this

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialog
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type "Whole Number (Integer)". This will create a new column which we will populate with the correct landclass data
* Click on the <code>Open Field Calculator</code> button (Ctrl + I). (If you get an error about only being able to create Virtual fields, go back to the Layer menu, export it and open the exported file).
* Select the following options:
** Update Existing Field
** Select the Landclass field you just created.
** Copy the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/corine_vector.txt into the Expression box (without the comment lines starting with <code>#</code>). This is just some simple code to set the attribute correctly. The code should be correct for CORINE vector data. If your data is from other sources you will need to work out how you want to map your source data landclasses to the CORINE ones. [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml] can be used as a guide.
* Select <code>OK</code>. You should see that your landclass column is now populated with the landclass data.
* Select <code>Layer->Save Layer Edits</code> to save you changes

=== Creating a Raster from a Vector Layer ===
To create a Raster from a Vector Layer select <code>Raster->Conversion->Rasterize (Vector to Raster)</code>.
[[File:QGIS Rasterize (Vector to Raster).png|thumb|Creating a Raster from a Vector Layer - QGIS Rasterize]]
Select the following options:

* Input Layer - correct layer, check CRS
* Field to use for burn-in value - select the <code>Landclass</code> column you created above.
* Output raster size units. This is going to set the resolution of your raster. You can work out the resolution in two different ways:
** Select "Georeferenced units" and determine how many degrees each pixel is in latitude and longitude.
** Select "Pixels" and determine the size of raster you want in pixels. [https://www.nhc.noaa.gov/gccalc.shtml This] is a good calculator to help. You input e.g. SE and SW coordinates and calculate to get the distance in Km. Then you multiply by thousand and devide by the number of metres per pixel (e.g. 5) -> resolution for width.
* Width/Horizontal Resolution. Enter the values you've calculated for the horizontal resolution (longitudinal), or the width of the raster
* Height/Vertical Resolution. Enter the values you've calculated for the vertical resolution (latitude or the height of the raster)
* Output extent - Select an option from the box on the right. You can edit the text afterwards (NB: East, West, South, North). Best practise is to create long thin strips of 1 degree latitude in height, as this makes subsequent processing much easier.
* Assign a specific nodata value to output bands - Select 0.0 for Ocean. CORINE vector data in particular has a lot of nodata for Oceans
* Advanced Parameters - No Compression
* Output data type - Byte
* Rasterized - Select a new filename

=== Simplifying a Raster Layer ===
Some Raster Landclass data (NLCD included) has too much noise - in particular large US highway systems are identified as Urban areas.

To smooth it out we can use the GRASS <code>n.neighbors</code> function from the Processing Toolbox in QGIS.

Select the following options:

* Input Layer - correct layer, check CRS
* Neighborhood operation - median. (This is not a normal image, so using an average will result in weird values)
* Neighborhood size - 5.
* Neighbors - Select a new filename.

=== Clipping a Raster Layer with OSM Data for Land (Corine) ===
The Corine dataset does not match OSM coastlines exactly. The following multi-stage process makes sure, that no Corine land-use is in the water as defined by OSM.

==== Download OSM Land Data ====

Download land polygons based on OSM data as a Shapefile from [https://osmdata.openstreetmap.de/data/land-polygons.html Land Polygons] and make sure to pick the WGS84 projected download with split polygons ("Large polygons are split, use for larger scales"). Once downloaded unzip the content into a directory.

==== Reclassifying the OSM Land Data Vector Layer ====
I QGIS make sure that only the layer for the raster for land data is selected (e.g. <code>land-polygons-split-4326</code>) -> in the map view you will see the whole earth. NB: typically you do this reclassify only once after download and can reuse the result for future processing.

Then:

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialogue
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type <code>Integer (32 bit)</code>. This will create a new column which we will populate with the correct land class data
* On top of the table on the left side choose "Landclass" in the drop-down menu, then input <code>2</code> into the field to the right and then press button "Update" all to the left of this field.
* Wait a bit and the close the dialogue.
* Select <code>Layer->Save Layer Edits</code> to save your changes (overwrite e.g. <code>land-polygons-split-4326</code>).

==== Convert the Land Data from Vector to Raster ====
Do the same as in chapter "Creating a Raster from a Vector Layer" above. The only difference is that the Input layer will be the land data polygons and you need to choose a different file name for the "Rasterized" (e.g. osm_land_scotland_5m.tif)

==== Remove Novalue Entries in the Land Data Raster ====
To do this:

* Select <code>Processing->Toolbox</code>. You should see a new box on the right side.
* Write "gdal_calc" in the search box and you should see an entry "Raster calculator". Double click on it and you will get a new dialogue window.
* In this dialogue:
** For "Input layer A" choose the raster from the previous chapter ((e.g. osm_land_scotland_5m.tif)
** In field "Calculation in gdalnumeric ..." write: <code>greater(A,0) * A</code>
** In field "Output raster type" choose <code>Byte</code>
** In field "Advanced Parameters" choose Profile <code>No compression</code>
** In field "Additional command-line parameters" write: <code>--hideNoData</code>
** In field "Calculated" choose a file (e.g. osm_land_scotland_allvalues_5m.tif)
** (In the "GDAL/OGR console call" it will have something similar to the follwing - just with different paths: <code>gdal_calc.py --overwrite --calc "greater(A ,0) * A" --format GTiff --type Byte -A /home/vanosten/custom-fg-scenery/data/osm_land_scotland_5m.tif --A_band 1 --co COMPRESS=NONE --co BIGTIFF=IF_NEEDED --hideNoData --outfile /home/vanosten/custom-fg-scenery/data/osm_land_scotland_allvalues_5m.tif</code>
** Press the "Run" button - and when complete close the dialogue.

You should now see a map only black and white. You can check for correctness by pressing <code>CTRL+SHIFT+I</code> to get a cursor with an arrow and an "i". First make sure the new raster is selected on the left side. Next click on the sea/ocean and then check in the "Identify Results" window on the right that the value is < 2. The click on the land and check that the value is 2.

==== Create the Final Clipped Corine Raster Against OSM Land Data =====
Do the following:

* In QGIS make sure that you have only the following two layers: the basis Corine raster (see chapter "Creating a Raster from a Vector Layer" - here e.g. corine_raster_scotland_5m.tif) and plus the raster from the previous step (e.g. osm_land_scotland_allvalues_5m.tif)
* Select <code>Raster->Raster Calculator ...</code> and a corresponding dialogue will open showing on the left hand side the two rasters.
* Choose a new "Output layer" (e.g. corine_raster_scotland_clipped_5m.tif).
* In the "Raster Calculator Expression" field input: <code>if ("osm_land_scotland_all_data_5m@1" < 2, 44, "corine_raster_scotland_5m@1")</code>
* Press button "OK" and wait a while (you will see a new dialogue with showing the progress.

Done. You have now a raster (e.g. corine_raster_scotland_clipped_5m.tif) which does not have land in areas, where OSM data has sea/ocean.

=== Reclassifying a Raster Layer ===
WS3.0 uses CORINE landclass values. If using data from other sources it needs to be reclassified to the correct values. genVPB.py has an option to do this, but you may wish to do so manually.

To do this select <code>GRASS->Raster->r.reclass</code> from the Processing Toolbox.

Select the following options:

* Input Raster Layer - correct layer, check CRS
* Reclass rules text - copy in the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/nlcd2019.txt. Or an appropriate mapping from your landclass data to CORINE. Note that you can also reference a file using the "File containing reclass rules" option. Note a mapping of 22 24 = 1 is the same as 22 and 24 = 1. For a range of 22 to 24 use 22 23 24 = 1.
* Reclassified - Select a new filename.

(If this doesn't work a similar function is available in the Processing Toolbox under <code>Raster analysis->Reclassify by table</code>. However this doesn't save your table once you close the dialog, and entries have to be manually entered individually which takes a lot of effort)

=== Processing NLCD for USA using the Raster Calculator and tools in QGIS ===

[[Processing_NLCD_for_USA_using_Raster_Calculator_and_tools_in_QGIS]]

=== Python script to process NLCD for the USA ===

[[Python_script_to_process_NLCD_for_the_USA]]

=== Python script to process Sentinel-2 data ===

[[Python_script_to_process_Sentinel-2_data]]

===Generating the Terrain using osgdem===
Instead of using genVPB.py, you may wish to run osgdem directly.

In the Windows/Docker platform you can send the generate tile command directly to osgdem.exe, one tile at a time.

Using the NLCD raster processing convention from above, following is the the final step after creating the raster and entering bash shell with the windows version of "docker run..."

osgdem --TERRAIN --image-ext png --RGBA --no-interpolate-imagery --disable-error-diffusion --geocentric --no-mip-mapping -t ./data/California-Southern_4326-84-hd-corrected.tiff -d ./SRTM-3/N32W115.hgt -b -115 32 -114 33 --PagedLOD -l 7 --radius-to-max-visible-distance-ratio 3 -o ./output/vpb/w120n30/w115n32/ws_w115n32.osgb

Note: the --image-ext png --RGBA flags are critical to successfully building correctly placed landclasses in the final VPB generated scenery.

If you prefer to run the scenery generation manually, running the VPB osgdem process is described in more detail here: [[Virtual Planet Builder#Running VPB]].

After doing this you should have an output directory containing files of the form <code>output/vpb/w010n50/w004n50/ws_w004n50.osgb</code>, plus a host of sub-directories. Each one of these is a 1x1 tile of terrain.

to leave the container simply type <code>exit</code>.

===Packaging the Scenery===
Once you have the terrain and line features they should be packaged in a scenery directory in vpb and Terrain sub-directories respectively. E.g.
MyCoolScenery/Terrain
MyCoolScenery/vpb
It is good practise to document the data sources used in scenery generation. Some source licenses require attribution of the original data source for anything derived, published or distributed.

To assist in fulfilling these license obligations, you can create a source.xml file in the scenery directory which includes attribution information. This will then be available from within the simulator under Help->Scenery Sources, and <u>may</u> fulfil the attribution requirements of your license. '''Note that you are responsible for fulfilling any license requirements from the data, not FlightGear'''.

The format of the file is straightforward:
<?xml version="1.0"?>
<PropertyList>
<nowiki><source></nowiki>
<name>Corine Land Cover (CLC) 2018, Version 2020_20u1</name>
<nowiki><link></nowiki><nowiki>http://web.archive.org/web/20221112175615/https://land.copernicus.eu/pan-european/corine-land-cover/clc2018?tab=metadata%2A</nowiki><nowiki></link></nowiki>
<license>GMES Open License</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>NASADEM Merged DEM Global 1 arc second V001</name>
<nowiki><link></nowiki><nowiki>https://www.earthdata.nasa.gov/</nowiki><nowiki></link></nowiki>
<license>Public Domain</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>OpenStreetMap</name>
<nowiki><link></nowiki><nowiki>https://www.openstreetmap.org/copyright</nowiki><nowiki></link></nowiki>
<license>Open Data Commons Open Database License</license>
<nowiki></source></nowiki>
</PropertyList>

Python script to process Sentinel-2 data

2026-05-15T15:46:53Z

Wlbragg: /* Python script to process Sentinel-2 data */

== Python script to process Sentinel-2 data ==
This is a slightly different process that that of the NLCD. Sentinel-2 data does not have any extra tree canopy coverage to merge in but this script still cuts out some superfluous urban clutter. Sentinel-2 data uses a two stage workflow. Step 1 cleans up the urban clutter and then splits the larger Sentinel-2 chunks of date to 1x1 tiles to help facilitate Step 2, which up-samples and smoothes the boundaries.

=== Part 1 ===

<syntaxhighlight lang="text">
from qgis.core import (
QgsRasterLayer,
QgsProcessingFeedback,
QgsRectangle
)
from qgis import processing
from osgeo import gdal
import subprocess
import os
import math

os.environ["GDAL_PAM_ENABLED"] = "NO"

# -----------------------------
# USER SETTINGS
# -----------------------------
path = '/mnt/Windows/'
country = 'Alabama'
part = '16R_20250101-20251231'

################################################# IMPORTANT #############################################
# Cuts Sentinel-2 chunks into FlightGear tiles
# Eliminates water only tiles
# Reclassifies Sentenial-2 landcover types to match FlightGear
# Cleans up any urban area road artifacts
# Beginning filename of the NLCD from the source needs to be
# 'nxxxxxxxxxxxxxxxx.tif'
# Also note that "/data/Sentinel-2/" is hardcoded into the path as well
# I needed the existing path structure to process it by state or country.
# Example beginning Sentinel-2 source:
# 16R_20250101-20251231.tif
# Full input path and filename to source example is:
# G:/Scenery/ws3.0/Alabama/data/Sentinel-2/16R_20250101-20251231.tif
# Final output path to processed files is:
# G:/Scenery/ws3.0/Alabama/data/Sentinel-2/tiles_16R_20250101-20251231/N30W086.tif * tile chunk
##########################################################################################################

################################################################### Step 1: Warp land cover 4326 ############################################################

input_raster = path + country + '/data/Sentinel-2/' + part + '.tif'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Land_Cover_4326.tiff'

processing.run(
"gdal:warpreproject",
{
'INPUT':input_raster,
'SOURCE_CRS': QgsCoordinateReferenceSystem('EPSG:5070'),
'TARGET_CRS': QgsCoordinateReferenceSystem('EPSG:4326'),
'RESAMPLING':0,
'NODATA':None,
'TARGET_RESOLUTION':None,
'OPTIONS':'',
'DATA_TYPE':1, # GDAL GDT_Byte
'TARGET_EXTENT':None,
'TARGET_EXTENT_CRS':None,
'MULTITHREADING':False,
'EXTRA':'',
'OUTPUT':output_path
}
)

print("Step 1: Warp land_cover completed. (Sentinel-2_" + country + part + "_Land_Cover_4326)")

############################################################## Step 2: Replace urban and clutter with grass ###################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Land_Cover_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Grass-Only_4326.tiff'

expression = (
'(A == 0) * 44 + '
'(A == 1) * 41 + '
'(A == 2) * 23 + '
'(A == 3) * 44 + '
'(A == 4) * 35 + '
'(A == 5) * 21 + '
'(A == 6) * 44 + '
'(A == 7) * 26 + '
'(A == 8) * 31 + '
'(A == 9) * 34 + '
'(A == 10) * 26 + '
'(A == 11) * 26'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows requires
#subprocess.run(command, shell=True)

print("Step 2: Replace urban and clutter with grass completed. (Sentinel-2_" + country + part + "_Grass-Only_4326)")

################################################################## Step 3: Reclass urban 2 ###########################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Land_Cover_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Reclassed-Urban_4326.tiff'

expression = (
'(A == 7)*2'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows requires
#subprocess.run(command, shell=True)

print("Step 3: Reclass urban completed. (Sentinel-2_" + country + part + "_Reclassed-Urban_4326)")

################################################################ Step 4: Remove clutter and roads from urban ###########################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Reclassed-Urban_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Urban-Only_4326.tiff'

processing.run(
"grass7:r.neighbors",
{
'input':input_path,
'selection':None,
'method':1, #1=median, 2=mode
'size':7,
'gauss':None,
'quantile':'',
'-c':False,
'-a':False,
'weight':'',
'output':output_path,
'GRASS_REGION_PARAMETER':None,
'GRASS_REGION_CELLSIZE_PARAMETER':0,
'GRASS_RASTER_FORMAT_OPT': 'TYPE=BYTE',
'GRASS_RASTER_FORMAT_META':''
}
)

print("Step 4: Remove clutter and roads from urban. (Sentinel-2_" + country + part + "_Urban-Only_4326)")

############################################################## Step 5: Combine grass only and clean urban #########################################################

input_path_a = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Urban-Only_4326.tiff'
input_path_b = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Grass-Only_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean_4326.tiff'

expression = (
'((A > 0) & (B > 0)) * A + '
'((A <= 0) | (B <= 0)) * B'
)
command = [
'gdal_calc.py',
'-A', input_path_a,
'-B', input_path_b,
'--outfile', output_path,
'--calc', expression,
'--NoDataValue', '0',
'--type', 'Byte'
]
subprocess.run(command)
#Windows requires
#subprocess.run(command, shell=True)

print("Step 5: Combined and clean completed. (Sentinel-2_" + country + part + "_Combined-Clean_4326)")

############################################################## Step 6: Cut into tiles #########################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean_4326.tiff'
output_folder = path + country + '/data/Sentinel-2/tiles_' + part + '/'
tile_size_deg = 1.0

os.makedirs(output_folder, exist_ok=True)

rlayer = QgsRasterLayer(input_path, "input")
if not rlayer.isValid():
raise Exception("Raster failed to load: " + input_path)

ext = rlayer.extent()
xmin = ext.xMinimum()
xmax = ext.xMaximum()
ymin = ext.yMinimum()
ymax = ext.yMaximum()

xmin_int = math.floor(xmin)
xmax_int = math.ceil(xmax)
ymin_int = math.floor(ymin)
ymax_int = math.ceil(ymax)

feedback = QgsProcessingFeedback()

for lat in range(ymin_int, ymax_int - 1):
for lon in range(xmin_int, xmax_int - 1):

tile_xmin = lon
tile_xmax = lon + tile_size_deg
tile_ymin = lat
tile_ymax = lat + tile_size_deg

if tile_xmax <= xmin or tile_xmin >= xmax:
continue
if tile_ymax <= ymin or tile_ymin >= ymax:
continue

tile_extent = f"{tile_xmin},{tile_xmax},{tile_ymin},{tile_ymax}"

ns = "N" if (lat + 1) >= 0 else "S"
ew = "E" if lon >= 0 else "W"
out_name = f"{ns}{abs(lat+1):02d}{ew}{abs(lon):03d}.tif"
out_path = os.path.join(output_folder, out_name)

tmp_tile = out_path.replace(".tif", "_tmp.tif")

processing.run(
"gdal:cliprasterbyextent",
{
'INPUT': input_path,
'PROJWIN': tile_extent,
'NODATA': 0,
'OPTIONS': '',
'DATA_TYPE': 0,
'OUTPUT': tmp_tile
},
feedback=feedback
)

if not os.path.exists(tmp_tile) or os.path.getsize(tmp_tile) < 50:
if os.path.exists(tmp_tile):
os.remove(tmp_tile)
print("Skipped (empty tile):", out_name)
continue

ds = gdal.Open(tmp_tile)
band = ds.GetRasterBand(1)
arr = band.ReadAsArray()

# If every pixel is zero → water only
if (arr == 0).all():
os.remove(tmp_tile)
print("Skipped (all water):", out_name)
continue

os.rename(tmp_tile, out_path)
print("Created:", out_path)

print("Tiling complete.")
</syntaxhighlight>

=== Part 2 ===

This is the pretty much the same final steps that the NLCD uses to up-sample and smooth the boundaries.

NOTE: the current genVPB.py script (osgdem) will not generate the final scenery water/land edge to this high of a resolution. It is set to a default tile size of 256x256, "--tile-image-size 256". This resolution is much higher than that. To achieve the same base resolution in the built scenery, osgdem needs a switch to "--tile-image-size 1024" to realize the higher resolution. However, when you apply the water mask flags --generate-water-raster --shrink-water 4 --coastline [path_to_coastal_shapefiles] using genVPB.py the cut mask will achieve the higher resolution.

<syntaxhighlight lang="text">
from qgis.core import QgsApplication, QgsCoordinateTransform, QgsProject, QgsRasterLayer, QgsCoordinateReferenceSystem, QgsProcessingException, QgsRasterBlock, QgsRectangle
from qgis.analysis import QgsRasterCalculator, QgsRasterCalculatorEntry
from qgis import processing
from processing.core.Processing import Processing
from osgeo import gdal, osr, ogr
import os
import numpy
import numpy as np
import subprocess

# Define input layer names, change according to your file names
path = '/mnt/Windows/';
country = 'Alabama';
part = 'N30W086';

#ratio of upscale to smoothing
percentage = 8
size = 11
#ratio of 11/15 upscale to smoothing is the next sweet spot, but starts to move boundary positions and starts to eliminate smaller land class features for not a ton of resolution gain.

################################## IMPORTANT ###############################
# Beginning filename of the NLCD from the source needs to be
# 'nxxxxxxxxxxxxxxxx.tif'
# Also note that "/data/Sentinel-2/" is hardcoded into the path as well
# I needed the existing path structure to process it by state or country.
# Example beginning Sentinel-2 source:
# N30W086.tif
# Full input path and filename to source example is:
# G:/Scenery/ws3.0/Alabama/data/Sentinel-2/N30W086.tif
# Final output path to last processed file is:
# G:/Scenery/ws3.0/Alabama/data/Sentinel-2/Sentinel-2_AlabamaN30W086_Smoothed-HD-Compressed_4326.tiff
############################################################################

################################################################## Step 1: Upsample to HD #################################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean-HD_4326.tiff'

# Open the original raster
ds = gdal.Open(input_path)
gt = ds.GetGeoTransform()

# Extract the original resolution
original_xRes = gt[1]
original_yRes = abs(gt[5])

# Define the percentage to resize by (e.g., 0.50 for 50%, 2.0 for 200%)
#defined at the beginning of the script
#percentage = 8.0 # Adjust this as needed

# Calculate the new resolution
new_xRes = original_xRes / percentage
new_yRes = original_yRes / percentage

# Perform the warp (resampling)
gdal.Warp(
output_path,
input_path,
xRes=new_xRes,
yRes=new_yRes,
outputType=gdal.GDT_Byte # Set the output type to uint8
)

print("Step 1: Upsample to. (Sentinel-2_" + country + part + "_Combined-Clean-HD_4326)")

################################################################## Step 2: Smooth all features in original dataset #################################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean-HD_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Smoothed-HD_4326.tiff'

processing.run(
"grass7:r.neighbors",
{
'input':input_path,
'selection':None,
'method':1, #1=median, 3=mode
'size':size,
'gauss':None,
'quantile':'',
'-c':False,
'-a':False,
'weight':'',
'output':output_path,
'GRASS_REGION_CELLSIZE_PARAMETER':0,
'GRASS_RASTER_FORMAT_OPT': 'TYPE=BYTE',
'GRASS_RASTER_FORMAT_META':''
}
)

print("Step 2: Smooth all features in original dataset completed. (Sentinel-2_" + country + part + "_Smoothed-HD_4326)")

################################################################## Step 3: Convert to 8Bit #################################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Smoothed-HD_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Smoothed-HD-Compressed_4326.tiff'

processing.run(
"gdal:translate",
{
'INPUT':input_path,
'TARGET_CRS':None,
'NODATA':0,
'COPY_SUBDATASETS':False,
'OPTIONS':'',
'EXTRA':'',
'DATA_TYPE':1,
'OUTPUT':output_path,
'OPTIONS': 'COMPRESS=LZW'
}
)

result_bit_conversion_layer = QgsRasterLayer(output_path, 'Sentinel-2_' + country + part + '_Smoothed-HD-Compressed_4326')
QgsProject.instance().addMapLayer(result_bit_conversion_layer)

print("Step 3: Convert to Compressed. (Sentinel-2_" + country + part + "_Smoothed-HD-Compressed_4326)")
</syntaxhighlight>

Python script to process Sentinel-2 data

2026-05-15T15:45:23Z

Wlbragg: /* Part 2 */

== Python script to process Sentinel-2 data ==
This is a slightly different process that that of the NLCD. Sentinel-2 data does not have any extra tree canopy coverage to merge in but this script still cuts out some superfluous urban clutter. It uses a two stage workflow. Step 1 cleans up the urban clutter and then splits the larger Sentinel-2 chunks of date to 1x1 tiles to help facilitate Step 2 processing wich up-samples and smoothes the boundaries.

=== Part 1 ===

<syntaxhighlight lang="text">
from qgis.core import (
QgsRasterLayer,
QgsProcessingFeedback,
QgsRectangle
)
from qgis import processing
from osgeo import gdal
import subprocess
import os
import math

os.environ["GDAL_PAM_ENABLED"] = "NO"

# -----------------------------
# USER SETTINGS
# -----------------------------
path = '/mnt/Windows/'
country = 'Alabama'
part = '16R_20250101-20251231'

################################################# IMPORTANT #############################################
# Cuts Sentinel-2 chunks into FlightGear tiles
# Eliminates water only tiles
# Reclassifies Sentenial-2 landcover types to match FlightGear
# Cleans up any urban area road artifacts
# Beginning filename of the NLCD from the source needs to be
# 'nxxxxxxxxxxxxxxxx.tif'
# Also note that "/data/Sentinel-2/" is hardcoded into the path as well
# I needed the existing path structure to process it by state or country.
# Example beginning Sentinel-2 source:
# 16R_20250101-20251231.tif
# Full input path and filename to source example is:
# G:/Scenery/ws3.0/Alabama/data/Sentinel-2/16R_20250101-20251231.tif
# Final output path to processed files is:
# G:/Scenery/ws3.0/Alabama/data/Sentinel-2/tiles_16R_20250101-20251231/N30W086.tif * tile chunk
##########################################################################################################

################################################################### Step 1: Warp land cover 4326 ############################################################

input_raster = path + country + '/data/Sentinel-2/' + part + '.tif'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Land_Cover_4326.tiff'

processing.run(
"gdal:warpreproject",
{
'INPUT':input_raster,
'SOURCE_CRS': QgsCoordinateReferenceSystem('EPSG:5070'),
'TARGET_CRS': QgsCoordinateReferenceSystem('EPSG:4326'),
'RESAMPLING':0,
'NODATA':None,
'TARGET_RESOLUTION':None,
'OPTIONS':'',
'DATA_TYPE':1, # GDAL GDT_Byte
'TARGET_EXTENT':None,
'TARGET_EXTENT_CRS':None,
'MULTITHREADING':False,
'EXTRA':'',
'OUTPUT':output_path
}
)

print("Step 1: Warp land_cover completed. (Sentinel-2_" + country + part + "_Land_Cover_4326)")

############################################################## Step 2: Replace urban and clutter with grass ###################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Land_Cover_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Grass-Only_4326.tiff'

expression = (
'(A == 0) * 44 + '
'(A == 1) * 41 + '
'(A == 2) * 23 + '
'(A == 3) * 44 + '
'(A == 4) * 35 + '
'(A == 5) * 21 + '
'(A == 6) * 44 + '
'(A == 7) * 26 + '
'(A == 8) * 31 + '
'(A == 9) * 34 + '
'(A == 10) * 26 + '
'(A == 11) * 26'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows requires
#subprocess.run(command, shell=True)

print("Step 2: Replace urban and clutter with grass completed. (Sentinel-2_" + country + part + "_Grass-Only_4326)")

################################################################## Step 3: Reclass urban 2 ###########################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Land_Cover_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Reclassed-Urban_4326.tiff'

expression = (
'(A == 7)*2'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows requires
#subprocess.run(command, shell=True)

print("Step 3: Reclass urban completed. (Sentinel-2_" + country + part + "_Reclassed-Urban_4326)")

################################################################ Step 4: Remove clutter and roads from urban ###########################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Reclassed-Urban_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Urban-Only_4326.tiff'

processing.run(
"grass7:r.neighbors",
{
'input':input_path,
'selection':None,
'method':1, #1=median, 2=mode
'size':7,
'gauss':None,
'quantile':'',
'-c':False,
'-a':False,
'weight':'',
'output':output_path,
'GRASS_REGION_PARAMETER':None,
'GRASS_REGION_CELLSIZE_PARAMETER':0,
'GRASS_RASTER_FORMAT_OPT': 'TYPE=BYTE',
'GRASS_RASTER_FORMAT_META':''
}
)

print("Step 4: Remove clutter and roads from urban. (Sentinel-2_" + country + part + "_Urban-Only_4326)")

############################################################## Step 5: Combine grass only and clean urban #########################################################

input_path_a = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Urban-Only_4326.tiff'
input_path_b = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Grass-Only_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean_4326.tiff'

expression = (
'((A > 0) & (B > 0)) * A + '
'((A <= 0) | (B <= 0)) * B'
)
command = [
'gdal_calc.py',
'-A', input_path_a,
'-B', input_path_b,
'--outfile', output_path,
'--calc', expression,
'--NoDataValue', '0',
'--type', 'Byte'
]
subprocess.run(command)
#Windows requires
#subprocess.run(command, shell=True)

print("Step 5: Combined and clean completed. (Sentinel-2_" + country + part + "_Combined-Clean_4326)")

############################################################## Step 6: Cut into tiles #########################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean_4326.tiff'
output_folder = path + country + '/data/Sentinel-2/tiles_' + part + '/'
tile_size_deg = 1.0

os.makedirs(output_folder, exist_ok=True)

rlayer = QgsRasterLayer(input_path, "input")
if not rlayer.isValid():
raise Exception("Raster failed to load: " + input_path)

ext = rlayer.extent()
xmin = ext.xMinimum()
xmax = ext.xMaximum()
ymin = ext.yMinimum()
ymax = ext.yMaximum()

xmin_int = math.floor(xmin)
xmax_int = math.ceil(xmax)
ymin_int = math.floor(ymin)
ymax_int = math.ceil(ymax)

feedback = QgsProcessingFeedback()

for lat in range(ymin_int, ymax_int - 1):
for lon in range(xmin_int, xmax_int - 1):

tile_xmin = lon
tile_xmax = lon + tile_size_deg
tile_ymin = lat
tile_ymax = lat + tile_size_deg

if tile_xmax <= xmin or tile_xmin >= xmax:
continue
if tile_ymax <= ymin or tile_ymin >= ymax:
continue

tile_extent = f"{tile_xmin},{tile_xmax},{tile_ymin},{tile_ymax}"

ns = "N" if (lat + 1) >= 0 else "S"
ew = "E" if lon >= 0 else "W"
out_name = f"{ns}{abs(lat+1):02d}{ew}{abs(lon):03d}.tif"
out_path = os.path.join(output_folder, out_name)

tmp_tile = out_path.replace(".tif", "_tmp.tif")

processing.run(
"gdal:cliprasterbyextent",
{
'INPUT': input_path,
'PROJWIN': tile_extent,
'NODATA': 0,
'OPTIONS': '',
'DATA_TYPE': 0,
'OUTPUT': tmp_tile
},
feedback=feedback
)

if not os.path.exists(tmp_tile) or os.path.getsize(tmp_tile) < 50:
if os.path.exists(tmp_tile):
os.remove(tmp_tile)
print("Skipped (empty tile):", out_name)
continue

ds = gdal.Open(tmp_tile)
band = ds.GetRasterBand(1)
arr = band.ReadAsArray()

# If every pixel is zero → water only
if (arr == 0).all():
os.remove(tmp_tile)
print("Skipped (all water):", out_name)
continue

os.rename(tmp_tile, out_path)
print("Created:", out_path)

print("Tiling complete.")
</syntaxhighlight>

=== Part 2 ===

This is the pretty much the same final steps that the NLCD uses to up-sample and smooth the boundaries.

NOTE: the current genVPB.py script (osgdem) will not generate the final scenery water/land edge to this high of a resolution. It is set to a default tile size of 256x256, "--tile-image-size 256". This resolution is much higher than that. To achieve the same base resolution in the built scenery, osgdem needs a switch to "--tile-image-size 1024" to realize the higher resolution. However, when you apply the water mask flags --generate-water-raster --shrink-water 4 --coastline [path_to_coastal_shapefiles] using genVPB.py the cut mask will achieve the higher resolution.

<syntaxhighlight lang="text">
from qgis.core import QgsApplication, QgsCoordinateTransform, QgsProject, QgsRasterLayer, QgsCoordinateReferenceSystem, QgsProcessingException, QgsRasterBlock, QgsRectangle
from qgis.analysis import QgsRasterCalculator, QgsRasterCalculatorEntry
from qgis import processing
from processing.core.Processing import Processing
from osgeo import gdal, osr, ogr
import os
import numpy
import numpy as np
import subprocess

# Define input layer names, change according to your file names
path = '/mnt/Windows/';
country = 'Alabama';
part = 'N30W086';

#ratio of upscale to smoothing
percentage = 8
size = 11
#ratio of 11/15 upscale to smoothing is the next sweet spot, but starts to move boundary positions and starts to eliminate smaller land class features for not a ton of resolution gain.

################################## IMPORTANT ###############################
# Beginning filename of the NLCD from the source needs to be
# 'nxxxxxxxxxxxxxxxx.tif'
# Also note that "/data/Sentinel-2/" is hardcoded into the path as well
# I needed the existing path structure to process it by state or country.
# Example beginning Sentinel-2 source:
# N30W086.tif
# Full input path and filename to source example is:
# G:/Scenery/ws3.0/Alabama/data/Sentinel-2/N30W086.tif
# Final output path to last processed file is:
# G:/Scenery/ws3.0/Alabama/data/Sentinel-2/Sentinel-2_AlabamaN30W086_Smoothed-HD-Compressed_4326.tiff
############################################################################

################################################################## Step 1: Upsample to HD #################################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean-HD_4326.tiff'

# Open the original raster
ds = gdal.Open(input_path)
gt = ds.GetGeoTransform()

# Extract the original resolution
original_xRes = gt[1]
original_yRes = abs(gt[5])

# Define the percentage to resize by (e.g., 0.50 for 50%, 2.0 for 200%)
#defined at the beginning of the script
#percentage = 8.0 # Adjust this as needed

# Calculate the new resolution
new_xRes = original_xRes / percentage
new_yRes = original_yRes / percentage

# Perform the warp (resampling)
gdal.Warp(
output_path,
input_path,
xRes=new_xRes,
yRes=new_yRes,
outputType=gdal.GDT_Byte # Set the output type to uint8
)

print("Step 1: Upsample to. (Sentinel-2_" + country + part + "_Combined-Clean-HD_4326)")

################################################################## Step 2: Smooth all features in original dataset #################################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean-HD_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Smoothed-HD_4326.tiff'

processing.run(
"grass7:r.neighbors",
{
'input':input_path,
'selection':None,
'method':1, #1=median, 3=mode
'size':size,
'gauss':None,
'quantile':'',
'-c':False,
'-a':False,
'weight':'',
'output':output_path,
'GRASS_REGION_CELLSIZE_PARAMETER':0,
'GRASS_RASTER_FORMAT_OPT': 'TYPE=BYTE',
'GRASS_RASTER_FORMAT_META':''
}
)

print("Step 2: Smooth all features in original dataset completed. (Sentinel-2_" + country + part + "_Smoothed-HD_4326)")

################################################################## Step 3: Convert to 8Bit #################################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Smoothed-HD_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Smoothed-HD-Compressed_4326.tiff'

processing.run(
"gdal:translate",
{
'INPUT':input_path,
'TARGET_CRS':None,
'NODATA':0,
'COPY_SUBDATASETS':False,
'OPTIONS':'',
'EXTRA':'',
'DATA_TYPE':1,
'OUTPUT':output_path,
'OPTIONS': 'COMPRESS=LZW'
}
)

result_bit_conversion_layer = QgsRasterLayer(output_path, 'Sentinel-2_' + country + part + '_Smoothed-HD-Compressed_4326')
QgsProject.instance().addMapLayer(result_bit_conversion_layer)

print("Step 3: Convert to Compressed. (Sentinel-2_" + country + part + "_Smoothed-HD-Compressed_4326)")
</syntaxhighlight>

Python script to process Sentinel-2 data

2026-05-15T15:39:38Z

Wlbragg: /* Part 1 */

== Python script to process Sentinel-2 data ==
This is a slightly different process that that of the NLCD. Sentinel-2 data does not have any extra tree canopy coverage to merge in but this script still cuts out some superfluous urban clutter. It uses a two stage workflow. Step 1 cleans up the urban clutter and then splits the larger Sentinel-2 chunks of date to 1x1 tiles to help facilitate Step 2 processing wich up-samples and smoothes the boundaries.

=== Part 1 ===

<syntaxhighlight lang="text">
from qgis.core import (
QgsRasterLayer,
QgsProcessingFeedback,
QgsRectangle
)
from qgis import processing
from osgeo import gdal
import subprocess
import os
import math

os.environ["GDAL_PAM_ENABLED"] = "NO"

# -----------------------------
# USER SETTINGS
# -----------------------------
path = '/mnt/Windows/'
country = 'Alabama'
part = '16R_20250101-20251231'

################################################# IMPORTANT #############################################
# Cuts Sentinel-2 chunks into FlightGear tiles
# Eliminates water only tiles
# Reclassifies Sentenial-2 landcover types to match FlightGear
# Cleans up any urban area road artifacts
# Beginning filename of the NLCD from the source needs to be
# 'nxxxxxxxxxxxxxxxx.tif'
# Also note that "/data/Sentinel-2/" is hardcoded into the path as well
# I needed the existing path structure to process it by state or country.
# Example beginning Sentinel-2 source:
# 16R_20250101-20251231.tif
# Full input path and filename to source example is:
# G:/Scenery/ws3.0/Alabama/data/Sentinel-2/16R_20250101-20251231.tif
# Final output path to processed files is:
# G:/Scenery/ws3.0/Alabama/data/Sentinel-2/tiles_16R_20250101-20251231/N30W086.tif * tile chunk
##########################################################################################################

################################################################### Step 1: Warp land cover 4326 ############################################################

input_raster = path + country + '/data/Sentinel-2/' + part + '.tif'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Land_Cover_4326.tiff'

processing.run(
"gdal:warpreproject",
{
'INPUT':input_raster,
'SOURCE_CRS': QgsCoordinateReferenceSystem('EPSG:5070'),
'TARGET_CRS': QgsCoordinateReferenceSystem('EPSG:4326'),
'RESAMPLING':0,
'NODATA':None,
'TARGET_RESOLUTION':None,
'OPTIONS':'',
'DATA_TYPE':1, # GDAL GDT_Byte
'TARGET_EXTENT':None,
'TARGET_EXTENT_CRS':None,
'MULTITHREADING':False,
'EXTRA':'',
'OUTPUT':output_path
}
)

print("Step 1: Warp land_cover completed. (Sentinel-2_" + country + part + "_Land_Cover_4326)")

############################################################## Step 2: Replace urban and clutter with grass ###################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Land_Cover_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Grass-Only_4326.tiff'

expression = (
'(A == 0) * 44 + '
'(A == 1) * 41 + '
'(A == 2) * 23 + '
'(A == 3) * 44 + '
'(A == 4) * 35 + '
'(A == 5) * 21 + '
'(A == 6) * 44 + '
'(A == 7) * 26 + '
'(A == 8) * 31 + '
'(A == 9) * 34 + '
'(A == 10) * 26 + '
'(A == 11) * 26'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows requires
#subprocess.run(command, shell=True)

print("Step 2: Replace urban and clutter with grass completed. (Sentinel-2_" + country + part + "_Grass-Only_4326)")

################################################################## Step 3: Reclass urban 2 ###########################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Land_Cover_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Reclassed-Urban_4326.tiff'

expression = (
'(A == 7)*2'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows requires
#subprocess.run(command, shell=True)

print("Step 3: Reclass urban completed. (Sentinel-2_" + country + part + "_Reclassed-Urban_4326)")

################################################################ Step 4: Remove clutter and roads from urban ###########################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Reclassed-Urban_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Urban-Only_4326.tiff'

processing.run(
"grass7:r.neighbors",
{
'input':input_path,
'selection':None,
'method':1, #1=median, 2=mode
'size':7,
'gauss':None,
'quantile':'',
'-c':False,
'-a':False,
'weight':'',
'output':output_path,
'GRASS_REGION_PARAMETER':None,
'GRASS_REGION_CELLSIZE_PARAMETER':0,
'GRASS_RASTER_FORMAT_OPT': 'TYPE=BYTE',
'GRASS_RASTER_FORMAT_META':''
}
)

print("Step 4: Remove clutter and roads from urban. (Sentinel-2_" + country + part + "_Urban-Only_4326)")

############################################################## Step 5: Combine grass only and clean urban #########################################################

input_path_a = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Urban-Only_4326.tiff'
input_path_b = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Grass-Only_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean_4326.tiff'

expression = (
'((A > 0) & (B > 0)) * A + '
'((A <= 0) | (B <= 0)) * B'
)
command = [
'gdal_calc.py',
'-A', input_path_a,
'-B', input_path_b,
'--outfile', output_path,
'--calc', expression,
'--NoDataValue', '0',
'--type', 'Byte'
]
subprocess.run(command)
#Windows requires
#subprocess.run(command, shell=True)

print("Step 5: Combined and clean completed. (Sentinel-2_" + country + part + "_Combined-Clean_4326)")

############################################################## Step 6: Cut into tiles #########################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean_4326.tiff'
output_folder = path + country + '/data/Sentinel-2/tiles_' + part + '/'
tile_size_deg = 1.0

os.makedirs(output_folder, exist_ok=True)

rlayer = QgsRasterLayer(input_path, "input")
if not rlayer.isValid():
raise Exception("Raster failed to load: " + input_path)

ext = rlayer.extent()
xmin = ext.xMinimum()
xmax = ext.xMaximum()
ymin = ext.yMinimum()
ymax = ext.yMaximum()

xmin_int = math.floor(xmin)
xmax_int = math.ceil(xmax)
ymin_int = math.floor(ymin)
ymax_int = math.ceil(ymax)

feedback = QgsProcessingFeedback()

for lat in range(ymin_int, ymax_int - 1):
for lon in range(xmin_int, xmax_int - 1):

tile_xmin = lon
tile_xmax = lon + tile_size_deg
tile_ymin = lat
tile_ymax = lat + tile_size_deg

if tile_xmax <= xmin or tile_xmin >= xmax:
continue
if tile_ymax <= ymin or tile_ymin >= ymax:
continue

tile_extent = f"{tile_xmin},{tile_xmax},{tile_ymin},{tile_ymax}"

ns = "N" if (lat + 1) >= 0 else "S"
ew = "E" if lon >= 0 else "W"
out_name = f"{ns}{abs(lat+1):02d}{ew}{abs(lon):03d}.tif"
out_path = os.path.join(output_folder, out_name)

tmp_tile = out_path.replace(".tif", "_tmp.tif")

processing.run(
"gdal:cliprasterbyextent",
{
'INPUT': input_path,
'PROJWIN': tile_extent,
'NODATA': 0,
'OPTIONS': '',
'DATA_TYPE': 0,
'OUTPUT': tmp_tile
},
feedback=feedback
)

if not os.path.exists(tmp_tile) or os.path.getsize(tmp_tile) < 50:
if os.path.exists(tmp_tile):
os.remove(tmp_tile)
print("Skipped (empty tile):", out_name)
continue

ds = gdal.Open(tmp_tile)
band = ds.GetRasterBand(1)
arr = band.ReadAsArray()

# If every pixel is zero → water only
if (arr == 0).all():
os.remove(tmp_tile)
print("Skipped (all water):", out_name)
continue

os.rename(tmp_tile, out_path)
print("Created:", out_path)

print("Tiling complete.")
</syntaxhighlight>

=== Part 2 ===

<syntaxhighlight lang="text">
from qgis.core import QgsApplication, QgsCoordinateTransform, QgsProject, QgsRasterLayer, QgsCoordinateReferenceSystem, QgsProcessingException, QgsRasterBlock, QgsRectangle
from qgis.analysis import QgsRasterCalculator, QgsRasterCalculatorEntry
from qgis import processing
from processing.core.Processing import Processing
from osgeo import gdal, osr, ogr
import os
import numpy
import numpy as np
import subprocess

# Define input layer names, change according to your file names
path = '/mnt/Windows/';
country = 'Alabama';
part = 'N30W086';

#ratio of upscale to smoothing
percentage = 8
size = 11

################################## IMPORTANT ###############################
# Beginning filename of the NLCD from the source needs to be
# 'nxxxxxxxxxxxxxxxx.tif'
# Also note that "/data/Sentinel-2/" is hardcoded into the path as well
# I needed the existing path structure to process it by state or country.
# Example beginning Sentinel-2 source:
# N30W086.tif
# Full input path and filename to source example is:
# G:/Scenery/ws3.0/Alabama/data/Sentinel-2/N30W086.tif
# Final output path to last processed file is:
# G:/Scenery/ws3.0/Alabama/data/Sentinel-2/Sentinel-2_AlabamaN30W086_Smoothed-HD-Compressed_4326.tiff
############################################################################

################################################################## Step 1: Upsample to HD #################################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean-HD_4326.tiff'

# Open the original raster
ds = gdal.Open(input_path)
gt = ds.GetGeoTransform()

# Extract the original resolution
original_xRes = gt[1]
original_yRes = abs(gt[5])

# Define the percentage to resize by (e.g., 0.50 for 50%, 2.0 for 200%)
#defined at the begining of the script
#percentage = 8.0 # Adjust this as needed

# Calculate the new resolution
new_xRes = original_xRes / percentage
new_yRes = original_yRes / percentage

# Perform the warp (resampling)
gdal.Warp(
output_path,
input_path,
xRes=new_xRes,
yRes=new_yRes,
outputType=gdal.GDT_Byte # Set the output type to uint8
)

print("Step 1: Upsample to. (Sentinel-2_" + country + part + "_Combined-Clean-HD_4326)")

################################################################## Step 2: Smooth all features in original dataset #################################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean-HD_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Smoothed-HD_4326.tiff'

processing.run(
"grass7:r.neighbors",
{
'input':input_path,
'selection':None,
'method':1, #1=median, 3=mode
'size':size,
'gauss':None,
'quantile':'',
'-c':False,
'-a':False,
'weight':'',
'output':output_path,
'GRASS_REGION_CELLSIZE_PARAMETER':0,
'GRASS_RASTER_FORMAT_OPT': 'TYPE=BYTE',
'GRASS_RASTER_FORMAT_META':''
}
)

print("Step 2: Smooth all features in original dataset completed. (Sentinel-2_" + country + part + "_Smoothed-HD_4326)")

################################################################## Step 3: Convert to 8Bit #################################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Smoothed-HD_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Smoothed-HD-Compressed_4326.tiff'

processing.run(
"gdal:translate",
{
'INPUT':input_path,
'TARGET_CRS':None,
'NODATA':0,
'COPY_SUBDATASETS':False,
'OPTIONS':'',
'EXTRA':'',
'DATA_TYPE':1,
'OUTPUT':output_path,
'OPTIONS': 'COMPRESS=LZW'
}
)

result_bit_conversion_layer = QgsRasterLayer(output_path, 'Sentinel-2_' + country + part + '_Smoothed-HD-Compressed_4326')
QgsProject.instance().addMapLayer(result_bit_conversion_layer)

print("Step 3: Convert to Compressed. (Sentinel-2_" + country + part + "_Smoothed-HD-Compressed_4326)")
</syntaxhighlight>

Python script to process NLCD for the USA

2026-05-15T15:32:13Z

Wlbragg: /* Optional Python script to process NLCD for the USA */

=== Optional Python script to process NLCD for the USA ===
You can optionally process the NLCD by loading this script in the python console of the QGIS Desktop program.
This python script method produces more refined data than by using the python calculator method above and it is more automated.
If you run this script outside the python console you will need to modify it to locate the data you are processing.
If you save the NLCD tiff's using the same consistent naming convention used in this example it is fairly simple to generate final WS3.0 tiff's to use to generate the scenery.

NOTE: the current genVPB.py script (osgdem) will not generate the final scenery water/land edge to this high of a resolution. It is set to a default tile size of 256x256, "--tile-image-size 256". This resolution is much higher than that. To achieve the same base resolution in the built scenery, osgdem needs a switch to "--tile-image-size 1024" to realize the higher resolution. However, when you apply the water mask flags --generate-water-raster --shrink-water 4 --coastline [path_to_coastal_shapefiles] using genVPB.py the cut mask will achieve the higher resolution.

You will start with an original tree layer and a land cover layer from the MRLC.gov site. See the section "Obtaining NLCD" in the above "Step By Step Procedure for Processing NLCD for the USA using the Raster Calculator" topic.

For example, to start with you will have a couple files named...

NLCD_2021_Tree_Canopy_Alaska141-140_60.tiff

NLCD_2021_Land_Cover_Alaska141-140_60.tiff

In the QGIS program the layer names you start with will be...

NLCD_2021_Tree_Canopy_Alaska141-140_60

NLCD_2021_Land_Cover_Alaska141-140_60

which will refer to the tiff files.

Running this script will generate a bunch of intermediate files including the last file, that will be the final finished file for running in the VPB script or VPB build environment Docker image.

The last file for this example for Alaska would be, NLCD_2021_Alaska141-140_60_Smoothed-HD-Compressed_4326.tiff

<syntaxhighlight lang="python">
from qgis.core import QgsApplication, QgsCoordinateTransform, QgsProject, QgsRasterLayer, QgsCoordinateReferenceSystem, QgsProcessingException, QgsRasterBlock, QgsRectangle
from qgis.analysis import QgsRasterCalculator, QgsRasterCalculatorEntry
from qgis import processing
from processing.core.Processing import Processing
from osgeo import gdal, osr, ogr
import os
import numpy
import numpy as np
import subprocess

# Define input layer names, change according to your file names
path = 'G:/Scenery/ws3.0/';
year = '2021';
state = 'Alaska';
part = '141-140_60';

# Ratio of upsampling to smoothing
percentage = 8
size = 11

################################## IMPORTANT ###############################
# Beginning filename of the NLCD from the source needs to be
# NLCD_' + year + '_Tree_Canopy_' + state + part + '.tiff'
# Also note that "/data/" is hardcoded into the path as well
# I needed the existing path structure to process it by state.
# For Alaska I used one lat and a few lon sections per chunck built.
# I will likely do the entire NLCD coverage area the same in future runs.
# Example beginning NLCD source:
# NLCD_2021_Tree_Canopy_Alaska141-140_60.tiff
# NLCD_2021_Land_Cover_Alaska141-140_60.tiff
# Full path and filename to source example is:
# G:/Scenery/ws3.0/Alaska/data/source/NLCD_2021_Tree_Canopy_Alaska141-140_60.tiff
# G:/Scenery/ws3.0/Alaska/data/source/NLCD_2021_Land_Cover_Alaska141-140_60.tiff
# Final output path to last processed file is:
# G:/Scenery/ws3.0/Alaska/data/NLCD_2021_Alaska141-140_60_Smoothed-HD-Compressed_4326
############################################################################

##################### Step 1: Reclass tree canopy to one landcover type 41, 42, or 43 #####################
#FG NLCD
#23 DeciduousBroadCover 41
#24 EvergreenForest 42
#25 MixedForest 43

# Define input and output paths
input_path = path + state + '/data/source/NLCD_' + year + '_Tree_Canopy_' + state + part + '.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Trees-Combined.tiff'

expression = (
'((A > 0) & (A < 255)) * 43 + '
'(A <= 0) * A'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows OS uses
#subprocess.run(command, shell=True)

print("Step 1: Calculate result_tree_canopy completed. (NLCD_" + year + "_" + state + part + "_Trees-Combined)")

##################### Step 2: Warp tree canopy to 4326 #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Trees-Combined.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Tree_Canopy_4326.tiff'

processing.run(
"gdal:warpreproject",
{
'INPUT':input_path,
'SOURCE_CRS':None,
'TARGET_CRS':QgsCoordinateReferenceSystem('EPSG:4326'),
'RESAMPLING':0,
'NODATA':None,
'TARGET_RESOLUTION':None,
'OPTIONS':'',
'DATA_TYPE':1, # GDAL GDT_Byte
'TARGET_EXTENT':None,
'TARGET_EXTENT_CRS':None,
'MULTITHREADING':False,
'EXTRA':'',
'OUTPUT':output_path
}
)

print("Step 2: Warp tree_canopy completed. (NLCD_" + year + "_" + state + part + "_Tree_Canopy_4326)")

##################### Step 3: Warp land cover 4326 #####################

input_path = path + state + '/data/source/NLCD_' + year + '_Land_Cover_' + state + part + '.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Land_Cover_4326.tiff'

processing.run(
"gdal:warpreproject",
{
'INPUT':input_path,
'SOURCE_CRS':None,
'TARGET_CRS':QgsCoordinateReferenceSystem('EPSG:4326'),
'RESAMPLING':0,
'NODATA':None,
'TARGET_RESOLUTION':None,
'OPTIONS':'',
'DATA_TYPE':1, # GDAL GDT_Byte
'TARGET_EXTENT':None,
'TARGET_EXTENT_CRS':None,
'MULTITHREADING':False,
'EXTRA':'',
'OUTPUT':output_path
}
)

print("Step 3: Warp land_cover completed. (NLCD_" + year + "_" + state + part + "_Land_Cover_4326)")

##################### Step 4: Combine land cover 4326 and tree canopy 4326 #####################

input_path_a = path + state + '/data/NLCD_' + year + '_' + state + part + '_Tree_Canopy_4326.tiff'
input_path_b = path + state + '/data/NLCD_' + year + '_' + state + part + '_Land_Cover_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Tree_Land_Combined_4326.tiff'

expression = (
'(((B > 0) & (B < 255)) & (B != 41) & (B != 42) & (B != 43) & (A > 0)) * A + '
'((B == 41) | (B == 42) | (B == 43) | (A <= 0)) * B'
)
command = [
'gdal_calc.py',
'-A', input_path_a,
'-B', input_path_b,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows OS uses
#subprocess.run(command, shell=True)

print("Step 4: Combine tree canopy and land cover completed. (NLCD_" + year + "_" + state + part + "_Tree_Land_Combined_4326)")

##################### Step 5: Replace urban and clutter with grass #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Tree_Land_Combined_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Grass-Only_4326.tiff'

expression = (
'(A == 0) * 44 + '
'(A == 11) * 41 + '
'(A == 12) * 34 + '
'(A == 21) * 26 + '
'(A == 22) * 26 + '
'(A == 23) * 26 + '
'(A == 24) * 26 + '
'(A == 31) * 27 + '
'(A == 41) * 23 + '
'(A == 42) * 24 + '
'(A == 43) * 25 + '
'(A == 51) * 30 + '
'(A == 52) * 29 + '
'(A == 71) * 26 + '
'(A == 72) * 32 + '
'(A == 73) * 31 + '
'(A == 74) * 31 + '
'(A == 75) * 32 + '
'(A == 81) * 18 + '
'(A == 82) * 19 + '
'(A == 90) * 25 + '
'(A == 95) * 35'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows OS uses
#subprocess.run(command, shell=True)

print("Step 5: Replace urban and clutter with grass completed. (NLCD_" + year + "_" + state + part + "_Grass-Only_4326)")

##################### Step 6: Reclass urban 21, 22, 23 or 24 #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Tree_Land_Combined_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Reclassed-Urban_4326.tiff'

expression = (
'(A == 21)*10 + '
'(A == 22)*1 + '
'(A == 23)*1 + '
'(A == 24)*2'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows OS uses
#subprocess.run(command, shell=True)

print("Step 6: Reclass urban completed. (NLCD_" + year + "_" + state + part + "_Reclassed-Urban_4326)")

##################### Step 7: Remove clutter and roads from urban #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Reclassed-Urban_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Urban-Only_4326.tiff'

processing.run(
"grass7:r.neighbors",
{
'input':input_path,
'selection':None,
'method':1, #1=median, 2=mode
'size':7,
'gauss':None,
'quantile':'',
'-c':False,
'-a':False,
'weight':'',
'output':output_path,
'GRASS_REGION_PARAMETER':None,
'GRASS_REGION_CELLSIZE_PARAMETER':0,
'GRASS_RASTER_FORMAT_OPT': 'TYPE=BYTE',
'GRASS_RASTER_FORMAT_META':''
}
)

print("Step 7: Remove clutter and roads from urban. (NLCD_" + year + "_" + state + part + "_Urban-Only_4326)")

##################### Step 8: Combine grass only and clean urban #####################

input_path_a = path + state + '/data/NLCD_' + year + '_' + state + part + '_Urban-Only_4326.tiff'
input_path_b = path + state + '/data/NLCD_' + year + '_' + state + part + '_Grass-Only_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Combined-Clean_4326.tiff'

expression = (
'((A > 0) & (B > 0)) * A + '
'((A <= 0) | (B <= 0)) * B'
)
command = [
'gdal_calc.py',
'-A', input_path_a,
'-B', input_path_b,
'--outfile', output_path,
'--calc', expression,
'--NoDataValue', '0',
'--type', 'Byte'
]
subprocess.run(command)
#Windows OS uses
#subprocess.run(command, shell=True)

print("Step 8: Combined and clean completed. (NLCD_" + year + "_" + state + part + "_Combined-Clean_4326)")

##################### Step 9: Upsample to HD #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Combined-Clean_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Combined-Clean-HD_4326.tiff'

# Open the original raster
ds = gdal.Open(input_path)
gt = ds.GetGeoTransform()

# Extract the original resolution
original_xRes = gt[1]
original_yRes = abs(gt[5])

# Define the percentage to resize by (e.g., 0.50 for 50%, 2.0 for 200%)
#defined at the beginning of the script
#percentage = 8.0

# Calculate the new resolution
new_xRes = original_xRes / percentage
new_yRes = original_yRes / percentage

# Perform the warp (resampling)
gdal.Warp(
output_path,
input_path,
xRes=new_xRes,
yRes=new_yRes,
outputType=gdal.GDT_Byte # Set the output type to uint8
)

print("Step 9: Upsample to. (NLCD_" + year + "_" + state + part + "_Combined-Clean-HD_4326)")

##################### Step 10: Smooth all features in original dataset #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Combined-Clean-HD_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Smoothed-HD_4326.tiff'

processing.run(
"grass7:r.neighbors",
{
'input':input_path,
'selection':None,
'method':3, #1=median, 3=mode
'size':size,
'gauss':None,
'quantile':'',
'-c':False,
'-a':False,
'weight':'',
'output':output_path,
'GRASS_REGION_CELLSIZE_PARAMETER':0,
'GRASS_RASTER_FORMAT_OPT': 'TYPE=BYTE',
'GRASS_RASTER_FORMAT_META':''
}
)

print("Step 10: Smooth all features in original dataset completed. (NLCD_" + year + "_" + state + part + "_Smoothed-HD_4326)")

##################### Step 11: Compress and insure 8Bit #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Smoothed-HD_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Smoothed-HD-Compressed_4326.tiff'

processing.run(
"gdal:translate",
{
'INPUT':input_path,
'TARGET_CRS':None,
'NODATA':0,
'COPY_SUBDATASETS':False,
'OPTIONS':'',
'EXTRA':'',
'DATA_TYPE':1,
'OUTPUT':output_path,
'OPTIONS': 'COMPRESS=LZW'
}
)

result_bit_conversion_layer = QgsRasterLayer(output_path, 'NLCD_' + year + '_' + state + part + '_Smoothed-HD-Compressed_4326')
QgsProject.instance().addMapLayer(result_bit_conversion_layer)

print("Step 11: Convert to Compressed. (NLCD_" + year + "_" + state + part + "_Smoothed-HD-Compressed_4326)")

</syntaxhighlight>

Howto:Create WS3.0 terrain

2026-05-06T15:27:30Z

Wlbragg: /* Python_script_to_process_Sentinel-2_data */

{{WS30 Navbar}}
This article provides instructions on how to generate basic WS3.0 terrain.

WS3.0 terrain consists of three parts:

# A terrain mesh consisting of a landclass texture draped over an elevation model.
# A high resolution water raster used to show water features such as rivers, lakes and coastline with more definition
# Line features such as roads and railways.

The terrain is generated by a set of tools that are packaged in a docker image for convenience.[[File:Diagram-export-21-12-2023-16 29 37.png|thumb|Basic WS3.0 Scenery Generation Process]]

== Prerequisites ==

=== Set up a Workspace ===
Create a directory with the following sub-directories:

* <code>cache</code>
* <code>data</code>
* <code>output/vpb</code>
* <code>output/Terrain</code>

=== Docker ===

# Install [https://docs.docker.com/get-started/ Docker] on your platform.
#Pull the docker image by running the following command

docker pull flightgear/ws30-vpb-generator:latest
Optionally, if you are hitting rate limits:
#Create an account on https://hub.docker.com/. (Note that you will need to click on an email verification link before you can log in for the first time)
#Run <code>docker login</code> before the '''docker pull''' command above

== Getting the base data ==
You need two pieces of data for the area of scenery you are generating:

# An elevation model (aka DEM). This indicates what altitude each point of the surface is.
# Landclass data showing what type of terrain is at each point of the surface. This is often either a Raster (effectively a texture), or vector data.

=== Elevation Model ===
Download the NASADEM elevation model for the area of scenery you wish to generate. This is available in 1x1 degree blocks from [https://lpdaac.usgs.gov/products/nasadem_hgtv001/ here], and with an interactive browser [https://search.earthdata.nasa.gov/search here].

Unzip the files into the <code>data</code> directory.

=== Landclass Raster ===
Download an landclass raster for the area of scenery you wish to generate.

* For Europe, use of [https://land.copernicus.eu/pan-european/corine-land-cover/clc2018 CORINE] is recommended.
* For the USA [https://www.mrlc.gov/viewer/ NLCD] is recommended
* Sentinel-2 data is available for the entire world via [https://livingatlas.arcgis.com/landcoverexplorer/ ESRI], but has limited set of landclasses.

Put these into the <code>data</code> directory.

More detailed terrain can be created by modifying the landclass raster, and/or generating a new raster from vector data. These processes are discussed below.

== Generating Terrain ==
To generate terrain you need to run the tools within the docker container we installed above. The docker image is like a small, independent virtual computing environment running within your system. This particular docker image has all the scenery generation tools already installed.

=== Running the docker container ===
Firstly, get the container running from the directory containing your <code>cache</code>, <code>data</code> and <code>output</code> directories:
docker run --rm --mount "type=bind,source=`pwd`/data,target=/home/flightgear/data,readonly" --mount "type=bind,source=`pwd`/output,target=/home/flightgear/output" --mount "type=bind,source=`pwd`/cache,target=/home/flightgear/cache" -it flightgear/ws30-vpb-generator:latest /bin/bash

You should now find yourself in a bash shell within your container. You should see data and output directories which are linked to the directories you created earlier:
flightgear@ddcac77f7d5e:~$ ls
cache data output bin scripts

=== Building the terrain ===
To build the terrain mesh, use the <code>genVPB.py</code> tool from inside the docker container:

Usage: genVPB.py --raster <input-raster> [ option ... ]
Usage: genVPB.py --bbox <lat0> <lon0> <lat1> <lon1> --sentinel --reclass <reclass> [ option ... ]

Arguments:
--raster RASTER Input landclass raster.
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--sentinel Use Sentinel2 landclass tiles
--sentinel-dir SENTINEL_DIR Directory for Sentinel Data. Default /home/flightgear/data/Sentinel-2
--hgt-dir HGT_DIR Directory containing HGT DEM files. Default /home/flightgear/data/NASADEM
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/output
--download-sentinel Download Sentinel2 tiles if needed
--reclass RECLASS Reclassify raster using file <reclass>. See ./scripts/mappings/
--coastline COASTLINE Clip against coastline against polygon (.osm)
--shrink-water SHRINK_WATER Shrink water bodies (landclasses 40, 41) by <pixels> pixels
--generate-water-raster Generate a water raster from OSM data
--generate-line-features Generate a water raster from OSM data
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--nasadem-server NASADEM_SERVER Set server to download NASADEM data from. Default https://e4ftl01.cr.usgs.gov/MEASURES/NASADEM_HGT.001/2000.02.11/)
--nasadem-user NASADEM_USER NASA Earthdata username.
--nasadem-password NASADEM_PASSWORD NASA Earthdata password.
--debug Debug output

For example, to generate a piece of terrain around Edinburgh (latitude 55.5, longitude 3 degrees West):
./scripts/genVPB.py --bbox 55 -4 56 -3 --raster ./data/uk_wgs84_10m_N54.tif

If you are using anything other than a CORINE raster you will need to reclassify the data to match the landclasses used by FlightGear. Those classes are defined in [https://gitlab.com/flightgear/fgdata/-/tree/next/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml]. You can reclassify them using the files in the [https://gitlab.com/flightgear/fgmeta/-/tree/next/ws30/mappings/ scripts/mappings] directory. E.g. to reclassify NLCD2019 data you can use <code>--reclassify ./scripts/mappings/nlcd2019.txt</code>.

genVPB.py will output the data to the output/vpb directory, in which you should find a series of files and directories.

=== Adding water ===
The terrain mesh does not have highly detailed water features - as typically the source data has a resolution of 10-25m. Water features are generated from OpenStreetMap data. To generate water features simply run the <code>genwaterraster.py</code> command.

Usage: genwaterraster.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--output-dir OUTPUT_DIR] [--cache-dir CACHE_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--output-dir OUTPUT_DIR Directory to write files into. Default /home/flightgear/output
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache

For example, to generate water for the area around Edinburgh:
./scripts/genwaterraster.py --bbox 55 -4 56 -3

Inside the ./output/vpb directory there should be a set of directories and .png files.

=== Adding roads and railways ===
The terrain mesh does not have any line features - things like roads. These are generated separately from OpenStreetMap data. To generate line features simply run the <code>genroads.py</code> command:

Usage: ./scripts/genroads.py [-h] --bbox lat0 lon0 lat1 lon1 [--debug] [--threads THREADS] [--cache-dir CACHE_DIR] [--output-dir OUTPUT_DIR]

Arguments:
--bbox lat0 lon0 lat1 lon1 Bounding box of scenery to be generated
--debug Debug output
--threads THREADS Number of parallel threads to run. Defaults to 1
--cache-dir CACHE_DIR Directory for OSM data cache. Default /home/flightgear/cache/
--output-dir OUTPUT_DIR Set output directory. Default /home/flightgear/cache/

For example, to generate roads for the area around Edinburgh:
./scripts/genroads.py --bbox 55 -4 56 -3

Inside the ./output/Terrain directory there should be a set of directories and, .STG files text files.

==Running FlightGear with the new WS3.0 Terrain==
To test the new terrain, simply include the output directory in your scenery path and run FlightGear with the <code>--prop:/scenery/use-vpb=true</code> to enable WS3.0.

== Advanced Techniques ==
The following sections describe more complex techniques to generate higher quality WS3.0 terrain. Almost all of them involve using different data sources to generate a more detailed landclass raster before running the final scenery generation processes described above. Generating a highly detailed landclass raster is where the magic happens.

Most techniques use gdal or grass to modify the raster/vector data, typically using the QGIS program.

=== Using a different elevation model ===
If you are using another elevation model other than NASAEM, then you may need to re-project it using QGIS/gdalwarp to the WGS84 CRS (aka EPSG:4326).

=== Landclass Data Requirements ===
For any landclass data we need to ensure the data is in the correct format. That means:

# Is a Raster (geotiff) rather than Vector data. This raster will become the texture on the terrain that the terrain shaders do their magic on.
# Uses the WGS84 Coordinate Reference System. The ensures that the terrain generation step is efficient.
# Has the correct landclass values for each terrain type. We use a set of values based on the CORINE raster set, defined in [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml].

Below is a quick table showing what steps you need to take for common landclass data sources.
{| class="wikitable"
|+
!Landclass Data
!Warp to WGS84 required?
!Landclass re-classification Required?
!Raster Simplification Required?
!Conversion to Raster Required?
|-
|CORINE Raster
|Yes
|No
|No
|No
|-
|CORINE Vector
|Yes
|Yes
|No
|Yes
|-
|NLCD
|No
|Yes
|Yes
|No
|-
|Sentinel-2
|Yes
|Yes
|No
|No
|}
Conversion to Raster must be done manually. Converting to WGS84 and the correct landclasses ''can'' be done by the genVPB.py script, but slows down scenery generation. Therefore if you are planning to generate scenery multiple times it is best to pre-process the files yourself.

The easiest way to do these operations is using QGIS, which is available for most platforms. If you are scripting a toolchain, the QGIS tools include command-line equivalents for all commands.

When using QGIS, set the Project CRS to WGS84 (aka EPSG:4326). You can then add layers of Raster or Vector data from files from the <code>Layer->Add Layer</code> menu. When performing any operations, <u>always</u> write out the data to a real file so you can go back to it later. Disk space is cheap :).

=== Warping Raster Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a raster layer to a different CRS using the Raster->Projections-Warp (Reproject) tool.

Select the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Resampling Method to Use - Nearest Neighbour. (Landclass data is not like normal images. You don't want to interpolate between values.)
* Nodata value for output bands - 0.0 (This means that any data at the edges will be Ocean, usually a reasonable default)
* Advanced Parameters - No Compression
* Output data type - Byte
* Reprojected - Choose a target filename

Alternatively you can do this step from the commandline.
gdalwarp -t_srs EPSG:4326 -dstnodata 0.0 -r near -ot Byte -of GTiff -co COMPRESS=NONE -co BIGTIFF=IF_NEEDED /home/stuart/FlightGear/VPB/data/CORINE/u2018_clc2018_v2020_20u1_raster100m/DATA/U2018_CLC2018_V2020_20u1.tif /home/stuart/FlightGear/VPB/data/scratch/corine_WGS84.tif

=== Warping Vector Layers to WGS84 ===
genVPB.py will automatically convert to WGS84 if it detects a landclass raster with a different Coordinate System. However, you may wish to do so manually instead so all your data is on the same coordinate system.

In QGIS you can warp a vector layer using Vector->Data Management Tools->Reproject Layer.

Set the following options in the dialog:

* Input Layer - Check you have selected the correct layer. The CRS is shown at the right.
* Target CRS - set to <code>EPSG:4326 - WGS84</code>, which should be your project CRS.
* Reprojected - Choose a target filename

=== Reclassifying Vector Layers ===
For CORINE vector data in particular, the attributes used in the vector data are not the same as those used by the CORINE Raster data. So we need to create a new attribute on the data.
[[File:Field Calculator.png|thumb|QGIS Field Calculator]]
To do this

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialog
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type "Whole Number (Integer)". This will create a new column which we will populate with the correct landclass data
* Click on the <code>Open Field Calculator</code> button (Ctrl + I). (If you get an error about only being able to create Virtual fields, go back to the Layer menu, export it and open the exported file).
* Select the following options:
** Update Existing Field
** Select the Landclass field you just created.
** Copy the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/corine_vector.txt into the Expression box (without the comment lines starting with <code>#</code>). This is just some simple code to set the attribute correctly. The code should be correct for CORINE vector data. If your data is from other sources you will need to work out how you want to map your source data landclasses to the CORINE ones. [https://sourceforge.net/p/flightgear/fgdata/ci/next/tree/Materials/base/landclass-mapping.xml Materials/base/landclass-mapping.xml] can be used as a guide.
* Select <code>OK</code>. You should see that your landclass column is now populated with the landclass data.
* Select <code>Layer->Save Layer Edits</code> to save you changes

=== Creating a Raster from a Vector Layer ===
To create a Raster from a Vector Layer select <code>Raster->Conversion->Rasterize (Vector to Raster)</code>.
[[File:QGIS Rasterize (Vector to Raster).png|thumb|Creating a Raster from a Vector Layer - QGIS Rasterize]]
Select the following options:

* Input Layer - correct layer, check CRS
* Field to use for burn-in value - select the <code>Landclass</code> column you created above.
* Output raster size units. This is going to set the resolution of your raster. You can work out the resolution in two different ways:
** Select "Georeferenced units" and determine how many degrees each pixel is in latitude and longitude.
** Select "Pixels" and determine the size of raster you want in pixels. [https://www.nhc.noaa.gov/gccalc.shtml This] is a good calculator to help. You input e.g. SE and SW coordinates and calculate to get the distance in Km. Then you multiply by thousand and devide by the number of metres per pixel (e.g. 5) -> resolution for width.
* Width/Horizontal Resolution. Enter the values you've calculated for the horizontal resolution (longitudinal), or the width of the raster
* Height/Vertical Resolution. Enter the values you've calculated for the vertical resolution (latitude or the height of the raster)
* Output extent - Select an option from the box on the right. You can edit the text afterwards (NB: East, West, South, North). Best practise is to create long thin strips of 1 degree latitude in height, as this makes subsequent processing much easier.
* Assign a specific nodata value to output bands - Select 0.0 for Ocean. CORINE vector data in particular has a lot of nodata for Oceans
* Advanced Parameters - No Compression
* Output data type - Byte
* Rasterized - Select a new filename

=== Simplifying a Raster Layer ===
Some Raster Landclass data (NLCD included) has too much noise - in particular large US highway systems are identified as Urban areas.

To smooth it out we can use the GRASS <code>n.neighbors</code> function from the Processing Toolbox in QGIS.

Select the following options:

* Input Layer - correct layer, check CRS
* Neighborhood operation - median. (This is not a normal image, so using an average will result in weird values)
* Neighborhood size - 5.
* Neighbors - Select a new filename.

=== Clipping a Raster Layer with OSM Data for Land (Corine) ===
The Corine dataset does not match OSM coastlines exactly. The following multi-stage process makes sure, that no Corine land-use is in the water as defined by OSM.

==== Download OSM Land Data ====

Download land polygons based on OSM data as a Shapefile from [https://osmdata.openstreetmap.de/data/land-polygons.html Land Polygons] and make sure to pick the WGS84 projected download with split polygons ("Large polygons are split, use for larger scales"). Once downloaded unzip the content into a directory.

==== Reclassifying the OSM Land Data Vector Layer ====
I QGIS make sure that only the layer for the raster for land data is selected (e.g. <code>land-polygons-split-4326</code>) -> in the map view you will see the whole earth. NB: typically you do this reclassify only once after download and can reuse the result for future processing.

Then:

* Select <code>Layer->Open Attribute Table</code>. You should see a table with multiple columns. Each row represents a feature in the data.
* Click on <code>Toggle Editing Mode</code> (Ctrl + E), on the top left of the dialogue
* Click on <code>New Field</code> (Ctrl+W) and create a new field called Landclass of type <code>Integer (32 bit)</code>. This will create a new column which we will populate with the correct land class data
* On top of the table on the left side choose "Landclass" in the drop-down menu, then input <code>2</code> into the field to the right and then press button "Update" all to the left of this field.
* Wait a bit and the close the dialogue.
* Select <code>Layer->Save Layer Edits</code> to save your changes (overwrite e.g. <code>land-polygons-split-4326</code>).

==== Convert the Land Data from Vector to Raster ====
Do the same as in chapter "Creating a Raster from a Vector Layer" above. The only difference is that the Input layer will be the land data polygons and you need to choose a different file name for the "Rasterized" (e.g. osm_land_scotland_5m.tif)

==== Remove Novalue Entries in the Land Data Raster ====
To do this:

* Select <code>Processing->Toolbox</code>. You should see a new box on the right side.
* Write "gdal_calc" in the search box and you should see an entry "Raster calculator". Double click on it and you will get a new dialogue window.
* In this dialogue:
** For "Input layer A" choose the raster from the previous chapter ((e.g. osm_land_scotland_5m.tif)
** In field "Calculation in gdalnumeric ..." write: <code>greater(A,0) * A</code>
** In field "Output raster type" choose <code>Byte</code>
** In field "Advanced Parameters" choose Profile <code>No compression</code>
** In field "Additional command-line parameters" write: <code>--hideNoData</code>
** In field "Calculated" choose a file (e.g. osm_land_scotland_allvalues_5m.tif)
** (In the "GDAL/OGR console call" it will have something similar to the follwing - just with different paths: <code>gdal_calc.py --overwrite --calc "greater(A ,0) * A" --format GTiff --type Byte -A /home/vanosten/custom-fg-scenery/data/osm_land_scotland_5m.tif --A_band 1 --co COMPRESS=NONE --co BIGTIFF=IF_NEEDED --hideNoData --outfile /home/vanosten/custom-fg-scenery/data/osm_land_scotland_allvalues_5m.tif</code>
** Press the "Run" button - and when complete close the dialogue.

You should now see a map only black and white. You can check for correctness by pressing <code>CTRL+SHIFT+I</code> to get a cursor with an arrow and an "i". First make sure the new raster is selected on the left side. Next click on the sea/ocean and then check in the "Identify Results" window on the right that the value is < 2. The click on the land and check that the value is 2.

==== Create the Final Clipped Corine Raster Against OSM Land Data =====
Do the following:

* In QGIS make sure that you have only the following two layers: the basis Corine raster (see chapter "Creating a Raster from a Vector Layer" - here e.g. corine_raster_scotland_5m.tif) and plus the raster from the previous step (e.g. osm_land_scotland_allvalues_5m.tif)
* Select <code>Raster->Raster Calculator ...</code> and a corresponding dialogue will open showing on the left hand side the two rasters.
* Choose a new "Output layer" (e.g. corine_raster_scotland_clipped_5m.tif).
* In the "Raster Calculator Expression" field input: <code>if ("osm_land_scotland_all_data_5m@1" < 2, 44, "corine_raster_scotland_5m@1")</code>
* Press button "OK" and wait a while (you will see a new dialogue with showing the progress.

Done. You have now a raster (e.g. corine_raster_scotland_clipped_5m.tif) which does not have land in areas, where OSM data has sea/ocean.

=== Reclassifying a Raster Layer ===
WS3.0 uses CORINE landclass values. If using data from other sources it needs to be reclassified to the correct values. genVPB.py has an option to do this, but you may wish to do so manually.

To do this select <code>GRASS->Raster->r.reclass</code> from the Processing Toolbox.

Select the following options:

* Input Raster Layer - correct layer, check CRS
* Reclass rules text - copy in the contents of https://sourceforge.net/p/flightgear/fgmeta/ci/next/tree/ws30/mappings/nlcd2019.txt. Or an appropriate mapping from your landclass data to CORINE. Note that you can also reference a file using the "File containing reclass rules" option. Note a mapping of 22 24 = 1 is the same as 22 and 24 = 1. For a range of 22 to 24 use 22 23 24 = 1.
* Reclassified - Select a new filename.

(If this doesn't work a similar function is available in the Processing Toolbox under <code>Raster analysis->Reclassify by table</code>. However this doesn't save your table once you close the dialog, and entries have to be manually entered individually which takes a lot of effort)

=== Processing NLCD for USA using the Raster Calculator and tools in QGIS ===

[[Processing_NLCD_for_USA_using_Raster_Calculator_and_tools_in_QGIS]]

=== Python script to process NLCD for the USA ===

[[Python_script_to_process_NLCD_for_the_USA]]

=== Python script to process Sentinel-2 data ===

[[Python_script_to_process_Sentinel-2_data]]

===Generating the Terrain using osgdem===
Instead of using genVPB.py, you may wish to run osgdem directly.

In the Windows/Docker platform you can send the generate tile command directly to osgdem.exe, one tile at a time.

Using the NLCD raster processing convention from above, following is the the final step after creating the raster and entering bash shell with the windows version of "docker run..."

osgdem --TERRAIN --image-ext png --RGBA --no-interpolate-imagery --disable-error-diffusion --geocentric --no-mip-mapping -t ./data/California-Southern_4326-84-hd-corrected.tiff -d ./SRTM-3/N32W115.hgt -b -115 32 -114 33 --PagedLOD -l 7 --radius-to-max-visible-distance-ratio 3 -o ./output/vpb/w120n30/w115n32/ws_w115n32.osgb

Note: the --image-ext png --RGBA flags are critical to successfully building correctly placed landclasses in the final VPB generated scenery.

If you prefer to run the scenery generation manually, running the VPB osgdem process is described in more detail here: [[Virtual Planet Builder#Running VPB]].

After doing this you should have an output directory containing files of the form <code>output/vpb/w010n50/w004n50/ws_w004n50.osgb</code>, plus a host of sub-directories. Each one of these is a 1x1 tile of terrain.

to leave the container simply type <code>exit</code>.

===Packaging the Scenery===
Once you have the terrain and line features they should be packaged in a scenery directory in vpb and Terrain sub-directories respectively. E.g.
MyCoolScenery/Terrain
MyCoolScenery/vpb
It is good practise to document the data sources used in scenery generation. Some source licenses require attribution of the original data source for anything derived, published or distributed.

To assist in fulfilling these license obligations, you can create a source.xml file in the scenery directory which includes attribution information. This will then be available from within the simulator under Help->Scenery Sources, and <u>may</u> fulfil the attribution requirements of your license. '''Note that you are responsible for fulfilling any license requirements from the data, not FlightGear'''.

The format of the file is straightforward:
<?xml version="1.0"?>
<PropertyList>
<nowiki><source></nowiki>
<name>Corine Land Cover (CLC) 2018, Version 2020_20u1</name>
<nowiki><link></nowiki><nowiki>http://web.archive.org/web/20221112175615/https://land.copernicus.eu/pan-european/corine-land-cover/clc2018?tab=metadata%2A</nowiki><nowiki></link></nowiki>
<license>GMES Open License</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>NASADEM Merged DEM Global 1 arc second V001</name>
<nowiki><link></nowiki><nowiki>https://www.earthdata.nasa.gov/</nowiki><nowiki></link></nowiki>
<license>Public Domain</license>
<nowiki></source></nowiki>
<nowiki><source></nowiki>
<name>OpenStreetMap</name>
<nowiki><link></nowiki><nowiki>https://www.openstreetmap.org/copyright</nowiki><nowiki></link></nowiki>
<license>Open Data Commons Open Database License</license>
<nowiki></source></nowiki>
</PropertyList>

Python script to process Sentinel-2 data

2026-05-02T04:34:33Z

Wlbragg: /* Part 2 */

== Python script to process Sentinel-2 data ==
=== Part 1 ===

<syntaxhighlight lang="text">
from qgis.core import (
QgsRasterLayer,
QgsProcessingFeedback,
QgsRectangle
)
from qgis import processing
from osgeo import gdal
import subprocess
import os
import math

os.environ["GDAL_PAM_ENABLED"] = "NO"

# -----------------------------
# USER SETTINGS
# -----------------------------
path = '/mnt/Windows/'
country = 'Alabama'
part = '16R_20250101-20251231'

################################################# IMPORTANT #############################################
# Cuts Sentinel-2 chunks into FlightGear tiles
# Eliminates water only tiles
# Reclassifies Sentenial-2 landcover types to match FlightGear
# Cleans up any urban area road artifacts
# Beginning filename of the NLCD from the source needs to be
# 'nxxxxxxxxxxxxxxxx.tif'
# Also note that "/data/Sentinel-2/" is hardcoded into the path as well
# I needed the existing path structure to process it by state or country.
# Example beginning Sentinel-2 source:
# 16R_20250101-20251231.tif
# Full input path and filename to source example is:
# G:/Scenery/ws3.0/Alabama/data/Sentinel-2/16R_20250101-20251231.tif
# Final output path to processed files is:
# G:/Scenery/ws3.0/Alabama/data/Sentinel-2/tiles_16R_20250101-20251231/N30W086.tif * tile chunk
##########################################################################################################

################################################################### Step 1: Warp land cover 4326 ############################################################

input_raster = path + country + '/data/Sentinel-2/' + part + '.tif'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Land_Cover_4326.tiff'

processing.run(
"gdal:warpreproject",
{
'INPUT':input_raster,
'SOURCE_CRS': QgsCoordinateReferenceSystem('EPSG:5070'),
'TARGET_CRS': QgsCoordinateReferenceSystem('EPSG:4326'),
'RESAMPLING':0,
'NODATA':None,
'TARGET_RESOLUTION':None,
'OPTIONS':'',
'DATA_TYPE':1, # GDAL GDT_Byte
'TARGET_EXTENT':None,
'TARGET_EXTENT_CRS':None,
'MULTITHREADING':False,
'EXTRA':'',
'OUTPUT':output_path
}
)

print("Step 1: Warp land_cover completed. (Sentinel-2_" + country + part + "_Land_Cover_4326)")

############################################################## Step 2: Replace urban and clutter with grass ###################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Land_Cover_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Grass-Only_4326.tiff'

expression = (
'(A == 0) * 44 + '
'(A == 1) * 41 + '
'(A == 2) * 23 + '
'(A == 3) * 44 + '
'(A == 4) * 35 + '
'(A == 5) * 21 + '
'(A == 6) * 44 + '
'(A == 7) * 26 + '
'(A == 8) * 31 + '
'(A == 9) * 34 + '
'(A == 10) * 26 + '
'(A == 11) * 26'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows requires
#subprocess.run(command, shell=True)

print("Step 2: Replace urban and clutter with grass completed. (Sentinel-2_" + country + part + "_Grass-Only_4326)")

################################################################## Step 3: Reclass urban 2 ###########################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Land_Cover_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Reclassed-Urban_4326.tiff'

expression = (
'(A == 7)*2'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows requires
#subprocess.run(command, shell=True)

print("Step 3: Reclass urban completed. (Sentinel-2_" + country + part + "_Reclassed-Urban_4326)")

################################################################ Step 4: Remove clutter and roads from urban ###########################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Reclassed-Urban_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Urban-Only_4326.tiff'

processing.run(
"grass7:r.neighbors",
{
'input':input_path,
'selection':None,
'method':1, #1=median, 2=mode
'size':7,
'gauss':None,
'quantile':'',
'-c':False,
'-a':False,
'weight':'',
'output':output_path,
'GRASS_REGION_PARAMETER':None,
'GRASS_REGION_CELLSIZE_PARAMETER':0,
'GRASS_RASTER_FORMAT_OPT': 'TYPE=BYTE',
'GRASS_RASTER_FORMAT_META':''
}
)

print("Step 4: Remove clutter and roads from urban. (Sentinel-2_" + country + part + "_Urban-Only_4326)")

############################################################## Step 5: Combine grass only and clean urban #########################################################

input_path_a = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Urban-Only_4326.tiff'
input_path_b = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Grass-Only_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean_4326.tiff'

expression = (
'((A > 0) & (B > 0)) * A + '
'((A <= 0) | (B <= 0)) * B'
)
command = [
'gdal_calc.py',
'-A', input_path_a,
'-B', input_path_b,
'--outfile', output_path,
'--calc', expression,
'--NoDataValue', '0',
'--type', 'Byte'
]
subprocess.run(command)
#Windows requires
#subprocess.run(command, shell=True)

print("Step 5: Combined and clean completed. (Sentinel-2_" + country + part + "_Combined-Clean_4326)")

############################################################## Step 6: Cut into tiles #########################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean_4326.tiff'
output_folder = path + country + '/data/Sentinel-2/tiles_' + part + '/'
tile_size_deg = 1.0

os.makedirs(output_folder, exist_ok=True)

rlayer = QgsRasterLayer(input_path, "input")
if not rlayer.isValid():
raise Exception("Raster failed to load: " + input_path)

ext = rlayer.extent()
xmin = ext.xMinimum()
xmax = ext.xMaximum()
ymin = ext.yMinimum()
ymax = ext.yMaximum()

xmin_int = math.floor(xmin)
xmax_int = math.ceil(xmax)
ymin_int = math.floor(ymin)
ymax_int = math.ceil(ymax)

feedback = QgsProcessingFeedback()

for lat in range(ymin_int, ymax_int - 1):
for lon in range(xmin_int, xmax_int - 1):

tile_xmin = lon
tile_xmax = lon + tile_size_deg
tile_ymin = lat
tile_ymax = lat + tile_size_deg

if tile_xmax <= xmin or tile_xmin >= xmax:
continue
if tile_ymax <= ymin or tile_ymin >= ymax:
continue

tile_extent = f"{tile_xmin},{tile_xmax},{tile_ymin},{tile_ymax}"

ns = "N" if (lat + 1) >= 0 else "S"
ew = "E" if lon >= 0 else "W"
out_name = f"{ns}{abs(lat+1):02d}{ew}{abs(lon):03d}.tif"
out_path = os.path.join(output_folder, out_name)

tmp_tile = out_path.replace(".tif", "_tmp.tif")

processing.run(
"gdal:cliprasterbyextent",
{
'INPUT': input_path,
'PROJWIN': tile_extent,
'NODATA': 0,
'OPTIONS': '',
'DATA_TYPE': 0,
'OUTPUT': tmp_tile
},
feedback=feedback
)

if not os.path.exists(tmp_tile) or os.path.getsize(tmp_tile) < 50:
if os.path.exists(tmp_tile):
os.remove(tmp_tile)
print("Skipped (empty tile):", out_name)
continue

ds = gdal.Open(tmp_tile)
band = ds.GetRasterBand(1)
arr = band.ReadAsArray()

# If every pixel is zero → water only
if (arr == 0).all():
os.remove(tmp_tile)
print("Skipped (all water):", out_name)
continue

os.rename(tmp_tile, out_path)
print("Created:", out_path)

print("Tiling complete.")
</syntaxhighlight>

=== Part 2 ===

<syntaxhighlight lang="text">
from qgis.core import QgsApplication, QgsCoordinateTransform, QgsProject, QgsRasterLayer, QgsCoordinateReferenceSystem, QgsProcessingException, QgsRasterBlock, QgsRectangle
from qgis.analysis import QgsRasterCalculator, QgsRasterCalculatorEntry
from qgis import processing
from processing.core.Processing import Processing
from osgeo import gdal, osr, ogr
import os
import numpy
import numpy as np
import subprocess

# Define input layer names, change according to your file names
path = '/mnt/Windows/';
country = 'Alabama';
part = 'N30W086';

#ratio of upscale to smoothing
percentage = 8
size = 11

################################## IMPORTANT ###############################
# Beginning filename of the NLCD from the source needs to be
# 'nxxxxxxxxxxxxxxxx.tif'
# Also note that "/data/Sentinel-2/" is hardcoded into the path as well
# I needed the existing path structure to process it by state or country.
# Example beginning Sentinel-2 source:
# N30W086.tif
# Full input path and filename to source example is:
# G:/Scenery/ws3.0/Alabama/data/Sentinel-2/N30W086.tif
# Final output path to last processed file is:
# G:/Scenery/ws3.0/Alabama/data/Sentinel-2/Sentinel-2_AlabamaN30W086_Smoothed-HD-Compressed_4326.tiff
############################################################################

################################################################## Step 1: Upsample to HD #################################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean-HD_4326.tiff'

# Open the original raster
ds = gdal.Open(input_path)
gt = ds.GetGeoTransform()

# Extract the original resolution
original_xRes = gt[1]
original_yRes = abs(gt[5])

# Define the percentage to resize by (e.g., 0.50 for 50%, 2.0 for 200%)
#defined at the begining of the script
#percentage = 8.0 # Adjust this as needed

# Calculate the new resolution
new_xRes = original_xRes / percentage
new_yRes = original_yRes / percentage

# Perform the warp (resampling)
gdal.Warp(
output_path,
input_path,
xRes=new_xRes,
yRes=new_yRes,
outputType=gdal.GDT_Byte # Set the output type to uint8
)

print("Step 1: Upsample to. (Sentinel-2_" + country + part + "_Combined-Clean-HD_4326)")

################################################################## Step 2: Smooth all features in original dataset #################################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean-HD_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Smoothed-HD_4326.tiff'

processing.run(
"grass7:r.neighbors",
{
'input':input_path,
'selection':None,
'method':1, #1=median, 3=mode
'size':size,
'gauss':None,
'quantile':'',
'-c':False,
'-a':False,
'weight':'',
'output':output_path,
'GRASS_REGION_CELLSIZE_PARAMETER':0,
'GRASS_RASTER_FORMAT_OPT': 'TYPE=BYTE',
'GRASS_RASTER_FORMAT_META':''
}
)

print("Step 2: Smooth all features in original dataset completed. (Sentinel-2_" + country + part + "_Smoothed-HD_4326)")

################################################################## Step 3: Convert to 8Bit #################################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Smoothed-HD_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Smoothed-HD-Compressed_4326.tiff'

processing.run(
"gdal:translate",
{
'INPUT':input_path,
'TARGET_CRS':None,
'NODATA':0,
'COPY_SUBDATASETS':False,
'OPTIONS':'',
'EXTRA':'',
'DATA_TYPE':1,
'OUTPUT':output_path,
'OPTIONS': 'COMPRESS=LZW'
}
)

result_bit_conversion_layer = QgsRasterLayer(output_path, 'Sentinel-2_' + country + part + '_Smoothed-HD-Compressed_4326')
QgsProject.instance().addMapLayer(result_bit_conversion_layer)

print("Step 3: Convert to Compressed. (Sentinel-2_" + country + part + "_Smoothed-HD-Compressed_4326)")
</syntaxhighlight>

Python script to process Sentinel-2 data

2026-04-30T21:06:36Z

Wlbragg: /* Part 2 */

== Python script to process Sentinel-2 data ==
=== Part 1 ===

<syntaxhighlight lang="text">
from qgis.core import (
QgsRasterLayer,
QgsProcessingFeedback,
QgsRectangle
)
from qgis import processing
from osgeo import gdal
import subprocess
import os
import math

os.environ["GDAL_PAM_ENABLED"] = "NO"

# -----------------------------
# USER SETTINGS
# -----------------------------
path = '/mnt/Windows/'
country = 'Alabama'
part = '16R_20250101-20251231'

################################################# IMPORTANT #############################################
# Cuts Sentinel-2 chunks into FlightGear tiles
# Eliminates water only tiles
# Reclassifies Sentenial-2 landcover types to match FlightGear
# Cleans up any urban area road artifacts
# Beginning filename of the NLCD from the source needs to be
# 'nxxxxxxxxxxxxxxxx.tif'
# Also note that "/data/Sentinel-2/" is hardcoded into the path as well
# I needed the existing path structure to process it by state or country.
# Example beginning Sentinel-2 source:
# 16R_20250101-20251231.tif
# Full input path and filename to source example is:
# G:/Scenery/ws3.0/Alabama/data/Sentinel-2/16R_20250101-20251231.tif
# Final output path to processed files is:
# G:/Scenery/ws3.0/Alabama/data/Sentinel-2/tiles_16R_20250101-20251231/N30W086.tif * tile chunk
##########################################################################################################

################################################################### Step 1: Warp land cover 4326 ############################################################

input_raster = path + country + '/data/Sentinel-2/' + part + '.tif'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Land_Cover_4326.tiff'

processing.run(
"gdal:warpreproject",
{
'INPUT':input_raster,
'SOURCE_CRS': QgsCoordinateReferenceSystem('EPSG:5070'),
'TARGET_CRS': QgsCoordinateReferenceSystem('EPSG:4326'),
'RESAMPLING':0,
'NODATA':None,
'TARGET_RESOLUTION':None,
'OPTIONS':'',
'DATA_TYPE':1, # GDAL GDT_Byte
'TARGET_EXTENT':None,
'TARGET_EXTENT_CRS':None,
'MULTITHREADING':False,
'EXTRA':'',
'OUTPUT':output_path
}
)

print("Step 1: Warp land_cover completed. (Sentinel-2_" + country + part + "_Land_Cover_4326)")

############################################################## Step 2: Replace urban and clutter with grass ###################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Land_Cover_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Grass-Only_4326.tiff'

expression = (
'(A == 0) * 44 + '
'(A == 1) * 41 + '
'(A == 2) * 23 + '
'(A == 3) * 44 + '
'(A == 4) * 35 + '
'(A == 5) * 21 + '
'(A == 6) * 44 + '
'(A == 7) * 26 + '
'(A == 8) * 31 + '
'(A == 9) * 34 + '
'(A == 10) * 26 + '
'(A == 11) * 26'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows requires
#subprocess.run(command, shell=True)

print("Step 2: Replace urban and clutter with grass completed. (Sentinel-2_" + country + part + "_Grass-Only_4326)")

################################################################## Step 3: Reclass urban 2 ###########################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Land_Cover_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Reclassed-Urban_4326.tiff'

expression = (
'(A == 7)*2'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows requires
#subprocess.run(command, shell=True)

print("Step 3: Reclass urban completed. (Sentinel-2_" + country + part + "_Reclassed-Urban_4326)")

################################################################ Step 4: Remove clutter and roads from urban ###########################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Reclassed-Urban_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Urban-Only_4326.tiff'

processing.run(
"grass7:r.neighbors",
{
'input':input_path,
'selection':None,
'method':1, #1=median, 2=mode
'size':7,
'gauss':None,
'quantile':'',
'-c':False,
'-a':False,
'weight':'',
'output':output_path,
'GRASS_REGION_PARAMETER':None,
'GRASS_REGION_CELLSIZE_PARAMETER':0,
'GRASS_RASTER_FORMAT_OPT': 'TYPE=BYTE',
'GRASS_RASTER_FORMAT_META':''
}
)

print("Step 4: Remove clutter and roads from urban. (Sentinel-2_" + country + part + "_Urban-Only_4326)")

############################################################## Step 5: Combine grass only and clean urban #########################################################

input_path_a = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Urban-Only_4326.tiff'
input_path_b = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Grass-Only_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean_4326.tiff'

expression = (
'((A > 0) & (B > 0)) * A + '
'((A <= 0) | (B <= 0)) * B'
)
command = [
'gdal_calc.py',
'-A', input_path_a,
'-B', input_path_b,
'--outfile', output_path,
'--calc', expression,
'--NoDataValue', '0',
'--type', 'Byte'
]
subprocess.run(command)
#Windows requires
#subprocess.run(command, shell=True)

print("Step 5: Combined and clean completed. (Sentinel-2_" + country + part + "_Combined-Clean_4326)")

############################################################## Step 6: Cut into tiles #########################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean_4326.tiff'
output_folder = path + country + '/data/Sentinel-2/tiles_' + part + '/'
tile_size_deg = 1.0

os.makedirs(output_folder, exist_ok=True)

rlayer = QgsRasterLayer(input_path, "input")
if not rlayer.isValid():
raise Exception("Raster failed to load: " + input_path)

ext = rlayer.extent()
xmin = ext.xMinimum()
xmax = ext.xMaximum()
ymin = ext.yMinimum()
ymax = ext.yMaximum()

xmin_int = math.floor(xmin)
xmax_int = math.ceil(xmax)
ymin_int = math.floor(ymin)
ymax_int = math.ceil(ymax)

feedback = QgsProcessingFeedback()

for lat in range(ymin_int, ymax_int - 1):
for lon in range(xmin_int, xmax_int - 1):

tile_xmin = lon
tile_xmax = lon + tile_size_deg
tile_ymin = lat
tile_ymax = lat + tile_size_deg

if tile_xmax <= xmin or tile_xmin >= xmax:
continue
if tile_ymax <= ymin or tile_ymin >= ymax:
continue

tile_extent = f"{tile_xmin},{tile_xmax},{tile_ymin},{tile_ymax}"

ns = "N" if (lat + 1) >= 0 else "S"
ew = "E" if lon >= 0 else "W"
out_name = f"{ns}{abs(lat+1):02d}{ew}{abs(lon):03d}.tif"
out_path = os.path.join(output_folder, out_name)

tmp_tile = out_path.replace(".tif", "_tmp.tif")

processing.run(
"gdal:cliprasterbyextent",
{
'INPUT': input_path,
'PROJWIN': tile_extent,
'NODATA': 0,
'OPTIONS': '',
'DATA_TYPE': 0,
'OUTPUT': tmp_tile
},
feedback=feedback
)

if not os.path.exists(tmp_tile) or os.path.getsize(tmp_tile) < 50:
if os.path.exists(tmp_tile):
os.remove(tmp_tile)
print("Skipped (empty tile):", out_name)
continue

ds = gdal.Open(tmp_tile)
band = ds.GetRasterBand(1)
arr = band.ReadAsArray()

# If every pixel is zero → water only
if (arr == 0).all():
os.remove(tmp_tile)
print("Skipped (all water):", out_name)
continue

os.rename(tmp_tile, out_path)
print("Created:", out_path)

print("Tiling complete.")
</syntaxhighlight>

=== Part 2 ===

<syntaxhighlight lang="text">
from qgis.core import QgsApplication, QgsCoordinateTransform, QgsProject, QgsRasterLayer, QgsCoordinateReferenceSystem, QgsProcessingException, QgsRasterBlock, QgsRectangle
from qgis.analysis import QgsRasterCalculator, QgsRasterCalculatorEntry
from qgis import processing
from processing.core.Processing import Processing
from osgeo import gdal, osr, ogr
import os
import numpy
import numpy as np
import subprocess

# Define input layer names, change according to your file names
path = '/mnt/Windows/';
country = 'Alabama';
part = 'N30W086';

#ratio of upscale to smoothing
percentage = 3
size = 11

################################## IMPORTANT ###############################
# Beginning filename of the NLCD from the source needs to be
# 'nxxxxxxxxxxxxxxxx.tif'
# Also note that "/data/Sentinel-2/" is hardcoded into the path as well
# I needed the existing path structure to process it by state or country.
# Example beginning Sentinel-2 source:
# N30W086.tif
# Full input path and filename to source example is:
# G:/Scenery/ws3.0/Alabama/data/Sentinel-2/N30W086.tif
# Final output path to last processed file is:
# G:/Scenery/ws3.0/Alabama/data/Sentinel-2/Sentinel-2_AlabamaN30W086_Smoothed-HD-Compressed_4326.tiff
############################################################################

################################################################## Step 1: Upsample to HD #################################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean-HD_4326.tiff'

# Open the original raster
ds = gdal.Open(input_path)
gt = ds.GetGeoTransform()

# Extract the original resolution
original_xRes = gt[1]
original_yRes = abs(gt[5])

# Define the percentage to resize by (e.g., 0.50 for 50%, 2.0 for 200%)
#defined at the begining of the script
#percentage = 8.0 # Adjust this as needed

# Calculate the new resolution
new_xRes = original_xRes / percentage
new_yRes = original_yRes / percentage

# Perform the warp (resampling)
gdal.Warp(
output_path,
input_path,
xRes=new_xRes,
yRes=new_yRes,
outputType=gdal.GDT_Byte # Set the output type to uint8
)

print("Step 1: Upsample to. (Sentinel-2_" + country + part + "_Combined-Clean-HD_4326)")

################################################################## Step 2: Smooth all features in original dataset #################################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean-HD_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Smoothed-HD_4326.tiff'

processing.run(
"grass7:r.neighbors",
{
'input':input_path,
'selection':None,
'method':1, #1=median, 3=mode
'size':size,
'gauss':None,
'quantile':'',
'-c':False,
'-a':False,
'weight':'',
'output':output_path,
'GRASS_REGION_CELLSIZE_PARAMETER':0,
'GRASS_RASTER_FORMAT_OPT': 'TYPE=BYTE',
'GRASS_RASTER_FORMAT_META':''
}
)

print("Step 2: Smooth all features in original dataset completed. (Sentinel-2_" + country + part + "_Smoothed-HD_4326)")

################################################################## Step 3: Convert to 8Bit #################################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Smoothed-HD_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Smoothed-HD-Compressed_4326.tiff'

processing.run(
"gdal:translate",
{
'INPUT':input_path,
'TARGET_CRS':None,
'NODATA':0,
'COPY_SUBDATASETS':False,
'OPTIONS':'',
'EXTRA':'',
'DATA_TYPE':1,
'OUTPUT':output_path,
'OPTIONS': 'COMPRESS=LZW'
}
)

result_bit_conversion_layer = QgsRasterLayer(output_path, 'Sentinel-2_' + country + part + '_Smoothed-HD-Compressed_4326')
QgsProject.instance().addMapLayer(result_bit_conversion_layer)

print("Step 3: Convert to Compressed. (Sentinel-2_" + country + part + "_Smoothed-HD-Compressed_4326)")
</syntaxhighlight>

Python script to process Sentinel-2 data

2026-04-30T19:33:30Z

Wlbragg: /* Part 2 */

== Python script to process Sentinel-2 data ==
=== Part 1 ===

<syntaxhighlight lang="text">
from qgis.core import (
QgsRasterLayer,
QgsProcessingFeedback,
QgsRectangle
)
from qgis import processing
from osgeo import gdal
import subprocess
import os
import math

os.environ["GDAL_PAM_ENABLED"] = "NO"

# -----------------------------
# USER SETTINGS
# -----------------------------
path = '/mnt/Windows/'
country = 'Alabama'
part = '16R_20250101-20251231'

################################################# IMPORTANT #############################################
# Cuts Sentinel-2 chunks into FlightGear tiles
# Eliminates water only tiles
# Reclassifies Sentenial-2 landcover types to match FlightGear
# Cleans up any urban area road artifacts
# Beginning filename of the NLCD from the source needs to be
# 'nxxxxxxxxxxxxxxxx.tif'
# Also note that "/data/Sentinel-2/" is hardcoded into the path as well
# I needed the existing path structure to process it by state or country.
# Example beginning Sentinel-2 source:
# 16R_20250101-20251231.tif
# Full input path and filename to source example is:
# G:/Scenery/ws3.0/Alabama/data/Sentinel-2/16R_20250101-20251231.tif
# Final output path to processed files is:
# G:/Scenery/ws3.0/Alabama/data/Sentinel-2/tiles_16R_20250101-20251231/N30W086.tif * tile chunk
##########################################################################################################

################################################################### Step 1: Warp land cover 4326 ############################################################

input_raster = path + country + '/data/Sentinel-2/' + part + '.tif'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Land_Cover_4326.tiff'

processing.run(
"gdal:warpreproject",
{
'INPUT':input_raster,
'SOURCE_CRS': QgsCoordinateReferenceSystem('EPSG:5070'),
'TARGET_CRS': QgsCoordinateReferenceSystem('EPSG:4326'),
'RESAMPLING':0,
'NODATA':None,
'TARGET_RESOLUTION':None,
'OPTIONS':'',
'DATA_TYPE':1, # GDAL GDT_Byte
'TARGET_EXTENT':None,
'TARGET_EXTENT_CRS':None,
'MULTITHREADING':False,
'EXTRA':'',
'OUTPUT':output_path
}
)

print("Step 1: Warp land_cover completed. (Sentinel-2_" + country + part + "_Land_Cover_4326)")

############################################################## Step 2: Replace urban and clutter with grass ###################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Land_Cover_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Grass-Only_4326.tiff'

expression = (
'(A == 0) * 44 + '
'(A == 1) * 41 + '
'(A == 2) * 23 + '
'(A == 3) * 44 + '
'(A == 4) * 35 + '
'(A == 5) * 21 + '
'(A == 6) * 44 + '
'(A == 7) * 26 + '
'(A == 8) * 31 + '
'(A == 9) * 34 + '
'(A == 10) * 26 + '
'(A == 11) * 26'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows requires
#subprocess.run(command, shell=True)

print("Step 2: Replace urban and clutter with grass completed. (Sentinel-2_" + country + part + "_Grass-Only_4326)")

################################################################## Step 3: Reclass urban 2 ###########################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Land_Cover_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Reclassed-Urban_4326.tiff'

expression = (
'(A == 7)*2'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows requires
#subprocess.run(command, shell=True)

print("Step 3: Reclass urban completed. (Sentinel-2_" + country + part + "_Reclassed-Urban_4326)")

################################################################ Step 4: Remove clutter and roads from urban ###########################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Reclassed-Urban_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Urban-Only_4326.tiff'

processing.run(
"grass7:r.neighbors",
{
'input':input_path,
'selection':None,
'method':1, #1=median, 2=mode
'size':7,
'gauss':None,
'quantile':'',
'-c':False,
'-a':False,
'weight':'',
'output':output_path,
'GRASS_REGION_PARAMETER':None,
'GRASS_REGION_CELLSIZE_PARAMETER':0,
'GRASS_RASTER_FORMAT_OPT': 'TYPE=BYTE',
'GRASS_RASTER_FORMAT_META':''
}
)

print("Step 4: Remove clutter and roads from urban. (Sentinel-2_" + country + part + "_Urban-Only_4326)")

############################################################## Step 5: Combine grass only and clean urban #########################################################

input_path_a = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Urban-Only_4326.tiff'
input_path_b = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Grass-Only_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean_4326.tiff'

expression = (
'((A > 0) & (B > 0)) * A + '
'((A <= 0) | (B <= 0)) * B'
)
command = [
'gdal_calc.py',
'-A', input_path_a,
'-B', input_path_b,
'--outfile', output_path,
'--calc', expression,
'--NoDataValue', '0',
'--type', 'Byte'
]
subprocess.run(command)
#Windows requires
#subprocess.run(command, shell=True)

print("Step 5: Combined and clean completed. (Sentinel-2_" + country + part + "_Combined-Clean_4326)")

############################################################## Step 6: Cut into tiles #########################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean_4326.tiff'
output_folder = path + country + '/data/Sentinel-2/tiles_' + part + '/'
tile_size_deg = 1.0

os.makedirs(output_folder, exist_ok=True)

rlayer = QgsRasterLayer(input_path, "input")
if not rlayer.isValid():
raise Exception("Raster failed to load: " + input_path)

ext = rlayer.extent()
xmin = ext.xMinimum()
xmax = ext.xMaximum()
ymin = ext.yMinimum()
ymax = ext.yMaximum()

xmin_int = math.floor(xmin)
xmax_int = math.ceil(xmax)
ymin_int = math.floor(ymin)
ymax_int = math.ceil(ymax)

feedback = QgsProcessingFeedback()

for lat in range(ymin_int, ymax_int - 1):
for lon in range(xmin_int, xmax_int - 1):

tile_xmin = lon
tile_xmax = lon + tile_size_deg
tile_ymin = lat
tile_ymax = lat + tile_size_deg

if tile_xmax <= xmin or tile_xmin >= xmax:
continue
if tile_ymax <= ymin or tile_ymin >= ymax:
continue

tile_extent = f"{tile_xmin},{tile_xmax},{tile_ymin},{tile_ymax}"

ns = "N" if (lat + 1) >= 0 else "S"
ew = "E" if lon >= 0 else "W"
out_name = f"{ns}{abs(lat+1):02d}{ew}{abs(lon):03d}.tif"
out_path = os.path.join(output_folder, out_name)

tmp_tile = out_path.replace(".tif", "_tmp.tif")

processing.run(
"gdal:cliprasterbyextent",
{
'INPUT': input_path,
'PROJWIN': tile_extent,
'NODATA': 0,
'OPTIONS': '',
'DATA_TYPE': 0,
'OUTPUT': tmp_tile
},
feedback=feedback
)

if not os.path.exists(tmp_tile) or os.path.getsize(tmp_tile) < 50:
if os.path.exists(tmp_tile):
os.remove(tmp_tile)
print("Skipped (empty tile):", out_name)
continue

ds = gdal.Open(tmp_tile)
band = ds.GetRasterBand(1)
arr = band.ReadAsArray()

# If every pixel is zero → water only
if (arr == 0).all():
os.remove(tmp_tile)
print("Skipped (all water):", out_name)
continue

os.rename(tmp_tile, out_path)
print("Created:", out_path)

print("Tiling complete.")
</syntaxhighlight>

=== Part 2 ===

<syntaxhighlight lang="text">
from qgis.core import QgsApplication, QgsCoordinateTransform, QgsProject, QgsRasterLayer, QgsCoordinateReferenceSystem, QgsProcessingException, QgsRasterBlock, QgsRectangle
from qgis.analysis import QgsRasterCalculator, QgsRasterCalculatorEntry
from qgis import processing
from processing.core.Processing import Processing
from osgeo import gdal, osr, ogr
import os
import numpy
import numpy as np
import subprocess

# Define input layer names, change according to your file names
path = '/mnt/Windows/';
country = 'Alabama';
part = 'N30W086';

#ratio of upscale to smoothing
percentage = 3
size = 11

################################## IMPORTANT ###############################
# Beginning filename of the NLCD from the source needs to be
# 'nxxxxxxxxxxxxxxxx.tif'
# Also note that "/data/Sentinel-2/" is hardcoded into the path as well
# I needed the existing path structure to process it by state or country.
# Example beginning Sentinel-2 source:
# N30W086.tif
# Full input path and filename to source example is:
# G:/Scenery/ws3.0/Alabama/data/Sentinel-2/N30W086.tif
# Final output path to last processed file is:
# G:/Scenery/ws3.0/Alabama/data/Sentinel-2/Sentinel-2_AlabamaN30W086_Smoothed-HD-Compressed_4326.tiff
############################################################################

################################################################## Step 1: Upsample to HD #################################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean-HD_4326.tiff'

# Open the original raster
ds = gdal.Open(input_path)
gt = ds.GetGeoTransform()

# Extract the original resolution
original_xRes = gt[1]
original_yRes = abs(gt[5])

# Define the percentage to resize by (e.g., 0.50 for 50%, 2.0 for 200%)
#defined at the begining of the script
#percentage = 8.0 # Adjust this as needed

# Calculate the new resolution
new_xRes = original_xRes / percentage
new_yRes = original_yRes / percentage

# Perform the warp (resampling)
gdal.Warp(
output_path,
input_path,
xRes=new_xRes,
yRes=new_yRes,
outputType=gdal.GDT_Byte # Set the output type to uint8
)

print("Step 1: Upsample to. (Sentinel-2_" + country + part + "_Combined-Clean-HD_4326)")

################################################################## Step 2: Smooth all features in original dataset #################################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean-HD_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Smoothed-HD_4326.tiff'

processing.run(
"grass7:r.neighbors",
{
'input':input_path,
'selection':None,
'method':3, #1=median, 3=mode
'size':size,
'gauss':None,
'quantile':'',
'-c':False,
'-a':False,
'weight':'',
'output':output_path,
'GRASS_REGION_CELLSIZE_PARAMETER':0,
'GRASS_RASTER_FORMAT_OPT': 'TYPE=BYTE',
'GRASS_RASTER_FORMAT_META':''
}
)

print("Step 2: Smooth all features in original dataset completed. (Sentinel-2_" + country + part + "_Smoothed-HD_4326)")

################################################################## Step 3: Convert to 8Bit #################################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Smoothed-HD_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Smoothed-HD-Compressed_4326.tiff'

processing.run(
"gdal:translate",
{
'INPUT':input_path,
'TARGET_CRS':None,
'NODATA':0,
'COPY_SUBDATASETS':False,
'OPTIONS':'',
'EXTRA':'',
'DATA_TYPE':1,
'OUTPUT':output_path,
'OPTIONS': 'COMPRESS=LZW'
}
)

result_bit_conversion_layer = QgsRasterLayer(output_path, 'Sentinel-2_' + country + part + '_Smoothed-HD-Compressed_4326')
QgsProject.instance().addMapLayer(result_bit_conversion_layer)

print("Step 3: Convert to Compressed. (Sentinel-2_" + country + part + "_Smoothed-HD-Compressed_4326)")
</syntaxhighlight>

Python script to process Sentinel-2 data

2026-04-30T19:33:13Z

Wlbragg: /* Part 1 */

== Python script to process Sentinel-2 data ==
=== Part 1 ===

<syntaxhighlight lang="text">
from qgis.core import (
QgsRasterLayer,
QgsProcessingFeedback,
QgsRectangle
)
from qgis import processing
from osgeo import gdal
import subprocess
import os
import math

os.environ["GDAL_PAM_ENABLED"] = "NO"

# -----------------------------
# USER SETTINGS
# -----------------------------
path = '/mnt/Windows/'
country = 'Alabama'
part = '16R_20250101-20251231'

################################################# IMPORTANT #############################################
# Cuts Sentinel-2 chunks into FlightGear tiles
# Eliminates water only tiles
# Reclassifies Sentenial-2 landcover types to match FlightGear
# Cleans up any urban area road artifacts
# Beginning filename of the NLCD from the source needs to be
# 'nxxxxxxxxxxxxxxxx.tif'
# Also note that "/data/Sentinel-2/" is hardcoded into the path as well
# I needed the existing path structure to process it by state or country.
# Example beginning Sentinel-2 source:
# 16R_20250101-20251231.tif
# Full input path and filename to source example is:
# G:/Scenery/ws3.0/Alabama/data/Sentinel-2/16R_20250101-20251231.tif
# Final output path to processed files is:
# G:/Scenery/ws3.0/Alabama/data/Sentinel-2/tiles_16R_20250101-20251231/N30W086.tif * tile chunk
##########################################################################################################

################################################################### Step 1: Warp land cover 4326 ############################################################

input_raster = path + country + '/data/Sentinel-2/' + part + '.tif'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Land_Cover_4326.tiff'

processing.run(
"gdal:warpreproject",
{
'INPUT':input_raster,
'SOURCE_CRS': QgsCoordinateReferenceSystem('EPSG:5070'),
'TARGET_CRS': QgsCoordinateReferenceSystem('EPSG:4326'),
'RESAMPLING':0,
'NODATA':None,
'TARGET_RESOLUTION':None,
'OPTIONS':'',
'DATA_TYPE':1, # GDAL GDT_Byte
'TARGET_EXTENT':None,
'TARGET_EXTENT_CRS':None,
'MULTITHREADING':False,
'EXTRA':'',
'OUTPUT':output_path
}
)

print("Step 1: Warp land_cover completed. (Sentinel-2_" + country + part + "_Land_Cover_4326)")

############################################################## Step 2: Replace urban and clutter with grass ###################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Land_Cover_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Grass-Only_4326.tiff'

expression = (
'(A == 0) * 44 + '
'(A == 1) * 41 + '
'(A == 2) * 23 + '
'(A == 3) * 44 + '
'(A == 4) * 35 + '
'(A == 5) * 21 + '
'(A == 6) * 44 + '
'(A == 7) * 26 + '
'(A == 8) * 31 + '
'(A == 9) * 34 + '
'(A == 10) * 26 + '
'(A == 11) * 26'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows requires
#subprocess.run(command, shell=True)

print("Step 2: Replace urban and clutter with grass completed. (Sentinel-2_" + country + part + "_Grass-Only_4326)")

################################################################## Step 3: Reclass urban 2 ###########################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Land_Cover_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Reclassed-Urban_4326.tiff'

expression = (
'(A == 7)*2'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows requires
#subprocess.run(command, shell=True)

print("Step 3: Reclass urban completed. (Sentinel-2_" + country + part + "_Reclassed-Urban_4326)")

################################################################ Step 4: Remove clutter and roads from urban ###########################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Reclassed-Urban_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Urban-Only_4326.tiff'

processing.run(
"grass7:r.neighbors",
{
'input':input_path,
'selection':None,
'method':1, #1=median, 2=mode
'size':7,
'gauss':None,
'quantile':'',
'-c':False,
'-a':False,
'weight':'',
'output':output_path,
'GRASS_REGION_PARAMETER':None,
'GRASS_REGION_CELLSIZE_PARAMETER':0,
'GRASS_RASTER_FORMAT_OPT': 'TYPE=BYTE',
'GRASS_RASTER_FORMAT_META':''
}
)

print("Step 4: Remove clutter and roads from urban. (Sentinel-2_" + country + part + "_Urban-Only_4326)")

############################################################## Step 5: Combine grass only and clean urban #########################################################

input_path_a = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Urban-Only_4326.tiff'
input_path_b = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Grass-Only_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean_4326.tiff'

expression = (
'((A > 0) & (B > 0)) * A + '
'((A <= 0) | (B <= 0)) * B'
)
command = [
'gdal_calc.py',
'-A', input_path_a,
'-B', input_path_b,
'--outfile', output_path,
'--calc', expression,
'--NoDataValue', '0',
'--type', 'Byte'
]
subprocess.run(command)
#Windows requires
#subprocess.run(command, shell=True)

print("Step 5: Combined and clean completed. (Sentinel-2_" + country + part + "_Combined-Clean_4326)")

############################################################## Step 6: Cut into tiles #########################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean_4326.tiff'
output_folder = path + country + '/data/Sentinel-2/tiles_' + part + '/'
tile_size_deg = 1.0

os.makedirs(output_folder, exist_ok=True)

rlayer = QgsRasterLayer(input_path, "input")
if not rlayer.isValid():
raise Exception("Raster failed to load: " + input_path)

ext = rlayer.extent()
xmin = ext.xMinimum()
xmax = ext.xMaximum()
ymin = ext.yMinimum()
ymax = ext.yMaximum()

xmin_int = math.floor(xmin)
xmax_int = math.ceil(xmax)
ymin_int = math.floor(ymin)
ymax_int = math.ceil(ymax)

feedback = QgsProcessingFeedback()

for lat in range(ymin_int, ymax_int - 1):
for lon in range(xmin_int, xmax_int - 1):

tile_xmin = lon
tile_xmax = lon + tile_size_deg
tile_ymin = lat
tile_ymax = lat + tile_size_deg

if tile_xmax <= xmin or tile_xmin >= xmax:
continue
if tile_ymax <= ymin or tile_ymin >= ymax:
continue

tile_extent = f"{tile_xmin},{tile_xmax},{tile_ymin},{tile_ymax}"

ns = "N" if (lat + 1) >= 0 else "S"
ew = "E" if lon >= 0 else "W"
out_name = f"{ns}{abs(lat+1):02d}{ew}{abs(lon):03d}.tif"
out_path = os.path.join(output_folder, out_name)

tmp_tile = out_path.replace(".tif", "_tmp.tif")

processing.run(
"gdal:cliprasterbyextent",
{
'INPUT': input_path,
'PROJWIN': tile_extent,
'NODATA': 0,
'OPTIONS': '',
'DATA_TYPE': 0,
'OUTPUT': tmp_tile
},
feedback=feedback
)

if not os.path.exists(tmp_tile) or os.path.getsize(tmp_tile) < 50:
if os.path.exists(tmp_tile):
os.remove(tmp_tile)
print("Skipped (empty tile):", out_name)
continue

ds = gdal.Open(tmp_tile)
band = ds.GetRasterBand(1)
arr = band.ReadAsArray()

# If every pixel is zero → water only
if (arr == 0).all():
os.remove(tmp_tile)
print("Skipped (all water):", out_name)
continue

os.rename(tmp_tile, out_path)
print("Created:", out_path)

print("Tiling complete.")
</syntaxhighlight>

=== Part 2 ===

<syntaxhighlight lang="text">
from qgis.core import QgsApplication, QgsCoordinateTransform, QgsProject, QgsRasterLayer, QgsCoordinateReferenceSystem, QgsProcessingException, QgsRasterBlock, QgsRectangle
from qgis.analysis import QgsRasterCalculator, QgsRasterCalculatorEntry
from qgis import processing
from processing.core.Processing import Processing
from osgeo import gdal, osr, ogr
import os
import numpy
import numpy as np
import subprocess

# Define input layer names, change according to your file names
path = '/mnt/Windows/';
country = 'Alabama';
part = 'N30W086';

#ratio of upscale to smoothing
percentage = 9
size = 15

################################## IMPORTANT ###############################
# Beginning filename of the NLCD from the source needs to be
# 'nxxxxxxxxxxxxxxxx.tif'
# Also note that "/data/Sentinel-2/" is hardcoded into the path as well
# I needed the existing path structure to process it by state or country.
# Example beginning Sentinel-2 source:
# N30W086.tif
# Full input path and filename to source example is:
# G:/Scenery/ws3.0/Alabama/data/Sentinel-2/N30W086.tif
# Final output path to last processed file is:
# G:/Scenery/ws3.0/Alabama/data/Sentinel-2/Sentinel-2_AlabamaN30W086_Smoothed-HD-Compressed_4326.tiff
############################################################################

################################################################## Step 1: Upsample to HD #################################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean-HD_4326.tiff'

# Open the original raster
ds = gdal.Open(input_path)
gt = ds.GetGeoTransform()

# Extract the original resolution
original_xRes = gt[1]
original_yRes = abs(gt[5])

# Define the percentage to resize by (e.g., 0.50 for 50%, 2.0 for 200%)
#defined at the begining of the script
#percentage = 8.0 # Adjust this as needed

# Calculate the new resolution
new_xRes = original_xRes / percentage
new_yRes = original_yRes / percentage

# Perform the warp (resampling)
gdal.Warp(
output_path,
input_path,
xRes=new_xRes,
yRes=new_yRes,
outputType=gdal.GDT_Byte # Set the output type to uint8
)

print("Step 1: Upsample to. (Sentinel-2_" + country + part + "_Combined-Clean-HD_4326)")

################################################################## Step 2: Smooth all features in original dataset #################################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean-HD_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Smoothed-HD_4326.tiff'

processing.run(
"grass7:r.neighbors",
{
'input':input_path,
'selection':None,
'method':3, #1=median, 3=mode
'size':size,
'gauss':None,
'quantile':'',
'-c':False,
'-a':False,
'weight':'',
'output':output_path,
'GRASS_REGION_CELLSIZE_PARAMETER':0,
'GRASS_RASTER_FORMAT_OPT': 'TYPE=BYTE',
'GRASS_RASTER_FORMAT_META':''
}
)

print("Step 2: Smooth all features in original dataset completed. (Sentinel-2_" + country + part + "_Smoothed-HD_4326)")

################################################################## Step 3: Convert to 8Bit #################################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Smoothed-HD_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Smoothed-HD-Compressed_4326.tiff'

processing.run(
"gdal:translate",
{
'INPUT':input_path,
'TARGET_CRS':None,
'NODATA':0,
'COPY_SUBDATASETS':False,
'OPTIONS':'',
'EXTRA':'',
'DATA_TYPE':1,
'OUTPUT':output_path,
'OPTIONS': 'COMPRESS=LZW'
}
)

result_bit_conversion_layer = QgsRasterLayer(output_path, 'Sentinel-2_' + country + part + '_Smoothed-HD-Compressed_4326')
QgsProject.instance().addMapLayer(result_bit_conversion_layer)

print("Step 3: Convert to Compressed. (Sentinel-2_" + country + part + "_Smoothed-HD-Compressed_4326)")
</syntaxhighlight>

Python script to process Sentinel-2 data

2026-04-30T18:18:00Z

Wlbragg: /* Part 2 */

== Python script to process Sentinel-2 data ==
=== Part 1 ===

<syntaxhighlight lang="text">
from qgis.core import (
QgsRasterLayer,
QgsProcessingFeedback,
QgsRectangle
)
from qgis import processing
from osgeo import gdal
import subprocess
import os
import math

os.environ["GDAL_PAM_ENABLED"] = "NO"

# -----------------------------
# USER SETTINGS
# -----------------------------
path = '/mnt/Windows/'
country = 'Alabama'
part = '16R_20250101-20251231'

################################################# IMPORTANT #############################################
# Cuts Sentinel-2 chunks into FlightGear tiles
# Eliminates water only tiles
# Reclassifies Sentenial-2 landcover types to match FlightGear
# Cleans up any urban area road artifacts
# Beginning filename of the NLCD from the source needs to be
# 'nxxxxxxxxxxxxxxxx.tif'
# Also note that "/data/Sentinel-2/" is hardcoded into the path as well
# I needed the existing path structure to process it by state or country.
# Example beginning Sentinel-2 source:
# 16R_20250101-20251231.tif
# Full input path and filename to source example is:
# G:/Scenery/ws3.0/Alabama/data/Sentinel-2/16R_20250101-20251231.tif
# Final output path to processed files is:
# G:/Scenery/ws3.0/Alabama/data/Sentinel-2/tiles_16R_20250101-20251231/N30W086.tif * tile chunk
##########################################################################################################

################################################################### Step 1: Warp land cover 4326 ############################################################

input_raster = path + country + '/data/Sentinel-2/' + part + '.tif'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Land_Cover_4326.tiff'

processing.run(
"gdal:warpreproject",
{
'INPUT':input_raster,
'SOURCE_CRS': QgsCoordinateReferenceSystem('EPSG:5070'),
'TARGET_CRS': QgsCoordinateReferenceSystem('EPSG:4326'),
'RESAMPLING':0,
'NODATA':None,
'TARGET_RESOLUTION':None,
'OPTIONS':'',
'DATA_TYPE':1, # GDAL GDT_Byte
'TARGET_EXTENT':None,
'TARGET_EXTENT_CRS':None,
'MULTITHREADING':False,
'EXTRA':'',
'OUTPUT':output_path
}
)

print("Step 1: Warp land_cover completed. (Sentinel-2_" + country + part + "_Land_Cover_4326)")

############################################################## Step 2: Replace urban and clutter with grass ###################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Land_Cover_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Grass-Only_4326.tiff'

expression = (
'(A == 0) * 44 + '
'(A == 1) * 41 + '
'(A == 2) * 23 + '
'(A == 3) * 44 + '
'(A == 4) * 35 + '
'(A == 5) * 21 + '
'(A == 6) * 44 + '
'(A == 7) * 26 + '
'(A == 8) * 31 + '
'(A == 9) * 34 + '
'(A == 10) * 26 + '
'(A == 11) * 26'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows requires
#subprocess.run(command, shell=True)

print("Step 2: Replace urban and clutter with grass completed. (Sentinel-2_" + country + part + "_Grass-Only_4326)")

################################################################## Step 3: Reclass urban 2 ###########################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Land_Cover_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Reclassed-Urban_4326.tiff'

expression = (
'(A == 2)*7'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows requires
#subprocess.run(command, shell=True)

print("Step 3: Reclass urban completed. (Sentinel-2_" + country + part + "_Reclassed-Urban_4326)")

################################################################ Step 4: Remove clutter and roads from urban ###########################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Reclassed-Urban_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Urban-Only_4326.tiff'

processing.run(
"grass7:r.neighbors",
{
'input':input_path,
'selection':None,
'method':1, #1=median, 2=mode
'size':7,
'gauss':None,
'quantile':'',
'-c':False,
'-a':False,
'weight':'',
'output':output_path,
'GRASS_REGION_PARAMETER':None,
'GRASS_REGION_CELLSIZE_PARAMETER':0,
'GRASS_RASTER_FORMAT_OPT': 'TYPE=BYTE',
'GRASS_RASTER_FORMAT_META':''
}
)

print("Step 4: Remove clutter and roads from urban. (Sentinel-2_" + country + part + "_Urban-Only_4326)")

############################################################## Step 5: Combine grass only and clean urban #########################################################

input_path_a = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Urban-Only_4326.tiff'
input_path_b = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Grass-Only_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean_4326.tiff'

expression = (
'((A > 0) & (B > 0)) * A + '
'((A <= 0) | (B <= 0)) * B'
)
command = [
'gdal_calc.py',
'-A', input_path_a,
'-B', input_path_b,
'--outfile', output_path,
'--calc', expression,
'--NoDataValue', '0',
'--type', 'Byte'
]
subprocess.run(command)
#Windows requires
#subprocess.run(command, shell=True)

print("Step 5: Combined and clean completed. (Sentinel-2_" + country + part + "_Combined-Clean_4326)")

############################################################## Step 6: Cut into tiles #########################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean_4326.tiff'
output_folder = path + country + '/data/Sentinel-2/tiles_' + part + '/'
tile_size_deg = 1.0

os.makedirs(output_folder, exist_ok=True)

rlayer = QgsRasterLayer(input_path, "input")
if not rlayer.isValid():
raise Exception("Raster failed to load: " + input_path)

ext = rlayer.extent()
xmin = ext.xMinimum()
xmax = ext.xMaximum()
ymin = ext.yMinimum()
ymax = ext.yMaximum()

xmin_int = math.floor(xmin)
xmax_int = math.ceil(xmax)
ymin_int = math.floor(ymin)
ymax_int = math.ceil(ymax)

feedback = QgsProcessingFeedback()

for lat in range(ymin_int, ymax_int - 1):
for lon in range(xmin_int, xmax_int - 1):

tile_xmin = lon
tile_xmax = lon + tile_size_deg
tile_ymin = lat
tile_ymax = lat + tile_size_deg

if tile_xmax <= xmin or tile_xmin >= xmax:
continue
if tile_ymax <= ymin or tile_ymin >= ymax:
continue

tile_extent = f"{tile_xmin},{tile_xmax},{tile_ymin},{tile_ymax}"

ns = "N" if (lat + 1) >= 0 else "S"
ew = "E" if lon >= 0 else "W"
out_name = f"{ns}{abs(lat+1):02d}{ew}{abs(lon):03d}.tif"
out_path = os.path.join(output_folder, out_name)

tmp_tile = out_path.replace(".tif", "_tmp.tif")

processing.run(
"gdal:cliprasterbyextent",
{
'INPUT': input_path,
'PROJWIN': tile_extent,
'NODATA': 0,
'OPTIONS': '',
'DATA_TYPE': 0,
'OUTPUT': tmp_tile
},
feedback=feedback
)

if not os.path.exists(tmp_tile) or os.path.getsize(tmp_tile) < 50:
if os.path.exists(tmp_tile):
os.remove(tmp_tile)
print("Skipped (empty tile):", out_name)
continue

ds = gdal.Open(tmp_tile)
band = ds.GetRasterBand(1)
arr = band.ReadAsArray()

# If every pixel is zero → water only
if (arr == 0).all():
os.remove(tmp_tile)
print("Skipped (all water):", out_name)
continue

os.rename(tmp_tile, out_path)
print("Created:", out_path)

print("Tiling complete.")
</syntaxhighlight>

=== Part 2 ===

<syntaxhighlight lang="text">
from qgis.core import QgsApplication, QgsCoordinateTransform, QgsProject, QgsRasterLayer, QgsCoordinateReferenceSystem, QgsProcessingException, QgsRasterBlock, QgsRectangle
from qgis.analysis import QgsRasterCalculator, QgsRasterCalculatorEntry
from qgis import processing
from processing.core.Processing import Processing
from osgeo import gdal, osr, ogr
import os
import numpy
import numpy as np
import subprocess

# Define input layer names, change according to your file names
path = '/mnt/Windows/';
country = 'Alabama';
part = 'N30W086';

#ratio of upscale to smoothing
percentage = 9
size = 15

################################## IMPORTANT ###############################
# Beginning filename of the NLCD from the source needs to be
# 'nxxxxxxxxxxxxxxxx.tif'
# Also note that "/data/Sentinel-2/" is hardcoded into the path as well
# I needed the existing path structure to process it by state or country.
# Example beginning Sentinel-2 source:
# N30W086.tif
# Full input path and filename to source example is:
# G:/Scenery/ws3.0/Alabama/data/Sentinel-2/N30W086.tif
# Final output path to last processed file is:
# G:/Scenery/ws3.0/Alabama/data/Sentinel-2/Sentinel-2_AlabamaN30W086_Smoothed-HD-Compressed_4326.tiff
############################################################################

################################################################## Step 1: Upsample to HD #################################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean-HD_4326.tiff'

# Open the original raster
ds = gdal.Open(input_path)
gt = ds.GetGeoTransform()

# Extract the original resolution
original_xRes = gt[1]
original_yRes = abs(gt[5])

# Define the percentage to resize by (e.g., 0.50 for 50%, 2.0 for 200%)
#defined at the begining of the script
#percentage = 8.0 # Adjust this as needed

# Calculate the new resolution
new_xRes = original_xRes / percentage
new_yRes = original_yRes / percentage

# Perform the warp (resampling)
gdal.Warp(
output_path,
input_path,
xRes=new_xRes,
yRes=new_yRes,
outputType=gdal.GDT_Byte # Set the output type to uint8
)

print("Step 1: Upsample to. (Sentinel-2_" + country + part + "_Combined-Clean-HD_4326)")

################################################################## Step 2: Smooth all features in original dataset #################################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean-HD_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Smoothed-HD_4326.tiff'

processing.run(
"grass7:r.neighbors",
{
'input':input_path,
'selection':None,
'method':3, #1=median, 3=mode
'size':size,
'gauss':None,
'quantile':'',
'-c':False,
'-a':False,
'weight':'',
'output':output_path,
'GRASS_REGION_CELLSIZE_PARAMETER':0,
'GRASS_RASTER_FORMAT_OPT': 'TYPE=BYTE',
'GRASS_RASTER_FORMAT_META':''
}
)

print("Step 2: Smooth all features in original dataset completed. (Sentinel-2_" + country + part + "_Smoothed-HD_4326)")

################################################################## Step 3: Convert to 8Bit #################################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Smoothed-HD_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Smoothed-HD-Compressed_4326.tiff'

processing.run(
"gdal:translate",
{
'INPUT':input_path,
'TARGET_CRS':None,
'NODATA':0,
'COPY_SUBDATASETS':False,
'OPTIONS':'',
'EXTRA':'',
'DATA_TYPE':1,
'OUTPUT':output_path,
'OPTIONS': 'COMPRESS=LZW'
}
)

result_bit_conversion_layer = QgsRasterLayer(output_path, 'Sentinel-2_' + country + part + '_Smoothed-HD-Compressed_4326')
QgsProject.instance().addMapLayer(result_bit_conversion_layer)

print("Step 3: Convert to Compressed. (Sentinel-2_" + country + part + "_Smoothed-HD-Compressed_4326)")
</syntaxhighlight>

Python script to process Sentinel-2 data

2026-04-30T18:17:18Z

Wlbragg: /* Part 1 */

== Python script to process Sentinel-2 data ==
=== Part 1 ===

<syntaxhighlight lang="text">
from qgis.core import (
QgsRasterLayer,
QgsProcessingFeedback,
QgsRectangle
)
from qgis import processing
from osgeo import gdal
import subprocess
import os
import math

os.environ["GDAL_PAM_ENABLED"] = "NO"

# -----------------------------
# USER SETTINGS
# -----------------------------
path = '/mnt/Windows/'
country = 'Alabama'
part = '16R_20250101-20251231'

################################################# IMPORTANT #############################################
# Cuts Sentinel-2 chunks into FlightGear tiles
# Eliminates water only tiles
# Reclassifies Sentenial-2 landcover types to match FlightGear
# Cleans up any urban area road artifacts
# Beginning filename of the NLCD from the source needs to be
# 'nxxxxxxxxxxxxxxxx.tif'
# Also note that "/data/Sentinel-2/" is hardcoded into the path as well
# I needed the existing path structure to process it by state or country.
# Example beginning Sentinel-2 source:
# 16R_20250101-20251231.tif
# Full input path and filename to source example is:
# G:/Scenery/ws3.0/Alabama/data/Sentinel-2/16R_20250101-20251231.tif
# Final output path to processed files is:
# G:/Scenery/ws3.0/Alabama/data/Sentinel-2/tiles_16R_20250101-20251231/N30W086.tif * tile chunk
##########################################################################################################

################################################################### Step 1: Warp land cover 4326 ############################################################

input_raster = path + country + '/data/Sentinel-2/' + part + '.tif'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Land_Cover_4326.tiff'

processing.run(
"gdal:warpreproject",
{
'INPUT':input_raster,
'SOURCE_CRS': QgsCoordinateReferenceSystem('EPSG:5070'),
'TARGET_CRS': QgsCoordinateReferenceSystem('EPSG:4326'),
'RESAMPLING':0,
'NODATA':None,
'TARGET_RESOLUTION':None,
'OPTIONS':'',
'DATA_TYPE':1, # GDAL GDT_Byte
'TARGET_EXTENT':None,
'TARGET_EXTENT_CRS':None,
'MULTITHREADING':False,
'EXTRA':'',
'OUTPUT':output_path
}
)

print("Step 1: Warp land_cover completed. (Sentinel-2_" + country + part + "_Land_Cover_4326)")

############################################################## Step 2: Replace urban and clutter with grass ###################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Land_Cover_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Grass-Only_4326.tiff'

expression = (
'(A == 0) * 44 + '
'(A == 1) * 41 + '
'(A == 2) * 23 + '
'(A == 3) * 44 + '
'(A == 4) * 35 + '
'(A == 5) * 21 + '
'(A == 6) * 44 + '
'(A == 7) * 26 + '
'(A == 8) * 31 + '
'(A == 9) * 34 + '
'(A == 10) * 26 + '
'(A == 11) * 26'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows requires
#subprocess.run(command, shell=True)

print("Step 2: Replace urban and clutter with grass completed. (Sentinel-2_" + country + part + "_Grass-Only_4326)")

################################################################## Step 3: Reclass urban 2 ###########################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Land_Cover_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Reclassed-Urban_4326.tiff'

expression = (
'(A == 2)*7'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows requires
#subprocess.run(command, shell=True)

print("Step 3: Reclass urban completed. (Sentinel-2_" + country + part + "_Reclassed-Urban_4326)")

################################################################ Step 4: Remove clutter and roads from urban ###########################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Reclassed-Urban_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Urban-Only_4326.tiff'

processing.run(
"grass7:r.neighbors",
{
'input':input_path,
'selection':None,
'method':1, #1=median, 2=mode
'size':7,
'gauss':None,
'quantile':'',
'-c':False,
'-a':False,
'weight':'',
'output':output_path,
'GRASS_REGION_PARAMETER':None,
'GRASS_REGION_CELLSIZE_PARAMETER':0,
'GRASS_RASTER_FORMAT_OPT': 'TYPE=BYTE',
'GRASS_RASTER_FORMAT_META':''
}
)

print("Step 4: Remove clutter and roads from urban. (Sentinel-2_" + country + part + "_Urban-Only_4326)")

############################################################## Step 5: Combine grass only and clean urban #########################################################

input_path_a = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Urban-Only_4326.tiff'
input_path_b = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Grass-Only_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean_4326.tiff'

expression = (
'((A > 0) & (B > 0)) * A + '
'((A <= 0) | (B <= 0)) * B'
)
command = [
'gdal_calc.py',
'-A', input_path_a,
'-B', input_path_b,
'--outfile', output_path,
'--calc', expression,
'--NoDataValue', '0',
'--type', 'Byte'
]
subprocess.run(command)
#Windows requires
#subprocess.run(command, shell=True)

print("Step 5: Combined and clean completed. (Sentinel-2_" + country + part + "_Combined-Clean_4326)")

############################################################## Step 6: Cut into tiles #########################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean_4326.tiff'
output_folder = path + country + '/data/Sentinel-2/tiles_' + part + '/'
tile_size_deg = 1.0

os.makedirs(output_folder, exist_ok=True)

rlayer = QgsRasterLayer(input_path, "input")
if not rlayer.isValid():
raise Exception("Raster failed to load: " + input_path)

ext = rlayer.extent()
xmin = ext.xMinimum()
xmax = ext.xMaximum()
ymin = ext.yMinimum()
ymax = ext.yMaximum()

xmin_int = math.floor(xmin)
xmax_int = math.ceil(xmax)
ymin_int = math.floor(ymin)
ymax_int = math.ceil(ymax)

feedback = QgsProcessingFeedback()

for lat in range(ymin_int, ymax_int - 1):
for lon in range(xmin_int, xmax_int - 1):

tile_xmin = lon
tile_xmax = lon + tile_size_deg
tile_ymin = lat
tile_ymax = lat + tile_size_deg

if tile_xmax <= xmin or tile_xmin >= xmax:
continue
if tile_ymax <= ymin or tile_ymin >= ymax:
continue

tile_extent = f"{tile_xmin},{tile_xmax},{tile_ymin},{tile_ymax}"

ns = "N" if (lat + 1) >= 0 else "S"
ew = "E" if lon >= 0 else "W"
out_name = f"{ns}{abs(lat+1):02d}{ew}{abs(lon):03d}.tif"
out_path = os.path.join(output_folder, out_name)

tmp_tile = out_path.replace(".tif", "_tmp.tif")

processing.run(
"gdal:cliprasterbyextent",
{
'INPUT': input_path,
'PROJWIN': tile_extent,
'NODATA': 0,
'OPTIONS': '',
'DATA_TYPE': 0,
'OUTPUT': tmp_tile
},
feedback=feedback
)

if not os.path.exists(tmp_tile) or os.path.getsize(tmp_tile) < 50:
if os.path.exists(tmp_tile):
os.remove(tmp_tile)
print("Skipped (empty tile):", out_name)
continue

ds = gdal.Open(tmp_tile)
band = ds.GetRasterBand(1)
arr = band.ReadAsArray()

# If every pixel is zero → water only
if (arr == 0).all():
os.remove(tmp_tile)
print("Skipped (all water):", out_name)
continue

os.rename(tmp_tile, out_path)
print("Created:", out_path)

print("Tiling complete.")
</syntaxhighlight>

=== Part 2 ===

<syntaxhighlight lang="text">
from qgis.core import QgsApplication, QgsCoordinateTransform, QgsProject, QgsRasterLayer, QgsCoordinateReferenceSystem, QgsProcessingException, QgsRasterBlock, QgsRectangle
from qgis.analysis import QgsRasterCalculator, QgsRasterCalculatorEntry
from qgis import processing
from processing.core.Processing import Processing
from osgeo import gdal, osr, ogr
import os
import numpy
import numpy as np
import subprocess

# Define input layer names, change according to your file names
path = '/mnt/Windows/';
country = 'Alabama';
part = 'N30W086';

#ratio of upscale to smoothing
percentage = 9
size = 15

################################## IMPORTANT ###############################
# Beginning filename of the NLCD from the source needs to be
# 'nxxxxxxxxxxxxxxxx.tif'
# Also note that "/data/Sentinel-2/" is hardcoded into the path as well
# I needed the existing path structure to process it by state or country.
# Example beginning Sentinel-2 source:
# N30W086.tif
# Full input path and filename to source example is:
# G:/Scenery/ws3.0/Alaska/data/Sentinel-2/N30W086.tif
# Final output path to last processed file is:
# G:/Scenery/ws3.0/Alaska//data/Sentinel-2/Sentinel-2_AlaskaN30W086_Smoothed-HD-Compressed_4326.tiff
############################################################################

################################################################## Step 1: Upsample to HD #################################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean-HD_4326.tiff'

# Open the original raster
ds = gdal.Open(input_path)
gt = ds.GetGeoTransform()

# Extract the original resolution
original_xRes = gt[1]
original_yRes = abs(gt[5])

# Define the percentage to resize by (e.g., 0.50 for 50%, 2.0 for 200%)
#defined at the begining of the script
#percentage = 8.0 # Adjust this as needed

# Calculate the new resolution
new_xRes = original_xRes / percentage
new_yRes = original_yRes / percentage

# Perform the warp (resampling)
gdal.Warp(
output_path,
input_path,
xRes=new_xRes,
yRes=new_yRes,
outputType=gdal.GDT_Byte # Set the output type to uint8
)

print("Step 1: Upsample to. (Sentinel-2_" + country + part + "_Combined-Clean-HD_4326)")

################################################################## Step 2: Smooth all features in original dataset #################################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean-HD_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Smoothed-HD_4326.tiff'

processing.run(
"grass7:r.neighbors",
{
'input':input_path,
'selection':None,
'method':3, #1=median, 3=mode
'size':size,
'gauss':None,
'quantile':'',
'-c':False,
'-a':False,
'weight':'',
'output':output_path,
'GRASS_REGION_CELLSIZE_PARAMETER':0,
'GRASS_RASTER_FORMAT_OPT': 'TYPE=BYTE',
'GRASS_RASTER_FORMAT_META':''
}
)

print("Step 2: Smooth all features in original dataset completed. (Sentinel-2_" + country + part + "_Smoothed-HD_4326)")

################################################################## Step 3: Convert to 8Bit #################################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Smoothed-HD_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Smoothed-HD-Compressed_4326.tiff'

processing.run(
"gdal:translate",
{
'INPUT':input_path,
'TARGET_CRS':None,
'NODATA':0,
'COPY_SUBDATASETS':False,
'OPTIONS':'',
'EXTRA':'',
'DATA_TYPE':1,
'OUTPUT':output_path,
'OPTIONS': 'COMPRESS=LZW'
}
)

result_bit_conversion_layer = QgsRasterLayer(output_path, 'Sentinel-2_' + country + part + '_Smoothed-HD-Compressed_4326')
QgsProject.instance().addMapLayer(result_bit_conversion_layer)

print("Step 3: Convert to Compressed. (Sentinel-2_" + country + part + "_Smoothed-HD-Compressed_4326)")
</syntaxhighlight>

Python script to process Sentinel-2 data

2026-04-30T18:15:20Z

Wlbragg: /* Python script to process Sentinel-2 data */

== Python script to process Sentinel-2 data ==
=== Part 1 ===

<syntaxhighlight lang="text">
from qgis.core import (
QgsRasterLayer,
QgsProcessingFeedback,
QgsRectangle
)
from qgis import processing
from osgeo import gdal
import subprocess
import os
import math

os.environ["GDAL_PAM_ENABLED"] = "NO"

# -----------------------------
# USER SETTINGS
# -----------------------------
path = '/mnt/Windows/'
country = 'Alabama'
part = '16R_20250101-20251231'

################################################# IMPORTANT #############################################
# Cuts Sentinel-2 chuncks into FlightGear tiles
# Eliminates water only tiles
# Reclassifies Sentenial-2 landcover types to match FlightGear
# Cleans up any urban area road artifacts
# Beginning filename of the NLCD from the source needs to be
# 'nxxxxxxxxxxxxxxxx.tif'
# Also note that "/data/Sentinel-2/" is hardcoded into the path as well
# I needed the existing path structure to process it by state or country.
# Example beginning Sentinel-2 source:
# 16R_20250101-20251231.tif
# Full input path and filename to source example is:
# G:/Scenery/ws3.0/Alaska/data/Sentinel-2/16R_20250101-20251231.tif
# Final output path to processed files is:
# G:/Scenery/ws3.0/Alaska//data/Sentinel-2/tiles_16R_20250101-20251231/N30W086.tif * tile chunck
##########################################################################################################

################################################################### Step 1: Warp land cover 4326 ############################################################

input_raster = path + country + '/data/Sentinel-2/' + part + '.tif'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Land_Cover_4326.tiff'

processing.run(
"gdal:warpreproject",
{
'INPUT':input_raster,
'SOURCE_CRS': QgsCoordinateReferenceSystem('EPSG:5070'),
'TARGET_CRS': QgsCoordinateReferenceSystem('EPSG:4326'),
'RESAMPLING':0,
'NODATA':None,
'TARGET_RESOLUTION':None,
'OPTIONS':'',
'DATA_TYPE':1, # GDAL GDT_Byte
'TARGET_EXTENT':None,
'TARGET_EXTENT_CRS':None,
'MULTITHREADING':False,
'EXTRA':'',
'OUTPUT':output_path
}
)

print("Step 1: Warp land_cover completed. (Sentinel-2_" + country + part + "_Land_Cover_4326)")

############################################################## Step 2: Replace urban and clutter with grass ###################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Land_Cover_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Grass-Only_4326.tiff'

expression = (
'(A == 0) * 44 + '
'(A == 1) * 41 + '
'(A == 2) * 23 + '
'(A == 3) * 44 + '
'(A == 4) * 35 + '
'(A == 5) * 21 + '
'(A == 6) * 44 + '
'(A == 7) * 26 + '
'(A == 8) * 31 + '
'(A == 9) * 34 + '
'(A == 10) * 26 + '
'(A == 11) * 26'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows requires
#subprocess.run(command, shell=True)

print("Step 2: Replace urban and clutter with grass completed. (Sentinel-2_" + country + part + "_Grass-Only_4326)")

################################################################## Step 3: Reclass urban 2 ###########################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Land_Cover_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Reclassed-Urban_4326.tiff'

expression = (
'(A == 2)*7'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows requires
#subprocess.run(command, shell=True)

print("Step 3: Reclass urban completed. (Sentinel-2_" + country + part + "_Reclassed-Urban_4326)")

################################################################ Step 4: Remove clutter and roads from urban ###########################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Reclassed-Urban_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Urban-Only_4326.tiff'

processing.run(
"grass7:r.neighbors",
{
'input':input_path,
'selection':None,
'method':1, #1=median, 2=mode
'size':7,
'gauss':None,
'quantile':'',
'-c':False,
'-a':False,
'weight':'',
'output':output_path,
'GRASS_REGION_PARAMETER':None,
'GRASS_REGION_CELLSIZE_PARAMETER':0,
'GRASS_RASTER_FORMAT_OPT': 'TYPE=BYTE',
'GRASS_RASTER_FORMAT_META':''
}
)

print("Step 4: Remove clutter and roads from urban. (Sentinel-2_" + country + part + "_Urban-Only_4326)")

############################################################## Step 5: Combine grass only and clean urban #########################################################

input_path_a = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Urban-Only_4326.tiff'
input_path_b = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Grass-Only_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean_4326.tiff'

expression = (
'((A > 0) & (B > 0)) * A + '
'((A <= 0) | (B <= 0)) * B'
)
command = [
'gdal_calc.py',
'-A', input_path_a,
'-B', input_path_b,
'--outfile', output_path,
'--calc', expression,
'--NoDataValue', '0',
'--type', 'Byte'
]
subprocess.run(command)
#Windows requires
#subprocess.run(command, shell=True)

print("Step 5: Combined and clean completed. (Sentinel-2_" + country + part + "_Combined-Clean_4326)")

############################################################## Step 6: Cut into tiles #########################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean_4326.tiff'
output_folder = path + country + '/data/Sentinel-2/tiles_' + part + '/'
tile_size_deg = 1.0

os.makedirs(output_folder, exist_ok=True)

rlayer = QgsRasterLayer(input_path, "input")
if not rlayer.isValid():
raise Exception("Raster failed to load: " + input_path)

ext = rlayer.extent()
xmin = ext.xMinimum()
xmax = ext.xMaximum()
ymin = ext.yMinimum()
ymax = ext.yMaximum()

xmin_int = math.floor(xmin)
xmax_int = math.ceil(xmax)
ymin_int = math.floor(ymin)
ymax_int = math.ceil(ymax)

feedback = QgsProcessingFeedback()

for lat in range(ymin_int, ymax_int - 1):
for lon in range(xmin_int, xmax_int - 1):

tile_xmin = lon
tile_xmax = lon + tile_size_deg
tile_ymin = lat
tile_ymax = lat + tile_size_deg

if tile_xmax <= xmin or tile_xmin >= xmax:
continue
if tile_ymax <= ymin or tile_ymin >= ymax:
continue

tile_extent = f"{tile_xmin},{tile_xmax},{tile_ymin},{tile_ymax}"

ns = "N" if (lat + 1) >= 0 else "S"
ew = "E" if lon >= 0 else "W"
out_name = f"{ns}{abs(lat+1):02d}{ew}{abs(lon):03d}.tif"
out_path = os.path.join(output_folder, out_name)

tmp_tile = out_path.replace(".tif", "_tmp.tif")

processing.run(
"gdal:cliprasterbyextent",
{
'INPUT': input_path,
'PROJWIN': tile_extent,
'NODATA': 0,
'OPTIONS': '',
'DATA_TYPE': 0,
'OUTPUT': tmp_tile
},
feedback=feedback
)

if not os.path.exists(tmp_tile) or os.path.getsize(tmp_tile) < 50:
if os.path.exists(tmp_tile):
os.remove(tmp_tile)
print("Skipped (empty tile):", out_name)
continue

ds = gdal.Open(tmp_tile)
band = ds.GetRasterBand(1)
arr = band.ReadAsArray()

# If every pixel is zero → water only
if (arr == 0).all():
os.remove(tmp_tile)
print("Skipped (all water):", out_name)
continue

os.rename(tmp_tile, out_path)
print("Created:", out_path)

print("Tiling complete.")
</syntaxhighlight>
=== Part 2 ===

<syntaxhighlight lang="text">
from qgis.core import QgsApplication, QgsCoordinateTransform, QgsProject, QgsRasterLayer, QgsCoordinateReferenceSystem, QgsProcessingException, QgsRasterBlock, QgsRectangle
from qgis.analysis import QgsRasterCalculator, QgsRasterCalculatorEntry
from qgis import processing
from processing.core.Processing import Processing
from osgeo import gdal, osr, ogr
import os
import numpy
import numpy as np
import subprocess

# Define input layer names, change according to your file names
path = '/mnt/Windows/';
country = 'Alabama';
part = 'N30W086';

#ratio of upscale to smoothing
percentage = 9
size = 15

################################## IMPORTANT ###############################
# Beginning filename of the NLCD from the source needs to be
# 'nxxxxxxxxxxxxxxxx.tif'
# Also note that "/data/Sentinel-2/" is hardcoded into the path as well
# I needed the existing path structure to process it by state or country.
# Example beginning Sentinel-2 source:
# N30W086.tif
# Full input path and filename to source example is:
# G:/Scenery/ws3.0/Alaska/data/Sentinel-2/N30W086.tif
# Final output path to last processed file is:
# G:/Scenery/ws3.0/Alaska//data/Sentinel-2/Sentinel-2_AlaskaN30W086_Smoothed-HD-Compressed_4326.tiff
############################################################################

################################################################## Step 1: Upsample to HD #################################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean-HD_4326.tiff'

# Open the original raster
ds = gdal.Open(input_path)
gt = ds.GetGeoTransform()

# Extract the original resolution
original_xRes = gt[1]
original_yRes = abs(gt[5])

# Define the percentage to resize by (e.g., 0.50 for 50%, 2.0 for 200%)
#defined at the begining of the script
#percentage = 8.0 # Adjust this as needed

# Calculate the new resolution
new_xRes = original_xRes / percentage
new_yRes = original_yRes / percentage

# Perform the warp (resampling)
gdal.Warp(
output_path,
input_path,
xRes=new_xRes,
yRes=new_yRes,
outputType=gdal.GDT_Byte # Set the output type to uint8
)

print("Step 1: Upsample to. (Sentinel-2_" + country + part + "_Combined-Clean-HD_4326)")

################################################################## Step 2: Smooth all features in original dataset #################################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean-HD_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Smoothed-HD_4326.tiff'

processing.run(
"grass7:r.neighbors",
{
'input':input_path,
'selection':None,
'method':3, #1=median, 3=mode
'size':size,
'gauss':None,
'quantile':'',
'-c':False,
'-a':False,
'weight':'',
'output':output_path,
'GRASS_REGION_CELLSIZE_PARAMETER':0,
'GRASS_RASTER_FORMAT_OPT': 'TYPE=BYTE',
'GRASS_RASTER_FORMAT_META':''
}
)

print("Step 2: Smooth all features in original dataset completed. (Sentinel-2_" + country + part + "_Smoothed-HD_4326)")

################################################################## Step 3: Convert to 8Bit #################################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Smoothed-HD_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Smoothed-HD-Compressed_4326.tiff'

processing.run(
"gdal:translate",
{
'INPUT':input_path,
'TARGET_CRS':None,
'NODATA':0,
'COPY_SUBDATASETS':False,
'OPTIONS':'',
'EXTRA':'',
'DATA_TYPE':1,
'OUTPUT':output_path,
'OPTIONS': 'COMPRESS=LZW'
}
)

result_bit_conversion_layer = QgsRasterLayer(output_path, 'Sentinel-2_' + country + part + '_Smoothed-HD-Compressed_4326')
QgsProject.instance().addMapLayer(result_bit_conversion_layer)

print("Step 3: Convert to Compressed. (Sentinel-2_" + country + part + "_Smoothed-HD-Compressed_4326)")
</syntaxhighlight>

Python script to process NLCD for the USA

2026-04-30T02:28:06Z

Wlbragg: /* Optional Python script to process NLCD for the USA */

=== Optional Python script to process NLCD for the USA ===
You can optionally process the NLCD by loading this script in the python console of the QGIS Desktop program.
This python script method produces more refined data than by using the python calculator method above and it is more automated.
If you run this script outside the python console you will need to modify it to locate the data you are processing.
If you save the NLCD tiff's using the same consistent naming convention used in this example it is fairly simple to generate final WS3.0 tiff's to use to generate the scenery.

You will start with an original tree layer and a land cover layer from the MRLC.gov site. See the section "Obtaining NLCD" in the above "Step By Step Procedure for Processing NLCD for the USA using the Raster Calculator" topic.

For example, to start with you will have a couple files named...

NLCD_2021_Tree_Canopy_Alaska141-140_60.tiff

NLCD_2021_Land_Cover_Alaska141-140_60.tiff

In the QGIS program the layer names you start with will be...

NLCD_2021_Tree_Canopy_Alaska141-140_60

NLCD_2021_Land_Cover_Alaska141-140_60

which will refer to the tiff files.

Running this script will generate a bunch of intermediate files including the last file, that will be the final finished file for running in the VPB script or VPB build environment Docker image.

The last file for this example for Alaska would be, NLCD_2021_Alaska141-140_60_Smoothed-HD-Compressed_4326.tiff

<syntaxhighlight lang="python">
from qgis.core import QgsApplication, QgsCoordinateTransform, QgsProject, QgsRasterLayer, QgsCoordinateReferenceSystem, QgsProcessingException, QgsRasterBlock, QgsRectangle
from qgis.analysis import QgsRasterCalculator, QgsRasterCalculatorEntry
from qgis import processing
from processing.core.Processing import Processing
from osgeo import gdal, osr, ogr
import os
import numpy
import numpy as np
import subprocess

# Define input layer names, change according to your file names
path = 'G:/Scenery/ws3.0/';
year = '2021';
state = 'Alaska';
part = '141-140_60';

# Ratio of upsampling to smoothing
percentage = 8
size = 11

################################## IMPORTANT ###############################
# Beginning filename of the NLCD from the source needs to be
# NLCD_' + year + '_Tree_Canopy_' + state + part + '.tiff'
# Also note that "/data/" is hardcoded into the path as well
# I needed the existing path structure to process it by state.
# For Alaska I used one lat and a few lon sections per chunck built.
# I will likely do the entire NLCD coverage area the same in future runs.
# Example beginning NLCD source:
# NLCD_2021_Tree_Canopy_Alaska141-140_60.tiff
# NLCD_2021_Land_Cover_Alaska141-140_60.tiff
# Full path and filename to source example is:
# G:/Scenery/ws3.0/Alaska/data/source/NLCD_2021_Tree_Canopy_Alaska141-140_60.tiff
# G:/Scenery/ws3.0/Alaska/data/source/NLCD_2021_Land_Cover_Alaska141-140_60.tiff
# Final output path to last processed file is:
# G:/Scenery/ws3.0/Alaska/data/NLCD_2021_Alaska141-140_60_Smoothed-HD-Compressed_4326
############################################################################

##################### Step 1: Reclass tree canopy to one landcover type 41, 42, or 43 #####################
#FG NLCD
#23 DeciduousBroadCover 41
#24 EvergreenForest 42
#25 MixedForest 43

# Define input and output paths
input_path = path + state + '/data/source/NLCD_' + year + '_Tree_Canopy_' + state + part + '.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Trees-Combined.tiff'

expression = (
'((A > 0) & (A < 255)) * 43 + '
'(A <= 0) * A'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows OS uses
#subprocess.run(command, shell=True)

print("Step 1: Calculate result_tree_canopy completed. (NLCD_" + year + "_" + state + part + "_Trees-Combined)")

##################### Step 2: Warp tree canopy to 4326 #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Trees-Combined.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Tree_Canopy_4326.tiff'

processing.run(
"gdal:warpreproject",
{
'INPUT':input_path,
'SOURCE_CRS':None,
'TARGET_CRS':QgsCoordinateReferenceSystem('EPSG:4326'),
'RESAMPLING':0,
'NODATA':None,
'TARGET_RESOLUTION':None,
'OPTIONS':'',
'DATA_TYPE':1, # GDAL GDT_Byte
'TARGET_EXTENT':None,
'TARGET_EXTENT_CRS':None,
'MULTITHREADING':False,
'EXTRA':'',
'OUTPUT':output_path
}
)

print("Step 2: Warp tree_canopy completed. (NLCD_" + year + "_" + state + part + "_Tree_Canopy_4326)")

##################### Step 3: Warp land cover 4326 #####################

input_path = path + state + '/data/source/NLCD_' + year + '_Land_Cover_' + state + part + '.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Land_Cover_4326.tiff'

processing.run(
"gdal:warpreproject",
{
'INPUT':input_path,
'SOURCE_CRS':None,
'TARGET_CRS':QgsCoordinateReferenceSystem('EPSG:4326'),
'RESAMPLING':0,
'NODATA':None,
'TARGET_RESOLUTION':None,
'OPTIONS':'',
'DATA_TYPE':1, # GDAL GDT_Byte
'TARGET_EXTENT':None,
'TARGET_EXTENT_CRS':None,
'MULTITHREADING':False,
'EXTRA':'',
'OUTPUT':output_path
}
)

print("Step 3: Warp land_cover completed. (NLCD_" + year + "_" + state + part + "_Land_Cover_4326)")

##################### Step 4: Combine land cover 4326 and tree canopy 4326 #####################

input_path_a = path + state + '/data/NLCD_' + year + '_' + state + part + '_Tree_Canopy_4326.tiff'
input_path_b = path + state + '/data/NLCD_' + year + '_' + state + part + '_Land_Cover_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Tree_Land_Combined_4326.tiff'

expression = (
'(((B > 0) & (B < 255)) & (B != 41) & (B != 42) & (B != 43) & (A > 0)) * A + '
'((B == 41) | (B == 42) | (B == 43) | (A <= 0)) * B'
)
command = [
'gdal_calc.py',
'-A', input_path_a,
'-B', input_path_b,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows OS uses
#subprocess.run(command, shell=True)

print("Step 4: Combine tree canopy and land cover completed. (NLCD_" + year + "_" + state + part + "_Tree_Land_Combined_4326)")

##################### Step 5: Replace urban and clutter with grass #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Tree_Land_Combined_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Grass-Only_4326.tiff'

expression = (
'(A == 0) * 44 + '
'(A == 11) * 41 + '
'(A == 12) * 34 + '
'(A == 21) * 26 + '
'(A == 22) * 26 + '
'(A == 23) * 26 + '
'(A == 24) * 26 + '
'(A == 31) * 27 + '
'(A == 41) * 23 + '
'(A == 42) * 24 + '
'(A == 43) * 25 + '
'(A == 51) * 30 + '
'(A == 52) * 29 + '
'(A == 71) * 26 + '
'(A == 72) * 32 + '
'(A == 73) * 31 + '
'(A == 74) * 31 + '
'(A == 75) * 32 + '
'(A == 81) * 18 + '
'(A == 82) * 19 + '
'(A == 90) * 25 + '
'(A == 95) * 35'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows OS uses
#subprocess.run(command, shell=True)

print("Step 5: Replace urban and clutter with grass completed. (NLCD_" + year + "_" + state + part + "_Grass-Only_4326)")

##################### Step 6: Reclass urban 21, 22, 23 or 24 #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Tree_Land_Combined_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Reclassed-Urban_4326.tiff'

expression = (
'(A == 21)*10 + '
'(A == 22)*1 + '
'(A == 23)*1 + '
'(A == 24)*2'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows OS uses
#subprocess.run(command, shell=True)

print("Step 6: Reclass urban completed. (NLCD_" + year + "_" + state + part + "_Reclassed-Urban_4326)")

##################### Step 7: Remove clutter and roads from urban #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Reclassed-Urban_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Urban-Only_4326.tiff'

processing.run(
"grass7:r.neighbors",
{
'input':input_path,
'selection':None,
'method':1, #1=median, 2=mode
'size':7,
'gauss':None,
'quantile':'',
'-c':False,
'-a':False,
'weight':'',
'output':output_path,
'GRASS_REGION_PARAMETER':None,
'GRASS_REGION_CELLSIZE_PARAMETER':0,
'GRASS_RASTER_FORMAT_OPT': 'TYPE=BYTE',
'GRASS_RASTER_FORMAT_META':''
}
)

print("Step 7: Remove clutter and roads from urban. (NLCD_" + year + "_" + state + part + "_Urban-Only_4326)")

##################### Step 8: Combine grass only and clean urban #####################

input_path_a = path + state + '/data/NLCD_' + year + '_' + state + part + '_Urban-Only_4326.tiff'
input_path_b = path + state + '/data/NLCD_' + year + '_' + state + part + '_Grass-Only_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Combined-Clean_4326.tiff'

expression = (
'((A > 0) & (B > 0)) * A + '
'((A <= 0) | (B <= 0)) * B'
)
command = [
'gdal_calc.py',
'-A', input_path_a,
'-B', input_path_b,
'--outfile', output_path,
'--calc', expression,
'--NoDataValue', '0',
'--type', 'Byte'
]
subprocess.run(command)
#Windows OS uses
#subprocess.run(command, shell=True)

print("Step 8: Combined and clean completed. (NLCD_" + year + "_" + state + part + "_Combined-Clean_4326)")

##################### Step 9: Upsample to HD #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Combined-Clean_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Combined-Clean-HD_4326.tiff'

# Open the original raster
ds = gdal.Open(input_path)
gt = ds.GetGeoTransform()

# Extract the original resolution
original_xRes = gt[1]
original_yRes = abs(gt[5])

# Define the percentage to resize by (e.g., 0.50 for 50%, 2.0 for 200%)
#defined at the beginning of the script
#percentage = 8.0

# Calculate the new resolution
new_xRes = original_xRes / percentage
new_yRes = original_yRes / percentage

# Perform the warp (resampling)
gdal.Warp(
output_path,
input_path,
xRes=new_xRes,
yRes=new_yRes,
outputType=gdal.GDT_Byte # Set the output type to uint8
)

print("Step 9: Upsample to. (NLCD_" + year + "_" + state + part + "_Combined-Clean-HD_4326)")

##################### Step 10: Smooth all features in original dataset #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Combined-Clean-HD_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Smoothed-HD_4326.tiff'

processing.run(
"grass7:r.neighbors",
{
'input':input_path,
'selection':None,
'method':3, #1=median, 3=mode
'size':size,
'gauss':None,
'quantile':'',
'-c':False,
'-a':False,
'weight':'',
'output':output_path,
'GRASS_REGION_CELLSIZE_PARAMETER':0,
'GRASS_RASTER_FORMAT_OPT': 'TYPE=BYTE',
'GRASS_RASTER_FORMAT_META':''
}
)

print("Step 10: Smooth all features in original dataset completed. (NLCD_" + year + "_" + state + part + "_Smoothed-HD_4326)")

##################### Step 11: Compress and insure 8Bit #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Smoothed-HD_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Smoothed-HD-Compressed_4326.tiff'

processing.run(
"gdal:translate",
{
'INPUT':input_path,
'TARGET_CRS':None,
'NODATA':0,
'COPY_SUBDATASETS':False,
'OPTIONS':'',
'EXTRA':'',
'DATA_TYPE':1,
'OUTPUT':output_path,
'OPTIONS': 'COMPRESS=LZW'
}
)

result_bit_conversion_layer = QgsRasterLayer(output_path, 'NLCD_' + year + '_' + state + part + '_Smoothed-HD-Compressed_4326')
QgsProject.instance().addMapLayer(result_bit_conversion_layer)

print("Step 11: Convert to Compressed. (NLCD_" + year + "_" + state + part + "_Smoothed-HD-Compressed_4326)")

</syntaxhighlight>

Python script to process Sentinel-2 data

2026-04-30T02:26:47Z

Wlbragg: /* Python script to process Sentinel-2 data */

== Python script to process Sentinel-2 data ==

<syntaxhighlight lang="text">
from qgis.core import QgsApplication, QgsCoordinateTransform, QgsProject, QgsRasterLayer, QgsCoordinateReferenceSystem, QgsProcessingException, QgsRasterBlock, QgsRectangle
from qgis.analysis import QgsRasterCalculator, QgsRasterCalculatorEntry
from qgis import processing
from processing.core.Processing import Processing
from osgeo import gdal, osr, ogr
import os
import numpy
import numpy as np
import subprocess

# Define input layer names, change according to your file names
path = '/mnt/Windows/';
country = 'Alabama';
part = '16R_20250101-20251231';

#ratio of upscale to smoothing
percentage = 9
size = 15

################################## IMPORTANT ###############################
# Beginning filename of the NLCD from the source needs to be
# 'xxxxxxxxxxxxxxxx.tif'
# Also note that "/source/" and "/data/" is hardcoded into the path as well
# I needed the existing path structure to process it by state.
# Example beginning Sentinel-2 source:
# 16R_20250101-20251231.tif
# Full path and filename to source example is:
# G:/Scenery/ws3.0/Alaska/source/Sentinel-2_Alaska141-140_60.tif
# Final output path to last processed file is:
# G:/Scenery/ws3.0/Alaska/data/Sentinel-2_Alaska141-140_60_Smoothed-HD-Compressed_4326.tiff
############################################################################

################################################################### Step 1: Warp land cover 4326 ############################################################

input_path = path + country + '/data/Sentinel-2/' + part + '.tif'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Land_Cover_4326.tiff'

#import os
#print("Exists:", os.path.exists(input_path))
#print("Dir exists:", os.path.exists(os.path.dirname(input_path)))
#print("Writable:", os.access(os.path.dirname(input_path), os.W_OK))

processing.run(
"gdal:warpreproject",
{
'INPUT':input_path,
'SOURCE_CRS':None,
'TARGET_CRS':QgsCoordinateReferenceSystem('EPSG:4326'),
'RESAMPLING':0,
'NODATA':None,
'TARGET_RESOLUTION':None,
'OPTIONS':'',
'DATA_TYPE':1, # GDAL GDT_Byte
'TARGET_EXTENT':None,
'TARGET_EXTENT_CRS':None,
'MULTITHREADING':False,
'EXTRA':'',
'OUTPUT':output_path
}
)

print("Step 1: Warp land_cover completed. (Sentinel-2_" + country + part + "_Land_Cover_4326)")

############################################################## Step 2: Replace urban and clutter with grass ###################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Land_Cover_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Grass-Only_4326.tiff'

expression = (
'(A == 0) * 44 + '
'(A == 1) * 41 + '
'(A == 2) * 23 + '
'(A == 3) * 44 + '
'(A == 4) * 35 + '
'(A == 5) * 21 + '
'(A == 6) * 44 + '
'(A == 7) * 26 + '
'(A == 8) * 31 + '
'(A == 9) * 34 + '
'(A == 10) * 26 + '
'(A == 11) * 26'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows OS uses
#subprocess.run(command, shell=True)

print("Step 2: Replace urban and clutter with grass completed. (Sentinel-2_" + country + part + "_Grass-Only_4326)")

################################################################## Step 3: Reclass urban 2 ###########################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Land_Cover_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Reclassed-Urban_4326.tiff'

expression = (
'(A == 2)*7'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command)
#Windows OS uses
#subprocess.run(command, shell=True)

print("Step 3: Reclass urban completed. (Sentinel-2_" + country + part + "_Reclassed-Urban_4326)")

################################################################ Step 4: Remove clutter and roads from urban ###########################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Reclassed-Urban_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Urban-Only_4326.tiff'

processing.run(
"grass7:r.neighbors",
{
'input':input_path,
'selection':None,
'method':1, #1=median, 2=mode
'size':7,
'gauss':None,
'quantile':'',
'-c':False,
'-a':False,
'weight':'',
'output':output_path,
'GRASS_REGION_PARAMETER':None,
'GRASS_REGION_CELLSIZE_PARAMETER':0,
'GRASS_RASTER_FORMAT_OPT': 'TYPE=BYTE',
'GRASS_RASTER_FORMAT_META':''
}
)

print("Step 4: Remove clutter and roads from urban. (Sentinel-2_" + country + part + "_Urban-Only_4326)")

############################################################## Step 5: Combine grass only and clean urban #########################################################

input_path_a = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Urban-Only_4326.tiff'
input_path_b = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Grass-Only_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean_4326.tiff'

expression = (
'((A > 0) & (B > 0)) * A + '
'((A <= 0) | (B <= 0)) * B'
)
command = [
'gdal_calc.py',
'-A', input_path_a,
'-B', input_path_b,
'--outfile', output_path,
'--calc', expression,
'--NoDataValue', '0',
'--type', 'Byte'
]
subprocess.run(command)
#Windows OS uses
#subprocess.run(command, shell=True)

print("Step 5: Combined and clean completed. (Sentinel-2_" + country + part + "_Combined-Clean_4326)")

################################################################## Step 6: Upsample to HD #################################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean-HD_4326.tiff'

# Open the original raster
ds = gdal.Open(input_path)
gt = ds.GetGeoTransform()

# Extract the original resolution
original_xRes = gt[1]
original_yRes = abs(gt[5])

# Define the percentage to resize by (e.g., 0.50 for 50%, 2.0 for 200%)
#defined at the begining of the script
#percentage = 8.0 # Adjust this as needed

# Calculate the new resolution
new_xRes = original_xRes / percentage
new_yRes = original_yRes / percentage

# Perform the warp (resampling)
gdal.Warp(
output_path,
input_path,
xRes=new_xRes,
yRes=new_yRes,
outputType=gdal.GDT_Byte # Set the output type to uint8
)

print("Step 6: Upsample to. (Sentinel-2_" + country + part + "_Combined-Clean-HD_4326)")

################################################################## Step 7: Smooth all features in original dataset #################################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Combined-Clean-HD_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Smoothed-HD_4326.tiff'

processing.run(
"grass7:r.neighbors",
{
'input':input_path,
'selection':None,
'method':3, #1=median, 3=mode
'size':size,
'gauss':None,
'quantile':'',
'-c':False,
'-a':False,
'weight':'',
'output':output_path,
'GRASS_REGION_CELLSIZE_PARAMETER':0,
'GRASS_RASTER_FORMAT_OPT': 'TYPE=BYTE',
'GRASS_RASTER_FORMAT_META':''
}
)

print("Step 7: Smooth all features in original dataset completed. (Sentinel-2_" + country + part + "_Smoothed-HD_4326)")

################################################################## Step 8: Convert to 8Bit #################################################################

input_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Smoothed-HD_4326.tiff'
output_path = path + country + '/data/Sentinel-2/Sentinel-2_' + country + part + '_Smoothed-HD-Compressed_4326.tiff'

processing.run(
"gdal:translate",
{
'INPUT':input_path,
'TARGET_CRS':None,
'NODATA':0,
'COPY_SUBDATASETS':False,
'OPTIONS':'',
'EXTRA':'',
'DATA_TYPE':1,
'OUTPUT':output_path,
'OPTIONS': 'COMPRESS=LZW'
}
)

result_bit_conversion_layer = QgsRasterLayer(output_path, 'Sentinel-2_' + country + part + '_Smoothed-HD-Compressed_4326')
QgsProject.instance().addMapLayer(result_bit_conversion_layer)

print("Step 8: Convert to Compressed. (Sentinel-2_" + country + part + "_Smoothed-HD-Compressed_4326)")

</syntaxhighlight>

Python script to process Sentinel-2 data

2026-04-29T15:25:46Z

Wlbragg: /* Python script to process Sentinel-2 data */

== Python script to process Sentinel-2 data ==

<syntaxhighlight lang="text">
from qgis.core import QgsApplication, QgsCoordinateTransform, QgsProject, QgsRasterLayer, QgsCoordinateReferenceSystem, QgsProcessingException, QgsRasterBlock, QgsRectangle
from qgis.analysis import QgsRasterCalculator, QgsRasterCalculatorEntry
from qgis import processing
from processing.core.Processing import Processing
from osgeo import gdal, osr, ogr
import os
import numpy
import numpy as np
import subprocess

#Define input layer names, change according to your file names

path = 'G:/Scenery/ws3.0/';
country = 'Alabama';
part = '16R_20250101-20251231';

#ratio of upscale to smoothing
percentage = 8
size = 11

##################################IMPORTANT ###############################
#Beginning filename of the NLCD from the source needs to be
#'xxxxxxxxxxxxxxxx.tif'
#Also note that "/source/" and "/data/" is hardcoded into the path as well
#I needed the existing path structure to process it by state.
#Example beginning Sentinel-2 source:
#16R_20250101-20251231.tif
#Full path and filename to source example is:
#G:/Scenery/ws3.0/Alaska/source/Sentinel-2_Alaska141-140_60.tif
#Final output path to last processed file is:
#G:/Scenery/ws3.0/Alaska/data/Sentinel-2_Alaska141-140_60_Smoothed-HD-Compressed_4326.tiff
############################################################################

################################## Step 1: Warp land cover 4326 ##################################

input_path = path + country + '/source/' + part + '.tif'
output_path = path + country + '/data/Sentinel-2_' + country + part + '_Land_Cover_4326.tiff'

processing.run(
"gdal:warpreproject",
{
'INPUT':input_path,
'SOURCE_CRS':None,
'TARGET_CRS':QgsCoordinateReferenceSystem('EPSG:4326'),
'RESAMPLING':0,
'NODATA':None,
'TARGET_RESOLUTION':None,
'OPTIONS':'',''
'DATA_TYPE':1, # GDAL GDT_Byte
'TARGET_EXTENT':None,
'TARGET_EXTENT_CRS':None,
'MULTITHREADING':False,
'EXTRA':'',''
'OUTPUT':output_path
}
)

print("Step 1: Warp land_cover completed. (Sentinel-2_" + country + part + "_Land_Cover_4326)")

################################## Step 2: Replace urban and clutter with grass ##################################

input_path = path + country + '/data/Sentinel-2_' + country + part + '_Land_Cover_4326.tiff'
output_path = path + country + '/data/Sentinel-2_' + country + part + '_Grass-Only_4326.tiff'

expression = (
'(A == 0) * 44 + '
'(A == 1) * 41 + '
'(A == 2) * 23 + '
'(A == 3) * 44 + '
'(A == 4) * 35 + '
'(A == 5) * 21 + '
'(A == 6) * 44 + '
'(A == 7) * 26 + '
'(A == 8) * 31 + '
'(A == 9) * 34 + '
'(A == 10) * 26 + '
'(A == 11) * 26'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command, shell=True)

print("Step 2: Replace urban and clutter with grass completed. (Sentinel-2_" + country + part + "_Grass-Only_4326)")

################################## Step 3: Reclass urban 21, 22, 23 or 24 ##################################

input_path = path + country + '/data/Sentinel-2_' + country + part + '_Land_Cover_4326.tiff'
output_path = path + country + '/data/Sentinel-2_' + country + part + '_Reclassed-Urban_4326.tiff'

expression = (
'(A == 2)*7'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command, shell=True)

print("Step 3: Reclass urban completed. (Sentinel-2_" + country + part + "_Reclassed-Urban_4326)")

################################## Step 4: Remove clutter and roads from urban ##################################

input_path = path + country + '/data/Sentinel-2_' + country + part + '_Reclassed-Urban_4326.tiff'
output_path = path + country + '/data/Sentinel-2_' + country + part + '_Urban-Only_4326.tiff'

processing.run(
"grass7:r.neighbors",
{
'input':input_path,
'selection':None,
'method':1, #1=median, 2=mode
'size':7,
'gauss':None,
'quantile':'',''
'-c':False,
'-a':False,
'weight':'',''
'output':output_path,
'GRASS_REGION_PARAMETER':None,
'GRASS_REGION_CELLSIZE_PARAMETER':0,
'GRASS_RASTER_FORMAT_OPT': 'TYPE=BYTE',
'GRASS_RASTER_FORMAT_META':
}
)

print("Step 4: Remove clutter and roads from urban. (Sentinel-2_" + country + part + "_Urban-Only_4326)")

################################## Step 5: Combine grass only and clean urban ##################################

input_path_a = path + country + '/data/Sentinel-2_' + country + part + '_Urban-Only_4326.tiff'
input_path_b = path + country + '/data/Sentinel-2_' + country + part + '_Grass-Only_4326.tiff'
output_path = path + country + '/data/Sentinel-2_' + country + part + '_Combined-Clean_4326.tiff'

expression = (
'((A > 0) & (B > 0)) * A + '
'((A <= 0) | (B <= 0)) * B'
)
command = [
'gdal_calc.py',
'-A', input_path_a,
'-B', input_path_b,
'--outfile', output_path,
'--calc', expression,
'--NoDataValue', '0',
'--type', 'Byte'
]
subprocess.run(command, shell=True)

print("Step 5: Combined and clean completed. (Sentinel-2_" + country + part + "_Combined-Clean_4326)")

################################## Step 6: Upsample to HD ##################################

input_path = path + country + '/data/Sentinel-2_' + country + part + '_Combined-Clean_4326.tiff'
output_path = path + country + '/data/Sentinel-2_' + country + part + '_Combined-Clean-HD_4326.tiff'

#Open the original raster
ds = gdal.Open(input_path)
gt = ds.GetGeoTransform()

#Extract the original resolution
original_xRes = gt[1]
original_yRes = abs(gt[5])

#Define the percentage to resize by (e.g., 0.50 for 50%, 2.0 for 200%)
defined at the begining of the script
#percentage = 8.0 # Adjust this as needed

#Calculate the new resolution
new_xRes = original_xRes / percentage
new_yRes = original_yRes / percentage

#Perform the warp (resampling)
gdal.Warp(
output_path,
input_path,
xRes=new_xRes,
yRes=new_yRes,
outputType=gdal.GDT_Byte # Set the output type to uint8
)

print("Step 6: Upsample to. (Sentinel-2_" + country + part + "_Combined-Clean-HD_4326)")

################################## Step 7: Smooth all features in original dataset ##################################

input_path = path + country + '/data/Sentinel-2_' + country + part + '_Combined-Clean-HD_4326.tiff'
output_path = path + country + '/data/Sentinel-2_' + country + part + '_Smoothed-HD_4326.tiff'

processing.run(
"grass7:r.neighbors",
{
'input':input_path,
'selection':None,
'method':3, #1=median, 3=mode
'size':size,
'gauss':None,
'quantile':'',''
'-c':False,
'-a':False,
'weight':'',''
'output':output_path,
'GRASS_REGION_CELLSIZE_PARAMETER':0,
'GRASS_RASTER_FORMAT_OPT': 'TYPE=BYTE',
'GRASS_RASTER_FORMAT_META':
}
)

print("Step 7: Smooth all features in original dataset completed. (Sentinel-2_" + country + part + "_Smoothed-HD_4326)")

################################## Step 8: Convert to 8Bit ##################################

input_path = path + country + '/data/Sentinel-2_' + country + part + '_Smoothed-HD_4326.tiff'
output_path = path + country + '/data/Sentinel-2_' + country + part + '_Smoothed-HD-Compressed_4326.tiff'

processing.run(
"gdal:translate",
{
'INPUT':input_path,
'TARGET_CRS':None,
'NODATA':0,
'COPY_SUBDATASETS':False,
'OPTIONS':'',''
'EXTRA':'',''
'DATA_TYPE':1,
'OUTPUT':output_path,
'OPTIONS': 'COMPRESS=LZW'
}
)

result_bit_conversion_layer = QgsRasterLayer(output_path, 'Sentinel-2_" + country + part + '_Smoothed-HD-Compressed_4326')
QgsProject.instance().addMapLayer(result_bit_conversion_layer)

print("Step 8: Convert to Compressed. (Sentinel-2_" + country + part + "_Smoothed-HD-Compressed_4326)")
</syntaxhighlight>

Python script to process NLCD for the USA

2026-04-29T15:24:46Z

Wlbragg: /* Optional Python script to process NLCD for the USA */

=== Optional Python script to process NLCD for the USA ===
You can optionally process the NLCD by loading this script in the python console of the QGIS Desktop program.
This python script method produces more refined data than by using the python calculator method above and it is more automated.
If you run this script outside the python console you will need to modify it to locate the data you are processing.
If you save the NLCD tiff's using the same consistent naming convention used in this example it is fairly simple to generate final WS3.0 tiff's to use to generate the scenery.

You will start with an original tree layer and a land cover layer from the MRLC.gov site. See the section "Obtaining NLCD" in the above "Step By Step Procedure for Processing NLCD for the USA using the Raster Calculator" topic.

For example, to start with you will have a couple files named...

NLCD_2021_Tree_Canopy_Alaska141-140_60.tiff

NLCD_2021_Land_Cover_Alaska141-140_60.tiff

In the QGIS program the layer names you start with will be...

NLCD_2021_Tree_Canopy_Alaska141-140_60

NLCD_2021_Land_Cover_Alaska141-140_60

which will refer to the tiff files.

Running this script will generate a bunch of intermediate files including the last file, that will be the final finished file for running in the VPB script or VPB build environment Docker image.

The last file for this example for Alaska would be, NLCD_2021_Alaska141-140_60_Smoothed-HD-Compressed_4326.tiff

<syntaxhighlight lang="python">
from qgis.core import QgsApplication, QgsCoordinateTransform, QgsProject, QgsRasterLayer, QgsCoordinateReferenceSystem, QgsProcessingException, QgsRasterBlock, QgsRectangle
from qgis.analysis import QgsRasterCalculator, QgsRasterCalculatorEntry
from qgis import processing
from processing.core.Processing import Processing
from osgeo import gdal, osr, ogr
import os
import numpy
import numpy as np
import subprocess

# Define input layer names, change according to your file names
path = 'G:/Scenery/ws3.0/';
year = '2021';
state = 'Alaska';
part = '141-140_60';

# Ratio of upsampling to smoothing
percentage = 8
size = 11

################################## IMPORTANT ###############################
# Beginning filename of the NLCD from the source needs to be
# NLCD_' + year + '_Tree_Canopy_' + state + part + '.tiff'
# Also note that "/data/" is hardcoded into the path as well
# I needed the existing path structure to process it by state.
# For Alaska I used one lat and a few lon sections per chunck built.
# I will likely do the entire NLCD coverage area the same in future runs.
# Example beginning NLCD source:
# NLCD_2021_Tree_Canopy_Alaska141-140_60.tiff
# NLCD_2021_Land_Cover_Alaska141-140_60.tiff
# Full path and filename to source example is:
# G:/Scenery/ws3.0/Alaska/data/source/NLCD_2021_Tree_Canopy_Alaska141-140_60.tiff
# G:/Scenery/ws3.0/Alaska/data/source/NLCD_2021_Land_Cover_Alaska141-140_60.tiff
# Final output path to last processed file is:
# G:/Scenery/ws3.0/Alaska/data/NLCD_2021_Alaska141-140_60_Smoothed-HD-Compressed_4326
############################################################################

##################### Step 1: Reclass tree canopy to one landcover type 41, 42, or 43 #####################
#FG NLCD
#23 DeciduousBroadCover 41
#24 EvergreenForest 42
#25 MixedForest 43

# Define input and output paths
input_path = path + state + '/data/source/NLCD_' + year + '_Tree_Canopy_' + state + part + '.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Trees-Combined.tiff'

expression = (
'((A > 0) & (A < 255)) * 43 + '
'(A <= 0) * A'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command, shell=True)

print("Step 1: Calculate result_tree_canopy completed. (NLCD_" + year + "_" + state + part + "_Trees-Combined)")

##################### Step 2: Warp tree canopy to 4326 #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Trees-Combined.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Tree_Canopy_4326.tiff'

processing.run(
"gdal:warpreproject",
{
'INPUT':input_path,
'SOURCE_CRS':None,
'TARGET_CRS':QgsCoordinateReferenceSystem('EPSG:4326'),
'RESAMPLING':0,
'NODATA':None,
'TARGET_RESOLUTION':None,
'OPTIONS':'',
'DATA_TYPE':1, # GDAL GDT_Byte
'TARGET_EXTENT':None,
'TARGET_EXTENT_CRS':None,
'MULTITHREADING':False,
'EXTRA':'',
'OUTPUT':output_path
}
)

print("Step 2: Warp tree_canopy completed. (NLCD_" + year + "_" + state + part + "_Tree_Canopy_4326)")

##################### Step 3: Warp land cover 4326 #####################

input_path = path + state + '/data/source/NLCD_' + year + '_Land_Cover_' + state + part + '.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Land_Cover_4326.tiff'

processing.run(
"gdal:warpreproject",
{
'INPUT':input_path,
'SOURCE_CRS':None,
'TARGET_CRS':QgsCoordinateReferenceSystem('EPSG:4326'),
'RESAMPLING':0,
'NODATA':None,
'TARGET_RESOLUTION':None,
'OPTIONS':'',
'DATA_TYPE':1, # GDAL GDT_Byte
'TARGET_EXTENT':None,
'TARGET_EXTENT_CRS':None,
'MULTITHREADING':False,
'EXTRA':'',
'OUTPUT':output_path
}
)

print("Step 3: Warp land_cover completed. (NLCD_" + year + "_" + state + part + "_Land_Cover_4326)")

##################### Step 4: Combine land cover 4326 and tree canopy 4326 #####################

input_path_a = path + state + '/data/NLCD_' + year + '_' + state + part + '_Tree_Canopy_4326.tiff'
input_path_b = path + state + '/data/NLCD_' + year + '_' + state + part + '_Land_Cover_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Tree_Land_Combined_4326.tiff'

expression = (
'(((B > 0) & (B < 255)) & (B != 41) & (B != 42) & (B != 43) & (A > 0)) * A + '
'((B == 41) | (B == 42) | (B == 43) | (A <= 0)) * B'
)
command = [
'gdal_calc.py',
'-A', input_path_a,
'-B', input_path_b,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command, shell=True)

print("Step 4: Combine tree canopy and land cover completed. (NLCD_" + year + "_" + state + part + "_Tree_Land_Combined_4326)")

##################### Step 5: Replace urban and clutter with grass #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Tree_Land_Combined_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Grass-Only_4326.tiff'

expression = (
'(A == 0) * 44 + '
'(A == 11) * 41 + '
'(A == 12) * 34 + '
'(A == 21) * 26 + '
'(A == 22) * 26 + '
'(A == 23) * 26 + '
'(A == 24) * 26 + '
'(A == 31) * 27 + '
'(A == 41) * 23 + '
'(A == 42) * 24 + '
'(A == 43) * 25 + '
'(A == 51) * 30 + '
'(A == 52) * 29 + '
'(A == 71) * 26 + '
'(A == 72) * 32 + '
'(A == 73) * 31 + '
'(A == 74) * 31 + '
'(A == 75) * 32 + '
'(A == 81) * 18 + '
'(A == 82) * 19 + '
'(A == 90) * 25 + '
'(A == 95) * 35'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command, shell=True)

print("Step 5: Replace urban and clutter with grass completed. (NLCD_" + year + "_" + state + part + "_Grass-Only_4326)")

##################### Step 6: Reclass urban 21, 22, 23 or 24 #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Tree_Land_Combined_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Reclassed-Urban_4326.tiff'

expression = (
'(A == 21)*10 + '
'(A == 22)*1 + '
'(A == 23)*1 + '
'(A == 24)*2'
)
command = [
'gdal_calc.py',
'-A', input_path,
'--outfile', output_path,
'--calc', expression,
'--type', 'Byte'
]
subprocess.run(command, shell=True)

print("Step 6: Reclass urban completed. (NLCD_" + year + "_" + state + part + "_Reclassed-Urban_4326)")

##################### Step 7: Remove clutter and roads from urban #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Reclassed-Urban_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Urban-Only_4326.tiff'

processing.run(
"grass7:r.neighbors",
{
'input':input_path,
'selection':None,
'method':1, #1=median, 2=mode
'size':7,
'gauss':None,
'quantile':'',
'-c':False,
'-a':False,
'weight':'',
'output':output_path,
'GRASS_REGION_PARAMETER':None,
'GRASS_REGION_CELLSIZE_PARAMETER':0,
'GRASS_RASTER_FORMAT_OPT': 'TYPE=BYTE',
'GRASS_RASTER_FORMAT_META':''
}
)

print("Step 7: Remove clutter and roads from urban. (NLCD_" + year + "_" + state + part + "_Urban-Only_4326)")

##################### Step 8: Combine grass only and clean urban #####################

input_path_a = path + state + '/data/NLCD_' + year + '_' + state + part + '_Urban-Only_4326.tiff'
input_path_b = path + state + '/data/NLCD_' + year + '_' + state + part + '_Grass-Only_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Combined-Clean_4326.tiff'

expression = (
'((A > 0) & (B > 0)) * A + '
'((A <= 0) | (B <= 0)) * B'
)
command = [
'gdal_calc.py',
'-A', input_path_a,
'-B', input_path_b,
'--outfile', output_path,
'--calc', expression,
'--NoDataValue', '0',
'--type', 'Byte'
]
subprocess.run(command, shell=True)

print("Step 8: Combined and clean completed. (NLCD_" + year + "_" + state + part + "_Combined-Clean_4326)")

##################### Step 9: Upsample to HD #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Combined-Clean_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Combined-Clean-HD_4326.tiff'

# Open the original raster
ds = gdal.Open(input_path)
gt = ds.GetGeoTransform()

# Extract the original resolution
original_xRes = gt[1]
original_yRes = abs(gt[5])

# Define the percentage to resize by (e.g., 0.50 for 50%, 2.0 for 200%)
#defined at the beginning of the script
#percentage = 8.0

# Calculate the new resolution
new_xRes = original_xRes / percentage
new_yRes = original_yRes / percentage

# Perform the warp (resampling)
gdal.Warp(
output_path,
input_path,
xRes=new_xRes,
yRes=new_yRes,
outputType=gdal.GDT_Byte # Set the output type to uint8
)

print("Step 9: Upsample to. (NLCD_" + year + "_" + state + part + "_Combined-Clean-HD_4326)")

##################### Step 10: Smooth all features in original dataset #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Combined-Clean-HD_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Smoothed-HD_4326.tiff'

processing.run(
"grass7:r.neighbors",
{
'input':input_path,
'selection':None,
'method':3, #1=median, 3=mode
'size':size,
'gauss':None,
'quantile':'',
'-c':False,
'-a':False,
'weight':'',
'output':output_path,
'GRASS_REGION_CELLSIZE_PARAMETER':0,
'GRASS_RASTER_FORMAT_OPT': 'TYPE=BYTE',
'GRASS_RASTER_FORMAT_META':''
}
)

print("Step 10: Smooth all features in original dataset completed. (NLCD_" + year + "_" + state + part + "_Smoothed-HD_4326)")

##################### Step 11: Compress and insure 8Bit #####################

input_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Smoothed-HD_4326.tiff'
output_path = path + state + '/data/NLCD_' + year + '_' + state + part + '_Smoothed-HD-Compressed_4326.tiff'

processing.run(
"gdal:translate",
{
'INPUT':input_path,
'TARGET_CRS':None,
'NODATA':0,
'COPY_SUBDATASETS':False,
'OPTIONS':'',
'EXTRA':'',
'DATA_TYPE':1,
'OUTPUT':output_path,
'OPTIONS': 'COMPRESS=LZW'
}
)

result_bit_conversion_layer = QgsRasterLayer(output_path, 'NLCD_' + year + '_' + state + part + '_Smoothed-HD-Compressed_4326')
QgsProject.instance().addMapLayer(result_bit_conversion_layer)

print("Step 11: Convert to Compressed. (NLCD_" + year + "_" + state + part + "_Smoothed-HD-Compressed_4326)")

</syntaxhighlight>