import React, {useContext} from "react";
import {HelpPopup, humanFileSize, isEmpty, PageContainer, TabLinks, useTitle, WROLModeMessage} from "./Common";
import {Route, Routes} from "react-router-dom";
import {getMapImportStatus, importMapFiles} from "../api";
import {
Checkbox,
Divider,
Icon as SIcon,
Loader as SLoader,
PlaceholderLine,
TableBody,
TableCell,
TableFooter,
TableHeader,
TableHeaderCell,
TableRow
} from "semantic-ui-react";
import Message from "semantic-ui-react/dist/commonjs/collections/Message";
import {Button, Loader, Placeholder, Table} from "./Theme";
import {StatusContext} from "../contexts/contexts";
function DockerMapImportWarning() {
const {status} = useContext(StatusContext);
if (status['dockerized']) {
return
Maps are not fully supported in a Docker container!
Only one PBF can be imported and displayed in the docker container.
To import a map file, run the following docker-compose commands:
docker-compose stop map
docker-compose rm map
docker-compose run --rm -v /absolute/path/to/map.osm.pbf:/data.osm.pbf
-v openstreetmap-data:/var/lib/postgresql/12/main map import
Be sure to change /absolute/path/to/map.osm.pbf!
After you have imported a new PBF file, you need to clear the rendered tile cache:
docker volume rm openstreetmap-rendered-tiles
docker volume create openstreetmap-rendered-tiles
Start your map container:
docker-compose up -d map
You can merge multiple PBF files using osmium (the merged file can then be imported):
Download only the areas you need. Large regions like all of Asia, or the entire
planet are most likely too large and won't render quickly. I recommend only
importing files less than 1GB on a Raspberry Pi.
Only *.osm.pbf files are supported!
Place downloaded map files into map/pbf so they can be imported here.
}
function SlowImportMessage() {
const {status} = useContext(StatusContext);
if (status && status['cpu_info'] && status['cpu_info']['temperature'] >= 80) {
return
CPU temperature is too high
Any import may take much more time because the CPU is throttled.
If your import takes more time than estimated, you will need an aftermarket cooler.
}
return <>>
}
class ManageMap extends React.Component {
constructor(props) {
super(props);
this.state = {
files: null,
pending: null,
import_running: false,
selectedPaths: [],
dockerized: null,
}
}
async componentDidMount() {
await this.fetchImportStatus();
this.intervalId = setInterval(this.fetchImportStatus, 1000 * 30);
}
componentWillUnmount() {
clearInterval(this.intervalId);
}
fetchImportStatus = async () => {
try {
const importStatus = await getMapImportStatus();
this.setState({
files: importStatus['files'],
pending: importStatus['pending'],
import_running: importStatus['import_running'],
dockerized: importStatus['dockerized'],
});
} catch (e) {
console.error(e);
}
}
import = async (e) => {
e.preventDefault();
this.setState({'ready': false});
const {files, selectedPaths} = this.state;
if (isEmpty(selectedPaths)) {
// No files are selected, import all.
let paths = [];
for (let i = 0; i < files.length; i++) {
paths = paths.concat([files[i].path]);
}
await importMapFiles(paths);
} else {
await importMapFiles(selectedPaths);
}
await this.fetchImportStatus();
}
handleCheckbox = (checked, pbf) => {
let {selectedPaths} = this.state;
if (checked === true) {
selectedPaths = selectedPaths.concat([pbf.path]);
} else {
const index = selectedPaths.indexOf(pbf.path);
if (index > -1) {
selectedPaths.splice(index, 1);
}
}
this.setState({selectedPaths});
}
tableRow = (pbf, disabled) => {
let ref = React.createRef();
const {size, path, imported, time_to_import} = pbf;
let sizeCells = (<>
{humanFileSize(size)}{humanFileSize(size * 25)}{time_to_import}
>);
return this.handleCheckbox(data.checked, pbf)}
/>
{path}
{this.state.pending && this.state.pending.indexOf(path) >= 0 ?
:
imported ? 'yes' : 'no'}
{size !== null ? sizeCells : }
}
render() {
const {files, selectedPaths, import_running, pending, dockerized} = this.state;
const importingMessage = pending ?
pending.length > 1 ? 'Importing...' : `Importing ${pending[0]}`
: null;
let disabled = dockerized || isEmpty(files) || import_running;
let importButton = ;
let rows;
if (!files) {
// Fetch request is not complete.
rows = ;
} else if (isEmpty(files)) {
rows = No PBF map files were found in map/pbf;
} else {
rows = files.map(i => this.tableRow(i, disabled));
}
let spaceHelpPopup = ;
let timeHelpPopup = ;
return
{importingMessage}
PBF FileImportedSizeSpace Required {spaceHelpPopup}Time to Import {timeHelpPopup}
{rows}
{importButton}
}
}
function MapApp() {
return (
)
}
export function MapRoute() {
useTitle('Map');
const links = [
{text: 'Map', to: '/map', key: 'map', end: true},
{text: 'Manage', to: '/map/manage', key: 'manage'},
];
return