JensandClaude Opus 5
70157400d9
De inlogpagina haalde 1,46 MB over de lijn, waaronder de volledige kaartmotor van 213 kB terwijl er geen kaart staat. De werkbank is nu een aparte brok die pas na aanmelden geladen wordt: de eerste JS-bundel gaat van 476 naar 30 kB, en met de beeldwerk uit een eerdere commit komt de inlogpagina op 344 kB. Bij het opstarten gingen 27 verzoeken de deur uit in drie golven. Alles werd vooraf opgehaald, ook voor werkbladen die de gebruiker misschien nooit opent, en twee daarvan werden dubbel opgevraagd door effecten die negentig milliseconde na elkaar liepen. Gelijktijdige en vlak opeenvolgende identieke GET-verzoeken delen nu één belofte, en elk werkblad haalt zijn eigen gegevens pas op wanneer het geopend wordt. Nu zestien verzoeken. Typen in het themazoekveld kostte 53 ms mediaan met uitschieters tot 127 ms, omdat die filterwaarde in het viewmodel van de hele werkruimte leefde. Het veld is een eigen component geworden dat zijn invoer zelf bijhoudt. React.memo om de kaart is geprobeerd en weer verwijderd: van de negentien props worden er te veel per render opnieuw gemaakt, dus de vergelijking sloeg nooit over. Verder: donker blijft de standaard maar er is nu een weg terug naar licht, de kaartondergrond schakelt mee zonder de datalagen te herbouwen, de onderste hero-afbeelding wordt pas opgehaald als hij in beeld komt, en de werkbank heeft een h1 zodat schermlezers een ankerpunt hebben. De tests op de bootstrap legden het oude gedrag vast en toetsen nu het nieuwe, van drie naar zeven gevallen. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
1513 lines
62 KiB
TypeScript
1513 lines
62 KiB
TypeScript
/**
|
|
* De werkbank, apart van App.
|
|
*
|
|
* Dit stond in App.tsx, waardoor de kaartmotor (maplibre, 213 kB over de lijn)
|
|
* en alle paneelopmaak in de eerste bundel zaten en dus door iedereen werden
|
|
* gedownload op het inlogscherm, waar geen kaart staat. Als eigen module wordt
|
|
* het een aparte brok die pas na aanmelden geladen wordt.
|
|
*
|
|
* Om dezelfde reden staan de stylesheets van de werkbank hier en niet in
|
|
* main.tsx: ook die horen bij deze brok.
|
|
*/
|
|
import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
|
|
import { CircleAlert, LogOut, MonitorUp, Moon, ShieldCheck, Sun, UserRound } from 'lucide-react'
|
|
import './styles/app.css'
|
|
import './styles/premium.css'
|
|
import './styles/atlas-workbench.css'
|
|
import './styles/atlas-premium-v2.css'
|
|
import './styles/professionalization.css'
|
|
// Laatst geladen en leidend: het geconsolideerde designsysteem.
|
|
// Zie de kop van geointel-system.css voor de reden.
|
|
import './styles/geointel-system.css'
|
|
import { ChangeDetectionPanel } from './components/analysis/ChangeDetectionPanel'
|
|
import { GeoAssistantPanel } from './components/assistant/GeoAssistantPanel'
|
|
import { DatasetPanel } from './components/datasets/DatasetPanel'
|
|
import { SourceCatalogPanel } from './components/datasets/SourceCatalogPanel'
|
|
import { DetectionLab } from './components/detection/DetectionLab'
|
|
import { ExportCenter } from './components/exports/ExportCenter'
|
|
import { ExportPreview } from './components/exports/ExportPreview'
|
|
import { WorkbenchInspector } from './components/inspector/WorkbenchInspector'
|
|
import { MapWorkspace } from './components/map/MapWorkspace'
|
|
import { OverviewWorkspace, type WorkspaceKey } from './components/overview/OverviewWorkspace'
|
|
import { AreaPanel } from './components/project/AreaPanel'
|
|
import { ProjectPanel } from './components/project/ProjectPanel'
|
|
import { QualityResultsPanel } from './components/quality/QualityResultsPanel'
|
|
import type { DatasetCreateResponse } from './types'
|
|
import { ProviderPanel } from './components/providers/ProviderPanel'
|
|
import { SegmentationLab } from './components/segmentation/SegmentationLab'
|
|
import {
|
|
WorkbenchNavigation,
|
|
type WorkspaceNavigationGroup,
|
|
type WorkspaceNavigationItem,
|
|
} from './components/shell/WorkbenchNavigation'
|
|
import { WorkspaceSignal } from './components/shell/WorkspaceSignal'
|
|
import { WorkspaceErrorBoundary } from './components/shell/WorkspaceErrorBoundary'
|
|
import { useSecondaryDisplay } from './components/shell/SecondaryDisplay'
|
|
import { useChangeDetectionWorkflow } from './hooks/useChangeDetectionWorkflow'
|
|
import { useDemoWorkflow } from './hooks/useDemoWorkflow'
|
|
import { useCoverageResolver } from './hooks/useCoverageResolver'
|
|
import { useDetectionWorkflow } from './hooks/useDetectionWorkflow'
|
|
import { useDatasetWorkflow } from './hooks/useDatasetWorkflow'
|
|
import { useExportWorkflow } from './hooks/useExportWorkflow'
|
|
import { useMapSelectionDataset } from './hooks/useMapSelectionDataset'
|
|
import { useMapSelectionQa } from './hooks/useMapSelectionQa'
|
|
import { useMapWorkspaceState } from './hooks/useMapWorkspaceState'
|
|
import { useOperatorSession } from './hooks/useOperatorSession'
|
|
import { useMapSelectionExtract } from './hooks/useMapSelectionExtract'
|
|
import { useMapOrthophotoAnalysis } from './hooks/useMapOrthophotoAnalysis'
|
|
import { isDetectionImageryDataset, isMapRasterDataset } from './lib/datasetCapabilities'
|
|
import { useProviderCapabilities } from './hooks/useProviderCapabilities'
|
|
import { useProjectWorkspace } from './hooks/useProjectWorkspace'
|
|
import { useQualityWorkflow } from './hooks/useQualityWorkflow'
|
|
import { useSegmentationWorkflow } from './hooks/useSegmentationWorkflow'
|
|
import { useSourceFreshness } from './hooks/useSourceFreshness'
|
|
import { useWorkbenchBootstrap } from './hooks/useWorkbenchBootstrap'
|
|
import { useWorkbenchTheme } from './hooks/useWorkbenchTheme'
|
|
import { useViewportVectorLayer } from './hooks/useViewportVectorLayer'
|
|
import { getDatasetDisplayName } from './lib/datasetDisplay'
|
|
import {
|
|
FLANDERS_WORKSPACE_LABEL,
|
|
FLANDERS_WORKSPACE_PROJECT_NAME,
|
|
NATIONAL_WORKSPACE_LABEL,
|
|
NATIONAL_WORKSPACE_PROJECT_NAME,
|
|
REGIONAL_WORKSPACE_LABEL,
|
|
REGIONAL_WORKSPACE_PROJECT_NAME,
|
|
} from './config/primaryFocus'
|
|
|
|
function isVectorDatasetType(datasetType: string): boolean {
|
|
return datasetType === 'vector' || datasetType === 'geojson'
|
|
}
|
|
|
|
const workspaceNavItems: WorkspaceNavigationItem[] = [
|
|
{ key: 'overview', label: 'Status', description: 'Beschikbaarheid en aandachtspunten' },
|
|
{ key: 'data', label: 'Bronnen', description: 'Gebieden en ingeladen gegevens' },
|
|
{ key: 'map', label: 'Kaart', description: 'Selecteren, uitlezen en vergelijken' },
|
|
{ key: 'assistant', label: 'AI-vragen', description: 'Vraag de lokale assistent over het actieve gebied' },
|
|
{ key: 'analysis', label: 'Kwaliteit', description: 'Resultaten controleren' },
|
|
{ key: 'ai', label: 'Beeldanalyse', description: 'Gebouwen herkennen op luchtbeelden' },
|
|
{ key: 'exports', label: 'Downloads', description: 'Resultaten bewaren en delen' },
|
|
{ key: 'system', label: 'Systeem', description: 'Bronkoppelingen en operationele status' },
|
|
]
|
|
|
|
const workspaceNavGroups: WorkspaceNavigationGroup[] = [
|
|
{ label: 'Verkennen', keys: ['map', 'data'] },
|
|
{ label: 'Vragen', keys: ['assistant'] },
|
|
{ label: 'Analyseren', keys: ['analysis', 'ai'] },
|
|
{ label: 'Afronden', keys: ['exports'] },
|
|
{ label: 'Beheer', keys: ['overview', 'system'] },
|
|
]
|
|
|
|
const guestWorkspaceKeys = new Set<WorkspaceKey>([
|
|
'overview',
|
|
'data',
|
|
'map',
|
|
'assistant',
|
|
'analysis',
|
|
'ai',
|
|
'exports',
|
|
])
|
|
const guestWorkspaceGroups: WorkspaceNavigationGroup[] = [
|
|
{ label: 'Verkennen', keys: ['map', 'data'] },
|
|
{ label: 'Vragen', keys: ['assistant'] },
|
|
{ label: 'Analyseren', keys: ['analysis', 'ai'] },
|
|
{ label: 'Afronden', keys: ['exports'] },
|
|
{ label: 'Demo', keys: ['overview'] },
|
|
]
|
|
|
|
interface WorkbenchAppProps {
|
|
username: string | null
|
|
accessMode: 'open' | 'operator' | 'guest'
|
|
loggingOut: boolean
|
|
onLogout: () => void
|
|
}
|
|
|
|
function WorkbenchApp({ username, accessMode, loggingOut, onLogout }: WorkbenchAppProps): JSX.Element {
|
|
const isGuest = accessMode === 'guest'
|
|
const [activeWorkspace, setActiveWorkspace] = useState<WorkspaceKey>('map')
|
|
const [inspectorOpen, setInspectorOpen] = useState(false)
|
|
const [guestDemoReady, setGuestDemoReady] = useState(!isGuest)
|
|
const secondaryDisplay = useSecondaryDisplay()
|
|
const { theme, toggleTheme } = useWorkbenchTheme()
|
|
// Welke onderdelen niet geladen konden worden. Zonder dit zag de gebruiker
|
|
// een leeg paneel, ongeacht of er niets is of de verbinding wegviel.
|
|
const [laadfouten, setLaadfouten] = useState<string[]>([])
|
|
const meldLaadfout = useCallback((onderdeel: string) => {
|
|
setLaadfouten((huidig) => (huidig.includes(onderdeel) ? huidig : [...huidig, onderdeel]))
|
|
}, [])
|
|
const guestDemoStartedRef = useRef(false)
|
|
const visibleWorkspaceItems = useMemo(
|
|
() => isGuest ? workspaceNavItems.filter((item) => guestWorkspaceKeys.has(item.key)) : workspaceNavItems,
|
|
[isGuest],
|
|
)
|
|
const visibleWorkspaceGroups = isGuest ? guestWorkspaceGroups : workspaceNavGroups
|
|
const [mapContentMode, setMapContentMode] = useState<'dataset' | 'analysis'>('dataset')
|
|
const [mapContextSourceLabel, setMapContextSourceLabel] = useState<string | null>(null)
|
|
const [mapContextLayerLabel, setMapContextLayerLabel] = useState<string | null>(null)
|
|
const workbenchMainRef = useRef<HTMLElement | null>(null)
|
|
const previousWorkspaceRef = useRef<WorkspaceKey>(activeWorkspace)
|
|
// De werkbank draait donker, de landingspagina licht. Zie de sectie
|
|
// "Operationeel donker" in geointel-system.css.
|
|
useEffect(() => {
|
|
document.body.classList.add('workbench-body')
|
|
return () => document.body.classList.remove('workbench-body')
|
|
}, [])
|
|
useEffect(() => {
|
|
if (isGuest && !guestWorkspaceKeys.has(activeWorkspace)) {
|
|
setActiveWorkspace('map')
|
|
}
|
|
}, [activeWorkspace, isGuest])
|
|
useEffect(() => {
|
|
workbenchMainRef.current?.scrollTo({ top: 0, left: 0 })
|
|
if (previousWorkspaceRef.current !== activeWorkspace) {
|
|
workbenchMainRef.current?.focus({ preventScroll: true })
|
|
}
|
|
previousWorkspaceRef.current = activeWorkspace
|
|
setInspectorOpen(false)
|
|
}, [activeWorkspace])
|
|
const {
|
|
projects,
|
|
selectedProject,
|
|
selectedProjectId,
|
|
areas,
|
|
datasets,
|
|
loadingProjects,
|
|
loadingAreas,
|
|
loadingDatasets,
|
|
archivingProjectId,
|
|
errorMessage,
|
|
projectForm,
|
|
areaForm,
|
|
loadProjects,
|
|
loadProjectData,
|
|
createProject,
|
|
createArea,
|
|
activateMunicipality,
|
|
archiveProject,
|
|
resetProjectData,
|
|
setSelectedProjectId,
|
|
setErrorMessage,
|
|
setProjectForm,
|
|
setAreaForm,
|
|
} = useProjectWorkspace()
|
|
const sourceFreshness = useSourceFreshness(selectedProjectId)
|
|
const selectProject = (projectId: string) => {
|
|
setMapContentMode('dataset')
|
|
setSelectedProjectId(projectId)
|
|
}
|
|
const {
|
|
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,
|
|
setSelectedIntersectTargetId,
|
|
setSelectedClipAreaId,
|
|
setRasterTileSize,
|
|
setRasterTileOverlap,
|
|
setRasterTileOutputName,
|
|
setRasterReprojectCrs,
|
|
setRasterReprojectResampling,
|
|
setNdviNirBand,
|
|
setNdviRedBand,
|
|
setNdwiGreenBand,
|
|
setNdwiNirBand,
|
|
setNdbiSwirBand,
|
|
setNdbiNirBand,
|
|
setDatasetForm,
|
|
} = useDatasetWorkflow({
|
|
selectedProjectId,
|
|
areas,
|
|
datasets,
|
|
loadProjectData,
|
|
setErrorMessage,
|
|
isVectorDatasetType,
|
|
})
|
|
const rasterUnavailableMessage = useMemo(() => {
|
|
if (!selectedDataset || selectedDataset.dataset_type !== 'raster' || !selectedDataset.metadata_json) {
|
|
return null
|
|
}
|
|
const metadata = selectedDataset.metadata_json as Record<string, unknown>
|
|
const processingCode = metadata['processing_code']
|
|
if (processingCode === 'RASTER_PROCESSING_UNAVAILABLE') {
|
|
return String(metadata['processing_error'] ?? 'Raster processing unavailable.')
|
|
}
|
|
return null
|
|
}, [selectedDataset])
|
|
|
|
const availableVectorTargets = useMemo(
|
|
() => datasets.filter((item) => item.id !== selectedDatasetId && isVectorDatasetType(item.dataset_type)),
|
|
[datasets, selectedDatasetId],
|
|
)
|
|
const availableVectorDatasets = useMemo(() => datasets.filter((item) => isVectorDatasetType(item.dataset_type)), [datasets])
|
|
const availableMapDatasets = useMemo(
|
|
() => {
|
|
const vectors = datasets.filter((dataset) => isVectorDatasetType(dataset.dataset_type) && dataset.status === 'ready')
|
|
const rasters = datasets.filter(isMapRasterDataset)
|
|
return [...vectors, ...rasters]
|
|
},
|
|
[datasets],
|
|
)
|
|
const referenceDatasets = useMemo(
|
|
() => availableVectorDatasets.filter((item) => item.dataset_role === 'reference'),
|
|
[availableVectorDatasets],
|
|
)
|
|
const candidateDatasets = useMemo(
|
|
() => availableVectorDatasets.filter((item) => item.dataset_role !== 'reference'),
|
|
[availableVectorDatasets],
|
|
)
|
|
const rasterDatasets = useMemo(() => datasets.filter((item) => item.dataset_type === 'raster'), [datasets])
|
|
const detectionRasterDatasets = useMemo(
|
|
() => rasterDatasets.filter(isDetectionImageryDataset),
|
|
[rasterDatasets],
|
|
)
|
|
const {
|
|
providers,
|
|
loadingCapabilities,
|
|
capabilitiesError,
|
|
loadCapabilities,
|
|
} = useProviderCapabilities()
|
|
const {
|
|
changeSourceDatasetId,
|
|
changeTargetDatasetId,
|
|
changeIouThreshold,
|
|
changeIncludeUnchanged,
|
|
runningChangeDetection,
|
|
changeDetectionResult,
|
|
changeDetectionError,
|
|
runChangeDetection,
|
|
setChangeSourceDatasetId,
|
|
setChangeTargetDatasetId,
|
|
setChangeIouThreshold,
|
|
setChangeIncludeUnchanged,
|
|
} = useChangeDetectionWorkflow({
|
|
selectedProjectId,
|
|
availableVectorDatasets,
|
|
loadDatasetJobs,
|
|
// Bind the comparison to whatever the operator has selected on the map.
|
|
getSelection: () => ({ bbox: mapSelectionBbox ?? null, areaId: selectedMapAreaId ?? null }),
|
|
})
|
|
const {
|
|
qaCandidateDatasetId,
|
|
qaReferenceDatasetId,
|
|
qaAreaId,
|
|
qaIouThreshold,
|
|
qaRunning,
|
|
qaResult,
|
|
qaError,
|
|
qualityChecks,
|
|
qualityChecksError,
|
|
qualityEvidenceGeoJson,
|
|
qualityEvidenceLoading,
|
|
qualityEvidenceError,
|
|
loadQualityChecks,
|
|
loadQualityEvidenceGeoJson,
|
|
clearQualityEvidenceGeoJson,
|
|
runQaComparison,
|
|
setQaCandidateDatasetId,
|
|
setQaReferenceDatasetId,
|
|
setQaAreaId,
|
|
setQaIouThreshold,
|
|
} = useQualityWorkflow({
|
|
selectedProjectId,
|
|
loadProjectData,
|
|
})
|
|
const {
|
|
detectionModels,
|
|
modelAssets,
|
|
loadingDetectionModels,
|
|
detectionModelError,
|
|
modelAssetError,
|
|
selectedDetectionDatasetId,
|
|
selectedDetectionModelId,
|
|
selectedModelAssetId,
|
|
detectionTileManifestPath,
|
|
detectionConfidenceThreshold,
|
|
runningDetection,
|
|
detectionRunResult,
|
|
detectionRunError,
|
|
detectionRuns,
|
|
selectedDetectionRunId,
|
|
detectionItems,
|
|
detectionTotal,
|
|
detectionTruncated,
|
|
detectionGeoJson,
|
|
detectionClassFilter,
|
|
detectionMinConfidenceFilter,
|
|
loadingDetectionResults,
|
|
detectionReferenceDatasetId,
|
|
detectionQaResult,
|
|
detectionQaError,
|
|
runningDetectionQa,
|
|
yoloPreflight,
|
|
loadingYoloPreflight,
|
|
yoloPreflightError,
|
|
calibrationThresholdText,
|
|
runningDetectionCalibration,
|
|
detectionCalibrationRows,
|
|
detectionCalibrationError,
|
|
detectionWorkflowStage,
|
|
loadDetectionModels,
|
|
loadYoloPreflight,
|
|
loadDetectionRuns,
|
|
loadDetectionResults,
|
|
runDetection,
|
|
uploadDetectionRaster,
|
|
prepareAndRunDetection,
|
|
compareDetectionRunWithReference,
|
|
runDetectionQa,
|
|
runDetectionCalibration,
|
|
applyDetectionOperatorProfile,
|
|
resetDetectionForProject,
|
|
setSelectedDetectionDatasetId,
|
|
setSelectedDetectionModelId,
|
|
setSelectedModelAssetId,
|
|
setDetectionTileManifestPath,
|
|
setDetectionConfidenceThreshold,
|
|
setSelectedDetectionRunId,
|
|
setDetectionClassFilter,
|
|
setDetectionMinConfidenceFilter,
|
|
setDetectionReferenceDatasetId,
|
|
setCalibrationThresholdText,
|
|
} = useDetectionWorkflow({
|
|
selectedProjectId,
|
|
rasterDatasets: detectionRasterDatasets,
|
|
qaIouThreshold,
|
|
loadProjectData,
|
|
loadQualityChecks,
|
|
})
|
|
const useRasterTileManifestForDetection = () => {
|
|
const manifestPath = latestRasterTileManifestPath.trim()
|
|
if (!manifestPath || !selectedDataset || !isDetectionImageryDataset(selectedDataset)) {
|
|
return
|
|
}
|
|
setDetectionTileManifestPath(manifestPath)
|
|
setSelectedDetectionDatasetId(selectedDataset.id)
|
|
setSelectedDetectionModelId('yolo-configured')
|
|
setDetectionConfidenceThreshold(0.25)
|
|
loadYoloPreflight(manifestPath).catch(() => meldLaadfout('modelcontrole'))
|
|
setActiveWorkspace('ai')
|
|
}
|
|
const {
|
|
segmentationModels,
|
|
loadingSegmentationModels,
|
|
segmentationModelError,
|
|
selectedSegmentationDatasetId,
|
|
selectedSegmentationModelId,
|
|
selectedSegmentationModel,
|
|
segmentationTileManifestPath,
|
|
segmentationConfidenceThreshold,
|
|
runningSegmentation,
|
|
segmentationRunResult,
|
|
segmentationRunError,
|
|
segmentationRuns,
|
|
selectedSegmentationRunId,
|
|
segmentationItems,
|
|
segmentationGeoJson,
|
|
segmentationClassFilter,
|
|
segmentationMinConfidenceFilter,
|
|
loadingSegmentationResults,
|
|
segmentationReferenceDatasetId,
|
|
segmentationQaResult,
|
|
segmentationQaError,
|
|
runningSegmentationQa,
|
|
loadSegmentationModels,
|
|
loadSegmentationRuns,
|
|
loadSegmentationResults,
|
|
runSegmentation,
|
|
runSegmentationQa,
|
|
resetSegmentationForProject,
|
|
setSelectedSegmentationDatasetId,
|
|
setSelectedSegmentationModelId,
|
|
setSegmentationTileManifestPath,
|
|
setSegmentationConfidenceThreshold,
|
|
setSelectedSegmentationRunId,
|
|
setSegmentationClassFilter,
|
|
setSegmentationMinConfidenceFilter,
|
|
setSegmentationReferenceDatasetId,
|
|
} = useSegmentationWorkflow({
|
|
selectedProjectId,
|
|
rasterDatasets,
|
|
qaIouThreshold,
|
|
loadProjectData,
|
|
loadQualityChecks,
|
|
})
|
|
const viewportVectorLayer = useViewportVectorLayer({
|
|
selectedProjectId,
|
|
selectedDataset,
|
|
featureCount: selectedDatasetSummary?.feature_count ?? selectedDataset?.feature_count ?? null,
|
|
isVectorDatasetType,
|
|
})
|
|
const analysisMapLayerAvailable = Boolean(changeDetectionResult?.geojson || segmentationGeoJson || detectionGeoJson)
|
|
const analysisMapLayerActive = mapContentMode === 'analysis' && analysisMapLayerAvailable
|
|
const viewportVectorLayerActive = viewportVectorLayer.enabled && !analysisMapLayerActive
|
|
const datasetMapContent = viewportVectorLayer.enabled ? viewportVectorLayer.data : datasetContent
|
|
const useRasterTileManifestForSegmentation = () => {
|
|
const manifestPath = latestRasterTileManifestPath.trim()
|
|
if (!manifestPath || !selectedDataset || selectedDataset.dataset_type !== 'raster') {
|
|
return
|
|
}
|
|
setSegmentationTileManifestPath(manifestPath)
|
|
setSelectedSegmentationDatasetId(selectedDataset.id)
|
|
setActiveWorkspace('ai')
|
|
}
|
|
const {
|
|
exports,
|
|
latestExport,
|
|
exportError,
|
|
loadingExports,
|
|
exporting,
|
|
selectionExporting,
|
|
selectionExportError,
|
|
latestSelectionExport,
|
|
exportPreview,
|
|
loadExports,
|
|
exportSelectedDatasetGeoJson,
|
|
exportSelectedDetectionRunGeoJson,
|
|
exportSelectedSegmentationRunGeoJson,
|
|
exportMapSelectionGeoJson,
|
|
persistMapResult,
|
|
exportProjectMetadata,
|
|
exportProjectReport,
|
|
previewExportContent,
|
|
downloadExportArtifact,
|
|
resetExportsForProject,
|
|
} = useExportWorkflow({
|
|
selectedProjectId,
|
|
selectedDataset,
|
|
selectedDetectionRunId,
|
|
selectedSegmentationRunId,
|
|
isVectorDatasetType,
|
|
})
|
|
const {
|
|
mapLayerVisible,
|
|
mapLayerOpacity,
|
|
selectedMapAreaId,
|
|
areaLayerVisible,
|
|
areaLayerOpacity,
|
|
selectedMapFeature,
|
|
areaFeatureCollection,
|
|
mapFeatureCollection,
|
|
mapLayerLabel,
|
|
mapFeatureCount,
|
|
areaFeatureCount,
|
|
setMapLayerVisible,
|
|
setMapLayerOpacity,
|
|
setSelectedMapAreaId,
|
|
setAreaLayerVisible,
|
|
setAreaLayerOpacity,
|
|
setSelectedMapFeature,
|
|
} = useMapWorkspaceState({
|
|
areas,
|
|
changeDetectionGeoJson: analysisMapLayerActive ? changeDetectionResult?.geojson ?? null : null,
|
|
segmentationGeoJson: analysisMapLayerActive ? segmentationGeoJson : null,
|
|
detectionGeoJson: analysisMapLayerActive ? detectionGeoJson : null,
|
|
datasetContent: datasetMapContent,
|
|
selectedDataset,
|
|
datasetLayerActive: Boolean(selectedDataset && isVectorDatasetType(selectedDataset.dataset_type)),
|
|
})
|
|
const {
|
|
mapSelectionBbox,
|
|
mapSelectionResult,
|
|
mapSelectionLoading,
|
|
mapSelectionError,
|
|
runMapSelectionExtract,
|
|
resetMapSelectionExtract,
|
|
setMapSelectionBbox,
|
|
} = useMapSelectionExtract({
|
|
selectedProjectId,
|
|
selectedDataset,
|
|
isVectorDatasetType,
|
|
})
|
|
const {
|
|
coverage: mapCoverage,
|
|
loadingCoverage: mapCoverageLoading,
|
|
coverageError: mapCoverageError,
|
|
coverageDurationMs: mapCoverageDurationMs,
|
|
coverageBudgetExceeded: mapCoverageBudgetExceeded,
|
|
} = useCoverageResolver({
|
|
projectId: selectedProjectId,
|
|
bbox: mapSelectionBbox,
|
|
})
|
|
const {
|
|
selectionDatasetSaving,
|
|
selectionDatasetError,
|
|
latestSelectionDataset,
|
|
deriveMapSelectionDataset,
|
|
} = useMapSelectionDataset({
|
|
selectedProjectId,
|
|
selectedDataset,
|
|
isVectorDatasetType,
|
|
loadProjectData,
|
|
loadDatasetDetails,
|
|
setMapLayerVisible,
|
|
})
|
|
const {
|
|
selectedMapQaReferenceDatasetId,
|
|
mapSelectionQaRunning,
|
|
mapSelectionQaError,
|
|
mapSelectionQaResult,
|
|
latestMapSelectionQualityCheckId,
|
|
runMapSelectionQa,
|
|
setSelectedMapQaReferenceDatasetId,
|
|
} = useMapSelectionQa({
|
|
selectedProjectId,
|
|
latestSelectionDataset,
|
|
loadQualityChecks,
|
|
loadProjectData,
|
|
})
|
|
const mapOrthophotoAnalysis = useMapOrthophotoAnalysis({
|
|
selectedProjectId,
|
|
selectedAreaId: areas.find((area) => /vervoerregio|operationele grens/i.test(area.name))?.id ?? selectedMapAreaId,
|
|
selectionBbox: mapSelectionBbox,
|
|
datasets,
|
|
loadProjectData,
|
|
prepareAndRunDetection: (datasetId) => prepareAndRunDetection(datasetId, 'yolo-configured'),
|
|
compareDetectionRunWithReference: (analysisRunId, referenceDatasetId, iouThreshold) =>
|
|
compareDetectionRunWithReference(analysisRunId, referenceDatasetId, false, iouThreshold),
|
|
loadQualityEvidence: (qualityCheckId) => loadQualityEvidenceGeoJson(qualityCheckId),
|
|
onAnalysisReady: () => {
|
|
setMapContentMode('analysis')
|
|
setMapLayerVisible(true)
|
|
setActiveWorkspace('map')
|
|
},
|
|
})
|
|
const openMapSelectionQualityEvidence = () => {
|
|
setActiveWorkspace('analysis')
|
|
}
|
|
const openQualityEvidenceOnMap = async (qualityCheckId: string) => {
|
|
const result = await loadQualityEvidenceGeoJson(qualityCheckId)
|
|
if (result) {
|
|
setMapLayerVisible(true)
|
|
setActiveWorkspace('map')
|
|
}
|
|
}
|
|
const {
|
|
loadingDemoWorkflow,
|
|
demoWorkflowMessage,
|
|
loadDemoWorkflow,
|
|
} = useDemoWorkflow({
|
|
restrictedMode: false,
|
|
loadProjects,
|
|
loadProjectData,
|
|
loadDatasetDetails,
|
|
loadDetectionRuns,
|
|
loadSegmentationRuns,
|
|
loadQualityChecks,
|
|
loadExports,
|
|
setSelectedProjectId: selectProject,
|
|
setSelectedDatasetId,
|
|
setSelectedMapAreaId,
|
|
setQaCandidateDatasetId,
|
|
setQaReferenceDatasetId,
|
|
setQaAreaId,
|
|
setSelectedDetectionDatasetId,
|
|
setDetectionReferenceDatasetId,
|
|
setSelectedSegmentationDatasetId,
|
|
setSegmentationReferenceDatasetId,
|
|
setErrorMessage,
|
|
})
|
|
|
|
useEffect(() => {
|
|
if (!isGuest || guestDemoStartedRef.current) return
|
|
guestDemoStartedRef.current = true
|
|
setGuestDemoReady(false)
|
|
void loadDemoWorkflow().finally(() => setGuestDemoReady(true))
|
|
}, [isGuest, loadDemoWorkflow])
|
|
|
|
useWorkbenchBootstrap({
|
|
restrictedMode: false,
|
|
activeWorkspace,
|
|
onLoadError: meldLaadfout,
|
|
selectedProjectId,
|
|
selectedDetectionRunId,
|
|
detectionClassFilter,
|
|
detectionMinConfidenceFilter,
|
|
selectedSegmentationRunId,
|
|
segmentationClassFilter,
|
|
segmentationMinConfidenceFilter,
|
|
loadProjects,
|
|
loadCapabilities,
|
|
loadDetectionModels,
|
|
loadSegmentationModels,
|
|
loadProjectData,
|
|
loadDetectionRuns,
|
|
loadSegmentationRuns,
|
|
loadQualityChecks,
|
|
loadExports,
|
|
loadDetectionResults,
|
|
loadSegmentationResults,
|
|
resetProjectData,
|
|
resetDatasetForProject,
|
|
resetDetectionForProject,
|
|
resetSegmentationForProject,
|
|
resetExportsForProject,
|
|
})
|
|
|
|
const selectedArea = areas.find((area) => area.id === selectedMapAreaId) ?? null
|
|
const activeWorkspaceItem = visibleWorkspaceItems.find((item) => item.key === activeWorkspace) ?? visibleWorkspaceItems[0]
|
|
const mapLayerSourceLabel = useMemo(() => {
|
|
if (analysisMapLayerActive && changeDetectionResult?.geojson) {
|
|
return 'Veranderingsanalyse'
|
|
}
|
|
if (analysisMapLayerActive && segmentationGeoJson) {
|
|
return 'Segmentatierun'
|
|
}
|
|
if (analysisMapLayerActive && detectionGeoJson) {
|
|
return 'Detectierun'
|
|
}
|
|
if ((datasetMapContent || viewportVectorLayer.enabled) && selectedDataset) {
|
|
return selectedDataset.dataset_type === 'raster' ? 'Rasterdatabron' : 'Vectordatabron'
|
|
}
|
|
return 'Geen actieve gegevens- of analyselaag'
|
|
}, [analysisMapLayerActive, changeDetectionResult?.geojson, datasetMapContent, detectionGeoJson, segmentationGeoJson, selectedDataset, viewportVectorLayer.enabled])
|
|
const mapLayerProvenance = useMemo(() => {
|
|
if (analysisMapLayerActive && changeDetectionResult?.geojson) {
|
|
return 'Vergelijking van twee bewaarde kaartlagen'
|
|
}
|
|
if (analysisMapLayerActive && segmentationGeoJson) {
|
|
return selectedSegmentationRunId ? 'Bewaarde segmentatieronde' : 'Segmentatieresultaten geladen'
|
|
}
|
|
if (analysisMapLayerActive && detectionGeoJson) {
|
|
return selectedDetectionRunId ? 'Bewaarde detectieronde' : 'Detectieresultaten geladen'
|
|
}
|
|
if ((datasetMapContent || viewportVectorLayer.enabled) && selectedDataset) {
|
|
return `Bewaarde ${selectedDataset.dataset_role === 'reference' ? 'referentielaag' : 'databron'}`
|
|
}
|
|
return 'Open een databron, detectieronde, segmentatieronde of veranderingsresultaat om het hier te tekenen.'
|
|
}, [
|
|
analysisMapLayerActive,
|
|
changeDetectionResult?.geojson,
|
|
changeSourceDatasetId,
|
|
changeTargetDatasetId,
|
|
datasetMapContent,
|
|
detectionGeoJson,
|
|
segmentationGeoJson,
|
|
selectedDataset,
|
|
selectedDetectionRunId,
|
|
selectedSegmentationRunId,
|
|
viewportVectorLayer.enabled,
|
|
])
|
|
const openDatasetInMap = (dataset: DatasetCreateResponse) => {
|
|
if (selectedProjectId) {
|
|
loadDatasetDetails(selectedProjectId, dataset)
|
|
}
|
|
setMapContentMode('dataset')
|
|
setMapLayerVisible(true)
|
|
setActiveWorkspace('map')
|
|
}
|
|
const runGuidedDetection = async () => {
|
|
const completed = await prepareAndRunDetection()
|
|
if (completed) {
|
|
setMapContentMode('analysis')
|
|
setMapLayerVisible(true)
|
|
setActiveWorkspace('map')
|
|
}
|
|
}
|
|
const openDetectionResultsOnMap = () => {
|
|
if (!detectionGeoJson) {
|
|
return
|
|
}
|
|
setMapContentMode('analysis')
|
|
setMapLayerVisible(true)
|
|
setActiveWorkspace('map')
|
|
}
|
|
const openDatasetExport = (dataset: DatasetCreateResponse) => {
|
|
if (selectedProjectId) {
|
|
loadDatasetDetails(selectedProjectId, dataset)
|
|
}
|
|
setActiveWorkspace('exports')
|
|
}
|
|
const openWorkflowGuidanceStep = (target: WorkspaceKey) => {
|
|
if (isGuest && !guestWorkspaceKeys.has(target)) {
|
|
setActiveWorkspace('map')
|
|
return
|
|
}
|
|
if (target === 'map' && availableMapDatasets.length > 0 && !mapFeatureCollection) {
|
|
openDatasetInMap(availableMapDatasets[0])
|
|
return
|
|
}
|
|
if (target === 'exports' && availableMapDatasets.length > 0 && !selectedDataset) {
|
|
openDatasetExport(availableMapDatasets[0])
|
|
return
|
|
}
|
|
setActiveWorkspace(target)
|
|
}
|
|
const hasAnalysisOutput =
|
|
qualityChecks.length > 0
|
|
|| Boolean(changeDetectionResult)
|
|
|| detectionItems.length > 0
|
|
|| segmentationItems.length > 0
|
|
const projectContextLabel = selectedProject?.name === NATIONAL_WORKSPACE_PROJECT_NAME
|
|
? NATIONAL_WORKSPACE_LABEL
|
|
: selectedProject?.name === REGIONAL_WORKSPACE_PROJECT_NAME
|
|
? REGIONAL_WORKSPACE_LABEL
|
|
: selectedProject?.name === FLANDERS_WORKSPACE_PROJECT_NAME
|
|
? FLANDERS_WORKSPACE_LABEL
|
|
: selectedProject?.name ?? 'Geen werkruimte'
|
|
const areaContextLabel = selectedArea?.name ?? (areas.length > 0 ? 'Kies een gebied' : 'Geen gebied')
|
|
const bathymetryProfileContextActive = Boolean(
|
|
activeWorkspace === 'map'
|
|
&& selectedDataset?.source_name === 'vmm_vha_bathymetry_profiles',
|
|
)
|
|
const bathymetryRasterContextActive = Boolean(
|
|
activeWorkspace === 'map'
|
|
&& selectedDataset?.source_name === 'spw_bathymetry',
|
|
)
|
|
const bathymetryContextActive = bathymetryProfileContextActive || bathymetryRasterContextActive
|
|
const regionalBathymetryContextActive = Boolean(
|
|
bathymetryProfileContextActive
|
|
&& selectedDataset?.source_metadata?.regional_partitions_complete === true
|
|
&& selectedArea
|
|
&& !/^Gemeente\s/i.test(selectedArea.name),
|
|
)
|
|
const regionalBathymetryManifest = String(
|
|
selectedDataset?.source_metadata?.partition_manifest_sha256 ?? '',
|
|
)
|
|
const regionalBathymetryPartitions = regionalBathymetryContextActive
|
|
? availableMapDatasets.filter(
|
|
(dataset) =>
|
|
dataset.source_name === 'vmm_vha_bathymetry_profiles'
|
|
&& dataset.source_metadata?.regional_partitions_complete === true
|
|
&& String(dataset.source_metadata?.partition_manifest_sha256 ?? '') === regionalBathymetryManifest,
|
|
)
|
|
: []
|
|
const regionalBathymetryProfileCount = regionalBathymetryPartitions.reduce(
|
|
(total, dataset) => total + (dataset.feature_count ?? dataset.vector_summary?.feature_count ?? 0),
|
|
0,
|
|
)
|
|
const bathymetryProfileCount = regionalBathymetryContextActive
|
|
? regionalBathymetryProfileCount
|
|
: selectedDataset?.feature_count ?? selectedDataset?.vector_summary?.feature_count ?? 0
|
|
const workspaceDataLoading = loadingProjects || loadingAreas || loadingDatasets
|
|
const workspaceStatusMessage = errorMessage
|
|
? `Werkruimtefout: ${errorMessage}`
|
|
: workspaceDataLoading
|
|
? 'Werkruimte en databronnen worden geladen.'
|
|
: selectedProject
|
|
? `${projectContextLabel} is geladen met ${datasets.length} databronnen en ${areas.length} gebieden.`
|
|
: 'Geen werkruimte geselecteerd.'
|
|
const datasetContextLabel = activeWorkspace === 'map' && mapContextSourceLabel
|
|
? mapContextSourceLabel
|
|
: analysisMapLayerActive && mapFeatureCollection
|
|
? `${mapLayerLabel} · controle vereist`
|
|
: selectedDataset
|
|
? getDatasetDisplayName(selectedDataset)
|
|
: workspaceDataLoading
|
|
? 'Bronnen worden geladen'
|
|
: datasets.length > 0
|
|
? 'Kies een bron'
|
|
: 'Geen bron'
|
|
const layerContextLabel = activeWorkspace === 'map' && mapContextLayerLabel
|
|
? mapContextLayerLabel
|
|
: bathymetryContextActive
|
|
? bathymetryRasterContextActive
|
|
? `${Number(selectedDataset?.source_metadata?.analysis_resolution_m ?? 0.5).toLocaleString('nl-BE')} m raster · mDNG · ${String(selectedDataset?.source_metadata?.survey_period ?? '2019-2022')}`
|
|
: regionalBathymetryContextActive
|
|
? `${bathymetryProfileCount.toLocaleString('nl-BE')} profielen · ${regionalBathymetryPartitions.length} gemeenten`
|
|
: `${bathymetryProfileCount.toLocaleString('nl-BE')} profielen`
|
|
: mapFeatureCollection
|
|
? `${mapFeatureCount.toLocaleString('nl-BE')} objecten`
|
|
: workspaceDataLoading
|
|
? 'Kaart wordt voorbereid'
|
|
: viewportVectorLayerActive
|
|
? 'Kaartlaag gekozen'
|
|
: activeWorkspace === 'map' && selectedDataset?.dataset_type === 'raster'
|
|
? 'Rasterlaag actief'
|
|
: 'Geen actieve laag'
|
|
|
|
return (
|
|
<div className={`${isGuest ? 'app-shell workbench-shell workbench-shell-guest' : 'app-shell workbench-shell'}${secondaryDisplay.isOpen ? ' workbench-shell-dual-display' : ''}`}>
|
|
<a
|
|
className="skip-link"
|
|
href="#workspace-main"
|
|
onClick={() => {
|
|
window.requestAnimationFrame(() => workbenchMainRef.current?.focus({ preventScroll: true }))
|
|
}}
|
|
>
|
|
Ga naar de werkruimte
|
|
</a>
|
|
{/* De werkbank begon bij h2, dus schermlezers kregen geen paginatitel en
|
|
geen ankerpunt om vanaf te navigeren. Deze kop noemt waar je bent en
|
|
verandert mee met het werkblad. */}
|
|
<h1 className="sr-only">GeoIntel — {activeWorkspaceItem.label}</h1>
|
|
<p className="sr-only" role="status" aria-live="polite">{workspaceStatusMessage}</p>
|
|
{laadfouten.length > 0 ? (
|
|
<div className="workspace-notice workspace-notice-load" role="alert">
|
|
<CircleAlert aria-hidden="true" />
|
|
<div>
|
|
<strong>Niet alles kon worden opgehaald</strong>
|
|
<span>
|
|
{laadfouten.join(', ')} {laadfouten.length === 1 ? 'is' : 'zijn'} niet geladen. Wat u hier ziet is
|
|
daardoor onvolledig; het is geen bevestiging dat er niets is.
|
|
</span>
|
|
</div>
|
|
<button type="button" className="secondary-action" onClick={() => setLaadfouten([])}>
|
|
Melding sluiten
|
|
</button>
|
|
</div>
|
|
) : null}
|
|
{errorMessage && activeWorkspace !== 'map' ? (
|
|
<div className="workspace-notice" role="alert">
|
|
<CircleAlert aria-hidden="true" />
|
|
<div>
|
|
<strong>Werkruimte vraagt aandacht</strong>
|
|
<span>{errorMessage}</span>
|
|
</div>
|
|
</div>
|
|
) : null}
|
|
|
|
<div className="workbench-layout">
|
|
<WorkbenchNavigation
|
|
activeWorkspace={activeWorkspace}
|
|
groups={visibleWorkspaceGroups}
|
|
items={visibleWorkspaceItems}
|
|
onSelect={setActiveWorkspace}
|
|
/>
|
|
|
|
<div className="workbench-stage">
|
|
<header className="workbench-topbar">
|
|
<div className="mobile-brand">
|
|
<img className="brand-mark geointel-mark" src="/geointel-icon.svg" alt="" aria-hidden="true" />
|
|
<strong>GeoIntel</strong>
|
|
</div>
|
|
<div className="context-bar" aria-label="Actieve werkcontext">
|
|
<div>
|
|
<span>Werkruimte</span>
|
|
<strong title={projectContextLabel}>{projectContextLabel}</strong>
|
|
</div>
|
|
<div>
|
|
<span>Gebied</span>
|
|
<strong title={areaContextLabel}>{areaContextLabel}</strong>
|
|
</div>
|
|
<div>
|
|
<span>Bron</span>
|
|
<strong title={datasetContextLabel}>{datasetContextLabel}</strong>
|
|
</div>
|
|
<div>
|
|
<span>Kaartlaag</span>
|
|
<strong title={layerContextLabel}>{layerContextLabel}</strong>
|
|
</div>
|
|
</div>
|
|
<div className="context-health" aria-label="Systeemstatus">
|
|
<span aria-hidden="true" />
|
|
<strong>{workspaceDataLoading ? 'Laden' : errorMessage ? 'Aandacht' : 'Gereed'}</strong>
|
|
</div>
|
|
<button
|
|
type="button"
|
|
className="workbench-theme-toggle"
|
|
onClick={toggleTheme}
|
|
aria-pressed={theme === 'light'}
|
|
title={theme === 'dark' ? 'Overschakelen naar de lichte werkstand' : 'Overschakelen naar de donkere werkstand'}
|
|
>
|
|
{theme === 'dark' ? <Sun aria-hidden="true" /> : <Moon aria-hidden="true" />}
|
|
<span className="sr-only">
|
|
{theme === 'dark' ? 'Lichte werkstand' : 'Donkere werkstand'}
|
|
</span>
|
|
</button>
|
|
<button
|
|
type="button"
|
|
className={secondaryDisplay.isOpen ? 'secondary-display-launch secondary-display-launch-active' : 'secondary-display-launch'}
|
|
aria-pressed={secondaryDisplay.isOpen}
|
|
aria-describedby={secondaryDisplay.error ? 'secondary-display-error' : undefined}
|
|
onClick={() => {
|
|
setActiveWorkspace('map')
|
|
if (secondaryDisplay.isOpen) secondaryDisplay.close()
|
|
else secondaryDisplay.open()
|
|
}}
|
|
>
|
|
<MonitorUp aria-hidden="true" />
|
|
<span>{secondaryDisplay.isOpen ? 'Sluit tweede scherm' : 'Open tweede scherm'}</span>
|
|
</button>
|
|
{username || isGuest ? (
|
|
<div
|
|
className={isGuest ? 'context-account context-account-guest' : 'context-account'}
|
|
aria-label={isGuest ? 'Tijdelijke gastensessie' : 'Aangemelde gebruiker'}
|
|
>
|
|
{isGuest ? <ShieldCheck aria-hidden="true" /> : <UserRound aria-hidden="true" />}
|
|
<span title={username ?? undefined}>{isGuest ? 'Gastmodus' : username}</span>
|
|
<button type="button" onClick={onLogout} disabled={loggingOut}>
|
|
<LogOut aria-hidden="true" />
|
|
<span>{loggingOut ? 'Afsluiten…' : isGuest ? 'Demo afsluiten' : 'Uitloggen'}</span>
|
|
</button>
|
|
</div>
|
|
) : null}
|
|
</header>
|
|
|
|
{secondaryDisplay.error ? (
|
|
<div className="secondary-display-error" id="secondary-display-error" role="alert">
|
|
<CircleAlert aria-hidden="true" />
|
|
<span>{secondaryDisplay.error}</span>
|
|
</div>
|
|
) : null}
|
|
|
|
{isGuest ? (
|
|
<div className="guest-mode-banner" role="status">
|
|
<ShieldCheck aria-hidden="true" />
|
|
<div>
|
|
<strong>Tijdelijke demowerkruimte</strong>
|
|
<span>Alle analysemodellen en werkfuncties zijn beschikbaar. Beheer, instellingen en blijvende gegevenswijzigingen blijven afgeschermd.</span>
|
|
</div>
|
|
<span className="guest-mode-badge">Analyse-toegang</span>
|
|
</div>
|
|
) : null}
|
|
|
|
{isGuest && (!guestDemoReady || loadingDemoWorkflow) ? (
|
|
<div className="guest-demo-loading" role="status" aria-live="polite">
|
|
<span aria-hidden="true" />
|
|
<strong>Demodata en kwaliteitsbewijs worden voorbereid…</strong>
|
|
</div>
|
|
) : null}
|
|
|
|
<div className="workbench-content">
|
|
|
|
{/* Eén werkblad dat gooit mag niet de hele werkbank meenemen. */}
|
|
<WorkspaceErrorBoundary resetKey={activeWorkspace} label={activeWorkspaceItem.label}>
|
|
<main
|
|
ref={workbenchMainRef}
|
|
className={activeWorkspace === 'map' ? 'workbench-main workbench-main-map' : 'workbench-main'}
|
|
id="workspace-main"
|
|
tabIndex={-1}
|
|
aria-busy={workspaceDataLoading}
|
|
>
|
|
{activeWorkspace !== 'map' ? <div className="workspace-heading">
|
|
<div className="workspace-heading-copy">
|
|
<p className="eyebrow">{selectedProject?.region ?? 'Belgie en Belgische Noordzee'}</p>
|
|
<h2>{activeWorkspaceItem.label}</h2>
|
|
</div>
|
|
<WorkspaceSignal workspace={activeWorkspace} />
|
|
<div className="workspace-heading-actions">
|
|
<p>{activeWorkspaceItem.description}</p>
|
|
{activeWorkspace !== 'overview' ? (
|
|
<button
|
|
type="button"
|
|
className={inspectorOpen ? 'inspector-toggle inspector-toggle-active' : 'inspector-toggle'}
|
|
onClick={() => setInspectorOpen((current) => !current)}
|
|
aria-expanded={inspectorOpen}
|
|
aria-controls="workbench-inspector"
|
|
>
|
|
{inspectorOpen ? 'Context sluiten' : 'Context bekijken'}
|
|
</button>
|
|
) : null}
|
|
</div>
|
|
</div> : null}
|
|
{activeWorkspace === 'overview' ? (
|
|
<OverviewWorkspace
|
|
selectedProject={selectedProject}
|
|
selectedProjectId={selectedProjectId}
|
|
areas={areas}
|
|
datasets={datasets}
|
|
qualityChecks={qualityChecks}
|
|
exports={exports}
|
|
activeLayerFeatureCount={mapFeatureCount}
|
|
selectedAreaHasGeometry={Boolean(areaFeatureCollection)}
|
|
hasAnalysisOutput={hasAnalysisOutput}
|
|
sourceFreshness={sourceFreshness}
|
|
onOpenWorkspace={openWorkflowGuidanceStep}
|
|
/>
|
|
) : null}
|
|
|
|
{activeWorkspace === 'data' ? (
|
|
<div className="workspace-grid workspace-grid-data">
|
|
<SourceCatalogPanel
|
|
datasets={datasets}
|
|
projectId={selectedProjectId ?? undefined}
|
|
loading={loadingDatasets}
|
|
/>
|
|
{isGuest ? (
|
|
<div className="guest-readonly-card">
|
|
<ShieldCheck aria-hidden="true" />
|
|
<div>
|
|
<strong>Bronnen bekijken zonder beheerrechten</strong>
|
|
<span>De demo gebruikt dezelfde beschikbare databronnen. Projecten, gebieden en uploads worden alleen door de operator beheerd.</span>
|
|
</div>
|
|
</div>
|
|
) : <>
|
|
<ProjectPanel
|
|
projects={projects}
|
|
selectedProjectId={selectedProjectId}
|
|
loadingProjects={loadingProjects}
|
|
archivingProjectId={archivingProjectId}
|
|
projectForm={projectForm}
|
|
loadingDemoWorkflow={loadingDemoWorkflow}
|
|
demoWorkflowMessage={demoWorkflowMessage}
|
|
onCreateProject={createProject}
|
|
onUpdateProjectForm={setProjectForm}
|
|
onSelectProject={selectProject}
|
|
onArchiveProject={archiveProject}
|
|
onLoadDemoWorkflow={loadDemoWorkflow}
|
|
/>
|
|
|
|
<AreaPanel
|
|
areas={areas}
|
|
selectedProject={selectedProject}
|
|
selectedProjectId={selectedProjectId}
|
|
loadingAreas={loadingAreas}
|
|
areaForm={areaForm}
|
|
selectedMapAreaId={selectedMapAreaId}
|
|
onCreateArea={createArea}
|
|
onUpdateAreaForm={setAreaForm}
|
|
onSelectMapArea={setSelectedMapAreaId}
|
|
/>
|
|
|
|
<DatasetPanel
|
|
selectedProjectId={selectedProjectId}
|
|
selectedDatasetId={selectedDatasetId}
|
|
areas={areas}
|
|
datasets={datasets}
|
|
datasetForm={datasetForm}
|
|
loadingDatasets={loadingDatasets}
|
|
onDatasetFormChange={setDatasetForm}
|
|
onUploadDataset={uploadDataset}
|
|
onLoadDatasetDetails={loadDatasetDetails}
|
|
onOpenInspector={() => setInspectorOpen(true)}
|
|
onRefreshMetadata={refreshMetadata}
|
|
onOpenDatasetInMap={openDatasetInMap}
|
|
onOpenDatasetExport={openDatasetExport}
|
|
/>
|
|
</>}
|
|
</div>
|
|
) : null}
|
|
|
|
<div className="workspace-persistent-map" hidden={activeWorkspace !== 'map'}>
|
|
<MapWorkspace
|
|
readOnly={false}
|
|
secondaryResultsContainer={secondaryDisplay.container}
|
|
selectedProjectId={selectedProjectId}
|
|
projects={projects}
|
|
areas={areas}
|
|
selectedMapAreaId={selectedMapAreaId}
|
|
areaFeatureCollection={areaFeatureCollection}
|
|
mapFeatureCollection={mapFeatureCollection}
|
|
qualityEvidenceGeoJson={qualityEvidenceGeoJson?.geojson ?? null}
|
|
qualityEvidenceFeatureCount={qualityEvidenceGeoJson?.feature_count ?? 0}
|
|
qualityEvidenceLoading={qualityEvidenceLoading}
|
|
qualityEvidenceError={qualityEvidenceError}
|
|
qualityEvidenceWarnings={qualityEvidenceGeoJson?.warnings ?? []}
|
|
mapLayerLabel={mapLayerLabel}
|
|
mapLayerSourceLabel={mapLayerSourceLabel}
|
|
mapLayerProvenance={mapLayerProvenance}
|
|
mapLayerVisible={mapLayerVisible}
|
|
mapLayerOpacity={mapLayerOpacity}
|
|
areaLayerVisible={areaLayerVisible}
|
|
areaLayerOpacity={areaLayerOpacity}
|
|
mapFeatureCount={mapFeatureCount}
|
|
areaFeatureCount={areaFeatureCount}
|
|
viewportVectorEnabled={viewportVectorLayerActive}
|
|
viewportVectorStatus={viewportVectorLayerActive ? viewportVectorLayer.statusMessage : null}
|
|
viewportVectorTone={viewportVectorLayer.error ? 'error' : viewportVectorLayer.truncated ? 'warning' : viewportVectorLayer.loading || viewportVectorLayer.zoomRequired ? 'pending' : 'ready'}
|
|
fitMapDataOnChange={!viewportVectorLayerActive}
|
|
mapContentMode={analysisMapLayerActive ? 'analysis' : 'dataset'}
|
|
analysisLayerAvailable={analysisMapLayerAvailable}
|
|
selectedMapFeature={selectedMapFeature}
|
|
mapSelectionBbox={mapSelectionBbox}
|
|
mapSelectionResult={mapSelectionResult}
|
|
mapSelectionLoading={mapSelectionLoading}
|
|
mapSelectionError={mapSelectionError}
|
|
coverage={mapCoverage}
|
|
coverageLoading={mapCoverageLoading}
|
|
coverageError={mapCoverageError}
|
|
coverageDurationMs={mapCoverageDurationMs}
|
|
coverageBudgetExceeded={mapCoverageBudgetExceeded}
|
|
workspaceLoading={workspaceDataLoading}
|
|
workspaceError={errorMessage}
|
|
selectionExporting={selectionExporting}
|
|
selectionExportError={selectionExportError}
|
|
latestSelectionExportPath={latestSelectionExport?.path ?? null}
|
|
selectionDatasetSaving={selectionDatasetSaving}
|
|
selectionDatasetError={selectionDatasetError}
|
|
latestSelectionDataset={latestSelectionDataset}
|
|
latestSelectionDatasetName={latestSelectionDataset?.name ?? null}
|
|
mapQaReferenceDatasets={referenceDatasets}
|
|
selectedMapQaReferenceDatasetId={selectedMapQaReferenceDatasetId}
|
|
mapSelectionQaRunning={mapSelectionQaRunning}
|
|
mapSelectionQaError={mapSelectionQaError}
|
|
mapSelectionQaResult={mapSelectionQaResult}
|
|
latestMapSelectionQualityCheckId={latestMapSelectionQualityCheckId}
|
|
orthophotoAnalysisStage={mapOrthophotoAnalysis.stage}
|
|
orthophotoAnalysisStatus={mapOrthophotoAnalysis.status}
|
|
orthophotoAnalysisError={mapOrthophotoAnalysis.error}
|
|
orthophotoAnalysisRunning={mapOrthophotoAnalysis.running}
|
|
orthophotoAnalysisQuality={mapOrthophotoAnalysis.lastQuality}
|
|
orthophotoAnalysisDetectionCount={mapOrthophotoAnalysis.lastDetectionCount}
|
|
orthophotoProducts={mapOrthophotoAnalysis.products}
|
|
selectedOrthophotoProductKey={mapOrthophotoAnalysis.selectedProductKey}
|
|
orthophotoResult={mapOrthophotoAnalysis.lastResult}
|
|
orthophotoImageUrl={mapOrthophotoAnalysis.imageUrl}
|
|
availableMapDatasets={availableMapDatasets}
|
|
selectedMapDatasetId={selectedDataset && availableMapDatasets.some((dataset) => dataset.id === selectedDataset.id) ? selectedDataset.id : ''}
|
|
selectedFeature={selectedMapFeature}
|
|
onSelectMapArea={setSelectedMapAreaId}
|
|
onActivateMunicipality={async (niscode) => {
|
|
const area = await activateMunicipality(niscode)
|
|
if (area) setSelectedMapAreaId(area.id)
|
|
return area
|
|
}}
|
|
onSetContextSourceLabel={setMapContextSourceLabel}
|
|
onSetContextLayerLabel={setMapContextLayerLabel}
|
|
onOpenDatasetInMap={openDatasetInMap}
|
|
onSetAreaLayerVisible={setAreaLayerVisible}
|
|
onSetAreaLayerOpacity={setAreaLayerOpacity}
|
|
onSetMapLayerVisible={setMapLayerVisible}
|
|
onSetMapLayerOpacity={setMapLayerOpacity}
|
|
onSetMapContentMode={setMapContentMode}
|
|
onSelectMapFeature={setSelectedMapFeature}
|
|
onMapViewportChange={viewportVectorLayer.setViewport}
|
|
onSetMapSelectionBbox={setMapSelectionBbox}
|
|
onRunMapSelectionExtract={runMapSelectionExtract}
|
|
onClearMapSelectionExtract={resetMapSelectionExtract}
|
|
onExportMapSelection={exportMapSelectionGeoJson}
|
|
onPersistMapResult={persistMapResult}
|
|
onDeriveMapSelectionDataset={deriveMapSelectionDataset}
|
|
onSelectMapQaReferenceDataset={setSelectedMapQaReferenceDatasetId}
|
|
onRunMapSelectionQa={runMapSelectionQa}
|
|
onOpenMapSelectionQualityEvidence={openMapSelectionQualityEvidence}
|
|
onRunOrthophotoAnalysis={mapOrthophotoAnalysis.run}
|
|
onSelectOrthophotoProduct={mapOrthophotoAnalysis.setSelectedProductKey}
|
|
onClearQualityEvidence={clearQualityEvidenceGeoJson}
|
|
onRefreshProjectData={() => (
|
|
selectedProjectId ? loadProjectData(selectedProjectId) : Promise.resolve(null)
|
|
)}
|
|
onOpenAssistant={() => setActiveWorkspace('assistant')}
|
|
onOpenExports={() => setActiveWorkspace('exports')}
|
|
/>
|
|
</div>
|
|
|
|
{activeWorkspace === 'analysis' ? (
|
|
<div className="workspace-grid workspace-grid-analysis">
|
|
<QualityResultsPanel
|
|
selectedProjectId={selectedProjectId}
|
|
qualityChecks={qualityChecks}
|
|
qualityChecksError={qualityChecksError}
|
|
candidateDatasets={candidateDatasets}
|
|
referenceDatasets={referenceDatasets}
|
|
onRefresh={() => loadQualityChecks()}
|
|
onOpenEvidenceMap={openQualityEvidenceOnMap}
|
|
evidenceLoading={qualityEvidenceLoading}
|
|
evidenceError={qualityEvidenceError}
|
|
onOpenMapWorkspace={() => setActiveWorkspace('map')}
|
|
onOpenAnalysisWorkspace={() => setActiveWorkspace('ai')}
|
|
/>
|
|
<details className="secondary-analysis-disclosure">
|
|
<summary>
|
|
<span>Historische vectorlagen vergelijken</span>
|
|
<strong>Geavanceerd</strong>
|
|
</summary>
|
|
<ChangeDetectionPanel
|
|
vectorDatasets={availableVectorDatasets}
|
|
sourceDatasetId={changeSourceDatasetId}
|
|
targetDatasetId={changeTargetDatasetId}
|
|
iouThreshold={changeIouThreshold}
|
|
includeUnchanged={changeIncludeUnchanged}
|
|
running={runningChangeDetection}
|
|
result={changeDetectionResult}
|
|
error={changeDetectionError}
|
|
onSourceDatasetChange={setChangeSourceDatasetId}
|
|
onTargetDatasetChange={setChangeTargetDatasetId}
|
|
onIouThresholdChange={setChangeIouThreshold}
|
|
onIncludeUnchangedChange={setChangeIncludeUnchanged}
|
|
onRun={runChangeDetection}
|
|
/>
|
|
</details>
|
|
</div>
|
|
) : null}
|
|
|
|
{activeWorkspace === 'assistant' ? (
|
|
<div className="workspace-grid workspace-grid-assistant">
|
|
<GeoAssistantPanel
|
|
selectedProjectId={selectedProjectId}
|
|
selectedAreaId={mapSelectionResult?.selection_area_id ?? (!mapSelectionBbox ? selectedArea?.id ?? null : null)}
|
|
selectedAreaName={selectedArea?.name ?? null}
|
|
selectionBbox={mapSelectionBbox}
|
|
/>
|
|
</div>
|
|
) : null}
|
|
|
|
{activeWorkspace === 'ai' ? (
|
|
<div className="workspace-grid workspace-grid-ai">
|
|
<DetectionLab
|
|
managementLocked={isGuest}
|
|
detectionModels={detectionModels}
|
|
modelAssets={modelAssets}
|
|
loadingDetectionModels={loadingDetectionModels}
|
|
detectionModelError={detectionModelError}
|
|
modelAssetError={modelAssetError}
|
|
selectedDetectionDatasetId={selectedDetectionDatasetId}
|
|
selectedDetectionModelId={selectedDetectionModelId}
|
|
selectedModelAssetId={selectedModelAssetId}
|
|
detectionTileManifestPath={detectionTileManifestPath}
|
|
detectionConfidenceThreshold={detectionConfidenceThreshold}
|
|
runningDetection={runningDetection}
|
|
detectionRunResult={detectionRunResult}
|
|
detectionRunError={detectionRunError}
|
|
detectionRuns={detectionRuns}
|
|
qualityChecks={qualityChecks}
|
|
calibrationThresholdText={calibrationThresholdText}
|
|
runningDetectionCalibration={runningDetectionCalibration}
|
|
detectionCalibrationRows={detectionCalibrationRows}
|
|
detectionCalibrationError={detectionCalibrationError}
|
|
detectionWorkflowStage={detectionWorkflowStage}
|
|
selectedDetectionRunId={selectedDetectionRunId}
|
|
detectionItems={detectionItems}
|
|
detectionTotal={detectionTotal}
|
|
detectionTruncated={detectionTruncated}
|
|
detectionClassFilter={detectionClassFilter}
|
|
detectionMinConfidenceFilter={detectionMinConfidenceFilter}
|
|
loadingDetectionResults={loadingDetectionResults}
|
|
detectionReferenceDatasetId={detectionReferenceDatasetId}
|
|
detectionQaResult={detectionQaResult}
|
|
detectionQaError={detectionQaError}
|
|
runningDetectionQa={runningDetectionQa}
|
|
yoloPreflight={yoloPreflight}
|
|
loadingYoloPreflight={loadingYoloPreflight}
|
|
yoloPreflightError={yoloPreflightError}
|
|
selectedProjectId={selectedProjectId}
|
|
rasterDatasets={detectionRasterDatasets}
|
|
referenceDatasets={referenceDatasets}
|
|
onLoadModels={loadDetectionModels}
|
|
onRefreshYoloPreflight={() => loadYoloPreflight()}
|
|
onSelectDataset={setSelectedDetectionDatasetId}
|
|
onSelectModel={setSelectedDetectionModelId}
|
|
onSelectModelAsset={setSelectedModelAssetId}
|
|
onSetConfidenceThreshold={setDetectionConfidenceThreshold}
|
|
onSetTileManifestPath={setDetectionTileManifestPath}
|
|
onRunDetection={runDetection}
|
|
onUploadRaster={uploadDetectionRaster}
|
|
onPrepareAndRunDetection={runGuidedDetection}
|
|
onOpenResultsOnMap={openDetectionResultsOnMap}
|
|
onLoadRuns={() => loadDetectionRuns()}
|
|
onSelectRun={setSelectedDetectionRunId}
|
|
onSetClassFilter={setDetectionClassFilter}
|
|
onSetMinConfidenceFilter={setDetectionMinConfidenceFilter}
|
|
onLoadResults={() => loadDetectionResults()}
|
|
onSelectReferenceDataset={setDetectionReferenceDatasetId}
|
|
onRunQa={runDetectionQa}
|
|
onSetCalibrationThresholdText={setCalibrationThresholdText}
|
|
onRunCalibration={runDetectionCalibration}
|
|
onOpenCalibrationEvidence={openQualityEvidenceOnMap}
|
|
onApplyOperatorProfile={applyDetectionOperatorProfile}
|
|
/>
|
|
|
|
<details className="secondary-analysis-disclosure segmentation-disclosure">
|
|
<summary>
|
|
<span>Segmentatie van beeldvlakken</span>
|
|
<strong>Nog niet geconfigureerd</strong>
|
|
</summary>
|
|
<SegmentationLab
|
|
segmentationModels={segmentationModels}
|
|
loadingSegmentationModels={loadingSegmentationModels}
|
|
segmentationModelError={segmentationModelError}
|
|
selectedSegmentationDatasetId={selectedSegmentationDatasetId}
|
|
selectedSegmentationModelId={selectedSegmentationModelId}
|
|
segmentationTileManifestPath={segmentationTileManifestPath}
|
|
segmentationConfidenceThreshold={segmentationConfidenceThreshold}
|
|
runningSegmentation={runningSegmentation}
|
|
segmentationRunResult={segmentationRunResult}
|
|
segmentationRunError={segmentationRunError}
|
|
segmentationRuns={segmentationRuns}
|
|
selectedSegmentationRunId={selectedSegmentationRunId}
|
|
segmentationItems={segmentationItems}
|
|
segmentationClassFilter={segmentationClassFilter}
|
|
segmentationMinConfidenceFilter={segmentationMinConfidenceFilter}
|
|
loadingSegmentationResults={loadingSegmentationResults}
|
|
segmentationReferenceDatasetId={segmentationReferenceDatasetId}
|
|
segmentationQaResult={segmentationQaResult}
|
|
segmentationQaError={segmentationQaError}
|
|
runningSegmentationQa={runningSegmentationQa}
|
|
selectedProjectId={selectedProjectId}
|
|
rasterDatasets={rasterDatasets}
|
|
referenceDatasets={referenceDatasets}
|
|
selectedSegmentationModelConfigured={Boolean(selectedSegmentationModel?.configured)}
|
|
selectedSegmentationModelLimitation={selectedSegmentationModel?.limitation_message ?? null}
|
|
onLoadModels={loadSegmentationModels}
|
|
onSelectDataset={setSelectedSegmentationDatasetId}
|
|
onSelectModel={setSelectedSegmentationModelId}
|
|
onSetTileManifestPath={setSegmentationTileManifestPath}
|
|
onSetConfidenceThreshold={setSegmentationConfidenceThreshold}
|
|
onRunSegmentation={runSegmentation}
|
|
onLoadRuns={() => loadSegmentationRuns()}
|
|
onSelectRun={setSelectedSegmentationRunId}
|
|
onSetClassFilter={setSegmentationClassFilter}
|
|
onSetMinConfidenceFilter={setSegmentationMinConfidenceFilter}
|
|
onLoadResults={() => loadSegmentationResults()}
|
|
onSelectReferenceDataset={setSegmentationReferenceDatasetId}
|
|
onRunQa={runSegmentationQa}
|
|
/>
|
|
</details>
|
|
</div>
|
|
) : null}
|
|
|
|
{activeWorkspace === 'exports' ? (
|
|
<div className="workspace-grid workspace-grid-exports">
|
|
<ExportCenter
|
|
selectedProjectId={selectedProjectId}
|
|
selectedDataset={selectedDataset}
|
|
selectedDetectionRunId={selectedDetectionRunId}
|
|
selectedSegmentationRunId={selectedSegmentationRunId}
|
|
exports={exports}
|
|
latestExport={latestExport}
|
|
exportError={exportError}
|
|
loadingExports={loadingExports}
|
|
exporting={exporting}
|
|
onRefresh={() => loadExports()}
|
|
onExportDataset={exportSelectedDatasetGeoJson}
|
|
onExportDetectionRun={exportSelectedDetectionRunGeoJson}
|
|
onExportSegmentationRun={exportSelectedSegmentationRunGeoJson}
|
|
onExportProjectMetadata={exportProjectMetadata}
|
|
onExportProjectReport={exportProjectReport}
|
|
onPreviewContent={previewExportContent}
|
|
onDownload={downloadExportArtifact}
|
|
/>
|
|
<ExportPreview content={exportPreview} />
|
|
</div>
|
|
) : null}
|
|
|
|
{activeWorkspace === 'system' ? (
|
|
<ProviderPanel
|
|
selectedProjectId={selectedProjectId}
|
|
providers={providers}
|
|
loadingCapabilities={loadingCapabilities}
|
|
capabilitiesError={capabilitiesError}
|
|
onRefresh={loadCapabilities}
|
|
onOpenSources={() => setActiveWorkspace('data')}
|
|
onOpenStatus={() => setActiveWorkspace('overview')}
|
|
onOpenMap={() => setActiveWorkspace('map')}
|
|
/>
|
|
) : null}
|
|
</main>
|
|
</WorkspaceErrorBoundary>
|
|
|
|
{inspectorOpen ? (
|
|
<aside className="workbench-inspector" id="workbench-inspector" aria-label="Details van de huidige selectie">
|
|
<WorkbenchInspector
|
|
selectedProject={selectedProject}
|
|
selectedArea={selectedArea}
|
|
selectedMapFeature={selectedMapFeature}
|
|
areas={areas}
|
|
datasetsCount={datasets.length}
|
|
qualityChecks={qualityChecks}
|
|
exports={exports}
|
|
latestExport={latestExport}
|
|
detectionRuns={detectionRuns}
|
|
selectedDetectionRunId={selectedDetectionRunId}
|
|
detectionItems={detectionItems}
|
|
segmentationRuns={segmentationRuns}
|
|
selectedSegmentationRunId={selectedSegmentationRunId}
|
|
segmentationItems={segmentationItems}
|
|
onOpenDataWorkspace={() => setActiveWorkspace('data')}
|
|
onOpenMapWorkspace={() => setActiveWorkspace('map')}
|
|
onOpenQualityWorkspace={() => setActiveWorkspace('analysis')}
|
|
onOpenExportsWorkspace={() => setActiveWorkspace('exports')}
|
|
onOpenAiWorkspace={() => setActiveWorkspace('ai')}
|
|
onClose={() => setInspectorOpen(false)}
|
|
datasetDetailProps={{
|
|
areas,
|
|
availableVectorTargets,
|
|
selectedDatasetId,
|
|
selectedDataset,
|
|
selectedDatasetSummary,
|
|
selectedRasterMetadata,
|
|
selectedRasterStats,
|
|
rasterPreview,
|
|
latestRasterTileManifestPath,
|
|
latestRasterTileManifest,
|
|
rasterUnavailableMessage,
|
|
selectedClipAreaId,
|
|
selectedIntersectTargetId,
|
|
rasterTileSize,
|
|
rasterTileOverlap,
|
|
rasterTileOutputName,
|
|
rasterReprojectCrs,
|
|
rasterReprojectResampling,
|
|
ndviNirBand,
|
|
ndviRedBand,
|
|
ndwiGreenBand,
|
|
ndwiNirBand,
|
|
ndbiSwirBand,
|
|
ndbiNirBand,
|
|
isRasterTileInputValid,
|
|
jobs,
|
|
loadingDatasetDetails,
|
|
datasetDetailError,
|
|
isVectorDatasetType,
|
|
onSetSelectedClipAreaId: setSelectedClipAreaId,
|
|
onSetSelectedIntersectTargetId: setSelectedIntersectTargetId,
|
|
onSetRasterTileSize: setRasterTileSize,
|
|
onSetRasterTileOverlap: setRasterTileOverlap,
|
|
onSetRasterTileOutputName: setRasterTileOutputName,
|
|
onSetRasterReprojectCrs: setRasterReprojectCrs,
|
|
onSetRasterReprojectResampling: setRasterReprojectResampling,
|
|
onSetNdviNirBand: setNdviNirBand,
|
|
onSetNdviRedBand: setNdviRedBand,
|
|
onSetNdwiGreenBand: setNdwiGreenBand,
|
|
onSetNdwiNirBand: setNdwiNirBand,
|
|
onSetNdbiSwirBand: setNdbiSwirBand,
|
|
onSetNdbiNirBand: setNdbiNirBand,
|
|
onRunRasterInspect: runRasterInspect,
|
|
onRunRasterPreview: runRasterPreview,
|
|
onRunRasterStats: runRasterStats,
|
|
onRunRasterReproject: runRasterReproject,
|
|
onRunRasterClip: runRasterClip,
|
|
onRunRasterTile: runRasterTile,
|
|
onUseTileManifestForDetection: useRasterTileManifestForDetection,
|
|
onUseTileManifestForSegmentation: useRasterTileManifestForSegmentation,
|
|
onRunRasterNdvi: runRasterNdvi,
|
|
onRunRasterNdwi: runRasterNdwi,
|
|
onRunRasterNdbi: runRasterNdbi,
|
|
onRunVectorClip: runVectorClip,
|
|
onRunVectorBuffer: runVectorBuffer,
|
|
onRunVectorIntersect: () => runVectorIntersect(availableVectorTargets),
|
|
onPickDerivedDataset: pickDerivedDataset,
|
|
}}
|
|
/>
|
|
</aside>
|
|
) : null}
|
|
</div>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
)
|
|
}
|
|
|
|
export default WorkbenchApp
|