From 3e734940cdb85c9b123ccd8620a282fdfebe0d38 Mon Sep 17 00:00:00 2001 From: Emanuele Gissi Date: Thu, 24 Aug 2023 13:46:00 +0200 Subject: [PATCH] Improve raster layers self-saving, improve DEUG output, rm old files, modular parameters --- qgis2fds_export_algo.py | 201 +- qgis2fds_params.py | 239 +- qgis2fds_provider.py | 2 - utils2.py | 160 ++ .../tests/golden_gate_remote/FDS/.gitignore | 3 + .../QGIS/golden_gate_remote.qgs | 2123 +++++++++++++++++ .../QGIS/layers/Extent.gpkg | Bin 0 -> 106496 bytes .../golden_gate_remote/QGIS/layers/Fire.gpkg | Bin 0 -> 106496 bytes .../QGIS/sheets/Landfire F13 landuse type.csv | 22 + .../golden_gate_remote/QGIS/sheets/wind.csv | 4 + 10 files changed, 2481 insertions(+), 273 deletions(-) create mode 100644 utils2.py create mode 100644 verification/tests/golden_gate_remote/FDS/.gitignore create mode 100644 verification/tests/golden_gate_remote/QGIS/golden_gate_remote.qgs create mode 100644 verification/tests/golden_gate_remote/QGIS/layers/Extent.gpkg create mode 100644 verification/tests/golden_gate_remote/QGIS/layers/Fire.gpkg create mode 100644 verification/tests/golden_gate_remote/QGIS/sheets/Landfire F13 landuse type.csv create mode 100644 verification/tests/golden_gate_remote/QGIS/sheets/wind.csv diff --git a/qgis2fds_export_algo.py b/qgis2fds_export_algo.py index eaeebcb..dd7dcec 100644 --- a/qgis2fds_export_algo.py +++ b/qgis2fds_export_algo.py @@ -16,9 +16,6 @@ QgsProcessingParameterRasterDestination, QgsProcessingParameterVectorDestination, QgsCoordinateReferenceSystem, - QgsCoordinateTransform, - QgsPointXY, - QgsPoint, QgsField, NULL, edit, @@ -27,7 +24,7 @@ from qgis.PyQt.QtCore import QVariant import processing -import math, time +import time from .qgis2fds_params import * from .types import ( utils, @@ -39,6 +36,7 @@ Texture, Wind, ) +from . import utils2 DEBUG = True @@ -94,13 +92,6 @@ def initAlgorithm(self, config=None): optional=True, ) ) - self.addParameter( - QgsProcessingParameterVectorDestination( - "ExtentDebug", - "Extent debug", - optional=True, - ) - ) def processAlgorithm(self, parameters, context, model_feedback): feedback = QgsProcessingMultiStepFeedback(6, model_feedback) @@ -115,54 +106,45 @@ def processAlgorithm(self, parameters, context, model_feedback): "feedback": feedback, "project": project, } + + # FIXME move to required place + chid = ChidParam.get(**kwargs) fds_path = FDSPathParam.get(**kwargs) - extent_layer = ExtentLayerParam.get(**kwargs) # in project crs - pixel_size = PixelSizeParam.get(**kwargs) - origin = OriginParam.get(**kwargs) # in project crs - dem_layer = DEMLayerParam.get(**kwargs) - landuse_layer = LanduseLayerParam.get(**kwargs) - landuse_type_filepath = LanduseTypeFilepathParam.get(**kwargs) + fire_layer = FireLayer.get(**kwargs) tex_layer = TexLayerParam.get(**kwargs) tex_pixel_size = TexPixelSizeParam.get(**kwargs) nmesh = NMeshParam.get(**kwargs) - cell_size = CellSizeParam.get(**kwargs) + export_obst = ExportOBSTParam.get(**kwargs) t_begin = StartTimeParam.get(**kwargs) t_end = EndTimeParam.get(**kwargs) wind_filepath = WindFilepathParam.get(**kwargs) text_filepath = TextFilepathParam.get(**kwargs) - # Check other params for None values - # origin is checked later - - if landuse_layer: - if not landuse_type_filepath: - raise QgsProcessingException( - f"Specify the landuse type for the {landuse_layer.name()} landuse layer.\n" - ) - if not cell_size: - cell_size = pixel_size + # Get extent_layer and origin + # Calc wgs84_extent and wgs84_origin - # Get wgs84_extent from extent_layer in WGS84 + extent_layer = ExtentLayerParam.get(**kwargs) # in project crs + origin = OriginParam.get(**kwargs) # in project crs wgs84_crs = QgsCoordinateReferenceSystem("EPSG:4326") - wgs84_extent = _transform_extent( + wgs84_extent = utils2.transform_extent( extent=extent_layer.extent(), source_crs=extent_layer.crs(), dest_crs=wgs84_crs, ) - feedback.setProgressText(f"\nWGS84 extent: {wgs84_extent}") - - # Check origin and get wgs84_origin if origin: - wgs84_origin = _transform_point( - point=origin, source_crs=project.crs(), dest_crs=wgs84_crs + wgs84_origin = utils2.transform_point( + point=origin, + source_crs=project.crs(), + dest_crs=wgs84_crs, ) else: - wgs84_origin = wgs84_extent.center() # in project crs + wgs84_origin = wgs84_extent.center() + feedback.setProgressText(f"WGS84 origin: {wgs84_origin}") # Calc applicable UTM crs at the origin @@ -173,42 +155,40 @@ def processAlgorithm(self, parameters, context, model_feedback): # Calc utm_origin - utm_origin = _transform_point( + utm_origin = utils2.transform_point( point=wgs84_origin, source_crs=wgs84_crs, dest_crs=utm_crs, ) feedback.setProgressText(f"UTM origin: {utm_origin}") - # Calc utm_extent - # Align it to pixel_size, better for sampling grid and DEM interpolation + # Get pixel_size + # Calc and adapt utm_extent: + # align it to the pixel_size, better for sampling grid and DEM interpolation + + pixel_size = PixelSizeParam.get(**kwargs) - utm_extent = _transform_extent( + utm_extent = utils2.transform_extent( extent=wgs84_extent, source_crs=wgs84_crs, dest_crs=utm_crs, ) - e = 1e-6 # epsilon used to nudge the native:creategrid algo - w = math.ceil(utm_extent.width() / pixel_size) * pixel_size + e - h = math.ceil(utm_extent.height() / pixel_size) * pixel_size + e - x_min, x_max, y_min, y_max = ( - utm_extent.xMinimum(), - utm_extent.xMaximum(), - utm_extent.yMinimum(), - utm_extent.yMaximum(), - ) - utm_extent.setXMaximum(x_min + w) - utm_extent.setYMinimum(y_max - h) - feedback.setProgressText(f"UTM extent: {utm_extent}") - feedback.setProgressText(f"Extent size: {x_max-x_min:.1f}x{y_max-y_min:.1f}m") + + utm_extent = utils2.get_extent_multiple_of_pixels( + extent=utm_extent, pixel_size=pixel_size, epsilon=1e-6 + ) # epsilon used to nudge the native:creategrid algo + + msg = f"UTM extent size: {utm_extent.width():.1f}x{utm_extent.height():.1f}m" + feedback.setProgressText(msg) if DEBUG: - _run_extent_to_layer( - parameters=parameters, + utils2.show_extent( context=context, feedback=feedback, extent=utm_extent, extent_crs=utm_crs, + name="DEBUG UTM extent", + style="Extent layer style.qml", ) feedback.setCurrentStep(1) @@ -227,7 +207,7 @@ def processAlgorithm(self, parameters, context, model_feedback): "VSPACING": pixel_size, "HOVERLAY": 0.0, "VOVERLAY": 0.0, - "OUTPUT": DEBUG and parameters["UtmGrid"] or QgsProcessing.TEMPORARY_OUTPUT, + "OUTPUT": QgsProcessing.TEMPORARY_OUTPUT, } outputs["UtmGrid"] = processing.run( "native:creategrid", @@ -260,31 +240,19 @@ def processAlgorithm(self, parameters, context, model_feedback): utm_idem_extent = utm_extent.buffered(pixel_size / 2.0 - e) if DEBUG: - _run_extent_to_layer( - parameters=parameters, + utils2.show_extent( context=context, feedback=feedback, extent=utm_idem_extent, extent_crs=utm_crs, + name="DEBUG UTM DEM extent", + style="Extent layer style.qml", ) - # Check DEM layer is local, otherwise save it - - dem_layer = DEMLayerParam.get_local( - algo=self, - parameters=parameters, - context=context, - feedback=feedback, - project=project, - extent=_transform_extent( - extent=utm_idem_extent, source_crs=utm_crs, dest_crs=dem_layer.crs() - ), # FIXME not useful here - ) - - return {} # FIXME - # Clip, reproject, and interpolate the DEM + dem_layer = DEMLayerParam.get(**kwargs, extent=utm_extent, extent_crs=utm_crs) + feedback.setProgressText("\nClip, reproject, and interpolate the DEM...") t0 = time.time() alg_params = { @@ -330,7 +298,7 @@ def processAlgorithm(self, parameters, context, model_feedback): "OFFSET": 0, "RASTER": outputs["Interpolation"]["OUTPUT"], "SCALE": 1, - "OUTPUT": DEBUG and parameters["UtmGrid"] or QgsProcessing.TEMPORARY_OUTPUT, + "OUTPUT": QgsProcessing.TEMPORARY_OUTPUT, } outputs["SetZFromDem"] = processing.run( "native:setzfromraster", @@ -348,14 +316,27 @@ def processAlgorithm(self, parameters, context, model_feedback): # Sample landuse values from landuse layer # The new data column name is bc1 - if landuse_layer and landuse_type_filepath: + landuse_layer = LanduseLayerParam.get( + **kwargs, extent=utm_extent, extent_crs=utm_crs + ) + landuse_type_filepath = LanduseTypeFilepathParam.get(**kwargs) + + if landuse_layer: feedback.setProgressText("\nSample landuse values from landuse layer...") t0 = time.time() + + # Check landuse type exists + + if not landuse_type_filepath: + msg = f"Landuse type not available, cannot proceed." + raise QgsProcessingException(msg) + + # Sample alg_params = { "COLUMN_PREFIX": "bc", # creates the bc1 field from landuse "INPUT": outputs["SetZFromDem"]["OUTPUT"], "RASTERCOPY": landuse_layer, - "OUTPUT": parameters["UtmGrid"], + "OUTPUT": QgsProcessing.TEMPORARY_OUTPUT, } outputs["SampleRasterValues"] = processing.run( "native:rastersampling", @@ -364,13 +345,12 @@ def processAlgorithm(self, parameters, context, model_feedback): feedback=feedback, is_child_algorithm=True, ) - # results["UtmGrid"] = outputs["SampleRasterValues"]["OUTPUT"] sampling_layer = context.getMapLayer( outputs["SampleRasterValues"]["OUTPUT"] ) feedback.setProgressText(f"time: {time.time()-t0:.1f}s") else: - feedback.setProgressText("\nNo landuse layer or type.") + feedback.setProgressText("\nNo landuse layer.") sampling_layer = context.getMapLayer(outputs["SetZFromDem"]["OUTPUT"]) with edit(sampling_layer): # create an empty bc1 field attributes = list((QgsField("bc1", QVariant.Int),)) @@ -381,6 +361,14 @@ def processAlgorithm(self, parameters, context, model_feedback): if feedback.isCanceled(): return {} + if DEBUG: + utils2.show_layer( + context=context, + feedback=feedback, + layer=sampling_layer, + name="DEBUG Sampling layer", + ) + # Get landuse type # (we need landuse_type.bc_out_default and .bc_in_default) @@ -496,6 +484,12 @@ def processAlgorithm(self, parameters, context, model_feedback): if feedback.isCanceled(): return {} + # Get cell_size + + cell_size = CellSizeParam.get(**kwargs) + if not cell_size: + cell_size = pixel_size + domain = Domain( feedback=feedback, utm_crs=utm_crs, @@ -547,57 +541,6 @@ def createInstance(self): # FIXME move elsewhere -def _transform_extent(extent, source_crs, dest_crs): - _tr = QgsCoordinateTransform(source_crs, dest_crs, QgsProject.instance()) - return _tr.transformBoundingBox(extent) - - -def _transform_point(point, source_crs, dest_crs): - _tr = QgsCoordinateTransform(source_crs, dest_crs, QgsProject.instance()) - return _tr.transform(QgsPointXY(point)) - - -def _run_create_spatial_index(parameters, context, feedback, vector_layer): - """Create spatial index of vector layer to speed up the next process.""" - feedback.setProgressText("\nCreate spatial index...") - t0 = time.time() - alg_params = { - "INPUT": vector_layer, - } - output = processing.run( - "native:createspatialindex", - alg_params, - context=context, - feedback=feedback, - is_child_algorithm=True, - ) - feedback.setProgressText(f"time: {time.time()-t0:.1f}s") - return output - - -def _run_extent_to_layer(parameters, context, feedback, extent, extent_crs): - """Show extent as vector layer.""" - x_min, x_max, y_min, y_max = ( - extent.xMinimum(), - extent.xMaximum(), - extent.yMinimum(), - extent.yMaximum(), - ) - extent_str = f"{x_min}, {x_max}, {y_min}, {y_max} [{extent_crs.authid()}]" - feedback.setProgressText(f"Extent to layer: {extent_str} ...") - alg_params = { - "INPUT": extent_str, - "OUTPUT": parameters["ExtentDebug"], # FIXME how to make it unlinked? - } - return processing.run( - "native:extenttolayer", - alg_params, - context=context, - feedback=feedback, - is_child_algorithm=True, - ) - - def _load_fire_layer_bc( parameters, context, feedback, sampling_layer, fire_layer, bc_field, bc_default ): diff --git a/qgis2fds_params.py b/qgis2fds_params.py index 140d220..269c5ab 100644 --- a/qgis2fds_params.py +++ b/qgis2fds_params.py @@ -25,6 +25,7 @@ QgsRasterLayer, ) import os +from . import utils2 class ChidParam: @@ -175,148 +176,6 @@ def get(cls, algo, parameters, context, feedback, project): ) # in project crs -class DEMLayerParam: - label = "dem_layer" - desc = "DEM layer" - default = None - optional = False - - @classmethod - def set(cls, algo, config, project): - defaultValue, _ = project.readEntry("qgis2fds", cls.label, cls.default) - # Suggest first layer name containing "dem" - if not defaultValue: - try: - defaultValue = [ - layer.name() - for layer in project.mapLayers().values() - if "DEM" in layer.name() or "dem" in layer.name() - ][0] - except IndexError: - pass - param = QgsProcessingParameterRasterLayer( - cls.label, - cls.desc, - defaultValue=defaultValue, - optional=cls.optional, - ) - algo.addParameter(param) - - @classmethod - def get(cls, algo, parameters, context, feedback, project): - value = algo.parameterAsRasterLayer(parameters, cls.label, context) - # Check valid - if not value.crs().isValid(): - raise QgsProcessingException( - f"DEM layer CRS {value.crs().description()} not valid, cannot proceed." - ) - project.writeEntry("qgis2fds", cls.label, parameters.get(cls.label)) # protect - feedback.setProgressText(f"{cls.desc}: {value}") - return value - - @classmethod - def get_local( - cls, - algo, - parameters, - context, - feedback, - project, - extent, # in layer crs! - relpath="./layers", - ): - layer = algo.parameterAsRasterLayer(parameters, cls.label, context) - url = layer.source() - if os.path.isfile(url): - return layer - # Make and check absolute path - project_path = project.absolutePath() - if not project_path: - raise QgsProcessingException( - "Save QGIS project to disk, cannot proceed." - ) # FIXME message - path = os.path.join(project_path, relpath) - # Create layers directory - # FIXME see https://stackoverflow.com/questions/273192/how-do-i-create-a-directory-and-any-missing-parent-directories - if not os.path.isdir(path): - feedback.setProgressText(f"Create directory {path}...") - os.makedirs(path, exist_ok=True) - if not os.path.isdir(path): - raise QgsProcessingException( - f"Error creating directory {path}, cannot proceed." - ) - # Save layer - # FIXME set style - filepath = os.path.join(path, f"{layer.name()}_saved.tif") - file_writer = QgsRasterFileWriter(filepath) - pipe = QgsRasterPipe() - provider = layer.dataProvider() - ok = pipe.set(provider.clone()) - if not ok: - raise QgsProcessingException( - f"Error saving layer data (pipe, {ok}), cannot proceed.\n{url}" - ) - feedback.setProgressText(f"pipe prepared. ok: {ok}, url: {url}, path: {path}") - nCols = round(extent.width() / layer.rasterUnitsPerPixelX()) # FIXME - nRows = round(extent.height() / layer.rasterUnitsPerPixelY()) # FIXME - # FIXME align extent with original grid - err = file_writer.writeRaster( - pipe=pipe, nCols=nCols, nRows=nRows, outputExtent=extent, crs=layer.crs() - ) - if err: - raise QgsProcessingException( - f"Error saving layer data (write, {err}), cannot proceed.\n{url}" - ) - feedback.setProgressText(f"tif saved. ok: {ok}, url: {url}, path: {filepath}") - new_layer = QgsRasterLayer(filepath, f"{layer.name()}_saved") # FIXME var name - if not new_layer.isValid(): - raise QgsProcessingException( - f"Error loading saved layer, cannot proceed.\n{url}" - ) - project.addMapLayer(new_layer) - project.writeEntry("qgis2fds", cls.label, filepath) - return new_layer - - -class LanduseLayerParam: - label = "landuse_layer" - desc = "Landuse layer (if not set, landuse is not exported)" - default = None - optional = True - - @classmethod - def set(cls, algo, config, project): - defaultValue, _ = project.readEntry("qgis2fds", cls.label, cls.default) - param = QgsProcessingParameterRasterLayer( - cls.label, - cls.desc, - defaultValue=defaultValue, - optional=cls.optional, - ) - algo.addParameter(param) - - @classmethod - def get(cls, algo, parameters, context, feedback, project): - value = None - if parameters.get(cls.label): - value = algo.parameterAsRasterLayer(parameters, cls.label, context) - if value: - # Check local - url = value.source() - if not os.path.isfile(url): - raise QgsProcessingException( - f"Landuse layer data is not saved locally, cannot proceed.\n{url}" - ) - # Check valid - if not value.crs().isValid(): - raise QgsProcessingException( - f"Landuse layer CRS {value.crs().description()} not valid, cannot proceed." - ) - project.writeEntry("qgis2fds", cls.label, parameters.get(cls.label)) # protect - feedback.setProgressText(f"{cls.desc}: {value}") - return value - - class LanduseTypeFilepathParam: label = "landuse_type_filepath" desc = "Landuse type *.csv file (if not set, landuse is not exported)" @@ -672,3 +531,99 @@ def get(cls, algo, parameters, context, feedback, project): raise QgsProcessingException(f"File {value} not found.") feedback.setProgressText(f"{cls.desc}: {value}") return value + + +# Layer Params + + +class _LayerParam: + label = "example_layer" + desc = "Example layer" + default = None + optional = False + + @classmethod + def set(cls, algo, config, project): + defaultValue, _ = project.readEntry("qgis2fds", cls.label, cls.default) + param = QgsProcessingParameterRasterLayer( + cls.label, + cls.desc, + defaultValue=defaultValue, + optional=cls.optional, + ) + algo.addParameter(param) + + @classmethod + def get(cls, algo, parameters, context, feedback, project, extent, extent_crs): + layer = None + if parameters.get(cls.label): + layer = algo.parameterAsRasterLayer(parameters, cls.label, context) + if layer: + # Check validity + if not layer.crs().isValid(): + msg = f"{cls.desc} CRS {layer.crs().description()} not valid, cannot proceed." + raise QgsProcessingException(msg) + + # Check local otherwise save it + url = layer.source() + if not os.path.isfile(url): + # Make and check absolute path + project_path = project.absolutePath() + if not project_path: + msg = "QGIS project is not saved to disk, cannot proceed." + raise QgsProcessingException(msg) + path = os.path.join(project_path, "layers") + + # Create layers directory + if not os.path.isdir(path): + try: + os.makedirs(path, exist_ok=True) + except: + msg = "Error creating path {path}." + raise QgsProcessingException(msg) + + # Trasform extent to the layer crs + extent = utils2.transform_extent( + extent=extent, + source_crs=extent_crs, + dest_crs=layer.crs(), + ) + + # Save the layer + filename = f"{layer.name()}_downloaded.tif" + filepath = os.path.join(path, filename) + utils2.save_raster_layer(layer=layer, extent=extent, filepath=filepath) + + # Load the layer, but do not link + layer = QgsRasterLayer(filepath, filename) + if not layer.isValid(): + msg = f"Layer {filename} is not valid, cannot proceed.\n{filepath}" + raise QgsProcessingException(msg) + + # Inform the user + msg = f""" +\n{cls.desc} is a link to a *remote data repository*. +The required layer data was just downloaded at: +{filepath} +To avoid downloading again, replace the remote repository with local data. +For help, see: https://github.com/firetools/qgis2fds/wiki/Save-remote-layers +""" + feedback.pushWarning(msg) + + project.writeEntry("qgis2fds", cls.label, parameters.get(cls.label)) # protect + feedback.setProgressText(f"{cls.desc}: {layer}") + return layer + + +class DEMLayerParam(_LayerParam): + label = "dem_layer" + desc = "DEM layer" + default = None + optional = False + + +class LanduseLayerParam(_LayerParam): + label = "landuse_layer" + desc = "Landuse layer (if not set, landuse is not exported)" + default = None + optional = True diff --git a/qgis2fds_provider.py b/qgis2fds_provider.py index fba64f7..0502dac 100644 --- a/qgis2fds_provider.py +++ b/qgis2fds_provider.py @@ -9,7 +9,6 @@ from qgis.core import QgsProcessingProvider from .qgis2fds_export_algo import qgis2fdsExportAlgo -from .extract_server_layer import extractServerLayerAlgorithm class qgis2fdsProvider(QgsProcessingProvider): @@ -30,7 +29,6 @@ def loadAlgorithms(self): Loads all algorithms belonging to this provider. """ self.addAlgorithm(qgis2fdsExportAlgo()) - self.addAlgorithm(extractServerLayerAlgorithm()) def id(self): """ diff --git a/utils2.py b/utils2.py new file mode 100644 index 0000000..1790574 --- /dev/null +++ b/utils2.py @@ -0,0 +1,160 @@ +# -*- coding: utf-8 -*- + +"""qgis2fds utils""" + +__author__ = "Emanuele Gissi" +__date__ = "2020-05-04" +__copyright__ = "(C) 2020 by Emanuele Gissi" +__revision__ = "$Format:%H$" # replaced with git SHA1 + +from qgis.core import ( + QgsCoordinateTransform, + QgsProject, + QgsPointXY, + QgsRectangle, + QgsRasterFileWriter, + QgsRasterPipe, + QgsProcessing, + QgsProcessingException, + QgsRasterLayer, +) +import processing +import os, time, math + + +def transform_extent(extent, source_crs, dest_crs): + _tr = QgsCoordinateTransform(source_crs, dest_crs, QgsProject.instance()) + return _tr.transformBoundingBox(extent) + + +def transform_point(point, source_crs, dest_crs): + _tr = QgsCoordinateTransform(source_crs, dest_crs, QgsProject.instance()) + return _tr.transform(QgsPointXY(point)) + + +def get_extent_aligned_to_raster(layer, extent, nlarger=10): + """Get extent aligned to raster pixels, in the same CRS.""" + # Get raster resolution + xres, yres = layer.rasterUnitsPerPixelX(), layer.rasterUnitsPerPixelY() + # Get top left extent corner coordinates, + # because raster grid starts from top left corner of raster_layer extent + lx0, ly1 = layer.extent().xMinimum(), layer.extent().yMaximum() + # Aligning raster_extent top left corner to raster_layer resolution, + # never reduce its size + x0, y0, x1, y1 = ( + extent.xMinimum(), + extent.yMinimum(), + extent.xMaximum(), + extent.yMaximum(), + ) + x0 = lx0 + (round((x0 - lx0) / xres) * xres) - xres * nlarger + x1 = lx0 + (round((x1 - lx0) / xres) * xres) + xres * nlarger + y0 = ly1 - (round((ly1 - y0) / yres) * yres) - xres * nlarger + y1 = ly1 - (round((ly1 - y1) / yres) * yres) + xres * nlarger + return QgsRectangle(x0, y0, x1, y1) + + +def get_extent_multiple_of_pixels(extent, pixel_size, epsilon): + """Get extent that has sizes exactly multiples of pixel size.""" + epsilon = 1e-6 # epsilon used to nudge the native:creategrid algo + width = math.ceil(extent.width() / pixel_size) * pixel_size + epsilon + height = math.ceil(extent.height() / pixel_size) * pixel_size + epsilon + x0, x1, y0, y1 = ( + extent.xMinimum(), + extent.xMaximum(), + extent.yMinimum(), + extent.yMaximum(), + ) + x1 = x0 + width + y0 = y1 - height + return QgsRectangle(x0, y0, x1, y1) + + +def save_raster_layer(layer, extent, filepath): + """Save aligned extent of layer in path.""" + # Prepare filepath and machinery + file_writer = QgsRasterFileWriter(filepath) + pipe = QgsRasterPipe() + provider = layer.dataProvider() + ok = pipe.set(provider.clone()) + if not ok: + msg = f"Error saving layer data, cannot proceed.\n(pipe, ok: {ok}) {filepath}" + raise QgsProcessingException(msg) + # Get aligned extent and set resolution + extent = get_extent_aligned_to_raster(layer=layer, extent=extent) + xres, yres = layer.rasterUnitsPerPixelX(), layer.rasterUnitsPerPixelY() + nCols = round(extent.width() / xres) + nRows = round(extent.height() / yres) + # Save and check + err = file_writer.writeRaster( + pipe=pipe, nCols=nCols, nRows=nRows, outputExtent=extent, crs=layer.crs() + ) + if err: + msg = ( + f"Error saving layer data, cannot proceed.\n(write, err: {err}) {filepath}" + ) + raise QgsProcessingException(msg) + return filepath + + +def show_extent(context, feedback, extent, extent_crs, name, style=None): + """Show extent as vector layer.""" + x0, x1, y0, y1 = ( + extent.xMinimum(), + extent.xMaximum(), + extent.yMinimum(), + extent.yMaximum(), + ) + extent_str = f"{x0}, {x1}, {y0}, {y1} [{extent_crs.authid()}]" + feedback.setProgressText(f"Extent to layer {name}: {extent_str} ...") + alg_params = { + "INPUT": extent_str, + "OUTPUT": QgsProcessing.TEMPORARY_OUTPUT, + } + output = processing.run( + "native:extenttolayer", + alg_params, + context=context, + feedback=feedback, + is_child_algorithm=True, + ) + show_layer( + context=context, + feedback=feedback, + layer=context.getMapLayer(output["OUTPUT"]), + name=name, + style=style, + ) + + +def show_layer(context, feedback, layer, name=None, style=None): + """Show layer.""" + feedback.setProgressText(f"Show layer {name}: {layer} ...") + if name: + layer.setName(name) + QgsProject.instance().addMapLayer(layer) + if style: + style_pathfile = os.path.join(get_plugin_path(), "styles", style) + layer.loadNamedStyle(style_pathfile) + layer.triggerRepaint() + + +def get_plugin_path(): + """Get current plugin path.""" + return os.path.dirname(os.path.realpath(__file__)) + + +def run_create_spatial_index(parameters, context, feedback, layer): + """Create spatial index of a vector layer to speed up the next process.""" + feedback.setProgressText("\nCreate spatial index...") + t0 = time.time() + alg_params = {"INPUT": layer} + output = processing.run( + "native:createspatialindex", + alg_params, + context=context, + feedback=feedback, + is_child_algorithm=True, + ) + feedback.setProgressText(f"time: {time.time()-t0:.1f}s") + return output diff --git a/verification/tests/golden_gate_remote/FDS/.gitignore b/verification/tests/golden_gate_remote/FDS/.gitignore new file mode 100644 index 0000000..4f2cc7b --- /dev/null +++ b/verification/tests/golden_gate_remote/FDS/.gitignore @@ -0,0 +1,3 @@ +# Ignore all files except myself +* +!.gitignore \ No newline at end of file diff --git a/verification/tests/golden_gate_remote/QGIS/golden_gate_remote.qgs b/verification/tests/golden_gate_remote/QGIS/golden_gate_remote.qgs new file mode 100644 index 0000000..083f9d4 --- /dev/null +++ b/verification/tests/golden_gate_remote/QGIS/golden_gate_remote.qgs @@ -0,0 +1,2123 @@ + + + + + + + + + PROJCRS["NAD83 / Conus Albers",BASEGEOGCRS["NAD83",DATUM["North American Datum 1983",ELLIPSOID["GRS 1980",6378137,298.257222101,LENGTHUNIT["metre",1]]],PRIMEM["Greenwich",0,ANGLEUNIT["degree",0.0174532925199433]],ID["EPSG",4269]],CONVERSION["Conus Albers",METHOD["Albers Equal Area",ID["EPSG",9822]],PARAMETER["Latitude of false origin",23,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8821]],PARAMETER["Longitude of false origin",-96,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8822]],PARAMETER["Latitude of 1st standard parallel",29.5,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8823]],PARAMETER["Latitude of 2nd standard parallel",45.5,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8824]],PARAMETER["Easting at false origin",0,LENGTHUNIT["metre",1],ID["EPSG",8826]],PARAMETER["Northing at false origin",0,LENGTHUNIT["metre",1],ID["EPSG",8827]]],CS[Cartesian,2],AXIS["easting (X)",east,ORDER[1],LENGTHUNIT["metre",1]],AXIS["northing (Y)",north,ORDER[2],LENGTHUNIT["metre",1]],USAGE[SCOPE["Data analysis and small scale data presentation for contiguous lower 48 states."],AREA["United States (USA) - CONUS onshore - Alabama; Arizona; Arkansas; California; Colorado; Connecticut; Delaware; Florida; Georgia; Idaho; Illinois; Indiana; Iowa; Kansas; Kentucky; Louisiana; Maine; Maryland; Massachusetts; Michigan; Minnesota; Mississippi; Missouri; Montana; Nebraska; Nevada; New Hampshire; New Jersey; New Mexico; New York; North Carolina; North Dakota; Ohio; Oklahoma; Oregon; Pennsylvania; Rhode Island; South Carolina; South Dakota; Tennessee; Texas; Utah; Vermont; Virginia; Washington; West Virginia; Wisconsin; Wyoming."],BBOX[24.41,-124.79,49.38,-66.91]],ID["EPSG",5070]] + +proj=aea +lat_0=23 +lon_0=-96 +lat_1=29.5 +lat_2=45.5 +x_0=0 +y_0=0 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs + 28001 + 5070 + EPSG:5070 + NAD83 / Conus Albers + aea + EPSG:7019 + false + + + + + + + + + + + + + + + + + + + + + + + + + + + + _22efb34a_9ea3_43b1_b7ee_81a012af26de + Extent_0642b0c8_932e_418f_9e94_a1a555ee0f05 + Fire_b0dc7bbb_6702_4e71_9afe_8048e4f66b7c + LC22_F13_230_30986d7a_216a_48d1_94b0_9da2b47191f5 + LC20_Elev_220_7c7e310a_6ee4_4098_a418_5cf5198b1e66 + + + + + + + + + + + + meters + + -2280897.22295342106372118 + 1962271.45374332135543227 + -2277236.57532570976763964 + 1965936.13406573003157973 + + 0 + + + PROJCRS["NAD83 / Conus Albers",BASEGEOGCRS["NAD83",DATUM["North American Datum 1983",ELLIPSOID["GRS 1980",6378137,298.257222101,LENGTHUNIT["metre",1]]],PRIMEM["Greenwich",0,ANGLEUNIT["degree",0.0174532925199433]],ID["EPSG",4269]],CONVERSION["Conus Albers",METHOD["Albers Equal Area",ID["EPSG",9822]],PARAMETER["Latitude of false origin",23,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8821]],PARAMETER["Longitude of false origin",-96,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8822]],PARAMETER["Latitude of 1st standard parallel",29.5,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8823]],PARAMETER["Latitude of 2nd standard parallel",45.5,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8824]],PARAMETER["Easting at false origin",0,LENGTHUNIT["metre",1],ID["EPSG",8826]],PARAMETER["Northing at false origin",0,LENGTHUNIT["metre",1],ID["EPSG",8827]]],CS[Cartesian,2],AXIS["easting (X)",east,ORDER[1],LENGTHUNIT["metre",1]],AXIS["northing (Y)",north,ORDER[2],LENGTHUNIT["metre",1]],USAGE[SCOPE["Data analysis and small scale data presentation for contiguous lower 48 states."],AREA["United States (USA) - CONUS onshore - Alabama; Arizona; Arkansas; California; Colorado; Connecticut; Delaware; Florida; Georgia; Idaho; Illinois; Indiana; Iowa; Kansas; Kentucky; Louisiana; Maine; Maryland; Massachusetts; Michigan; Minnesota; Mississippi; Missouri; Montana; Nebraska; Nevada; New Hampshire; New Jersey; New Mexico; New York; North Carolina; North Dakota; Ohio; Oklahoma; Oregon; Pennsylvania; Rhode Island; South Carolina; South Dakota; Tennessee; Texas; Utah; Vermont; Virginia; Washington; West Virginia; Wisconsin; Wyoming."],BBOX[24.41,-124.79,49.38,-66.91]],ID["EPSG",5070]] + +proj=aea +lat_0=23 +lon_0=-96 +lat_1=29.5 +lat_2=45.5 +x_0=0 +y_0=0 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs + 28001 + 5070 + EPSG:5070 + NAD83 / Conus Albers + aea + EPSG:7019 + false + + + 0 + + + + + + + + + + + + + + + + + + + + + + + Annotations_0ce50c8c_f1a5_4897_9f64_f112c78d87d6 + + + + + Annotations + + + PROJCRS["NAD83 / Conus Albers",BASEGEOGCRS["NAD83",DATUM["North American Datum 1983",ELLIPSOID["GRS 1980",6378137,298.257222101,LENGTHUNIT["metre",1]]],PRIMEM["Greenwich",0,ANGLEUNIT["degree",0.0174532925199433]],ID["EPSG",4269]],CONVERSION["Conus Albers",METHOD["Albers Equal Area",ID["EPSG",9822]],PARAMETER["Latitude of false origin",23,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8821]],PARAMETER["Longitude of false origin",-96,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8822]],PARAMETER["Latitude of 1st standard parallel",29.5,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8823]],PARAMETER["Latitude of 2nd standard parallel",45.5,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8824]],PARAMETER["Easting at false origin",0,LENGTHUNIT["metre",1],ID["EPSG",8826]],PARAMETER["Northing at false origin",0,LENGTHUNIT["metre",1],ID["EPSG",8827]]],CS[Cartesian,2],AXIS["easting (X)",east,ORDER[1],LENGTHUNIT["metre",1]],AXIS["northing (Y)",north,ORDER[2],LENGTHUNIT["metre",1]],USAGE[SCOPE["Data analysis and small scale data presentation for contiguous lower 48 states."],AREA["United States (USA) - CONUS onshore - Alabama; Arizona; Arkansas; California; Colorado; Connecticut; Delaware; Florida; Georgia; Idaho; Illinois; Indiana; Iowa; Kansas; Kentucky; Louisiana; Maine; Maryland; Massachusetts; Michigan; Minnesota; Mississippi; Missouri; Montana; Nebraska; Nevada; New Hampshire; New Jersey; New Mexico; New York; North Carolina; North Dakota; Ohio; Oklahoma; Oregon; Pennsylvania; Rhode Island; South Carolina; South Dakota; Tennessee; Texas; Utah; Vermont; Virginia; Washington; West Virginia; Wisconsin; Wyoming."],BBOX[24.41,-124.79,49.38,-66.91]],ID["EPSG",5070]] + +proj=aea +lat_0=23 +lon_0=-96 +lat_1=29.5 +lat_2=45.5 +x_0=0 +y_0=0 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs + 28001 + 5070 + EPSG:5070 + NAD83 / Conus Albers + aea + EPSG:7019 + false + + + + + + + + + + + + + + + + + + 0 + 0 + + + + + false + + + + + + + 1 + 1 + 1 + 0 + + + + 1 + 0 + + + + + + -122.49205780029299717 + 37.82763290405269885 + -122.48023986816400566 + 37.83367156982419743 + + + -122.49205780029299717 + 37.82763290405269885 + -122.48023986816400566 + 37.83367156982419743 + + Extent_0642b0c8_932e_418f_9e94_a1a555ee0f05 + ./layers/Extent.gpkg|layername=Extent + + + + Extent + + + GEOGCRS["WGS 84",ENSEMBLE["World Geodetic System 1984 ensemble",MEMBER["World Geodetic System 1984 (Transit)"],MEMBER["World Geodetic System 1984 (G730)"],MEMBER["World Geodetic System 1984 (G873)"],MEMBER["World Geodetic System 1984 (G1150)"],MEMBER["World Geodetic System 1984 (G1674)"],MEMBER["World Geodetic System 1984 (G1762)"],MEMBER["World Geodetic System 1984 (G2139)"],ELLIPSOID["WGS 84",6378137,298.257223563,LENGTHUNIT["metre",1]],ENSEMBLEACCURACY[2.0]],PRIMEM["Greenwich",0,ANGLEUNIT["degree",0.0174532925199433]],CS[ellipsoidal,2],AXIS["geodetic latitude (Lat)",north,ORDER[1],ANGLEUNIT["degree",0.0174532925199433]],AXIS["geodetic longitude (Lon)",east,ORDER[2],ANGLEUNIT["degree",0.0174532925199433]],USAGE[SCOPE["Horizontal component of 3D system."],AREA["World."],BBOX[-90,-180,90,180]],ID["EPSG",4326]] + +proj=longlat +datum=WGS84 +no_defs + 3452 + 4326 + EPSG:4326 + WGS 84 + longlat + EPSG:7030 + true + + + + + + + dataset + + + + + + + + + + + + + + + + + + GEOGCRS["WGS 84",ENSEMBLE["World Geodetic System 1984 ensemble",MEMBER["World Geodetic System 1984 (Transit)"],MEMBER["World Geodetic System 1984 (G730)"],MEMBER["World Geodetic System 1984 (G873)"],MEMBER["World Geodetic System 1984 (G1150)"],MEMBER["World Geodetic System 1984 (G1674)"],MEMBER["World Geodetic System 1984 (G1762)"],MEMBER["World Geodetic System 1984 (G2139)"],ELLIPSOID["WGS 84",6378137,298.257223563,LENGTHUNIT["metre",1]],ENSEMBLEACCURACY[2.0]],PRIMEM["Greenwich",0,ANGLEUNIT["degree",0.0174532925199433]],CS[ellipsoidal,2],AXIS["geodetic latitude (Lat)",north,ORDER[1],ANGLEUNIT["degree",0.0174532925199433]],AXIS["geodetic longitude (Lon)",east,ORDER[2],ANGLEUNIT["degree",0.0174532925199433]],USAGE[SCOPE["Horizontal component of 3D system."],AREA["World."],BBOX[-90,-180,90,180]],ID["EPSG",4326]] + +proj=longlat +datum=WGS84 +no_defs + 3452 + 4326 + EPSG:4326 + WGS 84 + longlat + EPSG:7030 + true + + + + + + + + + + + + + ogr + + + + + + + + + + + 1 + 1 + 1 + 0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + 0 + 1 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + + + 0 + generatedlayout + + + + + + + + + + + + + + + "fid" + + + + + -122.49008128145599983 + 37.82912004092190017 + -122.48259864265199326 + 37.83262069093999713 + + + -122.49008128145599983 + 37.82912004092190017 + -122.48259864265199326 + 37.83262069093999713 + + Fire_b0dc7bbb_6702_4e71_9afe_8048e4f66b7c + ./layers/Fire.gpkg|layername=Fire + + + + Fire + + + GEOGCRS["WGS 84",ENSEMBLE["World Geodetic System 1984 ensemble",MEMBER["World Geodetic System 1984 (Transit)"],MEMBER["World Geodetic System 1984 (G730)"],MEMBER["World Geodetic System 1984 (G873)"],MEMBER["World Geodetic System 1984 (G1150)"],MEMBER["World Geodetic System 1984 (G1674)"],MEMBER["World Geodetic System 1984 (G1762)"],MEMBER["World Geodetic System 1984 (G2139)"],ELLIPSOID["WGS 84",6378137,298.257223563,LENGTHUNIT["metre",1]],ENSEMBLEACCURACY[2.0]],PRIMEM["Greenwich",0,ANGLEUNIT["degree",0.0174532925199433]],CS[ellipsoidal,2],AXIS["geodetic latitude (Lat)",north,ORDER[1],ANGLEUNIT["degree",0.0174532925199433]],AXIS["geodetic longitude (Lon)",east,ORDER[2],ANGLEUNIT["degree",0.0174532925199433]],USAGE[SCOPE["Horizontal component of 3D system."],AREA["World."],BBOX[-90,-180,90,180]],ID["EPSG",4326]] + +proj=longlat +datum=WGS84 +no_defs + 3452 + 4326 + EPSG:4326 + WGS 84 + longlat + EPSG:7030 + true + + + + + + + dataset + + + + + + + + + + + + + + + + + + GEOGCRS["WGS 84",ENSEMBLE["World Geodetic System 1984 ensemble",MEMBER["World Geodetic System 1984 (Transit)"],MEMBER["World Geodetic System 1984 (G730)"],MEMBER["World Geodetic System 1984 (G873)"],MEMBER["World Geodetic System 1984 (G1150)"],MEMBER["World Geodetic System 1984 (G1674)"],MEMBER["World Geodetic System 1984 (G1762)"],MEMBER["World Geodetic System 1984 (G2139)"],ELLIPSOID["WGS 84",6378137,298.257223563,LENGTHUNIT["metre",1]],ENSEMBLEACCURACY[2.0]],PRIMEM["Greenwich",0,ANGLEUNIT["degree",0.0174532925199433]],CS[ellipsoidal,2],AXIS["geodetic latitude (Lat)",north,ORDER[1],ANGLEUNIT["degree",0.0174532925199433]],AXIS["geodetic longitude (Lon)",east,ORDER[2],ANGLEUNIT["degree",0.0174532925199433]],USAGE[SCOPE["Horizontal component of 3D system."],AREA["World."],BBOX[-90,-180,90,180]],ID["EPSG",4326]] + +proj=longlat +datum=WGS84 +no_defs + 3452 + 4326 + EPSG:4326 + WGS 84 + longlat + EPSG:7030 + true + + + + + + + + + + + + + ogr + + + + + + + + + + + 1 + 1 + 1 + 0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + 0 + 1 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + + + 0 + generatedlayout + + + + + + + + + + + + + + + + + + + + + "fid" + + + + + -2362395 + 221265 + 2327655 + 3267405 + + + -128.38690525209997872 + 22.42840490061946213 + -64.05405005567833143 + 52.48156003561286553 + + LC20_Elev_220_7c7e310a_6ee4_4098_a418_5cf5198b1e66 + dpiMode=7&identifier=landfire_wcs:LC20_Elev_220&tilePixelRatio=0&url=https://edcintl.cr.usgs.gov/geoserver/landfire_wcs/us_topo/wcs + + + + LC20_Elev_220 + + + PROJCRS["NAD83 / Conus Albers",BASEGEOGCRS["NAD83",DATUM["North American Datum 1983",ELLIPSOID["GRS 1980",6378137,298.257222101,LENGTHUNIT["metre",1]]],PRIMEM["Greenwich",0,ANGLEUNIT["degree",0.0174532925199433]],ID["EPSG",4269]],CONVERSION["Conus Albers",METHOD["Albers Equal Area",ID["EPSG",9822]],PARAMETER["Latitude of false origin",23,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8821]],PARAMETER["Longitude of false origin",-96,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8822]],PARAMETER["Latitude of 1st standard parallel",29.5,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8823]],PARAMETER["Latitude of 2nd standard parallel",45.5,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8824]],PARAMETER["Easting at false origin",0,LENGTHUNIT["metre",1],ID["EPSG",8826]],PARAMETER["Northing at false origin",0,LENGTHUNIT["metre",1],ID["EPSG",8827]]],CS[Cartesian,2],AXIS["easting (X)",east,ORDER[1],LENGTHUNIT["metre",1]],AXIS["northing (Y)",north,ORDER[2],LENGTHUNIT["metre",1]],USAGE[SCOPE["Data analysis and small scale data presentation for contiguous lower 48 states."],AREA["United States (USA) - CONUS onshore - Alabama; Arizona; Arkansas; California; Colorado; Connecticut; Delaware; Florida; Georgia; Idaho; Illinois; Indiana; Iowa; Kansas; Kentucky; Louisiana; Maine; Maryland; Massachusetts; Michigan; Minnesota; Mississippi; Missouri; Montana; Nebraska; Nevada; New Hampshire; New Jersey; New Mexico; New York; North Carolina; North Dakota; Ohio; Oklahoma; Oregon; Pennsylvania; Rhode Island; South Carolina; South Dakota; Tennessee; Texas; Utah; Vermont; Virginia; Washington; West Virginia; Wisconsin; Wyoming."],BBOX[24.41,-124.79,49.38,-66.91]],ID["EPSG",5070]] + +proj=aea +lat_0=23 +lon_0=-96 +lat_1=29.5 +lat_2=45.5 +x_0=0 +y_0=0 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs + 28001 + 5070 + EPSG:5070 + NAD83 / Conus Albers + aea + EPSG:7019 + false + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + 0 + + + + + false + + + + + + + + + + + + + wcs + + + + + + + + + 1 + 1 + 0 + 0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + None + WholeRaster + Estimated + 0.02 + 0.98 + 2 + + + + + + resamplingFilter + + 6 + + + + -2362395 + 258945 + 2263815 + 3177435 + + + -127.98737642604235987 + 22.76578041143468667 + -65.25444546636926191 + 51.64961241643037226 + + LC22_F13_230_30986d7a_216a_48d1_94b0_9da2b47191f5 + dpiMode=7&identifier=landfire_wcs:LC22_F13_230&tilePixelRatio=0&url=https://edcintl.cr.usgs.gov/geoserver/landfire_wcs/us_230/wcs + + + + LC22_F13_230 + + + PROJCRS["NAD83 / Conus Albers",BASEGEOGCRS["NAD83",DATUM["North American Datum 1983",ELLIPSOID["GRS 1980",6378137,298.257222101,LENGTHUNIT["metre",1]]],PRIMEM["Greenwich",0,ANGLEUNIT["degree",0.0174532925199433]],ID["EPSG",4269]],CONVERSION["Conus Albers",METHOD["Albers Equal Area",ID["EPSG",9822]],PARAMETER["Latitude of false origin",23,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8821]],PARAMETER["Longitude of false origin",-96,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8822]],PARAMETER["Latitude of 1st standard parallel",29.5,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8823]],PARAMETER["Latitude of 2nd standard parallel",45.5,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8824]],PARAMETER["Easting at false origin",0,LENGTHUNIT["metre",1],ID["EPSG",8826]],PARAMETER["Northing at false origin",0,LENGTHUNIT["metre",1],ID["EPSG",8827]]],CS[Cartesian,2],AXIS["easting (X)",east,ORDER[1],LENGTHUNIT["metre",1]],AXIS["northing (Y)",north,ORDER[2],LENGTHUNIT["metre",1]],USAGE[SCOPE["Data analysis and small scale data presentation for contiguous lower 48 states."],AREA["United States (USA) - CONUS onshore - Alabama; Arizona; Arkansas; California; Colorado; Connecticut; Delaware; Florida; Georgia; Idaho; Illinois; Indiana; Iowa; Kansas; Kentucky; Louisiana; Maine; Maryland; Massachusetts; Michigan; Minnesota; Mississippi; Missouri; Montana; Nebraska; Nevada; New Hampshire; New Jersey; New Mexico; New York; North Carolina; North Dakota; Ohio; Oklahoma; Oregon; Pennsylvania; Rhode Island; South Carolina; South Dakota; Tennessee; Texas; Utah; Vermont; Virginia; Washington; West Virginia; Wisconsin; Wyoming."],BBOX[24.41,-124.79,49.38,-66.91]],ID["EPSG",5070]] + +proj=aea +lat_0=23 +lon_0=-96 +lat_1=29.5 +lat_2=45.5 +x_0=0 +y_0=0 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs + 28001 + 5070 + EPSG:5070 + NAD83 / Conus Albers + aea + EPSG:7019 + false + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + 0 + + + + + false + + + + + + + + + + + + + wcs + + + + + + + + + 1 + 1 + 0 + 0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + None + WholeRaster + Estimated + 0.02 + 0.98 + 2 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + resamplingFilter + + 6 + + + + -20037508.34278924390673637 + -20037508.34278924763202667 + 20037508.34278924390673637 + 20037508.34278924763202667 + + + -180 + -85.05112877980660357 + 179.99999999999997158 + 85.05112877980660357 + + _22efb34a_9ea3_43b1_b7ee_81a012af26de + crs=EPSG:3857&format&type=xyz&url=https://tile.openstreetmap.org/%7Bz%7D/%7Bx%7D/%7By%7D.png&zmax=19&zmin=0 + + + + OpenStreetMap + + + PROJCRS["WGS 84 / Pseudo-Mercator",BASEGEOGCRS["WGS 84",ENSEMBLE["World Geodetic System 1984 ensemble",MEMBER["World Geodetic System 1984 (Transit)"],MEMBER["World Geodetic System 1984 (G730)"],MEMBER["World Geodetic System 1984 (G873)"],MEMBER["World Geodetic System 1984 (G1150)"],MEMBER["World Geodetic System 1984 (G1674)"],MEMBER["World Geodetic System 1984 (G1762)"],MEMBER["World Geodetic System 1984 (G2139)"],ELLIPSOID["WGS 84",6378137,298.257223563,LENGTHUNIT["metre",1]],ENSEMBLEACCURACY[2.0]],PRIMEM["Greenwich",0,ANGLEUNIT["degree",0.0174532925199433]],ID["EPSG",4326]],CONVERSION["Popular Visualisation Pseudo-Mercator",METHOD["Popular Visualisation Pseudo Mercator",ID["EPSG",1024]],PARAMETER["Latitude of natural origin",0,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8801]],PARAMETER["Longitude of natural origin",0,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8802]],PARAMETER["False easting",0,LENGTHUNIT["metre",1],ID["EPSG",8806]],PARAMETER["False northing",0,LENGTHUNIT["metre",1],ID["EPSG",8807]]],CS[Cartesian,2],AXIS["easting (X)",east,ORDER[1],LENGTHUNIT["metre",1]],AXIS["northing (Y)",north,ORDER[2],LENGTHUNIT["metre",1]],USAGE[SCOPE["Web mapping and visualisation."],AREA["World between 85.06°S and 85.06°N."],BBOX[-85.06,-180,85.06,180]],ID["EPSG",3857]] + +proj=merc +a=6378137 +b=6378137 +lat_ts=0 +lon_0=0 +x_0=0 +y_0=0 +k=1 +units=m +nadgrids=@null +wktext +no_defs + 3857 + 3857 + EPSG:3857 + WGS 84 / Pseudo-Mercator + merc + EPSG:7030 + false + + + + OpenStreetMap tiles + + + dataset + OpenStreetMap tiles + OpenStreetMap is built by a community of mappers that contribute and maintain data about roads, trails, cafés, railway stations, and much more, all over the world. + + + + + + Base map and data from OpenStreetMap and OpenStreetMap Foundation (CC-BY-SA). © https://www.openstreetmap.org and contributors. + Open Data Commons Open Database License (ODbL) + Creative Commons Attribution-ShareAlike (CC-BY-SA) + + + + PROJCRS["WGS 84 / Pseudo-Mercator",BASEGEOGCRS["WGS 84",ENSEMBLE["World Geodetic System 1984 ensemble",MEMBER["World Geodetic System 1984 (Transit)"],MEMBER["World Geodetic System 1984 (G730)"],MEMBER["World Geodetic System 1984 (G873)"],MEMBER["World Geodetic System 1984 (G1150)"],MEMBER["World Geodetic System 1984 (G1674)"],MEMBER["World Geodetic System 1984 (G1762)"],MEMBER["World Geodetic System 1984 (G2139)"],ELLIPSOID["WGS 84",6378137,298.257223563,LENGTHUNIT["metre",1]],ENSEMBLEACCURACY[2.0]],PRIMEM["Greenwich",0,ANGLEUNIT["degree",0.0174532925199433]],ID["EPSG",4326]],CONVERSION["Popular Visualisation Pseudo-Mercator",METHOD["Popular Visualisation Pseudo Mercator",ID["EPSG",1024]],PARAMETER["Latitude of natural origin",0,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8801]],PARAMETER["Longitude of natural origin",0,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8802]],PARAMETER["False easting",0,LENGTHUNIT["metre",1],ID["EPSG",8806]],PARAMETER["False northing",0,LENGTHUNIT["metre",1],ID["EPSG",8807]]],CS[Cartesian,2],AXIS["easting (X)",east,ORDER[1],LENGTHUNIT["metre",1]],AXIS["northing (Y)",north,ORDER[2],LENGTHUNIT["metre",1]],USAGE[SCOPE["Web mapping and visualisation."],AREA["World between 85.06°S and 85.06°N."],BBOX[-85.06,-180,85.06,180]],ID["EPSG",3857]] + +proj=merc +a=6378137 +b=6378137 +lat_ts=0 +lon_0=0 +x_0=0 +y_0=0 +k=1 +units=m +nadgrids=@null +wktext +no_defs + 3857 + 3857 + EPSG:3857 + WGS 84 / Pseudo-Mercator + merc + EPSG:7030 + false + + + + + + + wms + + + + + + + + + 1 + 1 + 0 + 0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + None + WholeRaster + Estimated + 0.02 + 0.98 + 2 + + + + + + resamplingFilter + + 0 + + + + + + + + + + + + 0 + + + 255 + 255 + 255 + 255 + 0 + 255 + 255 + + + false + + + + + + EPSG:7019 + + + m2 + meters + + + 5 + 2.5 + false + false + false + 1 + 0 + false + false + true + 0 + 255,0,0,255 + + + false + + + true + 2 + + false + + 1 + + + + + + + + + + + None + false + false + + + + + + 1 + false + conditions unknown + 90 + + + + 1 + + 8 + + false + + false + + 0 + + false + + + + + + + + false + + + + + false + + 5000 + + + + false + + + + 10 + golden_gate_local + LC20_Elev_220_7c7e310a_6ee4_4098_a418_5cf5198b1e66 + false + Extent_0642b0c8_932e_418f_9e94_a1a555ee0f05 + ../FDS + Fire_b0dc7bbb_6702_4e71_9afe_8048e4f66b7c + LC22_F13_230_30986d7a_216a_48d1_94b0_9da2b47191f5 + ./sheets/Landfire F13 landuse type.csv + 4 + -2279359.733937,1963331.421795 [EPSG:5070] + 10 + 0 + 30 + + 2 + + /home/egissi/Documenti/Git/qgis2fds/verification/tests/golden_gate_local/QGIS/sheets/wind.csv + + + + + + + + + + + PROJCRS["WGS 84 / Pseudo-Mercator",BASEGEOGCRS["WGS 84",ENSEMBLE["World Geodetic System 1984 ensemble",MEMBER["World Geodetic System 1984 (Transit)"],MEMBER["World Geodetic System 1984 (G730)"],MEMBER["World Geodetic System 1984 (G873)"],MEMBER["World Geodetic System 1984 (G1150)"],MEMBER["World Geodetic System 1984 (G1674)"],MEMBER["World Geodetic System 1984 (G1762)"],MEMBER["World Geodetic System 1984 (G2139)"],ELLIPSOID["WGS 84",6378137,298.257223563,LENGTHUNIT["metre",1]],ENSEMBLEACCURACY[2.0]],PRIMEM["Greenwich",0,ANGLEUNIT["degree",0.0174532925199433]],ID["EPSG",4326]],CONVERSION["Popular Visualisation Pseudo-Mercator",METHOD["Popular Visualisation Pseudo Mercator",ID["EPSG",1024]],PARAMETER["Latitude of natural origin",0,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8801]],PARAMETER["Longitude of natural origin",0,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8802]],PARAMETER["False easting",0,LENGTHUNIT["metre",1],ID["EPSG",8806]],PARAMETER["False northing",0,LENGTHUNIT["metre",1],ID["EPSG",8807]]],CS[Cartesian,2],AXIS["easting (X)",east,ORDER[1],LENGTHUNIT["metre",1]],AXIS["northing (Y)",north,ORDER[2],LENGTHUNIT["metre",1]],USAGE[SCOPE["Web mapping and visualisation."],AREA["World between 85.06°S and 85.06°N."],BBOX[-85.06,-180,85.06,180]],ID["EPSG",3857]] + +proj=merc +a=6378137 +b=6378137 +lat_ts=0 +lon_0=0 +x_0=0 +y_0=0 +k=1 +units=m +nadgrids=@null +wktext +no_defs + 3857 + 3857 + EPSG:3857 + WGS 84 / Pseudo-Mercator + merc + EPSG:7030 + false + + + + + PROJCRS["NAD83 / Conus Albers",BASEGEOGCRS["NAD83",DATUM["North American Datum 1983",ELLIPSOID["GRS 1980",6378137,298.257222101,LENGTHUNIT["metre",1]]],PRIMEM["Greenwich",0,ANGLEUNIT["degree",0.0174532925199433]],ID["EPSG",4269]],CONVERSION["Conus Albers",METHOD["Albers Equal Area",ID["EPSG",9822]],PARAMETER["Latitude of false origin",23,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8821]],PARAMETER["Longitude of false origin",-96,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8822]],PARAMETER["Latitude of 1st standard parallel",29.5,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8823]],PARAMETER["Latitude of 2nd standard parallel",45.5,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8824]],PARAMETER["Easting at false origin",0,LENGTHUNIT["metre",1],ID["EPSG",8826]],PARAMETER["Northing at false origin",0,LENGTHUNIT["metre",1],ID["EPSG",8827]]],CS[Cartesian,2],AXIS["easting (X)",east,ORDER[1],LENGTHUNIT["metre",1]],AXIS["northing (Y)",north,ORDER[2],LENGTHUNIT["metre",1]],USAGE[SCOPE["Data analysis and small scale data presentation for contiguous lower 48 states."],AREA["United States (USA) - CONUS onshore - Alabama; Arizona; Arkansas; California; Colorado; Connecticut; Delaware; Florida; Georgia; Idaho; Illinois; Indiana; Iowa; Kansas; Kentucky; Louisiana; Maine; Maryland; Massachusetts; Michigan; Minnesota; Mississippi; Missouri; Montana; Nebraska; Nevada; New Hampshire; New Jersey; New Mexico; New York; North Carolina; North Dakota; Ohio; Oklahoma; Oregon; Pennsylvania; Rhode Island; South Carolina; South Dakota; Tennessee; Texas; Utah; Vermont; Virginia; Washington; West Virginia; Wisconsin; Wyoming."],BBOX[24.41,-124.79,49.38,-66.91]],ID["EPSG",5070]] + +proj=aea +lat_0=23 +lon_0=-96 +lat_1=29.5 +lat_2=45.5 +x_0=0 +y_0=0 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs + 28001 + 5070 + EPSG:5070 + NAD83 / Conus Albers + aea + EPSG:7019 + false + + + + + + + GEOGCRS["WGS 84",ENSEMBLE["World Geodetic System 1984 ensemble",MEMBER["World Geodetic System 1984 (Transit)"],MEMBER["World Geodetic System 1984 (G730)"],MEMBER["World Geodetic System 1984 (G873)"],MEMBER["World Geodetic System 1984 (G1150)"],MEMBER["World Geodetic System 1984 (G1674)"],MEMBER["World Geodetic System 1984 (G1762)"],MEMBER["World Geodetic System 1984 (G2139)"],ELLIPSOID["WGS 84",6378137,298.257223563,LENGTHUNIT["metre",1]],ENSEMBLEACCURACY[2.0]],PRIMEM["Greenwich",0,ANGLEUNIT["degree",0.0174532925199433]],CS[ellipsoidal,2],AXIS["geodetic latitude (Lat)",north,ORDER[1],ANGLEUNIT["degree",0.0174532925199433]],AXIS["geodetic longitude (Lon)",east,ORDER[2],ANGLEUNIT["degree",0.0174532925199433]],USAGE[SCOPE["Horizontal component of 3D system."],AREA["World."],BBOX[-90,-180,90,180]],ID["EPSG",4326]] + +proj=longlat +datum=WGS84 +no_defs + 3452 + 4326 + EPSG:4326 + WGS 84 + longlat + EPSG:7030 + true + + + + + PROJCRS["NAD83 / Conus Albers",BASEGEOGCRS["NAD83",DATUM["North American Datum 1983",ELLIPSOID["GRS 1980",6378137,298.257222101,LENGTHUNIT["metre",1]]],PRIMEM["Greenwich",0,ANGLEUNIT["degree",0.0174532925199433]],ID["EPSG",4269]],CONVERSION["Conus Albers",METHOD["Albers Equal Area",ID["EPSG",9822]],PARAMETER["Latitude of false origin",23,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8821]],PARAMETER["Longitude of false origin",-96,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8822]],PARAMETER["Latitude of 1st standard parallel",29.5,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8823]],PARAMETER["Latitude of 2nd standard parallel",45.5,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8824]],PARAMETER["Easting at false origin",0,LENGTHUNIT["metre",1],ID["EPSG",8826]],PARAMETER["Northing at false origin",0,LENGTHUNIT["metre",1],ID["EPSG",8827]]],CS[Cartesian,2],AXIS["easting (X)",east,ORDER[1],LENGTHUNIT["metre",1]],AXIS["northing (Y)",north,ORDER[2],LENGTHUNIT["metre",1]],USAGE[SCOPE["Data analysis and small scale data presentation for contiguous lower 48 states."],AREA["United States (USA) - CONUS onshore - Alabama; Arizona; Arkansas; California; Colorado; Connecticut; Delaware; Florida; Georgia; Idaho; Illinois; Indiana; Iowa; Kansas; Kentucky; Louisiana; Maine; Maryland; Massachusetts; Michigan; Minnesota; Mississippi; Missouri; Montana; Nebraska; Nevada; New Hampshire; New Jersey; New Mexico; New York; North Carolina; North Dakota; Ohio; Oklahoma; Oregon; Pennsylvania; Rhode Island; South Carolina; South Dakota; Tennessee; Texas; Utah; Vermont; Virginia; Washington; West Virginia; Wisconsin; Wyoming."],BBOX[24.41,-124.79,49.38,-66.91]],ID["EPSG",5070]] + +proj=aea +lat_0=23 +lon_0=-96 +lat_1=29.5 +lat_2=45.5 +x_0=0 +y_0=0 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs + 28001 + 5070 + EPSG:5070 + NAD83 / Conus Albers + aea + EPSG:7019 + false + + + + + + + + + + + + + + + + + + + + + + + + + Emanuele Gissi + 2023-08-22T14:11:37 + + + + + + + + + + + PROJCRS["NAD83 / Conus Albers",BASEGEOGCRS["NAD83",DATUM["North American Datum 1983",ELLIPSOID["GRS 1980",6378137,298.257222101,LENGTHUNIT["metre",1]]],PRIMEM["Greenwich",0,ANGLEUNIT["degree",0.0174532925199433]],ID["EPSG",4269]],CONVERSION["Conus Albers",METHOD["Albers Equal Area",ID["EPSG",9822]],PARAMETER["Latitude of false origin",23,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8821]],PARAMETER["Longitude of false origin",-96,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8822]],PARAMETER["Latitude of 1st standard parallel",29.5,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8823]],PARAMETER["Latitude of 2nd standard parallel",45.5,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8824]],PARAMETER["Easting at false origin",0,LENGTHUNIT["metre",1],ID["EPSG",8826]],PARAMETER["Northing at false origin",0,LENGTHUNIT["metre",1],ID["EPSG",8827]]],CS[Cartesian,2],AXIS["easting (X)",east,ORDER[1],LENGTHUNIT["metre",1]],AXIS["northing (Y)",north,ORDER[2],LENGTHUNIT["metre",1]],USAGE[SCOPE["Data analysis and small scale data presentation for contiguous lower 48 states."],AREA["United States (USA) - CONUS onshore - Alabama; Arizona; Arkansas; California; Colorado; Connecticut; Delaware; Florida; Georgia; Idaho; Illinois; Indiana; Iowa; Kansas; Kentucky; Louisiana; Maine; Maryland; Massachusetts; Michigan; Minnesota; Mississippi; Missouri; Montana; Nebraska; Nevada; New Hampshire; New Jersey; New Mexico; New York; North Carolina; North Dakota; Ohio; Oklahoma; Oregon; Pennsylvania; Rhode Island; South Carolina; South Dakota; Tennessee; Texas; Utah; Vermont; Virginia; Washington; West Virginia; Wisconsin; Wyoming."],BBOX[24.41,-124.79,49.38,-66.91]],ID["EPSG",5070]] + +proj=aea +lat_0=23 +lon_0=-96 +lat_1=29.5 +lat_2=45.5 +x_0=0 +y_0=0 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs + 28001 + 5070 + EPSG:5070 + NAD83 / Conus Albers + aea + EPSG:7019 + false + + + + + + + + + + + + + + + + + + + + + + GEOGCRS["WGS 84",ENSEMBLE["World Geodetic System 1984 ensemble",MEMBER["World Geodetic System 1984 (Transit)"],MEMBER["World Geodetic System 1984 (G730)"],MEMBER["World Geodetic System 1984 (G873)"],MEMBER["World Geodetic System 1984 (G1150)"],MEMBER["World Geodetic System 1984 (G1674)"],MEMBER["World Geodetic System 1984 (G1762)"],MEMBER["World Geodetic System 1984 (G2139)"],ELLIPSOID["WGS 84",6378137,298.257223563,LENGTHUNIT["metre",1]],ENSEMBLEACCURACY[2.0]],PRIMEM["Greenwich",0,ANGLEUNIT["degree",0.0174532925199433]],CS[ellipsoidal,2],AXIS["geodetic latitude (Lat)",north,ORDER[1],ANGLEUNIT["degree",0.0174532925199433]],AXIS["geodetic longitude (Lon)",east,ORDER[2],ANGLEUNIT["degree",0.0174532925199433]],USAGE[SCOPE["Horizontal component of 3D system."],AREA["World."],BBOX[-90,-180,90,180]],ID["EPSG",4326]] + +proj=longlat +datum=WGS84 +no_defs + 3452 + 4326 + EPSG:4326 + WGS 84 + longlat + EPSG:7030 + true + + + + + + + diff --git a/verification/tests/golden_gate_remote/QGIS/layers/Extent.gpkg b/verification/tests/golden_gate_remote/QGIS/layers/Extent.gpkg new file mode 100644 index 0000000000000000000000000000000000000000..4debf1d14a5aac81e2f38c26fd2647fc35612cc1 GIT binary patch literal 106496 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 VMq#({O8Unv-t2uD4rvH@n+CJx=T0JT}fAr>*0* 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 literal 0 HcmV?d00001 diff --git a/verification/tests/golden_gate_remote/QGIS/sheets/Landfire F13 landuse type.csv b/verification/tests/golden_gate_remote/QGIS/sheets/Landfire F13 landuse type.csv new file mode 100644 index 0000000..6ac1d6e --- /dev/null +++ b/verification/tests/golden_gate_remote/QGIS/sheets/Landfire F13 landuse type.csv @@ -0,0 +1,22 @@ +landuse,SURF +0,"&SURF ID='NA' RGB=255,255,255 /" +1,"&SURF ID='A01' RGB=255,254,212 VEG_LSET_FUEL_INDEX=1 /" +2,"&SURF ID='A02' RGB=255,253,102 VEG_LSET_FUEL_INDEX=2 /" +3,"&SURF ID='A03' RGB=236,212,99 VEG_LSET_FUEL_INDEX=3 /" +4,"&SURF ID='A04' RGB=254,193,119 VEG_LSET_FUEL_INDEX=4 /" +5,"&SURF ID='A05' RGB=249,197,92 VEG_LSET_FUEL_INDEX=5 /" +6,"&SURF ID='A06' RGB=217,196,152 VEG_LSET_FUEL_INDEX=6 /" +7,"&SURF ID='A07' RGB=170,155,127 VEG_LSET_FUEL_INDEX=7 /" +8,"&SURF ID='A08' RGB=229,253,214 VEG_LSET_FUEL_INDEX=8 /" +9,"&SURF ID='A09' RGB=162,191,90 VEG_LSET_FUEL_INDEX=9 /" +10,"&SURF ID='A10' RGB=114,154,85 VEG_LSET_FUEL_INDEX=10 /" +11,"&SURF ID='A11' RGB=235,212,253 VEG_LSET_FUEL_INDEX=11 /" +12,"&SURF ID='A12' RGB=163,177,243 VEG_LSET_FUEL_INDEX=12 /" +13,"&SURF ID='A13' RGB=0,0,0 VEG_LSET_FUEL_INDEX=13 /" +91,"&SURF ID='Urban' RGB=186,119,80 /" +92,"&SURF ID='Snow-Ice' RGB=234,234,234 /" +93,"&SURF ID='Agricolture' RGB=253,242,242 /" +98,"&SURF ID='Water' RGB=137,183,221 /" +99,"&SURF ID='Barren' RGB=133,153,156 /" +1000,"&SURF ID='Ignition' VEG_LSET_IGNITE_TIME=0. COLOR='RED' /" +1001,"&SURF ID='Burned' RGB=20,20,20 /" diff --git a/verification/tests/golden_gate_remote/QGIS/sheets/wind.csv b/verification/tests/golden_gate_remote/QGIS/sheets/wind.csv new file mode 100644 index 0000000..fb6c862 --- /dev/null +++ b/verification/tests/golden_gate_remote/QGIS/sheets/wind.csv @@ -0,0 +1,4 @@ +Time,Speed,Direction +0,2,45 +180,5,90 +360,10,135