609 lines
21 KiB
TypeScript
609 lines
21 KiB
TypeScript
import { FormEvent, useEffect, useMemo, useRef, useState } from 'react'
|
|
import { datasetsApi, jobsApi } from '../services/api'
|
|
import type {
|
|
AreaRead,
|
|
DatasetCreateResponse,
|
|
JobRead,
|
|
RasterTileHandoff,
|
|
RasterMetadataResponse,
|
|
RasterPreviewResponse,
|
|
RasterStatsResponse,
|
|
VectorSummary,
|
|
} from '../types'
|
|
import { formatError } from '../lib/formatError'
|
|
import { isPrimaryFocusMunicipalityBoundaryDataset } from '../config/primaryFocus'
|
|
import { VECTOR_VIEWPORT_FEATURE_THRESHOLD } from '../config/vectorDelivery'
|
|
|
|
interface DatasetWorkflowOptions {
|
|
selectedProjectId: string | null
|
|
areas: AreaRead[]
|
|
datasets: DatasetCreateResponse[]
|
|
loadProjectData: (projectId: string) => Promise<{ datasets: DatasetCreateResponse[] } | null>
|
|
setErrorMessage: (message: string | null) => void
|
|
isVectorDatasetType: (datasetType: string) => boolean
|
|
}
|
|
|
|
function toRasterMetadata(metadata: Record<string, unknown> | null | undefined): RasterMetadataResponse | null {
|
|
if (!metadata) {
|
|
return null
|
|
}
|
|
return metadata as unknown as RasterMetadataResponse
|
|
}
|
|
|
|
function isOperationalScopeBoundaryDataset(dataset: DatasetCreateResponse): boolean {
|
|
return (
|
|
dataset.status === 'ready' &&
|
|
(dataset.dataset_type === 'vector' || dataset.dataset_type === 'geojson') &&
|
|
dataset.source_metadata?.layer_type === 'regional_boundary'
|
|
)
|
|
}
|
|
|
|
function extractRasterTileManifestPath(job: JobRead | null | undefined): string {
|
|
const manifest = toRasterTileHandoff(job)
|
|
return manifest?.manifest_path ?? ''
|
|
}
|
|
|
|
function optionalString(value: unknown): string | null {
|
|
return typeof value === 'string' && value.trim().length > 0 ? value : null
|
|
}
|
|
|
|
function optionalNumber(value: unknown): number | null {
|
|
return typeof value === 'number' && Number.isFinite(value) ? value : null
|
|
}
|
|
|
|
function toRasterTileHandoff(job: JobRead | null | undefined): RasterTileHandoff | null {
|
|
const result = job?.result_json
|
|
if (!result) {
|
|
return null
|
|
}
|
|
const manifestPath = result.manifest_path
|
|
if (typeof manifestPath !== 'string' || manifestPath.trim().length === 0) {
|
|
return null
|
|
}
|
|
const manifest = typeof result.manifest === 'object' && result.manifest !== null
|
|
? result.manifest as Record<string, unknown>
|
|
: {}
|
|
return {
|
|
manifest_path: manifestPath,
|
|
tile_set_id: optionalString(result.tile_set_id) ?? optionalString(manifest.tile_set_id),
|
|
tile_size: optionalNumber(result.tile_size) ?? optionalNumber(manifest.tile_size),
|
|
overlap: optionalNumber(result.overlap) ?? optionalNumber(manifest.overlap),
|
|
count: optionalNumber(result.count) ?? optionalNumber(manifest.count),
|
|
source_dataset_id: optionalString(result.source_dataset_id) ?? optionalString(manifest.source_dataset_id),
|
|
created_at: optionalString(manifest.created_at),
|
|
}
|
|
}
|
|
|
|
export function useDatasetWorkflow({
|
|
selectedProjectId,
|
|
areas,
|
|
datasets,
|
|
loadProjectData,
|
|
setErrorMessage,
|
|
isVectorDatasetType,
|
|
}: DatasetWorkflowOptions) {
|
|
const [selectedDatasetId, setSelectedDatasetId] = useState<string | null>(null)
|
|
const [selectedDataset, setSelectedDataset] = useState<DatasetCreateResponse | null>(null)
|
|
const [selectedDatasetSummary, setSelectedDatasetSummary] = useState<VectorSummary | null>(null)
|
|
const [selectedRasterMetadata, setSelectedRasterMetadata] = useState<RasterMetadataResponse | null>(null)
|
|
const [selectedRasterStats, setSelectedRasterStats] = useState<RasterStatsResponse | null>(null)
|
|
const [datasetContent, setDatasetContent] = useState<GeoJSON.FeatureCollection | null>(null)
|
|
const [jobs, setJobs] = useState<JobRead[]>([])
|
|
const [rasterPreview, setRasterPreview] = useState<RasterPreviewResponse | null>(null)
|
|
const [latestRasterTileManifestPath, setLatestRasterTileManifestPath] = useState('')
|
|
const [latestRasterTileManifest, setLatestRasterTileManifest] = useState<RasterTileHandoff | null>(null)
|
|
const [selectedIntersectTargetId, setSelectedIntersectTargetId] = useState('')
|
|
const [selectedClipAreaId, setSelectedClipAreaId] = useState('')
|
|
const [rasterTileSize, setRasterTileSize] = useState(512)
|
|
const [rasterTileOverlap, setRasterTileOverlap] = useState(64)
|
|
const [rasterTileOutputName, setRasterTileOutputName] = useState('')
|
|
const [rasterReprojectCrs, setRasterReprojectCrs] = useState('EPSG:31370')
|
|
const [rasterReprojectResampling, setRasterReprojectResampling] = useState('nearest')
|
|
const [ndviNirBand, setNdviNirBand] = useState(4)
|
|
const [ndviRedBand, setNdviRedBand] = useState(3)
|
|
const [ndwiGreenBand, setNdwiGreenBand] = useState(2)
|
|
const [ndwiNirBand, setNdwiNirBand] = useState(4)
|
|
const [ndbiSwirBand, setNdbiSwirBand] = useState(5)
|
|
const [ndbiNirBand, setNdbiNirBand] = useState(4)
|
|
const [loadingDatasetDetails, setLoadingDatasetDetails] = useState(false)
|
|
const [datasetDetailError, setDatasetDetailError] = useState<string | null>(null)
|
|
const datasetDetailRequestSequence = useRef(0)
|
|
const [datasetForm, setDatasetForm] = useState({
|
|
datasetType: 'vector',
|
|
source: 'user_upload',
|
|
datasetRole: 'source',
|
|
sourceName: '',
|
|
referenceLayerName: '',
|
|
sourceMetadataJson: '',
|
|
provenanceMetadataJson: '',
|
|
areaId: '',
|
|
file: null as File | null,
|
|
})
|
|
|
|
const isRasterTileInputValid = useMemo(
|
|
() => rasterTileSize > 0 && rasterTileOverlap >= 0 && rasterTileOverlap < rasterTileSize,
|
|
[rasterTileSize, rasterTileOverlap],
|
|
)
|
|
|
|
useEffect(() => {
|
|
if (areas.length === 0) {
|
|
setSelectedClipAreaId('')
|
|
} else if (!selectedClipAreaId || !areas.some((area) => area.id === selectedClipAreaId)) {
|
|
setSelectedClipAreaId(areas[0].id)
|
|
}
|
|
}, [areas, selectedClipAreaId])
|
|
|
|
useEffect(() => {
|
|
if (!selectedProjectId || selectedDatasetId || datasets.length === 0) {
|
|
return
|
|
}
|
|
// Auto-open the first usable dataset so Data, Map and Exports start with real context.
|
|
const defaultDataset =
|
|
datasets.find(isOperationalScopeBoundaryDataset) ??
|
|
datasets.find(isPrimaryFocusMunicipalityBoundaryDataset) ??
|
|
datasets.find((dataset) => isVectorDatasetType(dataset.dataset_type) && dataset.status === 'ready') ??
|
|
datasets.find((dataset) => dataset.status === 'ready') ??
|
|
datasets[0]
|
|
if (defaultDataset) {
|
|
loadDatasetDetails(selectedProjectId, defaultDataset).catch(() => null)
|
|
}
|
|
}, [datasets, isVectorDatasetType, selectedDatasetId, selectedProjectId])
|
|
|
|
const loadDatasetJobs = async (projectId: string, datasetId: string, detailRequestId?: number) => {
|
|
const response = await jobsApi.list(projectId, { dataset_id: datasetId, limit: 20, offset: 0 })
|
|
if (detailRequestId != null && detailRequestId !== datasetDetailRequestSequence.current) {
|
|
return
|
|
}
|
|
setJobs(response.items)
|
|
const latestRasterTileJob = response.items.find(
|
|
(job) => job.job_type === 'raster.tile' && extractRasterTileManifestPath(job),
|
|
)
|
|
const manifest = toRasterTileHandoff(latestRasterTileJob)
|
|
const manifestPath = manifest ? manifest.manifest_path : ''
|
|
setLatestRasterTileManifest(manifest)
|
|
setLatestRasterTileManifestPath(manifestPath)
|
|
}
|
|
|
|
const loadDatasetDetails = async (projectId: string, dataset: DatasetCreateResponse) => {
|
|
const detailRequestId = ++datasetDetailRequestSequence.current
|
|
setLoadingDatasetDetails(true)
|
|
setDatasetDetailError(null)
|
|
setSelectedDataset(dataset)
|
|
setSelectedDatasetSummary(null)
|
|
setSelectedRasterMetadata(null)
|
|
setSelectedRasterStats(null)
|
|
setDatasetContent(null)
|
|
setRasterPreview(null)
|
|
setLatestRasterTileManifestPath('')
|
|
setLatestRasterTileManifest(null)
|
|
setSelectedDatasetId(dataset.id)
|
|
setJobs([])
|
|
try {
|
|
if (isVectorDatasetType(dataset.dataset_type)) {
|
|
const summary = await datasetsApi.vectorSummary(projectId, dataset.id)
|
|
if (detailRequestId !== datasetDetailRequestSequence.current) {
|
|
return
|
|
}
|
|
setSelectedDatasetSummary(summary)
|
|
const featureCount = summary.feature_count ?? dataset.feature_count
|
|
if (featureCount == null || featureCount <= VECTOR_VIEWPORT_FEATURE_THRESHOLD) {
|
|
const content = await datasetsApi.getContent(projectId, dataset.id)
|
|
if (detailRequestId !== datasetDetailRequestSequence.current) {
|
|
return
|
|
}
|
|
setDatasetContent(content)
|
|
}
|
|
} else if (dataset.dataset_type === 'raster') {
|
|
try {
|
|
const rasterInspection = await datasetsApi.rasterInspect(projectId, dataset.id)
|
|
if (detailRequestId !== datasetDetailRequestSequence.current) {
|
|
return
|
|
}
|
|
setSelectedRasterMetadata(toRasterMetadata(rasterInspection.metadata))
|
|
} catch (error) {
|
|
if (detailRequestId !== datasetDetailRequestSequence.current) {
|
|
return
|
|
}
|
|
setSelectedRasterMetadata(null)
|
|
setDatasetDetailError(formatError(error, 'Raster metadata unavailable'))
|
|
}
|
|
}
|
|
await loadDatasetJobs(projectId, dataset.id, detailRequestId)
|
|
} catch (error) {
|
|
if (detailRequestId === datasetDetailRequestSequence.current) {
|
|
setDatasetDetailError(formatError(error, 'Unable to load dataset detail'))
|
|
}
|
|
} finally {
|
|
if (detailRequestId === datasetDetailRequestSequence.current) {
|
|
setLoadingDatasetDetails(false)
|
|
}
|
|
}
|
|
}
|
|
|
|
const uploadDataset = async (event: FormEvent) => {
|
|
event.preventDefault()
|
|
if (!selectedProjectId || !datasetForm.file) {
|
|
setErrorMessage('Select project and upload a file')
|
|
return
|
|
}
|
|
if (!datasetForm.datasetRole) {
|
|
setErrorMessage('Select dataset role')
|
|
return
|
|
}
|
|
if (datasetForm.datasetRole === 'reference' && datasetForm.datasetType !== 'vector' && datasetForm.datasetType !== 'geojson') {
|
|
setErrorMessage('Reference role requires vector dataset upload')
|
|
return
|
|
}
|
|
if (datasetForm.sourceMetadataJson) {
|
|
try {
|
|
const parsedSourceMetadata = JSON.parse(datasetForm.sourceMetadataJson)
|
|
if (parsedSourceMetadata === null || typeof parsedSourceMetadata !== 'object') {
|
|
setErrorMessage('Source metadata must be a JSON object')
|
|
return
|
|
}
|
|
} catch {
|
|
setErrorMessage('Source metadata must be valid JSON')
|
|
return
|
|
}
|
|
}
|
|
if (datasetForm.provenanceMetadataJson) {
|
|
try {
|
|
const parsedProvenanceMetadata = JSON.parse(datasetForm.provenanceMetadataJson)
|
|
if (parsedProvenanceMetadata === null || typeof parsedProvenanceMetadata !== 'object') {
|
|
setErrorMessage('Provenance metadata must be a JSON object')
|
|
return
|
|
}
|
|
} catch {
|
|
setErrorMessage('Provenance metadata must be valid JSON')
|
|
return
|
|
}
|
|
}
|
|
try {
|
|
await datasetsApi.upload(selectedProjectId, {
|
|
file: datasetForm.file,
|
|
datasetType: datasetForm.datasetType,
|
|
source: datasetForm.source,
|
|
datasetRole: datasetForm.datasetRole,
|
|
sourceName: datasetForm.sourceName || undefined,
|
|
referenceLayerName: datasetForm.referenceLayerName || undefined,
|
|
sourceMetadataJson: datasetForm.sourceMetadataJson || undefined,
|
|
provenanceMetadataJson: datasetForm.provenanceMetadataJson || undefined,
|
|
areaId: datasetForm.areaId || undefined,
|
|
})
|
|
setDatasetForm((previous) => ({ ...previous, file: null }))
|
|
await loadProjectData(selectedProjectId)
|
|
} catch (error) {
|
|
setErrorMessage(error instanceof Error ? error.message : 'Failed to upload dataset')
|
|
}
|
|
}
|
|
|
|
const refreshSelectedDatasetAfterJob = async () => {
|
|
if (!selectedProjectId || !selectedDatasetId) {
|
|
return
|
|
}
|
|
await Promise.all([loadDatasetJobs(selectedProjectId, selectedDatasetId), loadProjectData(selectedProjectId)])
|
|
const refreshed = datasets.find((dataset) => dataset.id === selectedDatasetId)
|
|
if (refreshed) {
|
|
loadDatasetDetails(selectedProjectId, refreshed).catch(() => null)
|
|
}
|
|
}
|
|
|
|
const runVectorClip = async () => {
|
|
if (!selectedProjectId || !selectedDatasetId) {
|
|
return
|
|
}
|
|
if (!selectedClipAreaId) {
|
|
setDatasetDetailError('Select an area for clipping')
|
|
return
|
|
}
|
|
setDatasetDetailError(null)
|
|
try {
|
|
await datasetsApi.vectorClip(selectedProjectId, selectedDatasetId, {
|
|
area_id: selectedClipAreaId,
|
|
output_name: `${selectedDataset?.name.replace(/\.geojson$/, '')}-clipped`,
|
|
})
|
|
await refreshSelectedDatasetAfterJob()
|
|
} catch (error) {
|
|
setDatasetDetailError(formatError(error, 'Vector clip failed'))
|
|
}
|
|
}
|
|
|
|
const runVectorBuffer = async () => {
|
|
if (!selectedProjectId || !selectedDatasetId) {
|
|
return
|
|
}
|
|
setDatasetDetailError(null)
|
|
try {
|
|
await datasetsApi.vectorBuffer(selectedProjectId, selectedDatasetId, {
|
|
distance_m: 25,
|
|
dissolve: false,
|
|
})
|
|
await refreshSelectedDatasetAfterJob()
|
|
} catch (error) {
|
|
setDatasetDetailError(formatError(error, 'Vector buffer failed'))
|
|
}
|
|
}
|
|
|
|
const runVectorIntersect = async (availableVectorTargets: DatasetCreateResponse[]) => {
|
|
if (!selectedProjectId || !selectedDatasetId) {
|
|
return
|
|
}
|
|
const targetId = selectedIntersectTargetId || availableVectorTargets[0]?.id
|
|
if (!targetId) {
|
|
setDatasetDetailError('Select an intersect target dataset')
|
|
return
|
|
}
|
|
setDatasetDetailError(null)
|
|
try {
|
|
await datasetsApi.vectorIntersect(selectedProjectId, selectedDatasetId, {
|
|
other_dataset_id: targetId,
|
|
})
|
|
await refreshSelectedDatasetAfterJob()
|
|
} catch (error) {
|
|
setDatasetDetailError(formatError(error, 'Vector intersect failed'))
|
|
}
|
|
}
|
|
|
|
const runRasterInspect = async () => {
|
|
if (!selectedProjectId || !selectedDatasetId) {
|
|
return
|
|
}
|
|
try {
|
|
const response = await datasetsApi.inspectRaster(selectedProjectId, selectedDatasetId)
|
|
setSelectedRasterMetadata(toRasterMetadata(response.metadata))
|
|
setDatasetDetailError(null)
|
|
} catch (error) {
|
|
setDatasetDetailError(formatError(error, 'Raster inspect unavailable'))
|
|
}
|
|
}
|
|
|
|
const runRasterPreview = async () => {
|
|
if (!selectedProjectId || !selectedDatasetId) {
|
|
return
|
|
}
|
|
try {
|
|
const response = await datasetsApi.rasterPreview(selectedProjectId, selectedDatasetId)
|
|
setRasterPreview(response)
|
|
if (response.metadata) {
|
|
setSelectedRasterMetadata(toRasterMetadata(response.metadata))
|
|
}
|
|
setDatasetDetailError(null)
|
|
} catch (error) {
|
|
setDatasetDetailError(formatError(error, 'Raster preview unavailable'))
|
|
setRasterPreview(null)
|
|
}
|
|
}
|
|
|
|
const runRasterStats = async () => {
|
|
if (!selectedProjectId || !selectedDatasetId) {
|
|
return
|
|
}
|
|
try {
|
|
const response = await datasetsApi.rasterStats(selectedProjectId, selectedDatasetId)
|
|
setSelectedRasterStats(response)
|
|
setDatasetDetailError(null)
|
|
} catch (error) {
|
|
setDatasetDetailError(formatError(error, 'Raster stats unavailable'))
|
|
setSelectedRasterStats(null)
|
|
}
|
|
}
|
|
|
|
const runRasterReproject = async () => {
|
|
if (!selectedProjectId || !selectedDatasetId) {
|
|
return
|
|
}
|
|
const targetCrs = rasterReprojectCrs.trim()
|
|
if (!targetCrs) {
|
|
setDatasetDetailError('Target CRS is required for raster reproject')
|
|
return
|
|
}
|
|
try {
|
|
await datasetsApi.rasterReproject(selectedProjectId, selectedDatasetId, {
|
|
target_crs: targetCrs,
|
|
resampling: rasterReprojectResampling,
|
|
})
|
|
await refreshSelectedDatasetAfterJob()
|
|
setDatasetDetailError(null)
|
|
} catch (error) {
|
|
setDatasetDetailError(formatError(error, 'Raster reproject failed'))
|
|
}
|
|
}
|
|
|
|
const runRasterClip = async () => {
|
|
if (!selectedProjectId || !selectedDatasetId) {
|
|
return
|
|
}
|
|
if (!selectedClipAreaId) {
|
|
setDatasetDetailError('Select an area for raster clip')
|
|
return
|
|
}
|
|
try {
|
|
await datasetsApi.rasterClip(selectedProjectId, selectedDatasetId, {
|
|
area_id: selectedClipAreaId,
|
|
output_name: `raster-clipped-${selectedDatasetId}`,
|
|
})
|
|
await refreshSelectedDatasetAfterJob()
|
|
setDatasetDetailError(null)
|
|
} catch (error) {
|
|
setDatasetDetailError(formatError(error, 'Raster clip failed'))
|
|
}
|
|
}
|
|
|
|
const runRasterTile = async () => {
|
|
if (!selectedProjectId || !selectedDatasetId) {
|
|
return
|
|
}
|
|
try {
|
|
const job = await datasetsApi.rasterTile(selectedProjectId, selectedDatasetId, {
|
|
tile_size: rasterTileSize,
|
|
overlap: rasterTileOverlap,
|
|
output_name: rasterTileOutputName || undefined,
|
|
})
|
|
const manifest = toRasterTileHandoff(job)
|
|
const manifestPath = manifest?.manifest_path ?? ''
|
|
setLatestRasterTileManifest(manifest)
|
|
setLatestRasterTileManifestPath(manifestPath)
|
|
await refreshSelectedDatasetAfterJob()
|
|
if (manifestPath) {
|
|
setLatestRasterTileManifest(manifest)
|
|
setLatestRasterTileManifestPath(manifestPath)
|
|
}
|
|
setDatasetDetailError(null)
|
|
} catch (error) {
|
|
setDatasetDetailError(formatError(error, 'Raster tile failed'))
|
|
}
|
|
}
|
|
|
|
const runRasterNdvi = async () => {
|
|
if (!selectedProjectId || !selectedDatasetId) {
|
|
return
|
|
}
|
|
try {
|
|
await datasetsApi.rasterNdvi(selectedProjectId, selectedDatasetId, {
|
|
nir_band: ndviNirBand,
|
|
red_band: ndviRedBand,
|
|
})
|
|
await refreshSelectedDatasetAfterJob()
|
|
setDatasetDetailError(null)
|
|
} catch (error) {
|
|
setDatasetDetailError(formatError(error, 'Raster NDVI failed'))
|
|
}
|
|
}
|
|
|
|
const runRasterNdwi = async () => {
|
|
if (!selectedProjectId || !selectedDatasetId) {
|
|
return
|
|
}
|
|
try {
|
|
await datasetsApi.rasterNdwi(selectedProjectId, selectedDatasetId, {
|
|
green_band: ndwiGreenBand,
|
|
nir_band: ndwiNirBand,
|
|
})
|
|
await refreshSelectedDatasetAfterJob()
|
|
setDatasetDetailError(null)
|
|
} catch (error) {
|
|
setDatasetDetailError(formatError(error, 'Raster NDWI failed'))
|
|
}
|
|
}
|
|
|
|
const runRasterNdbi = async () => {
|
|
if (!selectedProjectId || !selectedDatasetId) {
|
|
return
|
|
}
|
|
try {
|
|
await datasetsApi.rasterNdbi(selectedProjectId, selectedDatasetId, {
|
|
swir_band: ndbiSwirBand,
|
|
nir_band: ndbiNirBand,
|
|
})
|
|
await refreshSelectedDatasetAfterJob()
|
|
setDatasetDetailError(null)
|
|
} catch (error) {
|
|
setDatasetDetailError(formatError(error, 'Raster NDBI failed'))
|
|
}
|
|
}
|
|
|
|
const pickDerivedDataset = async (datasetId: string) => {
|
|
if (!selectedProjectId) {
|
|
return
|
|
}
|
|
const target = datasets.find((item) => item.id === datasetId)
|
|
if (target) {
|
|
await loadDatasetDetails(selectedProjectId, target)
|
|
}
|
|
}
|
|
|
|
const refreshMetadata = async (datasetId: string) => {
|
|
if (!selectedProjectId) {
|
|
return
|
|
}
|
|
const refreshed = await datasetsApi.refreshMetadata(selectedProjectId, datasetId)
|
|
await loadProjectData(selectedProjectId)
|
|
if (selectedDataset?.id === datasetId) {
|
|
setSelectedDataset(refreshed)
|
|
if (isVectorDatasetType(refreshed.dataset_type)) {
|
|
loadDatasetDetails(selectedProjectId, refreshed).catch(() => null)
|
|
}
|
|
}
|
|
}
|
|
|
|
const resetDatasetForProject = () => {
|
|
datasetDetailRequestSequence.current += 1
|
|
setSelectedDatasetId(null)
|
|
setSelectedDataset(null)
|
|
setSelectedDatasetSummary(null)
|
|
setSelectedRasterMetadata(null)
|
|
setSelectedRasterStats(null)
|
|
setDatasetContent(null)
|
|
setRasterPreview(null)
|
|
setLatestRasterTileManifestPath('')
|
|
setLatestRasterTileManifest(null)
|
|
setJobs([])
|
|
setLoadingDatasetDetails(false)
|
|
setDatasetDetailError(null)
|
|
}
|
|
|
|
return {
|
|
selectedDatasetId,
|
|
selectedDataset,
|
|
selectedDatasetSummary,
|
|
selectedRasterMetadata,
|
|
selectedRasterStats,
|
|
datasetContent,
|
|
jobs,
|
|
rasterPreview,
|
|
latestRasterTileManifestPath,
|
|
latestRasterTileManifest,
|
|
selectedIntersectTargetId,
|
|
selectedClipAreaId,
|
|
rasterTileSize,
|
|
rasterTileOverlap,
|
|
rasterTileOutputName,
|
|
rasterReprojectCrs,
|
|
rasterReprojectResampling,
|
|
ndviNirBand,
|
|
ndviRedBand,
|
|
ndwiGreenBand,
|
|
ndwiNirBand,
|
|
ndbiSwirBand,
|
|
ndbiNirBand,
|
|
loadingDatasetDetails,
|
|
datasetDetailError,
|
|
datasetForm,
|
|
isRasterTileInputValid,
|
|
loadDatasetJobs,
|
|
loadDatasetDetails,
|
|
uploadDataset,
|
|
runVectorClip,
|
|
runVectorBuffer,
|
|
runVectorIntersect,
|
|
runRasterInspect,
|
|
runRasterPreview,
|
|
runRasterStats,
|
|
runRasterReproject,
|
|
runRasterClip,
|
|
runRasterTile,
|
|
runRasterNdvi,
|
|
runRasterNdwi,
|
|
runRasterNdbi,
|
|
pickDerivedDataset,
|
|
refreshMetadata,
|
|
resetDatasetForProject,
|
|
setSelectedDatasetId,
|
|
setSelectedDataset,
|
|
setSelectedIntersectTargetId,
|
|
setSelectedClipAreaId,
|
|
setRasterTileSize,
|
|
setRasterTileOverlap,
|
|
setRasterTileOutputName,
|
|
setRasterReprojectCrs,
|
|
setRasterReprojectResampling,
|
|
setNdviNirBand,
|
|
setNdviRedBand,
|
|
setNdwiGreenBand,
|
|
setNdwiNirBand,
|
|
setNdbiSwirBand,
|
|
setNdbiNirBand,
|
|
setDatasetForm,
|
|
}
|
|
}
|