mirror of
https://github.com/lrnselfreliance/wrolpi.git
synced 2026-11-20 23:16:17 -05:00
A map is exported as a PDF: a 1:24,000 quadrangle, in layers, on a sheet, which says where it is (#1006)
* The map can choose a 1:24,000 quadrangle to export (#971) The first part of exporting a map as a PDF: a grid of 7.5-minute quadrangles is drawn over the map, and a click chooses one. The grid is arithmetic, so it needs no data. Exporting itself is not here yet; the button is disabled. Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com> * A quadrangle of the map is exported as a PDF with a layer for each map layer (#972) * A quadrangle of the map is exported as a PDF with a layer for each map layer The browser draws the quadrangle off the screen at the size of a 1:24,000 sheet, once for each layer which is on, and the API puts the images in a PDF, each in a layer of its own which a reader can show and hide. A layer in which nothing is drawn is left out. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * The exported map's canvas keeps what was drawn, and an export's memory is bounded - The drawing buffer is asked for where this MapLibre reads it (canvasContextAttributes); as an option of the map it was ignored, so the canvas could be read after it was cleared. - Each layer's pixels are compressed in the PDF as the layer is added. PyMuPDF kept them uncompressed until the PDF was written: about 90 MB a layer of a quadrangle, all at once. - The pixels of all the layers together are limited, before any image is decoded. - pymupdf is imported when a PDF is made, not when the API starts. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> --------- Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com> * An exported map says where on the Earth it is (#973) * An exported map says where on the Earth it is The PDF's page has a geospatial viewport (ISO 32000-2): the page is the map in Web Mercator, with the latitude and longitude of each corner. The corners are the edges of the picture the browser drew, read from the map which drew it. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * A map whose edge is the antimeridian can be exported The map's arithmetic puts the east edge of the last quadrangle before the antimeridian a rounding error past 180 degrees, and the export was refused. An edge within 1e-8 of a degree of 180 is at 180 (it is not wrapped to -180); a map which is really across the antimeridian is still refused. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> --------- Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com> * An exported map is on a sheet: a margin, a grid, scale bars and notes (#974) * An exported map is on a sheet: a margin, a grid, scale bars and notes The map is put on a larger page with what a topographic map has around it: a title, the latitude and longitude of its corners and of ticks between them, scale bars (kilometers, miles, feet), and notes of the projection, the grid and where the map's data is from. Over the map is a 1,000 meter UTM grid, each line named in the margin. The grid and the margin are PDF layers of their own. The PDF says where the map is, not where the page is. The picker has a box to export the map alone. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * The scale of a narrow map is written under its name, not over it A quadrangle near a pole is two inches wide, which is not room for its name and its scale on one line. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> --------- Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com> * An exported map says where a compass points (#975) * An exported map says where a compass points The sheet has a diagram of the three norths (true, grid and magnetic) beside its scale bars, and a note of how far magnetic north is from true north on the day the map was made, and how fast it moves. The declination is from the World Magnetic Model 2025 (NOAA NCEI and the British Geological Survey; public domain), whose coefficient file is shipped: nothing is downloaded. The model is good until 2030; outside its years nothing is said of a compass. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * A corner of an exported map is not also a tick The edges of the picture the browser draws are a hair outside the quadrangle's, so the quadrangle's own edges were taken for ticks inside the map, and each was written over the coordinate of its corner. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * A compass which passes due south has moved a little, not most of the way around Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> --------- Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com> * A map can be exported at 400 DPI (#976) The picker has a choice of 300 or 400 DPI. A map is drawn less sharp than was asked for, rather than refused, when it would be more pixels than the API makes a PDF of: a quadrangle near the equator, or one with many layers on. The picker says so while it draws. Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com> * An exported quadrangle goes by the name the USGS gives it (#977) * An exported quadrangle goes by the name the USGS gives it The picker says what the chosen quadrangle is called, and the sheet's title, the PDF's title and the file's name have it. Where the USGS has no name, which is most of the world, a quadrangle goes by where it is, as before. The names are an index of the 65,600 7.5 minute quadrangles of The National Map (U.S. Geological Survey; public domain), which is shipped: nothing is downloaded. In Alaska a USGS quadrangle is wider than 7.5 minutes, so a quadrangle of the picker's grid there is "Part of" the one which has its middle. The places the tests of the map export are of are changed for others. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * An area half of which is the last quadrangle of the land is a part of it The middle of such an area is on the quadrangle's east or north edge, with no quadrangle beyond it, and it was given no name. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> --------- Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com> * The PDF of a map is made by a Job, which the browser watches (#978) * The PDF of a map is made by a Job, which the browser watches A PDF of a quadrangle is a minute or two of work on a Raspberry Pi 4, and the request which waited for it was cut off after a minute: only the smallest quadrangles could be exported there. Now the browser describes the map, sends the image of each layer in a request of its own, and starts a Job; it watches the Job, shows how far along it is, and fetches the PDF when the Job is done. Cancel stops the Job. The images are kept on disk until the PDF is made of them, and an export is removed when it is an hour old. The credits on the sheet are no longer cut off: an attribution which names many sources is each of them. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * A cancelled map export stops, and is removed - A cancelled Job is not over until the thread making the PDF has stopped, so the next Job does not start beside it; the work can also be stopped while the sheet is drawn and the PDF written. - DELETE /api/map/export/<id> stops an export at any step and removes what was sent; the browser calls it when the person exporting cancels, while layers are sent as well as while the PDF is made. - An export whose Job is waiting or running is not removed for being old; one whose Job was cancelled is removed at once. - Cancel while the map is drawn stops the drawing between two layers. - Exports are kept in a directory made for this user alone, which is refused when it is a link or is another user's; only what is an export there is removed. - A request for the finished PDF which is lost is made again. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> --------- Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com> * An overlay's areas and lines go under the map's labels, and its own labels over them (#979) An overlay was drawn whole over the basemap, so an area it filled covered the names of what is in it. Labels are now always on top: the areas, lines and pictures of every overlay are under the basemap's labels, and the text, icons and points of every overlay are over them. It is so in the map, the standalone viewer, and an exported PDF, where an overlay with both is two layers ("Towers" and "Towers (labels)"). Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com> * An overlay's ground is over the ground of every basemap file (#980) * An overlay's ground is over the ground of every basemap file On a map of several basemap files, the ground of an overlay was put before the first label of the first file, which is under the land, water and roads of every file after it: an overlay's areas and lines were hidden, and in an exported PDF its layer was just above the background. It goes where the basemap's labels begin: the first of the labels which are over all of the basemap's ground. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * The labels of every basemap file are over the ground of every file A map of several basemap files was their layers one file after another, so only the labels of the last file were on top: the labels of the others were under the land, water and roads of the files after them, and under the ground of an overlay. Both viewers now draw the ground of every file and then the labels of every file. The contour lines are drawn after the basemap's labels and are not of the basemap: an overlay's ground goes under the basemap's labels, not under the contours instead. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> --------- Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com> * Contours are drawn from as deep as the terrain file goes (#981) The map read a terrain file to zoom 8, which is how deep the terrain WROLPi offers goes, however deep the file was. It now reads a file as deep as the file says it goes, in both viewers, and draws finer contour lines from a deeper file: every 40 feet (or 20 meters) from zoom 11, as a 1:24,000 sheet has. A file which goes to zoom 8 is drawn as it was. Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com> * An exported map names its small roads (#982) * An exported map names its small roads A quadrangle is drawn at about zoom 13. The basemap's style names small roads from zoom 15, and its tiles have no names for them below zoom 14, so the streets of a town were printed as lines with no names. Before the map is drawn, the tiles of zoom 14 which the quadrangle is in are read, and the roads in them which have a name are given to the export map as a source of its own. The layer which names small roads draws from that source, as its style says to. At the scale of a sheet most streets are shorter than their names, and a map writes a name along a line only where the line is longer. Such a road is named over its middle, turned as the road goes; a road in pieces is named once. A source whose tiles can not be read is exported as before. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * The names of small roads are placed by the export, at every latitude A quadrangle nearer the equator is drawn at a little over zoom 14, where the names were not read and the style still kept them for zoom 15: such a map had no names of small roads. They are now read wherever a layer would not name roads. Every name of a small road is now a point: over the middle of its road, turned as the road goes under it, again every 400 pixels of a long road. Before, a road long enough was left for the map to name along its line, which the map often does not (the line bends, or is in pieces), and a short piece beside it was named too. One place decides where a road is named, so a road in pieces is named once, and a piece of another kind of road does not take the name. Reading the names can be cancelled. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> --------- Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com> * A sheet has a bar of meters, its norths in mils, and how far apart its contour lines are (#983) Under the map are bars of kilometers, meters, miles and feet. How far the grid's north and a compass's north are from true north is written in mils as well as in degrees, in the diagram and in the notes: a compass may be marked in either. A map which is exported with its contour lines says how far apart they are (CONTOUR INTERVAL 40 FEET), under the bars. The browser knows: it is the interval of the tiles the lines are made for at the zoom of the sheet, in the unit the map measures in. It says so with the sheet, and what is not an interval is not written. Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com> * A sheet says what the quadrangles around it are called (#984) * A sheet says what the quadrangles around it are called Under the scale bars is a diagram of nine squares, the map the middle one, and beside it what the USGS calls each of the eight around it: the sheets to print to carry on off the edge of this one. The names are from the index of quadrangles which names the sheet itself. A quadrangle with no name (out to sea, or over a border) has no number; a map of where the USGS names nothing, and a map too narrow for the diagram, go without. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * A sheet is never beside itself Where a quadrangle of the USGS is wider than the map (Alaska), the area the size of the map to its east or west is often more of the quadrangle the map is in, and the diagram named the sheet as its own neighbor. The quadrangle on a side is now the next one which is not the map's own. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> --------- Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com> * A sheet has a legend of the lines of its map (#985) * A sheet has a legend of the lines of its map Under the scale bars is what each kind of line of the map is: highway, major road, minor road, path, railway, boundary, contour and index contour, each a piece of the line as the map draws it, on the color of the map's land. The map's style says how a line is drawn at each zoom, and a sheet is drawn at one. The browser, which has the style, says what each line's color, width, dashes and edges are at that zoom; the API draws them. A line is in the legend when its layer is exported and draws something at that zoom. What the browser sends is made into lines before it is kept: what is not a line is left out, and the map is exported. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * A legend has no line too thin to see, and no name longer than its room A style brings a line in from nothing as the map is zoomed in: a path is a few hundredths of a point wide on a quadrangle near the equator. It was in the legend, drawn several times wider than on the map. A line under a tenth of a point is now left out, by the browser and by the API. What a line is called is cut to the room beside its line, as the name of an adjoining quadrangle is. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> --------- Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com> * Fixes to the map PDF export: wrong neighbors, leftover exports, exports which outlive the map (#989) * A sheet names what is around it, and its edges, by where they are and not a hair from there The edges the browser gives of a map are a hair outside its quadrangle. The quadrangles around a map whose middle is on the edge two share (every other map of Alaska) were those around the map west of it, and one of them was the map itself. An edge a hair south of the equator was 0 degrees south, a map which ended where the UTM zones do had no grid, and a sheet dated in the last year there is could not be made. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * An export is removed when it is over, and its work stops when the API does The images and the PDF of an export were kept until the next export began, however long that was. The browser now has the export removed however it ends, and old exports are removed when a PDF is made too. The work of a Job which ended because the API was stopping went on to the end of the PDF, with the API waiting for it. What is said of an export, and each image, is written whole. Text which is no text is taken out when an export begins, not found by the Job. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * An export stops with its map, and waits for a page which can not be seen Leaving the map while it was exported left the export going, to fail or to hand a PDF to another page; so did closing the picker, which is now left open. A PDF which arrives after the export was stopped is not saved. The time a page is behind another tab is not counted against a map which is drawing. The name of a road is one line. A photograph which ends a little inside the map is not made a JPEG with a black strip. An accent in the name of a quadrangle is not a gap in the name of its file. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * A PDF is not kept from who made it by a server slow to remove the export Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> --------- Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com> * An exported map has its water over its parks (#990) * A sheet names what is around it, and its edges, by where they are and not a hair from there The edges the browser gives of a map are a hair outside its quadrangle. The quadrangles around a map whose middle is on the edge two share (every other map of Alaska) were those around the map west of it, and one of them was the map itself. An edge a hair south of the equator was 0 degrees south, a map which ended where the UTM zones do had no grid, and a sheet dated in the last year there is could not be made. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * An export is removed when it is over, and its work stops when the API does The images and the PDF of an export were kept until the next export began, however long that was. The browser now has the export removed however it ends, and old exports are removed when a PDF is made too. The work of a Job which ended because the API was stopping went on to the end of the PDF, with the API waiting for it. What is said of an export, and each image, is written whole. Text which is no text is taken out when an export begins, not found by the Job. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * An export stops with its map, and waits for a page which can not be seen Leaving the map while it was exported left the export going, to fail or to hand a PDF to another page; so did closing the picker, which is now left open. A PDF which arrives after the export was stopped is not saved. The time a page is behind another tab is not counted against a map which is drawing. The name of a road is one line. A photograph which ends a little inside the map is not made a JPEG with a black strip. An accent in the name of a quadrangle is not a gap in the name of its file. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * An exported map has its water over its parks A layer of the PDF was one image, drawn where the topmost of its layers is. The parks of Land Cover are under the water on the map and its piers are over it, so all of Land Cover was drawn over the water: a lake in a park, or among houses, was not on the PDF. A second basemap file put its water over the first's buildings. A layer is now as many images as it must be, each where it is on the map, in one layer of the PDF: a part which fills an area stays where it is, and a part which is only lines is drawn with the next. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * A PDF is not kept from who made it by a server slow to remove the export Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * A map file which is of somewhere else is not drawn when a map is exported Each basemap file is several images of an exported map, and most files of a library are of other places: each was an image of nothing, counted against how many images an export may be and how sharp it may be. A file whose own edges are outside the quadrangle is now left out before the layers are counted. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> --------- Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com> * An exported map has its streams (#991) A basemap draws streams from zoom 14, and service roads and taxiways from 13. A quadrangle is drawn a little short of that (zoom 13.8 at 40 degrees, 13.2 at 61), from tiles which have them: none were on the PDF. What is drawn from a zoom no deeper than a quadrangle's detail is drawn. Names are left as they are. Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com> * An export which is cancelled stops at once, in the middle of a request (#993) * An export which is cancelled stops at once, in the middle of a request An export was stopped between two requests. The image of a layer is tens of megabytes, which is a long request on a slow connection, and a request to a server which has stopped answering never ends: the export said it was stopping until then. Cancel, and leaving the map, now end the request. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * The requests an export makes after its layers are sent are seen to be stopped too Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> --------- Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com> * A map is exported as it is printed: on white, in dark lines (#996) * A map is exported as it is printed: on white, in dark lines The light and dark maps are made for a screen. On paper their roads are white on pale gray and their streams half a pixel of pale blue. The printed map is a third look, of the map's own: white ground, dark road edges and names, blue streams wide enough to see, paths drawn, brown contours. It is what a map is exported in unless Light or Dark is chosen where the quadrangle is, and the choice is remembered in the browser. While a quadrangle is chosen the map is shown in the look it will be exported in. The light and dark maps are as they were. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * Changing the look of the map does not move it What is done when a new style is in place was asked for after the style was set. A style which only differs from the one the map has is in place before that, so it was done at the next change of style instead, with where the map had been at this one: the map went back there when a quadrangle was chosen, and again when it was not. It is asked for first, and the map is not moved at all. An export no longer waits for the map to be still, which it need not and which nothing ended. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> --------- Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com> * The colors of the printed map are chosen where its layers are (#997) * The colors of the printed map are chosen where its layers are While a quadrangle is chosen and the map is shown as it is printed, each layer of the layer control has its color beside it, to be changed: one for most, three for the land (what grows, what was built, sand and ice) and two for names (the name, and what is around it). A basemap has several colors where one is chosen, which are shades of it. The edge of a road stays dark. What is chosen is remembered in the browser, and can be put back. The map on the screen is as it was. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * A ramp on a bridge is the color of a major road, as it is off one A basemap draws a ramp on a bridge in the color of a minor road on a bridge: on the printed map it was white where the rest of the ramp is yellow, and followed the color chosen for minor roads. What puts the colors back is a button, which a keyboard reaches. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> --------- Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com> * A layer with nothing in it does not make an exported map less sharp (#1001) * A layer with nothing in it does not make an exported map less sharp How sharp a map may be depends on how many images it is, and every group of layers was counted: a basemap file with no runway, highway or boundary in the quadrangle was images of nothing, drawn, sent, and counted against the rest. A map of 23 images asked for at 400 DPI was made at 330. The groups are now looked at first, on a small map, and only those with something in them are drawn, as sharp as that many may be. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * An image which arrives after its export was removed is not kept, and one mil is a mil Stopping an export while an image was on its way left the image behind it, in a directory nothing would remove for an hour. An angle of one mil was "1 mils" on the sheet. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> --------- Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com> * The map which is exported from is made as sharp as it is to be (#1002) * The map which is exported from is made as sharp as it is to be The groups of a map are looked at on a small map, which was then made larger to draw them. A browser lets a canvas be larger when it is made than it lets one be made larger afterwards: a quadrangle asked for at 400 DPI was 33 million pixels, 288 DPI at 40 degrees, less than before the groups were looked at first. The small map is now removed, and the map which is exported from is made in its place. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * A canvas the browser stopped drawing on is not a layer with nothing in it A canvas whose drawing was taken away by the browser reads as clear, and a group looked at then was left out of the PDF without a word: the export fails instead. An export stopped as the last group is looked at does not make the map it would have been drawn on. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> --------- Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com> * An exported map says where it is in a projection Adobe Acrobat knows (#1003) * An exported map says where it is in a projection Adobe Acrobat knows The page was said to be in Web Mercator, which it is drawn in. Acrobat does not know Web Mercator, in the words of the standard or in Esri's: it took the page for a map, and put every place on it at 0, 0. The page is now said to be Mercator on the WGS 84 ellipsoid, which it reads, with the same corners. Between the corners the two differ by under three centimeters on the ground. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * How well a page is said to be where it is, is measured from what the PDF says The test of it measured two formulas of its own. It now reads the corners and the projection from the PDF and does a reader's sum with them. The few centimeters are of a quadrangle: a taller page is less well said, by the square of how tall it is, which the comment now says and a test measures. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> --------- Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com> * The help says how a map is exported as a PDF (#1004) The help of the map is five pages, one of them the PDF export. Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com> --------- Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com>
This commit is contained in:
parent
d157057d81
commit
faf8e735d1
42 changed files with 8744 additions and 102 deletions
|
|
@ -1,11 +1,13 @@
|
|||
import asyncio
|
||||
from http import HTTPStatus
|
||||
|
||||
from sanic import Request, response, Blueprint
|
||||
from sanic_ext import validate
|
||||
from sanic_ext.extensions.openapi import openapi
|
||||
|
||||
from modules.map import lib, schema, search
|
||||
from modules.map import export, export_job, lib, quads, schema, search
|
||||
from modules.map.pins import get_map_pins_config
|
||||
from modules.map.sheet import legend_as_sent
|
||||
from wrolpi.api_utils import json_response
|
||||
from wrolpi.common import wrol_mode_check
|
||||
from wrolpi.events import Events
|
||||
|
|
@ -175,3 +177,144 @@ async def rebuild_single_search_index(_: Request, filename: str):
|
|||
if started:
|
||||
return json_response({'message': f'Search index rebuild started for {filename}'}, HTTPStatus.ACCEPTED)
|
||||
return json_response({'error': 'File not found'}, HTTPStatus.NOT_FOUND)
|
||||
|
||||
|
||||
@map_bp.get('/quad')
|
||||
@openapi.description('The name of the USGS quadrangle of an area of the map')
|
||||
async def get_quad(request: Request):
|
||||
"""What the USGS calls the quadrangle between `west`, `south`, `east` and `north` (degrees): `quad` is its
|
||||
`name`, its `state`, and whether it is `exact`ly that area (and not a larger quadrangle which has the middle
|
||||
of it); or null where there is no name, which is most of the world."""
|
||||
try:
|
||||
west, south, east, north = (float(request.args.get(i)) for i in ('west', 'south', 'east', 'north'))
|
||||
except (TypeError, ValueError):
|
||||
return response.json({'error': 'The edges of the area are four numbers'}, HTTPStatus.BAD_REQUEST)
|
||||
if not (-180 <= west < east <= 180 and -90 <= south < north <= 90):
|
||||
# Not so of a number which is not one, either.
|
||||
return response.json({'error': 'The edges are not those of an area of the map'}, HTTPStatus.BAD_REQUEST)
|
||||
# The index is read from its file the first time, which is not for the event loop.
|
||||
name = await asyncio.to_thread(quads.quad_name, west, south, east, north)
|
||||
return json_response({'quad': name.__json__() if name else None})
|
||||
|
||||
|
||||
# How much may be written on the sheet of an exported map.
|
||||
SHEET_TEXT_LENGTH = 300
|
||||
SHEET_CREDITS = 40
|
||||
|
||||
|
||||
def _export_text(value) -> str:
|
||||
"""What was sent as text of an exported map (its title, the name of a layer), as it can be written in a PDF:
|
||||
no longer than a line of a sheet, and with nothing in it which is not a character."""
|
||||
text = str(value or '').replace('\x00', '')
|
||||
return text.encode('utf-8', 'replace').decode('utf-8')[:SHEET_TEXT_LENGTH]
|
||||
|
||||
|
||||
def _sheet_contours(contours) -> dict:
|
||||
"""How far apart the contour lines of a map are, as the browser says it, for `export.Sheet`. A map with no
|
||||
contour lines says nothing; what is said is written on the sheet only when it is an interval (see
|
||||
`modules.map.sheet`)."""
|
||||
if not isinstance(contours, dict):
|
||||
return {}
|
||||
interval = contours.get('interval')
|
||||
if isinstance(interval, bool) or not isinstance(interval, (int, float)):
|
||||
return {}
|
||||
return dict(contour_interval=float(interval), contour_unit=str(contours.get('unit') or '')[:SHEET_TEXT_LENGTH])
|
||||
|
||||
|
||||
def _export_error(e: Exception):
|
||||
"""The response for an export which could not go on."""
|
||||
if isinstance(e, export_job.ExportNotFound):
|
||||
return response.json({'error': str(e)}, HTTPStatus.NOT_FOUND)
|
||||
if isinstance(e, export_job.ExportNotReady):
|
||||
return response.json({'error': str(e)}, HTTPStatus.CONFLICT)
|
||||
if isinstance(e, export_job.ExportStorageError):
|
||||
return response.json({'error': str(e)}, HTTPStatus.INTERNAL_SERVER_ERROR)
|
||||
return response.json({'error': str(e)}, HTTPStatus.BAD_REQUEST)
|
||||
|
||||
|
||||
EXPORT_ERRORS = (export.InvalidExport, export_job.ExportNotFound, export_job.ExportNotReady,
|
||||
export_job.ExportStorageError)
|
||||
|
||||
|
||||
@map_bp.post('/export')
|
||||
@openapi.description('Begin the export of a map as a PDF')
|
||||
async def post_export(request: Request):
|
||||
"""The browser draws the map, one image for each layer; the API puts them in a PDF, each in a layer of its own.
|
||||
That takes a minute or two on a Raspberry Pi, so it is a Job:
|
||||
|
||||
1. This request describes the map, and is answered with an `export_id`.
|
||||
2. `POST /api/map/export/<export_id>/layer/<index>` sends the image of each layer.
|
||||
3. `POST /api/map/export/<export_id>/start` is answered with a `job_id`, to watch at `/api/jobs/<job_id>`.
|
||||
4. `GET /api/map/export/<export_id>/pdf` is the PDF, once the Job is complete.
|
||||
|
||||
`DELETE /api/map/export/<export_id>` stops an export at any of those steps, and removes what was sent.
|
||||
|
||||
The JSON body: `width` and `height` in pixels, `dpi`, `title`, `layers`: the name of each image from the bottom
|
||||
up (images of one name are one layer of the PDF), `bounds`: the west, south, east and north edges of the images in degrees, with which the PDF says where it
|
||||
is, and `sheet`: with which the map is put on a sheet with a margin and a grid; `name`, `credits` and `date`
|
||||
are written on it, `contours` (`{"interval": 40, "unit": "feet"}`, or "meters") when the map has contour
|
||||
lines, and `legend`: the lines of the map as they are drawn (see `modules.map.sheet.Sheet`)."""
|
||||
try:
|
||||
meta = request.json
|
||||
width, height, dpi = int(meta['width']), int(meta['height']), float(meta['dpi'])
|
||||
names = [_export_text(i) for i in meta['layers']]
|
||||
title = _export_text(meta.get('title')) or None
|
||||
bounds = meta.get('bounds')
|
||||
sheet = meta.get('sheet')
|
||||
if sheet is not None:
|
||||
sheet = export.Sheet(
|
||||
name=_export_text(sheet.get('name')) or None,
|
||||
credits=[_export_text(i) for i in (sheet.get('credits') or [])[:SHEET_CREDITS]],
|
||||
date=_export_text(sheet.get('date')) or None,
|
||||
**_sheet_contours(sheet.get('contours')),
|
||||
legend=legend_as_sent(sheet.get('legend')),
|
||||
)
|
||||
except Exception: # noqa Whatever is made of a body which is not the description of a map.
|
||||
return response.json({'error': 'The description of the map is not valid'}, HTTPStatus.BAD_REQUEST)
|
||||
|
||||
try:
|
||||
# Old exports are removed from the disk here, which is not for the event loop.
|
||||
export_id = await asyncio.to_thread(export_job.create_export, names, width, height, dpi, title, bounds, sheet)
|
||||
except EXPORT_ERRORS as e:
|
||||
return _export_error(e)
|
||||
return json_response({'export_id': export_id}, HTTPStatus.CREATED)
|
||||
|
||||
|
||||
@map_bp.post('/export/<export_id:str>/layer/<index:int>')
|
||||
@openapi.description('Send the image (PNG or JPEG) of one layer of a map which is being exported')
|
||||
async def post_export_layer(request: Request, export_id: str, index: int):
|
||||
try:
|
||||
await asyncio.to_thread(export_job.save_layer, export_id, index, request.body)
|
||||
except EXPORT_ERRORS as e:
|
||||
return _export_error(e)
|
||||
return response.empty()
|
||||
|
||||
|
||||
@map_bp.post('/export/<export_id:str>/start')
|
||||
@openapi.description('Queue the Job which makes the PDF of a map, all of whose layers have been sent')
|
||||
async def post_export_start(_: Request, export_id: str):
|
||||
try:
|
||||
job_id = await asyncio.to_thread(export_job.start_export, export_id)
|
||||
except EXPORT_ERRORS as e:
|
||||
return _export_error(e)
|
||||
return json_response({'job_id': job_id}, HTTPStatus.ACCEPTED)
|
||||
|
||||
|
||||
@map_bp.delete('/export/<export_id:str>')
|
||||
@openapi.description('Stop the export of a map: cancel its Job, if it has one, and remove what was sent')
|
||||
async def delete_export(_: Request, export_id: str):
|
||||
try:
|
||||
await asyncio.to_thread(export_job.remove_export, export_id)
|
||||
except EXPORT_ERRORS as e:
|
||||
return _export_error(e)
|
||||
return response.empty()
|
||||
|
||||
|
||||
@map_bp.get('/export/<export_id:str>/pdf')
|
||||
@openapi.description('The PDF of an exported map, once the Job which makes it is complete')
|
||||
async def get_export_pdf(_: Request, export_id: str):
|
||||
try:
|
||||
pdf = await asyncio.to_thread(export_job.get_export_pdf, export_id)
|
||||
except EXPORT_ERRORS as e:
|
||||
return _export_error(e)
|
||||
return await response.file(pdf, mime_type='application/pdf', filename='map.pdf')
|
||||
|
|
|
|||
|
|
@ -49,3 +49,12 @@ def make_pmtiles(test_directory) -> Callable[..., Path]:
|
|||
return path
|
||||
|
||||
return _
|
||||
|
||||
|
||||
@pytest.fixture(autouse=True)
|
||||
def map_export_root(tmp_path, monkeypatch) -> Path:
|
||||
"""Exports of the map are kept in a directory of the test, not of the machine."""
|
||||
from modules.map import export_job
|
||||
root = tmp_path / 'map-export'
|
||||
monkeypatch.setattr(export_job, 'EXPORT_ROOT', root)
|
||||
return root
|
||||
|
|
|
|||
295
modules/map/export.py
Normal file
295
modules/map/export.py
Normal file
|
|
@ -0,0 +1,295 @@
|
|||
"""Build the PDF of an exported map.
|
||||
|
||||
The map is drawn by the browser, which is the only thing that draws it as the user sees it: one image for each
|
||||
layer the user has turned on, all of the same area and size. Here they become one page, each image in a PDF
|
||||
layer (an "optional content group") of its own, so a reader can show and hide them as the map can.
|
||||
|
||||
The page is also told where on the Earth it is (a "geospatial PDF", ISO 32000-2 section 12.10), so a reader which
|
||||
knows how can show coordinates, measure, and put a GPS position on the map.
|
||||
|
||||
The map can be put on a sheet (see `modules.map.sheet`): a margin around it with what a printed map has there, and
|
||||
a grid over it.
|
||||
"""
|
||||
import io
|
||||
import math
|
||||
import pathlib
|
||||
import zlib
|
||||
from dataclasses import dataclass
|
||||
from typing import Callable, List, Optional, Sequence
|
||||
|
||||
from PIL import Image
|
||||
|
||||
from modules.map.sheet import Sheet, draw_sheet, plan_sheet
|
||||
from wrolpi.common import logger
|
||||
|
||||
logger = logger.getChild(__name__)
|
||||
|
||||
__all__ = ['ExportLayer', 'InvalidExport', 'Sheet', 'build_layered_pdf', 'check_export', 'geospatial_viewport',
|
||||
'MAX_LAYERS', 'MAX_SIDE', 'MAX_PIXELS', 'MAX_TOTAL_PIXELS', 'MIN_DPI', 'MAX_DPI']
|
||||
|
||||
# What the browser may ask for. Every image is decoded, so what an export costs is its pixels, whatever the size
|
||||
# of the upload (an image of one color is a few kilobytes however large it is).
|
||||
MAX_LAYERS = 64
|
||||
MAX_SIDE = 16384
|
||||
# The pixels of one layer, which are in memory together (a few bytes each) while it is put in the PDF. A 1:24,000
|
||||
# quadrangle at 300 DPI is 23 to 47 megapixels, more the nearer it is to the equator; at 400 DPI, 40 to 83. The
|
||||
# browser draws a map less sharp than it was asked to rather than send more than this.
|
||||
MAX_PIXELS = 64_000_000
|
||||
# The pixels of every layer of a map together, which is the work an export is. A quadrangle of 40 megapixels with
|
||||
# 24 layers on is about 960 million.
|
||||
MAX_TOTAL_PIXELS = 1_000_000_000
|
||||
# How hard an image is compressed in the PDF (zlib, 1 to 9). Less is a few seconds faster and a much larger file.
|
||||
COMPRESSION_LEVEL = 6
|
||||
MIN_DPI = 36
|
||||
MAX_DPI = 1200
|
||||
IMAGE_FORMATS = ('PNG', 'JPEG')
|
||||
|
||||
POINTS_PER_INCH = 72
|
||||
|
||||
|
||||
# The map is drawn in Web Mercator, in which the area between two meridians and two parallels is a rectangle: the
|
||||
# page. Its four corners, in latitude and longitude, are all a reader needs to know of where it is.
|
||||
#
|
||||
# What a reader is told of the projection is not Web Mercator, which Adobe Acrobat does not know (it says every
|
||||
# place is at 0, 0), but Mercator on the WGS 84 ellipsoid, which every reader knows. Web Mercator is Mercator on
|
||||
# a sphere: across a page of a map the two differ by a stretch from north to south, which the corners say, and
|
||||
# what is left is under three centimeters on the ground across a quadrangle, at any latitude. It grows with the
|
||||
# square of how tall the page is (a third of a meter for half a degree, more than a meter for a degree), so a
|
||||
# map much taller than a quadrangle wants more than its corners said. (To say only that the page is in
|
||||
# latitude and longitude would be read too, and be up to 7 meters out at 61 degrees on a quadrangle: a degree
|
||||
# of latitude is not as tall at the top of a Mercator page as at the bottom.)
|
||||
#
|
||||
# The words are Esri's, as GDAL writes them in a PDF: Acrobat reads those.
|
||||
PAGE_PROJECTION_EPSG = 3395
|
||||
PAGE_PROJECTION_WKT = (
|
||||
'PROJCS["WGS_1984_World_Mercator",'
|
||||
'GEOGCS["GCS_WGS_1984",DATUM["D_WGS_1984",SPHEROID["WGS_1984",6378137.0,298.257223563]],'
|
||||
'PRIMEM["Greenwich",0.0],UNIT["Degree",0.0174532925199433]],'
|
||||
'PROJECTION["Mercator"],'
|
||||
'PARAMETER["False_Easting",0.0],PARAMETER["False_Northing",0.0],'
|
||||
'PARAMETER["Central_Meridian",0.0],PARAMETER["Standard_Parallel_1",0.0],'
|
||||
'UNIT["Meter",1.0]]'
|
||||
)
|
||||
# Web Mercator has no poles: this is as far north or south as it goes.
|
||||
MAX_LATITUDE = 85.06
|
||||
# The browser's arithmetic can put the edge of the world a hair past where it is (180.00000000000125 degrees). An
|
||||
# edge within this of 180 degrees is at 180 degrees; one further past it is of a map which crosses the antimeridian.
|
||||
LONGITUDE_SLIVER = 1e-8
|
||||
|
||||
|
||||
class InvalidExport(ValueError):
|
||||
"""The layers sent can not be made into a map."""
|
||||
|
||||
|
||||
@dataclass
|
||||
class ExportLayer:
|
||||
# What the layer is called in the reader's list of layers.
|
||||
name: str
|
||||
# A PNG or JPEG image, or the file it is in. The images of a map are a hundred megabytes together, so those
|
||||
# in files are read one at a time, when each is needed.
|
||||
image: Optional[bytes] = None
|
||||
path: Optional[pathlib.Path] = None
|
||||
|
||||
def read(self) -> bytes:
|
||||
return self.image if self.image is not None else pathlib.Path(self.path).read_bytes()
|
||||
|
||||
|
||||
def _is_blank(image: Image.Image) -> bool:
|
||||
"""True when nothing was drawn: every pixel of the image is transparent."""
|
||||
if image.mode in ('RGBA', 'LA'):
|
||||
return image.getchannel('A').getextrema()[1] == 0
|
||||
if image.mode == 'P' and 'transparency' in image.info:
|
||||
return image.convert('RGBA').getchannel('A').getextrema()[1] == 0
|
||||
return False
|
||||
|
||||
|
||||
def _check_layer(layer: ExportLayer, width: int, height: int) -> bool:
|
||||
"""Raises InvalidExport when the layer is not an image of the map. Returns whether there is anything in it."""
|
||||
try:
|
||||
image = Image.open(io.BytesIO(layer.read()))
|
||||
if image.format not in IMAGE_FORMATS:
|
||||
raise InvalidExport(f'The layer {layer.name!r} is not a PNG or JPEG image')
|
||||
if image.size != (width, height):
|
||||
raise InvalidExport(f'The layer {layer.name!r} is {image.size[0]}x{image.size[1]},'
|
||||
f' but the map is {width}x{height}')
|
||||
return not _is_blank(image)
|
||||
except InvalidExport:
|
||||
raise
|
||||
except Exception as e:
|
||||
# Whatever Pillow makes of something which is not an image.
|
||||
raise InvalidExport(f'The layer {layer.name!r} is not a readable image') from e
|
||||
|
||||
|
||||
def _edge_longitude(longitude: float) -> float:
|
||||
"""A longitude which is a rounding error past the edge of the world, put on it. It is not wrapped: the east
|
||||
edge of the last map before the antimeridian is at 180 degrees, not at -180."""
|
||||
if 180 < abs(longitude) < 180 + LONGITUDE_SLIVER:
|
||||
return math.copysign(180.0, longitude)
|
||||
return longitude
|
||||
|
||||
|
||||
def _check_bounds(bounds: Sequence[float]) -> List[float]:
|
||||
"""The west, south, east and north edges of a map, in degrees. Raises InvalidExport when they are not."""
|
||||
try:
|
||||
west, south, east, north = (float(i) for i in bounds)
|
||||
except (TypeError, ValueError) as e:
|
||||
raise InvalidExport('The edges of the map are not four numbers') from e
|
||||
west, east = _edge_longitude(west), _edge_longitude(east)
|
||||
edges = [west, south, east, north]
|
||||
if not all(math.isfinite(i) for i in edges) or not (-180 <= west < east <= 180) \
|
||||
or not (-MAX_LATITUDE <= south < north <= MAX_LATITUDE):
|
||||
raise InvalidExport(f'A map with the edges {edges} can not be exported')
|
||||
return edges
|
||||
|
||||
|
||||
def _pdf_string(text: str) -> str:
|
||||
"""A string as it is written in a PDF: as it is when it is ASCII, else in UTF-16."""
|
||||
if text.isascii():
|
||||
return '(' + text.replace('\\', '\\\\').replace('(', '\\(').replace(')', '\\)') + ')'
|
||||
return '<' + (b'\xfe\xff' + text.encode('utf-16-be')).hex().upper() + '>'
|
||||
|
||||
|
||||
def geospatial_viewport(width: float, height: float, bounds: Sequence[float], name: str = None,
|
||||
origin: Sequence[float] = (0, 0)) -> str:
|
||||
"""The value of a page's `/VP`: a viewport which covers the map (`width` by `height` points, its lower left
|
||||
corner at `origin`: so far right of, and up from, the page's), and says it is the map between `bounds` (west,
|
||||
south, east, north; degrees of WGS 84), in the projection a reader is told of (see PAGE_PROJECTION_WKT).
|
||||
|
||||
A point of the map is given as a part of the way across and up it (0 to 1, from the lower left), and the
|
||||
corners are listed as GDAL and the readers which follow it expect: upper left, lower left, lower right,
|
||||
upper right. The coordinates of each are its latitude, then its longitude.
|
||||
"""
|
||||
west, south, east, north = _check_bounds(bounds)
|
||||
corners = '0 1 0 0 1 0 1 1'
|
||||
points = ' '.join(f'{lat:.9f} {lon:.9f}' for lat, lon in ((north, west), (south, west), (south, east),
|
||||
(north, east)))
|
||||
name = f' /Name {_pdf_string(name)}' if name else ''
|
||||
return (
|
||||
f'[<< /Type /Viewport{name}'
|
||||
f' /BBox [{origin[0]:.3f} {origin[1]:.3f} {origin[0] + width:.3f} {origin[1] + height:.3f}]'
|
||||
f' /Measure << /Type /Measure /Subtype /GEO'
|
||||
f' /Bounds [{corners}] /GPTS [{points}] /LPTS [{corners}]'
|
||||
f' /GCS << /Type /PROJCS /EPSG {PAGE_PROJECTION_EPSG} /WKT {_pdf_string(PAGE_PROJECTION_WKT)} >>'
|
||||
f' /PDU [/M /SQM /DEG] >> >>]'
|
||||
)
|
||||
|
||||
|
||||
def _compress_stream(doc, xref: int):
|
||||
"""Compress the stream of an object of the PDF, when it is not already."""
|
||||
if doc.xref_get_key(xref, 'Filter')[0] != 'null':
|
||||
return
|
||||
doc.update_stream(xref, zlib.compress(doc.xref_stream_raw(xref), COMPRESSION_LEVEL), compress=False)
|
||||
doc.xref_set_key(xref, 'Filter', '/FlateDecode')
|
||||
|
||||
|
||||
def _insert_layer(doc, page, rect, layer: ExportLayer, groups: dict):
|
||||
"""Put the image of a layer in a rectangle of the page, in the PDF layer of its name: its own, unless an
|
||||
image before it had the name. (`groups` is the PDF layer of each name so far.) A layer of the map may be
|
||||
several images, with other layers drawn between them.
|
||||
|
||||
PyMuPDF keeps the pixels of an image uncompressed until the PDF is written: about 90 MB for each layer of a
|
||||
quadrangle, all of them at once. They are compressed here instead, so only one layer's are ever in memory."""
|
||||
if layer.name not in groups:
|
||||
groups[layer.name] = doc.add_ocg(layer.name, on=True)
|
||||
xref = page.insert_image(rect, stream=layer.read(), oc=groups[layer.name])
|
||||
_compress_stream(doc, xref)
|
||||
# The transparency of a PNG is an image of its own.
|
||||
kind, mask = doc.xref_get_key(xref, 'SMask')
|
||||
if kind == 'xref':
|
||||
_compress_stream(doc, int(mask.split()[0]))
|
||||
|
||||
|
||||
def check_export(layer_count: int, width: int, height: int, dpi: float, bounds: Optional[Sequence[float]] = None,
|
||||
sheet: Optional[Sheet] = None) -> Optional[List[float]]:
|
||||
"""Raises InvalidExport when a map of `layer_count` images of `width` by `height` pixels can not be made into a
|
||||
PDF. No image is read: this is what can be said of a map before its images are sent. Returns the `bounds`
|
||||
as they are used."""
|
||||
if layer_count < 1:
|
||||
raise InvalidExport('There are no layers to export')
|
||||
if layer_count > MAX_LAYERS:
|
||||
raise InvalidExport(f'A map of more than {MAX_LAYERS} layers can not be exported')
|
||||
if not (0 < width <= MAX_SIDE and 0 < height <= MAX_SIDE) or width * height > MAX_PIXELS:
|
||||
raise InvalidExport(f'A map of {width}x{height} pixels can not be exported')
|
||||
if layer_count * width * height > MAX_TOTAL_PIXELS:
|
||||
raise InvalidExport(f'A map of {layer_count} layers of {width}x{height} pixels is too large to export;'
|
||||
f' turn some layers off')
|
||||
if not MIN_DPI <= dpi <= MAX_DPI:
|
||||
raise InvalidExport(f'A map can not be exported at {dpi} DPI')
|
||||
if bounds is not None:
|
||||
return _check_bounds(bounds)
|
||||
if sheet is not None:
|
||||
raise InvalidExport('The edges of the map are needed to put it on a sheet')
|
||||
return None
|
||||
|
||||
|
||||
def build_layered_pdf(layers: List[ExportLayer], width: int, height: int, dpi: float, title: str = None,
|
||||
bounds: Optional[Sequence[float]] = None, sheet: Optional[Sheet] = None,
|
||||
progress: Optional[Callable[[int, int], None]] = None) -> bytes:
|
||||
"""A one page PDF of the layers, the first at the bottom, each in a PDF layer of its own.
|
||||
|
||||
A layer in which nothing was drawn is left out.
|
||||
|
||||
@param layers: The images of the map, all `width` by `height` pixels.
|
||||
@param dpi: How many of those pixels are an inch of the page.
|
||||
@param bounds: The west, south, east and north edges of the images, in degrees. With them the PDF says where
|
||||
it is on the Earth; the images must be Web Mercator, and all of the map between those edges.
|
||||
@param sheet: With this the map is on a sheet, which says this of it. The sheet needs `bounds`.
|
||||
@param progress: Called with how many steps are done, and how many there are, before each step. A PDF takes
|
||||
a minute or two on a Raspberry Pi, which is long to wait with nothing said; and it may raise to stop the
|
||||
work.
|
||||
@raise InvalidExport: When the layers are not of one map.
|
||||
"""
|
||||
# Before any image is decoded.
|
||||
bounds = check_export(len(layers), width, height, dpi, bounds, sheet)
|
||||
|
||||
# Each layer is looked at, and then each which has anything in it is put in the PDF: two steps a layer.
|
||||
steps = 2 * len(layers)
|
||||
|
||||
def step(done: int):
|
||||
if progress:
|
||||
progress(done, steps)
|
||||
|
||||
drawn = []
|
||||
for index, layer in enumerate(layers):
|
||||
step(index)
|
||||
if _check_layer(layer, width, height):
|
||||
drawn.append(layer)
|
||||
if not drawn:
|
||||
raise InvalidExport('Nothing is drawn in any layer of the map')
|
||||
|
||||
# Not imported at module level: pymupdf also imports onnxruntime (~2s on a Pi 4), which the API must not pay
|
||||
# for at startup.
|
||||
import pymupdf
|
||||
|
||||
doc = pymupdf.open()
|
||||
try:
|
||||
map_width, map_height = width * POINTS_PER_INCH / dpi, height * POINTS_PER_INCH / dpi
|
||||
if sheet is not None:
|
||||
plan = plan_sheet(map_width, map_height, bounds, sheet)
|
||||
page = doc.new_page(width=plan.width, height=plan.height)
|
||||
rect = pymupdf.Rect(plan.map_rect)
|
||||
else:
|
||||
plan = None
|
||||
page = doc.new_page(width=map_width, height=map_height)
|
||||
rect = page.rect
|
||||
groups = {}
|
||||
for index, layer in enumerate(drawn):
|
||||
# A layer which was left out is a step done.
|
||||
step(len(layers) + (len(layers) - len(drawn)) + index)
|
||||
_insert_layer(doc, page, rect, layer, groups)
|
||||
step(steps)
|
||||
if plan is not None:
|
||||
draw_sheet(doc, page, plan)
|
||||
# Every step is done; what is told may still stop the work, here and before the PDF is written.
|
||||
step(steps)
|
||||
if bounds is not None:
|
||||
# A PDF measures up from the bottom of the page.
|
||||
origin = (rect.x0, page.rect.height - rect.y1)
|
||||
doc.xref_set_key(page.xref, 'VP', geospatial_viewport(rect.width, rect.height, bounds, title, origin))
|
||||
doc.set_metadata(dict(title=title or 'Map', creator='WROLPi', producer='WROLPi'))
|
||||
step(steps)
|
||||
pdf = doc.tobytes(garbage=3)
|
||||
step(steps)
|
||||
return pdf
|
||||
finally:
|
||||
doc.close()
|
||||
321
modules/map/export_job.py
Normal file
321
modules/map/export_job.py
Normal file
|
|
@ -0,0 +1,321 @@
|
|||
"""Making the PDF of an exported map as a Job.
|
||||
|
||||
A PDF of a map is a minute or two of work on a Raspberry Pi: too long for a request to wait on. So the browser
|
||||
describes the map and is given the id of an export; it sends the image of each layer, one a request (together they
|
||||
are a hundred megabytes, more than one request may be); then it asks for the PDF to be made, and is given the id of
|
||||
a Job (see `wrolpi.jobs`). It watches the Job, and when the Job is done it fetches the PDF.
|
||||
|
||||
An export is a directory, which holds what was said of the map, the images until the PDF is made of them, and then
|
||||
the PDF. It is on a disk, not in memory. It is removed when the person exporting stops it, when its Job is
|
||||
cancelled, or when it is old; never while its Job is waiting or running.
|
||||
"""
|
||||
import asyncio
|
||||
import json
|
||||
import os
|
||||
import pathlib
|
||||
import re
|
||||
import shutil
|
||||
import stat
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
from typing import List, Optional
|
||||
|
||||
from modules.map import export
|
||||
from wrolpi.common import logger
|
||||
from wrolpi.errors import UnknownJob
|
||||
from wrolpi.jobs import (CANCELLED, COMPLETE, PENDING, RUNNING, cancel_job, get_current_job, get_job,
|
||||
register_job)
|
||||
|
||||
logger = logger.getChild(__name__)
|
||||
|
||||
__all__ = ['ExportNotFound', 'ExportNotReady', 'ExportStorageError', 'create_export', 'save_layer', 'start_export',
|
||||
'get_export_pdf', 'remove_export', 'remove_old_exports', 'map_export_pdf_job', 'EXPORT_ROOT', 'EXPORT_KEEP_SECONDS', 'MAX_LAYER_BYTES']
|
||||
|
||||
# Where exports are kept. Not /tmp, which is memory on a Raspberry Pi. /var/tmp is a directory anyone on the
|
||||
# machine may make things in, so this one is only used when it is a real directory of this user's (see `_root`).
|
||||
EXPORT_ROOT = pathlib.Path('/var/tmp/wrolpi-map-export')
|
||||
# An export which is this old is removed: its PDF was fetched long ago, or never will be.
|
||||
EXPORT_KEEP_SECONDS = 60 * 60
|
||||
# The most one image of a layer may be. A layer of a quadrangle at 400 DPI is 20 to 30 MB as a PNG.
|
||||
MAX_LAYER_BYTES = 64 * 1024 * 1024
|
||||
JOB_NAME = 'map_export_pdf'
|
||||
META_FILE = 'meta.json'
|
||||
PDF_FILE = 'map.pdf'
|
||||
EXPORT_ID = re.compile(r'^[0-9a-f]{32}$')
|
||||
PNG_MAGIC, JPEG_MAGIC = b'\x89PNG\r\n\x1a\n', b'\xff\xd8\xff'
|
||||
|
||||
|
||||
class ExportNotFound(Exception):
|
||||
"""There is no such export: it was never made, or it was old and has been removed."""
|
||||
|
||||
|
||||
class ExportNotReady(Exception):
|
||||
"""The export is not as far along as it was asked to be."""
|
||||
|
||||
|
||||
class ExportStorageError(Exception):
|
||||
"""Where exports are kept can not be used."""
|
||||
|
||||
|
||||
class ExportCancelled(Exception):
|
||||
"""The Job which was making the PDF was cancelled."""
|
||||
|
||||
|
||||
def _is_own_directory(path: pathlib.Path) -> bool:
|
||||
"""Whether a path is a directory itself (not a link to one) which this user owns."""
|
||||
try:
|
||||
status = os.lstat(path)
|
||||
except OSError:
|
||||
return False
|
||||
return stat.S_ISDIR(status.st_mode) and status.st_uid == os.getuid()
|
||||
|
||||
|
||||
def _root(create: bool = False) -> Optional[pathlib.Path]:
|
||||
"""Where exports are kept, or None when there is no such directory (and it is not to be made).
|
||||
|
||||
It is made for this user alone: the images of a map are whatever the user has on their map.
|
||||
|
||||
@raise ExportStorageError: When what is there is not a directory of this user's: a link there, which another
|
||||
user of the machine may have made, would have exports written (and old ones removed) wherever it leads."""
|
||||
if create:
|
||||
try:
|
||||
os.mkdir(EXPORT_ROOT, 0o700)
|
||||
except FileExistsError:
|
||||
pass
|
||||
except OSError as e:
|
||||
raise ExportStorageError(f'The directory of map exports can not be made: {EXPORT_ROOT}') from e
|
||||
if not os.path.lexists(EXPORT_ROOT):
|
||||
return None
|
||||
if not _is_own_directory(EXPORT_ROOT):
|
||||
raise ExportStorageError(f'The directory of map exports is not a directory of this user: {EXPORT_ROOT}')
|
||||
if create and stat.S_IMODE(os.lstat(EXPORT_ROOT).st_mode) != 0o700:
|
||||
# One which was made before it was made for this user alone.
|
||||
os.chmod(EXPORT_ROOT, 0o700)
|
||||
return EXPORT_ROOT
|
||||
|
||||
|
||||
def _directory(export_id: str) -> pathlib.Path:
|
||||
"""Where an export is. The id is what `create_export` gave, and nothing else: it becomes part of a path."""
|
||||
if not EXPORT_ID.match(str(export_id)):
|
||||
raise ExportNotFound(f'There is no export {export_id!r}')
|
||||
root = _root()
|
||||
directory = root / export_id if root else None
|
||||
if directory is None or not _is_own_directory(directory) or not (directory / META_FILE).is_file():
|
||||
raise ExportNotFound(f'There is no export {export_id!r}')
|
||||
return directory
|
||||
|
||||
|
||||
def _read_meta(directory: pathlib.Path) -> dict:
|
||||
return json.loads((directory / META_FILE).read_text())
|
||||
|
||||
|
||||
def _write_whole(path: pathlib.Path, contents: bytes):
|
||||
"""Write a file so that whoever reads it reads all of it, or what was there before: never a part."""
|
||||
partial = path.with_name(f'{path.name}.{uuid.uuid4().hex}.part')
|
||||
try:
|
||||
partial.write_bytes(contents)
|
||||
os.replace(partial, path)
|
||||
finally:
|
||||
partial.unlink(missing_ok=True)
|
||||
|
||||
|
||||
def _write_meta(directory: pathlib.Path, meta: dict):
|
||||
_write_whole(directory / META_FILE, json.dumps(meta).encode())
|
||||
|
||||
|
||||
def _layer_file(directory: pathlib.Path, index: int) -> pathlib.Path:
|
||||
return directory / f'layer-{index:03d}'
|
||||
|
||||
|
||||
def _job_status(meta: dict) -> Optional[str]:
|
||||
"""The status of the Job of an export, or None when it has none: it was not started, or the API has
|
||||
restarted since and has forgotten the Job."""
|
||||
if not meta.get('job_id'):
|
||||
return None
|
||||
try:
|
||||
return get_job(meta['job_id'])['status']
|
||||
except UnknownJob:
|
||||
return None
|
||||
|
||||
|
||||
def remove_old_exports(now: float = None):
|
||||
"""Remove the exports which are done with. An export is a hundred megabytes until its PDF is made, and tens
|
||||
after.
|
||||
|
||||
An export whose Job is waiting or running is kept however old it is: its images are what the Job is to work
|
||||
from, and it may wait behind another Job for longer than an export is kept. One whose Job was cancelled is
|
||||
removed at once. Any other is removed when it is old. Only what is an export is touched."""
|
||||
now = time.time() if now is None else now
|
||||
root = _root()
|
||||
if root is None:
|
||||
return
|
||||
for directory in root.iterdir():
|
||||
try:
|
||||
if not EXPORT_ID.match(directory.name) or not _is_own_directory(directory):
|
||||
continue
|
||||
try:
|
||||
status = _job_status(_read_meta(directory))
|
||||
except (OSError, ValueError):
|
||||
# No description which can be read: not an export any Job can use.
|
||||
status = None
|
||||
if status in (PENDING, RUNNING):
|
||||
continue
|
||||
if status == CANCELLED or now - directory.stat().st_mtime > EXPORT_KEEP_SECONDS:
|
||||
shutil.rmtree(directory, ignore_errors=True)
|
||||
except OSError as e:
|
||||
logger.warning(f'Could not remove the old map export {directory}', exc_info=e)
|
||||
|
||||
|
||||
def remove_export(export_id: str):
|
||||
"""Stop an export, and remove it: the person exporting does not want it.
|
||||
|
||||
Its Job is cancelled when it is waiting or running. A running Job stops between two layers and removes the
|
||||
images itself; until then they are in use, so what is left of the export is removed later, with the old ones."""
|
||||
directory = _directory(export_id)
|
||||
meta = _read_meta(directory)
|
||||
status = _job_status(meta)
|
||||
if status in (PENDING, RUNNING):
|
||||
cancel_job(meta['job_id'])
|
||||
if status != RUNNING:
|
||||
shutil.rmtree(directory, ignore_errors=True)
|
||||
|
||||
|
||||
def create_export(layers: List[str], width: int, height: int, dpi: float, title: Optional[str] = None,
|
||||
bounds=None, sheet: Optional[export.Sheet] = None) -> str:
|
||||
"""Begin an export of a map of these layers (their names, from the bottom up). Returns its id.
|
||||
|
||||
@raise InvalidExport: When such a map can not be exported; no image has been sent yet."""
|
||||
bounds = export.check_export(len(layers), width, height, dpi, bounds, sheet)
|
||||
root = _root(create=True)
|
||||
remove_old_exports()
|
||||
export_id = uuid.uuid4().hex
|
||||
directory = root / export_id
|
||||
os.mkdir(directory, 0o700)
|
||||
_write_meta(directory, dict(
|
||||
layers=[str(i) for i in layers], width=width, height=height, dpi=dpi, title=title, bounds=bounds,
|
||||
sheet=dict(name=sheet.name, credits=list(sheet.credits), date=sheet.date,
|
||||
contour_interval=sheet.contour_interval, contour_unit=sheet.contour_unit,
|
||||
legend=sheet.legend) if sheet else None,
|
||||
job_id=None,
|
||||
))
|
||||
return export_id
|
||||
|
||||
|
||||
def save_layer(export_id: str, index: int, image: bytes):
|
||||
"""Keep the image of one layer of an export.
|
||||
|
||||
@raise InvalidExport: When it is not an image of a layer of that export."""
|
||||
directory = _directory(export_id)
|
||||
meta = _read_meta(directory)
|
||||
if meta['job_id']:
|
||||
raise export.InvalidExport('The PDF of this map is already being made')
|
||||
if not 0 <= index < len(meta['layers']):
|
||||
raise export.InvalidExport(f'The map has {len(meta["layers"])} layers; there is no layer {index}')
|
||||
if not image or len(image) > MAX_LAYER_BYTES:
|
||||
raise export.InvalidExport(f'The image of the layer {meta["layers"][index]!r} is empty, or is too large')
|
||||
if not image.startswith((PNG_MAGIC, JPEG_MAGIC)):
|
||||
raise export.InvalidExport(f'The layer {meta["layers"][index]!r} is not a PNG or JPEG image')
|
||||
_write_whole(_layer_file(directory, index), image)
|
||||
if not (directory / META_FILE).is_file():
|
||||
# The export was removed while this image was on its way: the image is not left behind it.
|
||||
shutil.rmtree(directory, ignore_errors=True)
|
||||
raise ExportNotFound(f'There is no export {export_id!r}')
|
||||
|
||||
|
||||
def start_export(export_id: str) -> str:
|
||||
"""Queue the Job which makes the PDF of an export, all of whose images have been sent. Returns the Job's id;
|
||||
asked again, the same Job's."""
|
||||
directory = _directory(export_id)
|
||||
meta = _read_meta(directory)
|
||||
if meta['job_id']:
|
||||
return meta['job_id']
|
||||
missing = [name for index, name in enumerate(meta['layers']) if not _layer_file(directory, index).is_file()]
|
||||
if missing:
|
||||
raise ExportNotReady(f'The images of {len(missing)} layers have not been sent: {", ".join(missing[:5])}')
|
||||
job_id = map_export_pdf_job.enqueue(description=f'Map PDF: {meta["title"] or "a map"}', export_id=export_id)
|
||||
meta['job_id'] = job_id
|
||||
_write_meta(directory, meta)
|
||||
return job_id
|
||||
|
||||
|
||||
def get_export_pdf(export_id: str) -> pathlib.Path:
|
||||
"""The PDF of an export.
|
||||
|
||||
@raise ExportNotReady: When it has not been made (yet, or because the Job failed or was cancelled)."""
|
||||
directory = _directory(export_id)
|
||||
pdf = directory / PDF_FILE
|
||||
if not pdf.is_file():
|
||||
job_id = _read_meta(directory).get('job_id')
|
||||
status = get_job(job_id)['status'] if job_id else 'not started'
|
||||
raise ExportNotReady(f'The PDF has not been made (the job is {status})' if status != COMPLETE
|
||||
else 'The PDF is gone')
|
||||
return pdf
|
||||
|
||||
|
||||
def _make_pdf(directory: pathlib.Path, job, stop: threading.Event) -> dict:
|
||||
"""Make the PDF of an export from its images, which are removed whether or not it could be made.
|
||||
|
||||
The work stops between two layers when the Job is cancelled, and when `stop` is set: the Job was ended by
|
||||
something other than its being cancelled (the API is stopping), which the Job itself does not say."""
|
||||
meta = _read_meta(directory)
|
||||
layers = [export.ExportLayer(name=name, path=_layer_file(directory, index))
|
||||
for index, name in enumerate(meta['layers'])]
|
||||
sheet = export.Sheet(**meta['sheet']) if meta['sheet'] else None
|
||||
|
||||
def stopped() -> bool:
|
||||
return stop.is_set() or job.cancel_requested()
|
||||
|
||||
def progress(done: int, steps: int):
|
||||
# Between two layers is where the work can be stopped.
|
||||
if stopped():
|
||||
raise ExportCancelled()
|
||||
job.set_progress(100 * done / steps)
|
||||
|
||||
try:
|
||||
pdf = export.build_layered_pdf(layers, meta['width'], meta['height'], meta['dpi'], meta['title'],
|
||||
meta['bounds'], sheet, progress=progress)
|
||||
# Under another name until all of it is written: a PDF which is there is a whole one.
|
||||
partial = directory / f'{PDF_FILE}.part'
|
||||
partial.write_bytes(pdf)
|
||||
if stopped():
|
||||
partial.unlink(missing_ok=True)
|
||||
raise ExportCancelled()
|
||||
partial.rename(directory / PDF_FILE)
|
||||
return dict(export_id=directory.name, size=len(pdf))
|
||||
finally:
|
||||
for layer in layers:
|
||||
layer.path.unlink(missing_ok=True)
|
||||
|
||||
|
||||
@register_job(JOB_NAME)
|
||||
async def map_export_pdf_job(export_id: str):
|
||||
"""Make the PDF of an export. The work is in a thread: this process has other things to keep doing.
|
||||
|
||||
A Job which is cancelled is not over until that thread has stopped: Jobs are run one at a time so that two of
|
||||
them do not work a Raspberry Pi at once, and the next is not to start beside the work of this one."""
|
||||
directory = _directory(export_id)
|
||||
job = get_current_job()
|
||||
job.log(f'Making the PDF of the map export {export_id}')
|
||||
# Old exports are removed here too: an export may be the last for a long while.
|
||||
await asyncio.to_thread(remove_old_exports)
|
||||
stop = threading.Event()
|
||||
work = asyncio.ensure_future(asyncio.to_thread(_make_pdf, directory, job, stop))
|
||||
try:
|
||||
# Shielded: cancelling this Job must not let go of the thread, which can not be stopped from here.
|
||||
result = await asyncio.shield(work)
|
||||
except asyncio.CancelledError:
|
||||
# The thread is told to stop, which it does between two layers. Wait for it to: an API which is stopping
|
||||
# waits for its threads, and is not to wait for all of a PDF.
|
||||
stop.set()
|
||||
await asyncio.wait({work})
|
||||
if not work.cancelled():
|
||||
work.exception()
|
||||
raise
|
||||
except ExportCancelled:
|
||||
# The work saw that the Job was cancelled before the Job's runner did. The runner is who ends a cancelled
|
||||
# Job (it looks every second), so wait for it to.
|
||||
await asyncio.Event().wait()
|
||||
raise
|
||||
job.log(f'The PDF is {result["size"]} bytes')
|
||||
return result
|
||||
121
modules/map/magnetic.py
Normal file
121
modules/map/magnetic.py
Normal file
|
|
@ -0,0 +1,121 @@
|
|||
"""Where a compass points: the World Magnetic Model.
|
||||
|
||||
A compass does not point at the north a map is drawn to, and how far off it is depends on where it is and when.
|
||||
The model is the Earth's magnetic field as a sum of spherical harmonics, each of which changes at a steady rate
|
||||
for the five years the model is good for.
|
||||
|
||||
`wmm/WMM2025.COF` is the coefficient file of the World Magnetic Model 2025, as it is published by the NOAA
|
||||
National Centers for Environmental Information and the British Geological Survey
|
||||
(https://www.ncei.noaa.gov/products/world-magnetic-model). It is a work of the U.S. Government, in the public
|
||||
domain. It is good from 2025.0 until 2030.0, when its successor is published: put that file beside it, and name
|
||||
it in MODEL_PATH.
|
||||
"""
|
||||
import math
|
||||
import pathlib
|
||||
from dataclasses import dataclass
|
||||
from functools import lru_cache
|
||||
from typing import List, Optional, Tuple
|
||||
|
||||
__all__ = ['MagneticModel', 'load_model', 'declination', 'MODEL_PATH']
|
||||
|
||||
MODEL_PATH = pathlib.Path(__file__).parent / 'wmm' / 'WMM2025.COF'
|
||||
# How many years a model is good for, from its epoch.
|
||||
MODEL_YEARS = 5
|
||||
|
||||
# The WGS 84 ellipsoid (kilometers), and the radius of the sphere the model is of.
|
||||
WGS84_A = 6378.137
|
||||
WGS84_F = 1 / 298.257223563
|
||||
WGS84_E2 = WGS84_F * (2 - WGS84_F)
|
||||
MODEL_RADIUS = 6371.2
|
||||
|
||||
|
||||
@dataclass
|
||||
class MagneticModel:
|
||||
# The decimal year the coefficients are of.
|
||||
epoch: float
|
||||
name: str
|
||||
# (n, m, g, h, the change of g in a year, the change of h in a year): nanoteslas.
|
||||
coefficients: List[Tuple[int, int, float, float, float, float]]
|
||||
|
||||
@property
|
||||
def degree(self) -> int:
|
||||
return max(i[0] for i in self.coefficients)
|
||||
|
||||
def covers(self, year: float) -> bool:
|
||||
return self.epoch <= year < self.epoch + MODEL_YEARS
|
||||
|
||||
def field(self, latitude: float, longitude: float, year: float,
|
||||
altitude: float = 0) -> Tuple[float, float, float]:
|
||||
"""The magnetic field (nanoteslas north, east and down) at a place (degrees of WGS 84; `altitude` is
|
||||
kilometers above the ellipsoid) in a decimal year."""
|
||||
phi, lam = math.radians(latitude), math.radians(longitude)
|
||||
# The place as the sphere has it: how far from the center of the Earth, and at what angle from its axis.
|
||||
curvature = WGS84_A / math.sqrt(1 - WGS84_E2 * math.sin(phi) ** 2)
|
||||
p = (curvature + altitude) * math.cos(phi)
|
||||
z = (curvature * (1 - WGS84_E2) + altitude) * math.sin(phi)
|
||||
r = math.hypot(p, z)
|
||||
geocentric = math.asin(z / r)
|
||||
cos_t, sin_t = math.sin(geocentric), math.cos(geocentric)
|
||||
|
||||
# The Schmidt semi-normalized Legendre functions of the angle from the axis, and their derivatives.
|
||||
size = self.degree + 1
|
||||
legendre = [[0.0] * size for _ in range(size)]
|
||||
derivative = [[0.0] * size for _ in range(size)]
|
||||
legendre[0][0] = 1.0
|
||||
for n in range(1, size):
|
||||
for m in range(n + 1):
|
||||
if n == m:
|
||||
k = 1.0 if n == 1 else math.sqrt((2 * n - 1) / (2 * n))
|
||||
legendre[n][n] = k * sin_t * legendre[n - 1][n - 1]
|
||||
derivative[n][n] = k * (sin_t * derivative[n - 1][n - 1] + cos_t * legendre[n - 1][n - 1])
|
||||
else:
|
||||
k = math.sqrt(n * n - m * m)
|
||||
before = math.sqrt((n - 1) ** 2 - m * m) if n > 1 and m <= n - 2 else 0.0
|
||||
legendre[n][m] = ((2 * n - 1) * cos_t * legendre[n - 1][m]
|
||||
- before * (legendre[n - 2][m] if n > 1 else 0.0)) / k
|
||||
derivative[n][m] = ((2 * n - 1) * (cos_t * derivative[n - 1][m] - sin_t * legendre[n - 1][m])
|
||||
- before * (derivative[n - 2][m] if n > 1 else 0.0)) / k
|
||||
|
||||
years = year - self.epoch
|
||||
north = east = down = 0.0
|
||||
for n, m, g, h, g_rate, h_rate in self.coefficients:
|
||||
g, h = g + years * g_rate, h + years * h_rate
|
||||
ratio = (MODEL_RADIUS / r) ** (n + 2)
|
||||
cos_m, sin_m = math.cos(m * lam), math.sin(m * lam)
|
||||
north += ratio * (g * cos_m + h * sin_m) * derivative[n][m]
|
||||
east += ratio * m * (g * sin_m - h * cos_m) * legendre[n][m] / sin_t
|
||||
down -= ratio * (n + 1) * (g * cos_m + h * sin_m) * legendre[n][m]
|
||||
|
||||
# From the sphere's north and down to the ellipsoid's.
|
||||
turn = geocentric - phi
|
||||
return (north * math.cos(turn) - down * math.sin(turn), east,
|
||||
north * math.sin(turn) + down * math.cos(turn))
|
||||
|
||||
def declination(self, latitude: float, longitude: float, year: float, altitude: float = 0) -> float:
|
||||
"""How far east of true north (degrees) a compass points at a place in a decimal year."""
|
||||
north, east, _ = self.field(latitude, longitude, year, altitude)
|
||||
return math.degrees(math.atan2(east, north))
|
||||
|
||||
|
||||
@lru_cache(maxsize=None)
|
||||
def load_model(path: pathlib.Path = MODEL_PATH) -> MagneticModel:
|
||||
"""Read a model's coefficient file: a line of its epoch and name, then a line for each harmonic."""
|
||||
lines = path.read_text().splitlines()
|
||||
epoch, name = lines[0].split()[:2]
|
||||
coefficients = []
|
||||
for line in lines[1:]:
|
||||
parts = line.split()
|
||||
if len(parts) != 6:
|
||||
# The lines of nines which end the file.
|
||||
continue
|
||||
coefficients.append((int(parts[0]), int(parts[1]), *(float(i) for i in parts[2:])))
|
||||
return MagneticModel(epoch=float(epoch), name=name, coefficients=coefficients)
|
||||
|
||||
|
||||
def declination(latitude: float, longitude: float, year: float) -> Optional[float]:
|
||||
"""How far east of true north (degrees) a compass points at a place on the ground in a decimal year, or None
|
||||
in a year the model is not of: it is not known, and a guess is worse than nothing."""
|
||||
model = load_model()
|
||||
if not model.covers(year):
|
||||
return None
|
||||
return model.declination(latitude, longitude, year)
|
||||
117
modules/map/quads.py
Normal file
117
modules/map/quads.py
Normal file
|
|
@ -0,0 +1,117 @@
|
|||
"""What a quadrangle of the map is called.
|
||||
|
||||
The U.S. Geological Survey names each of its 7.5 minute quadrangles, after a town or a mountain or a lake in it
|
||||
("Berthoud", Colorado). `quads/usgs_7_5_minute.tsv.gz` is the index of those names, from the Map Indices of
|
||||
The National Map (public domain); `wrolpi/scripts/build_map_quad_names.py` makes it.
|
||||
|
||||
Most of those quadrangles are 7.5 minutes each way, with their edges on whole multiples of 7.5 minutes. Not all:
|
||||
in Alaska a quadrangle is wider the further north it is, and around some islands they are moved to fit the land.
|
||||
So a place is looked for in the quadrangle which has it, and whether that quadrangle is the one asked about is
|
||||
said too.
|
||||
"""
|
||||
import bisect
|
||||
import gzip
|
||||
import pathlib
|
||||
from dataclasses import dataclass
|
||||
from functools import lru_cache
|
||||
from typing import Dict, List, Optional, Tuple
|
||||
|
||||
__all__ = ['QuadName', 'quad_name', 'load_index', 'INDEX_PATH']
|
||||
|
||||
INDEX_PATH = pathlib.Path(__file__).parent / 'quads' / 'usgs_7_5_minute.tsv.gz'
|
||||
SECONDS_PER_DEGREE = 3600
|
||||
# No quadrangle is taller than this (seconds of arc): how far south of a place its quadrangle may start.
|
||||
TALLEST = 450
|
||||
# Edges this near (seconds of arc) are the same edge.
|
||||
SAME_EDGE = 1
|
||||
# A place this near (seconds of arc) past the outer edge of a quadrangle is on that edge: the edges the map gives
|
||||
# are a hair from where they are.
|
||||
OUTER_EDGE = 0.01
|
||||
# A place is where it is to the nearest this much (seconds of arc; 3 meters): the edges the map gives are a hair
|
||||
# from where they are, and the middle of an area is often on the edge two quadrangles share.
|
||||
NEAREST = 0.1
|
||||
|
||||
|
||||
@dataclass
|
||||
class QuadName:
|
||||
name: str
|
||||
state: str
|
||||
# Whether the named quadrangle is the area which was asked about, and not a larger or a moved one which has
|
||||
# the middle of it.
|
||||
exact: bool
|
||||
|
||||
def __json__(self) -> dict:
|
||||
return dict(name=self.name, state=self.state, exact=self.exact)
|
||||
|
||||
|
||||
# The quadrangles which start at one latitude: their west edges in order, and (west, east, north, name, state) of
|
||||
# each, in the same order.
|
||||
Row = Tuple[List[int], List[Tuple[int, int, int, str, str]]]
|
||||
|
||||
|
||||
@lru_cache(maxsize=None)
|
||||
def load_index(path: pathlib.Path = INDEX_PATH) -> Tuple[List[int], Dict[int, str]]:
|
||||
"""The index: the latitudes (seconds of arc) quadrangles start at, in order, and the lines of the quadrangles
|
||||
which start at each.
|
||||
|
||||
The lines are kept as they are written (3 MB; as numbers and names they are 17 MB in each process of the API),
|
||||
and are not read until a name is asked for."""
|
||||
rows: Dict[int, List[str]] = {}
|
||||
with gzip.open(path, 'rt', encoding='utf-8') as fh:
|
||||
for line in fh:
|
||||
rows.setdefault(int(line[:line.index('\t')]), []).append(line)
|
||||
return sorted(rows), {south: ''.join(lines) for south, lines in rows.items()}
|
||||
|
||||
|
||||
@lru_cache(maxsize=32)
|
||||
def _row(south: int) -> Row:
|
||||
"""The quadrangles which start at a latitude. Those asked about one after another are near each other, so
|
||||
the few rows last read are kept."""
|
||||
wests, cells = [], []
|
||||
for line in load_index()[1][south].splitlines():
|
||||
_, west, east, north, name, state = line.split('\t')
|
||||
# The lines are in order, so these are.
|
||||
wests.append(int(west))
|
||||
cells.append((int(west), int(east), int(north), name, state))
|
||||
return wests, cells
|
||||
|
||||
|
||||
def _find(x: float, y: float, outer: float = 0) -> Optional[Tuple[int, int, int, int, str, str]]:
|
||||
"""The quadrangle (west, south, east, north, name, state) which has a place (seconds of arc), or None.
|
||||
|
||||
A place on an edge two quadrangles share is in the one east, or north, of it: a quadrangle has its west and
|
||||
south edges, and not its east and north ones. With `outer` it has those too, and that much (seconds of arc)
|
||||
past them."""
|
||||
souths, _ = load_index()
|
||||
# The rows which may have the place, from the nearest to start south of it.
|
||||
last = bisect.bisect_right(souths, y)
|
||||
for row_south in reversed(souths[max(0, last - 8):last]):
|
||||
if row_south < y - TALLEST * 2:
|
||||
break
|
||||
wests, cells = _row(row_south)
|
||||
index = bisect.bisect_right(wests, x) - 1
|
||||
# Quadrangles moved to fit an island lie over their neighbors a little, so the one before is looked at too.
|
||||
for cell_west, cell_east, cell_north, name, state in cells[max(0, index - 1):index + 1][::-1]:
|
||||
if outer:
|
||||
within = x <= cell_east + outer and y <= cell_north + outer
|
||||
else:
|
||||
within = x < cell_east and y < cell_north
|
||||
if within and cell_west <= x and row_south <= y:
|
||||
return cell_west, row_south, cell_east, cell_north, name, state
|
||||
return None
|
||||
|
||||
|
||||
def quad_name(west: float, south: float, east: float, north: float) -> Optional[QuadName]:
|
||||
"""What the USGS calls the quadrangle between these edges (degrees), or None where it has none: most of the
|
||||
world.
|
||||
|
||||
It is the quadrangle which has the middle of the area. Where the middle is on the east or north edge of a
|
||||
quadrangle with none beyond it (an area half of which is the last quadrangle of the land), it is that one."""
|
||||
x = round((west + east) / 2 * SECONDS_PER_DEGREE / NEAREST) * NEAREST
|
||||
y = round((south + north) / 2 * SECONDS_PER_DEGREE / NEAREST) * NEAREST
|
||||
found = _find(x, y) or _find(x, y, outer=OUTER_EDGE)
|
||||
if found is None:
|
||||
return None
|
||||
edges = [round(i * SECONDS_PER_DEGREE) for i in (west, south, east, north)]
|
||||
exact = all(abs(a - b) <= SAME_EDGE for a, b in zip(edges, found[:4]))
|
||||
return QuadName(name=found[4], state=found[5], exact=exact)
|
||||
BIN
modules/map/quads/usgs_7_5_minute.tsv.gz
Normal file
BIN
modules/map/quads/usgs_7_5_minute.tsv.gz
Normal file
Binary file not shown.
871
modules/map/sheet.py
Normal file
871
modules/map/sheet.py
Normal file
|
|
@ -0,0 +1,871 @@
|
|||
"""The sheet an exported map is printed on: what a topographic map has around and over the map itself.
|
||||
|
||||
Around the map is a margin with a title, the latitude and longitude of the map's corners and of ticks along its
|
||||
edges, scale bars, a diagram of the three norths (true, grid and magnetic), and notes (the projection, the grid,
|
||||
where a compass points, where the map's data is from). Over the map is a grid of
|
||||
1,000 meter squares (Universal Transverse Mercator), which is how a position is read from, or found on, paper.
|
||||
|
||||
All of it is drawn as lines and text, in PDF layers of its own which a reader can turn off.
|
||||
"""
|
||||
import dataclasses
|
||||
import datetime
|
||||
import math
|
||||
from dataclasses import dataclass, field
|
||||
from typing import List, Optional, Sequence, Tuple
|
||||
|
||||
from modules.map import magnetic, quads
|
||||
|
||||
__all__ = ['Sheet', 'SheetPlan', 'plan_sheet', 'draw_sheet', 'to_utm', 'from_utm', 'utm_zone', 'map_scale',
|
||||
'format_angle', 'graticule_interval', 'SHEET_LAYER', 'GRID_LAYER', 'LegendLine', 'legend_lines',
|
||||
'legend_as_sent', 'adjoining_quads', 'mils']
|
||||
|
||||
# The names of the sheet's PDF layers.
|
||||
SHEET_LAYER = 'Sheet'
|
||||
GRID_LAYER = 'UTM grid'
|
||||
|
||||
# The WGS 84 ellipsoid.
|
||||
WGS84_A = 6378137.0
|
||||
WGS84_F = 1 / 298.257223563
|
||||
WGS84_E2 = WGS84_F * (2 - WGS84_F)
|
||||
|
||||
# Universal Transverse Mercator.
|
||||
UTM_SCALE = 0.9996
|
||||
UTM_FALSE_EASTING = 500_000.0
|
||||
UTM_FALSE_NORTHING_SOUTH = 10_000_000.0
|
||||
# Where UTM is used: nearer the poles than this, positions are given another way.
|
||||
UTM_SOUTH, UTM_NORTH = -80.0, 84.0
|
||||
GRID_METERS = 1000
|
||||
# More lines than this across a map are too many to read; the squares are made ten times larger until there are
|
||||
# fewer.
|
||||
GRID_MAX_LINES = 60
|
||||
|
||||
POINTS_PER_INCH = 72
|
||||
METERS_PER_POINT = 0.0254 / POINTS_PER_INCH
|
||||
METERS_PER_MILE = 1609.344
|
||||
METERS_PER_FOOT = 0.3048
|
||||
|
||||
# The sizes of the sheet, in points.
|
||||
MARGIN = 54
|
||||
TOP_MARGIN = 64
|
||||
FONT = 'helv'
|
||||
BOLD = 'hebo'
|
||||
TITLE_SIZE = 13
|
||||
# Between two lines of the title, and the least there is between the name and the scale on one line.
|
||||
TITLE_LEADING = 18
|
||||
TITLE_GAP = 18
|
||||
LABEL_SIZE = 6.5
|
||||
NOTE_SIZE = 7
|
||||
NOTE_LEADING = 9.5
|
||||
BAR_HEIGHT = 4
|
||||
BAR_SPACING = 27
|
||||
# The bars: kilometers, meters, miles and feet.
|
||||
BAR_COUNT = 4
|
||||
# The room under the bars for how far apart the contour lines are.
|
||||
CONTOUR_LEADING = 16
|
||||
# The units contour lines are apart in, as they are written.
|
||||
CONTOUR_UNITS = dict(feet='FEET', meters='METERS')
|
||||
# The diagram of the quadrangles around the map: how large each of its nine squares is, how much room the
|
||||
# diagram and the names beside it take under the bars, and the narrowest map which has room for it.
|
||||
ADJOINING_SQUARE = 12
|
||||
ADJOINING_HEIGHT = 58
|
||||
ADJOINING_MIN_WIDTH = 280
|
||||
ADJOINING_COLUMN = 150
|
||||
# How many maps over to look for the next quadrangle: the widest of the USGS is under four maps wide.
|
||||
ADJOINING_STEPS = 4
|
||||
ADJOINING_GRAY = (0.75, 0.75, 0.75)
|
||||
GRAY = (0.6, 0.6, 0.6)
|
||||
# Where the eight are from the map, in the order they are numbered: (columns east, rows north).
|
||||
ADJOINING = ((-1, 1), (0, 1), (1, 1), (-1, 0), (1, 0), (-1, -1), (0, -1), (1, -1))
|
||||
# The legend: the most lines it has, how long what each is called may be, how wide and tall the room of one is,
|
||||
# how long its piece of line is, and the least and the most a line is drawn wide (points): a line thinner than
|
||||
# the least is not one which is seen on the map, and is left out.
|
||||
LEGEND_LINES = 12
|
||||
LEGEND_LABEL = 40
|
||||
LEGEND_ITEM_WIDTH = 118
|
||||
LEGEND_ITEM_HEIGHT = 13
|
||||
LEGEND_SAMPLE = 30
|
||||
LEGEND_WIDTHS = (0.1, 5)
|
||||
LEGEND_DASHES = 6
|
||||
WHITE = (1, 1, 1)
|
||||
# A compass is marked in degrees, or in mils: 6,400 of them around.
|
||||
MILS_PER_DEGREE = 6400 / 360
|
||||
# From the bottom of the map to the first scale bar, and from the last note to the bottom of the page.
|
||||
BARS_OFFSET = 52
|
||||
BOTTOM_PADDING = 36
|
||||
TICK_LENGTH = 7
|
||||
CROSS_LENGTH = 5
|
||||
BLACK = (0, 0, 0)
|
||||
GRID_COLOR = (0.1, 0.2, 0.55)
|
||||
|
||||
# The spacings a map's ticks of latitude and longitude may have, in seconds of arc.
|
||||
GRATICULE_INTERVALS = (36000, 18000, 3600, 1800, 900, 450, 300, 150, 60, 30, 15, 5, 1)
|
||||
|
||||
|
||||
@dataclass
|
||||
class LegendLine:
|
||||
"""A kind of line of the map (a road, a boundary), as it is drawn there: for the legend."""
|
||||
label: str
|
||||
# Red, green and blue, each from 0 to 1.
|
||||
color: Tuple[float, float, float]
|
||||
# How wide it is, in points.
|
||||
width: float
|
||||
opacity: float = 1
|
||||
# The lengths of its dashes and of the gaps between them, in points; nothing when it is unbroken.
|
||||
dash: Tuple[float, ...] = ()
|
||||
# The line under it which is its edges: its color, and how wide it is, edges and all.
|
||||
casing_color: Optional[Tuple[float, float, float]] = None
|
||||
casing_width: float = 0
|
||||
|
||||
|
||||
@dataclass
|
||||
class Sheet:
|
||||
"""What the browser says of a map, to be written around it."""
|
||||
# What the map is called.
|
||||
name: Optional[str] = None
|
||||
# Where the data of the map is from.
|
||||
credits: Sequence[str] = ()
|
||||
# When the map was made, as it is to be written. When it is a day (2026-11-15), the sheet says where a
|
||||
# compass points on that day.
|
||||
date: Optional[str] = None
|
||||
# How far apart the map's contour lines are, and in what (one of CONTOUR_UNITS); None when it has none.
|
||||
contour_interval: Optional[float] = None
|
||||
contour_unit: Optional[str] = None
|
||||
# The lines of the map as the browser drew them, for the legend: `{"ground": [r, g, b], "lines": [{"label",
|
||||
# "color", "width", "opacity", "dash", "casing_color", "casing_width"}, ...]}` (see `LegendLine`; `ground`
|
||||
# is the color of the land they are drawn on). It is whatever was sent: `legend_lines` makes lines of it.
|
||||
legend: Optional[dict] = None
|
||||
|
||||
|
||||
@dataclass
|
||||
class SheetPlan:
|
||||
"""Where everything on a sheet goes. Lengths are points; `y` is down the page from its top."""
|
||||
width: float
|
||||
height: float
|
||||
# The rectangle of the page the map is in: left, top, right, bottom.
|
||||
map_rect: Tuple[float, float, float, float]
|
||||
# The west, south, east and north edges of the map.
|
||||
bounds: Tuple[float, float, float, float]
|
||||
# How many times larger the ground is than the map, at the middle of the map.
|
||||
scale: float
|
||||
name: Optional[str] = None
|
||||
notes: List[str] = field(default_factory=list)
|
||||
# The UTM zone the map's grid is of, or None where there is no grid.
|
||||
zone: Optional[int] = None
|
||||
# How far east of true north (degrees) the grid's north, and a compass, point at the middle of the map.
|
||||
# None where there is no grid, and when it is not known where a compass points.
|
||||
grid_north: Optional[float] = None
|
||||
magnetic_north: Optional[float] = None
|
||||
# How far apart the contour lines are, as it is written under the scale bars; None when there are none.
|
||||
contours: Optional[str] = None
|
||||
# What the USGS calls the eight quadrangles around the map, in the order of ADJOINING (None for one it has
|
||||
# no name for); None when it has a name for none of them, and when the sheet has no room to say.
|
||||
adjoining: Optional[List[Optional[str]]] = None
|
||||
# The lines of the legend, and the color of the land they are drawn on.
|
||||
legend: List[LegendLine] = field(default_factory=list)
|
||||
legend_ground: Tuple[float, float, float] = WHITE
|
||||
|
||||
@property
|
||||
def south_hemisphere(self) -> bool:
|
||||
return (self.bounds[1] + self.bounds[3]) / 2 < 0
|
||||
|
||||
def point(self, latitude: float, longitude: float) -> Tuple[float, float]:
|
||||
"""Where on the page a place is. The map is Web Mercator."""
|
||||
x0, y0, x1, y1 = self.map_rect
|
||||
west, south, east, north = self.bounds
|
||||
top, bottom = _mercator_y(north), _mercator_y(south)
|
||||
return (x0 + (longitude - west) / (east - west) * (x1 - x0),
|
||||
y0 + (top - _mercator_y(latitude)) / (top - bottom) * (y1 - y0))
|
||||
|
||||
|
||||
def _mercator_y(latitude: float) -> float:
|
||||
return math.log(math.tan(math.pi / 4 + math.radians(latitude) / 2))
|
||||
|
||||
|
||||
def _middle_latitude(south: float, north: float) -> float:
|
||||
"""The latitude half way up a Web Mercator map."""
|
||||
y = (_mercator_y(south) + _mercator_y(north)) / 2
|
||||
return math.degrees(2 * math.atan(math.exp(y)) - math.pi / 2)
|
||||
|
||||
|
||||
def map_scale(width: float, bounds: Sequence[float]) -> float:
|
||||
"""How many times larger the ground is than a map `width` points wide, at the middle of the map."""
|
||||
west, south, east, north = bounds
|
||||
latitude = math.radians(_middle_latitude(south, north))
|
||||
meters_per_degree = math.radians(1) * WGS84_A * math.cos(latitude) \
|
||||
/ math.sqrt(1 - WGS84_E2 * math.sin(latitude) ** 2)
|
||||
return meters_per_degree * (east - west) / (width * METERS_PER_POINT)
|
||||
|
||||
|
||||
# Universal Transverse Mercator, by the series of Krüger (as Karney gives them), which is good to well under a
|
||||
# millimeter within a zone.
|
||||
_N = WGS84_F / (2 - WGS84_F)
|
||||
_RADIUS = WGS84_A / (1 + _N) * (1 + _N ** 2 / 4 + _N ** 4 / 64)
|
||||
_ALPHA = (_N / 2 - 2 * _N ** 2 / 3 + 5 * _N ** 3 / 16, 13 * _N ** 2 / 48 - 3 * _N ** 3 / 5, 61 * _N ** 3 / 240)
|
||||
_BETA = (_N / 2 - 2 * _N ** 2 / 3 + 37 * _N ** 3 / 96, _N ** 2 / 48 + _N ** 3 / 15, 17 * _N ** 3 / 480)
|
||||
_DELTA = (2 * _N - 2 * _N ** 2 / 3 - 2 * _N ** 3, 7 * _N ** 2 / 3 - 8 * _N ** 3 / 5, 56 * _N ** 3 / 15)
|
||||
|
||||
|
||||
def utm_zone(longitude: float) -> int:
|
||||
"""The UTM zone (1 to 60) a longitude is in. The zones are six degrees wide, everywhere: those which are
|
||||
made wider around Norway and Svalbard are not."""
|
||||
return min(60, int((longitude + 180) // 6) + 1)
|
||||
|
||||
|
||||
def _central_meridian(zone: int) -> float:
|
||||
return math.radians(zone * 6 - 183)
|
||||
|
||||
|
||||
def to_utm(latitude: float, longitude: float, zone: int, south: bool = False) -> Tuple[float, float]:
|
||||
"""The easting and northing (meters) of a place, in a UTM zone of WGS 84."""
|
||||
phi = math.radians(latitude)
|
||||
lam = math.radians(longitude) - _central_meridian(zone)
|
||||
c = 2 * math.sqrt(_N) / (1 + _N)
|
||||
t = math.sinh(math.atanh(math.sin(phi)) - c * math.atanh(c * math.sin(phi)))
|
||||
xi = math.atan2(t, math.cos(lam))
|
||||
eta = math.atanh(math.sin(lam) / math.sqrt(1 + t * t))
|
||||
northing = xi + sum(a * math.sin(2 * j * xi) * math.cosh(2 * j * eta) for j, a in enumerate(_ALPHA, 1))
|
||||
easting = eta + sum(a * math.cos(2 * j * xi) * math.sinh(2 * j * eta) for j, a in enumerate(_ALPHA, 1))
|
||||
return (UTM_FALSE_EASTING + UTM_SCALE * _RADIUS * easting,
|
||||
(UTM_FALSE_NORTHING_SOUTH if south else 0) + UTM_SCALE * _RADIUS * northing)
|
||||
|
||||
|
||||
def from_utm(easting: float, northing: float, zone: int, south: bool = False) -> Tuple[float, float]:
|
||||
"""The latitude and longitude (degrees of WGS 84) of a place in a UTM zone."""
|
||||
xi = (northing - (UTM_FALSE_NORTHING_SOUTH if south else 0)) / (UTM_SCALE * _RADIUS)
|
||||
eta = (easting - UTM_FALSE_EASTING) / (UTM_SCALE * _RADIUS)
|
||||
xi_ = xi - sum(b * math.sin(2 * j * xi) * math.cosh(2 * j * eta) for j, b in enumerate(_BETA, 1))
|
||||
eta_ = eta - sum(b * math.cos(2 * j * xi) * math.sinh(2 * j * eta) for j, b in enumerate(_BETA, 1))
|
||||
chi = math.asin(math.sin(xi_) / math.cosh(eta_))
|
||||
phi = chi + sum(d * math.sin(2 * j * chi) for j, d in enumerate(_DELTA, 1))
|
||||
lam = _central_meridian(zone) + math.atan2(math.sinh(eta_), math.cos(xi_))
|
||||
return math.degrees(phi), math.degrees(lam)
|
||||
|
||||
|
||||
def format_angle(degrees: float, positive: str = '', negative: str = '', short: bool = False) -> str:
|
||||
"""An angle in degrees, minutes and seconds, as a sheet has it: 61°07'30". The seconds are left out when
|
||||
there are none. `short` leaves the degrees out too (07'30"), as the ticks between a map's corners do.
|
||||
|
||||
The angle is on the side its seconds are: an edge of a map a hair south of the equator is 0°00', and not
|
||||
south of anything."""
|
||||
seconds = round(abs(degrees) * 3600)
|
||||
d, m, s = seconds // 3600, seconds // 60 % 60, seconds % 60
|
||||
text = f"{m:02d}'" if short else f"{d}°{m:02d}'"
|
||||
if s:
|
||||
text += f'{s:02d}"'
|
||||
return text + (negative if degrees < 0 and seconds else positive if seconds else '')
|
||||
|
||||
|
||||
def graticule_interval(span: float) -> float:
|
||||
"""How far apart (degrees) the ticks of latitude and longitude are on a map `span` degrees across: the
|
||||
largest spacing which divides it in three or more. A 7.5 minute map has a tick every 2.5 minutes."""
|
||||
for seconds in GRATICULE_INTERVALS:
|
||||
if seconds * 3 <= round(span * 3600):
|
||||
return seconds / 3600
|
||||
return GRATICULE_INTERVALS[-1] / 3600
|
||||
|
||||
|
||||
# A tick nearer an edge of the map than this part of the way to the next tick is that edge: the edges of the
|
||||
# picture the browser draws are a hair outside the map it was asked for (a millionth of a degree).
|
||||
TICK_CLEARANCE = 0.01
|
||||
|
||||
|
||||
def _multiples(interval: float, low: float, high: float) -> List[float]:
|
||||
"""The multiples of `interval` between `low` and `high`, and not at (or a hair from) either."""
|
||||
first = math.floor(low / interval)
|
||||
values = []
|
||||
for i in range(first, first + 100_000):
|
||||
value = i * interval
|
||||
if value >= high - interval * TICK_CLEARANCE:
|
||||
break
|
||||
if value > low + interval * TICK_CLEARANCE:
|
||||
values.append(value)
|
||||
return values
|
||||
|
||||
|
||||
def _latin(text: str) -> str:
|
||||
"""Text as the sheet's font can write it."""
|
||||
for old, new in (('′', "'"), ('″', '"'), ('’', "'"), ('‘', "'"), ('“', '"'), ('”', '"'), ('–', '-'),
|
||||
('—', '-'), (' ', ' ')):
|
||||
text = text.replace(old, new)
|
||||
text = ' '.join(text.split())
|
||||
return text.encode('latin-1', 'replace').decode('latin-1')
|
||||
|
||||
|
||||
def _text_width(text: str, size: float, font: str = FONT) -> float:
|
||||
# Not imported at module level: see build_layered_pdf.
|
||||
import pymupdf
|
||||
return pymupdf.get_text_length(text, fontname=font, fontsize=size)
|
||||
|
||||
|
||||
def _wrap(text: str, width: float, size: float) -> List[str]:
|
||||
"""The lines of `text`, none wider than `width`."""
|
||||
lines, line = [], ''
|
||||
for word in text.split():
|
||||
longer = f'{line} {word}' if line else word
|
||||
if line and _text_width(longer, size) > width:
|
||||
lines.append(line)
|
||||
line = word
|
||||
else:
|
||||
line = longer
|
||||
return lines + [line] if line else lines
|
||||
|
||||
|
||||
def _grid_convergence(latitude: float, longitude: float, zone: int, south: bool) -> float:
|
||||
"""How far east of true north (degrees) the grid's north is at a place."""
|
||||
easting, northing = to_utm(latitude, longitude, zone, south)
|
||||
lat, lon = from_utm(easting, northing + 1000, zone, south)
|
||||
return math.degrees(math.atan2(math.radians(lon - longitude) * math.cos(math.radians(latitude)),
|
||||
math.radians(lat - latitude)))
|
||||
|
||||
|
||||
def _east_or_west(angle: float) -> str:
|
||||
"""An angle east of north as it is said: 2°34' west. No north is known to better than a minute."""
|
||||
return f'{format_angle(_to_the_minute(abs(angle)))} {"west" if angle < 0 else "east"}'
|
||||
|
||||
|
||||
def mils(angle: float) -> int:
|
||||
"""An angle (degrees) in the mils a compass may be marked in."""
|
||||
return round(abs(angle) * MILS_PER_DEGREE)
|
||||
|
||||
|
||||
def _mils(angle: float) -> str:
|
||||
"""An angle in mils, as it is said: "46 mils", and "1 mil"."""
|
||||
count = mils(angle)
|
||||
return f'{count} mil' if count == 1 else f'{count} mils'
|
||||
|
||||
|
||||
def _north_of_true(angle: float) -> str:
|
||||
"""How far a north is from true north, as it is said: 2°34' west (46 mils)."""
|
||||
return f'{_east_or_west(angle)} ({_mils(angle)})'
|
||||
|
||||
|
||||
def adjoining_quads(bounds: Sequence[float]) -> Optional[List[Optional[str]]]:
|
||||
"""What the USGS calls the quadrangle on each of the eight sides of a map, in the order of ADJOINING. None
|
||||
when it has a name for none of them: most of the world.
|
||||
|
||||
A quadrangle of the USGS may be larger than the map (in Alaska they are wider), so the area the size of the
|
||||
map beside it may be more of the quadrangle the map is in. The quadrangle on that side is the next one
|
||||
which is not: a sheet is never beside itself."""
|
||||
west, south, east, north = bounds
|
||||
width, height = east - west, north - south
|
||||
own = quads.quad_name(west, south, east, north)
|
||||
names = []
|
||||
for columns, rows in ADJOINING:
|
||||
name = None
|
||||
for step in range(1, ADJOINING_STEPS + 1):
|
||||
name = quads.quad_name(west + step * columns * width, south + step * rows * height,
|
||||
east + step * columns * width, north + step * rows * height)
|
||||
if name is None or own is None or (name.name, name.state) != (own.name, own.state):
|
||||
break
|
||||
else:
|
||||
name = None
|
||||
names.append(_latin(name.name) if name else None)
|
||||
return names if any(names) else None
|
||||
|
||||
|
||||
def _number(value, least: float, most: float) -> Optional[float]:
|
||||
"""A number which was sent, kept between two others; None when it is not a number."""
|
||||
if isinstance(value, bool) or not isinstance(value, (int, float)) or not math.isfinite(value):
|
||||
return None
|
||||
return min(most, max(least, float(value)))
|
||||
|
||||
|
||||
def _color(value) -> Optional[Tuple[float, float, float]]:
|
||||
"""A color which was sent (red, green and blue, each from 0 to 1); None when it is not one."""
|
||||
if not isinstance(value, (list, tuple)) or len(value) != 3:
|
||||
return None
|
||||
parts = tuple(_number(i, 0, 1) for i in value)
|
||||
return None if None in parts else parts
|
||||
|
||||
|
||||
def legend_lines(legend) -> Tuple[Tuple[float, float, float], List[LegendLine]]:
|
||||
"""The color of the land, and the lines, of the legend which a browser sent (see `Sheet.legend`). What is
|
||||
not a line (it has no name, no color or no width) is left out, and a line is drawn no wider than a legend
|
||||
has room for."""
|
||||
if not isinstance(legend, dict):
|
||||
return WHITE, []
|
||||
lines = []
|
||||
raw = legend.get('lines')
|
||||
for line in (raw if isinstance(raw, list) else [])[:LEGEND_LINES]:
|
||||
if not isinstance(line, dict):
|
||||
continue
|
||||
label = _latin(str(line.get('label') or '')).strip()[:LEGEND_LABEL]
|
||||
color, width = _color(line.get('color')), _number(line.get('width'), 0, LEGEND_WIDTHS[1])
|
||||
if not label or color is None or width is None or width < LEGEND_WIDTHS[0]:
|
||||
continue
|
||||
dash = line.get('dash')
|
||||
dash = [_number(i, 0.1, LEGEND_SAMPLE) for i in (dash if isinstance(dash, (list, tuple)) else [])[:LEGEND_DASHES]]
|
||||
opacity = _number(line.get('opacity'), 0.05, 1)
|
||||
casing_color, casing_width = _color(line.get('casing_color')), _number(line.get('casing_width'), 0, 8)
|
||||
lines.append(LegendLine(
|
||||
label=label, color=color, width=width, opacity=1 if opacity is None else opacity,
|
||||
dash=() if None in dash else tuple(dash),
|
||||
casing_color=casing_color if casing_width else None,
|
||||
casing_width=casing_width if casing_color and casing_width else 0))
|
||||
return _color(legend.get('ground')) or WHITE, lines
|
||||
|
||||
|
||||
def legend_as_sent(legend) -> Optional[dict]:
|
||||
"""The legend which a browser sent with only what `legend_lines` makes of it, as it is sent; None when it
|
||||
has no lines."""
|
||||
ground, lines = legend_lines(legend)
|
||||
return dict(ground=list(ground), lines=[dataclasses.asdict(line) for line in lines]) if lines else None
|
||||
|
||||
|
||||
def _legend_columns(plan: 'SheetPlan') -> int:
|
||||
"""How many lines of the legend go side by side under a map as wide as this one."""
|
||||
return max(1, int((plan.map_rect[2] - plan.map_rect[0]) // LEGEND_ITEM_WIDTH))
|
||||
|
||||
|
||||
def _legend_height(plan: 'SheetPlan') -> float:
|
||||
"""The room the legend takes under the map: nothing, when it has no lines."""
|
||||
if not plan.legend:
|
||||
return 0
|
||||
rows = math.ceil(len(plan.legend) / _legend_columns(plan))
|
||||
return LABEL_SIZE + 8 + rows * LEGEND_ITEM_HEIGHT + 8
|
||||
|
||||
|
||||
def _contours(sheet: 'Sheet') -> Optional[str]:
|
||||
"""How far apart the contour lines are, as it is written: CONTOUR INTERVAL 40 FEET."""
|
||||
interval, unit = sheet.contour_interval, CONTOUR_UNITS.get(sheet.contour_unit)
|
||||
if not unit or not isinstance(interval, (int, float)) or not math.isfinite(interval) or interval <= 0:
|
||||
return None
|
||||
return f'CONTOUR INTERVAL {interval:,.10g} {unit}'
|
||||
|
||||
|
||||
def _to_the_minute(angle: float) -> float:
|
||||
return round(angle * 60) / 60
|
||||
|
||||
|
||||
def _decimal_year(date: Optional[str]) -> Optional[float]:
|
||||
"""A day (2026-11-15) as a year and a part of one, or None when it is not a day."""
|
||||
try:
|
||||
day = datetime.date.fromisoformat(str(date).strip()[:10])
|
||||
first = datetime.date(day.year, 1, 1)
|
||||
return day.year + (day - first).days / (datetime.date(day.year + 1, 1, 1) - first).days
|
||||
except ValueError:
|
||||
# Not a day, or one with no year after it.
|
||||
return None
|
||||
|
||||
|
||||
def _format_scale(scale: float) -> str:
|
||||
"""1:24,000. A map's scale is not known closer than three figures."""
|
||||
digits = max(0, math.floor(math.log10(scale)) - 2)
|
||||
return f'1:{round(scale / 10 ** digits) * 10 ** digits:,}'
|
||||
|
||||
|
||||
def _grid_meters(plan: 'SheetPlan') -> int:
|
||||
"""How far apart the lines of the map's grid are."""
|
||||
(low_e, high_e), (low_n, high_n) = _utm_extent(plan)
|
||||
meters = GRID_METERS
|
||||
while (high_e - low_e) / meters > GRID_MAX_LINES or (high_n - low_n) / meters > GRID_MAX_LINES:
|
||||
meters *= 10
|
||||
return meters
|
||||
|
||||
|
||||
def _utm_extent(plan: 'SheetPlan') -> Tuple[Tuple[float, float], Tuple[float, float]]:
|
||||
"""The least and greatest easting, and northing, on the map."""
|
||||
west, south, east, north = plan.bounds
|
||||
places = [to_utm(lat, lon, plan.zone, plan.south_hemisphere)
|
||||
for lat in (south, (south + north) / 2, north) for lon in (west, (west + east) / 2, east)]
|
||||
eastings, northings = [i[0] for i in places], [i[1] for i in places]
|
||||
return (min(eastings), max(eastings)), (min(northings), max(northings))
|
||||
|
||||
|
||||
def plan_sheet(map_width: float, map_height: float, bounds: Sequence[float], sheet: Sheet) -> SheetPlan:
|
||||
"""Where a map of `map_width` by `map_height` points, between `bounds` (west, south, east, north), goes on a
|
||||
sheet, and what is written under it."""
|
||||
west, south, east, north = bounds
|
||||
plan = SheetPlan(width=0, height=0, map_rect=(0, 0, 0, 0), bounds=(west, south, east, north),
|
||||
scale=map_scale(map_width, bounds), name=_latin(sheet.name) if sheet.name else None)
|
||||
middle = _middle_latitude(south, north), (west + east) / 2
|
||||
# By its middle: the edges of a map are a hair outside it, and a map which ends where the zones do has a grid.
|
||||
if UTM_SOUTH <= middle[0] <= UTM_NORTH:
|
||||
plan.zone = utm_zone(middle[1])
|
||||
|
||||
notes = [f'Scale {_format_scale(plan.scale)} at the middle of the map. Projection: Web Mercator.'
|
||||
f' Datum: WGS 84. True north is up the page.']
|
||||
if plan.zone:
|
||||
plan.grid_north = _grid_convergence(*middle, plan.zone, plan.south_hemisphere)
|
||||
notes.append(
|
||||
f'{_grid_meters(plan):,} meter grid: Universal Transverse Mercator, zone {plan.zone}'
|
||||
f'{"S" if plan.south_hemisphere else "N"}. Grid north is {_north_of_true(plan.grid_north)} of true'
|
||||
f' north at the middle of the map.')
|
||||
year = _decimal_year(sheet.date)
|
||||
plan.magnetic_north = magnetic.declination(*middle, year) if year else None
|
||||
if plan.magnetic_north is not None:
|
||||
model = magnetic.load_model()
|
||||
# The shorter way around: a compass which passes due south goes from 180 west to 180 east.
|
||||
yearly = (model.declination(*middle, year + 1) - plan.magnetic_north + 180) % 360 - 180
|
||||
notes.append(
|
||||
f'Magnetic north is {_north_of_true(plan.magnetic_north)} of true north at the middle of the map on'
|
||||
f' {_latin(sheet.date)}, and moves about {_east_or_west(yearly)} each year ({model.name}).')
|
||||
names = [_latin(str(i)) for i in sheet.credits if str(i).strip()]
|
||||
if names:
|
||||
notes.append('Map data: ' + '; '.join(names))
|
||||
notes.append(f'Made with WROLPi, {_latin(sheet.date)}.' if sheet.date else 'Made with WROLPi.')
|
||||
for note in notes:
|
||||
plan.notes.extend(_wrap(note, map_width, NOTE_SIZE))
|
||||
plan.contours = _contours(sheet)
|
||||
if map_width >= ADJOINING_MIN_WIDTH:
|
||||
plan.adjoining = adjoining_quads(bounds)
|
||||
|
||||
plan.legend_ground, plan.legend = legend_lines(sheet.legend)
|
||||
|
||||
plan.width = map_width + 2 * MARGIN
|
||||
plan.map_rect = (MARGIN, TOP_MARGIN, MARGIN + map_width, TOP_MARGIN + map_height)
|
||||
plan.height = TOP_MARGIN + map_height + BARS_OFFSET + BAR_COUNT * BAR_SPACING \
|
||||
+ (CONTOUR_LEADING if plan.contours else 0) + (ADJOINING_HEIGHT if plan.adjoining else 0) \
|
||||
+ _legend_height(plan) + len(plan.notes) * NOTE_LEADING + BOTTOM_PADDING
|
||||
return plan
|
||||
|
||||
|
||||
def _clip(points: Sequence[Tuple[float, float]], rect: Sequence[float]) -> List[List[Tuple[float, float]]]:
|
||||
"""The parts of a line (through `points`) which are in a rectangle."""
|
||||
x0, y0, x1, y1 = rect
|
||||
pieces, piece = [], []
|
||||
for (ax, ay), (bx, by) in zip(points, points[1:]):
|
||||
# Liang-Barsky: the part of the way from a to b which is inside.
|
||||
start, end = 0.0, 1.0
|
||||
dx, dy = bx - ax, by - ay
|
||||
inside = True
|
||||
for p, q in ((-dx, ax - x0), (dx, x1 - ax), (-dy, ay - y0), (dy, y1 - ay)):
|
||||
if p == 0:
|
||||
inside = inside and q >= 0
|
||||
elif p < 0:
|
||||
start = max(start, q / p)
|
||||
else:
|
||||
end = min(end, q / p)
|
||||
if not inside or start > end:
|
||||
if piece:
|
||||
pieces.append(piece)
|
||||
piece = []
|
||||
continue
|
||||
a, b = (ax + start * dx, ay + start * dy), (ax + end * dx, ay + end * dy)
|
||||
if not piece or start > 0:
|
||||
if piece:
|
||||
pieces.append(piece)
|
||||
piece = [a]
|
||||
piece.append(b)
|
||||
if end < 1:
|
||||
pieces.append(piece)
|
||||
piece = []
|
||||
if piece:
|
||||
pieces.append(piece)
|
||||
return [i for i in pieces if len(i) > 1]
|
||||
|
||||
|
||||
class _Pen:
|
||||
"""Draws the lines and text of one PDF layer."""
|
||||
|
||||
def __init__(self, page, group: int):
|
||||
self.shape = page.new_shape()
|
||||
self.group = group
|
||||
|
||||
def line(self, points: Sequence[Tuple[float, float]], width: float = 0.5, color=BLACK, opacity: float = 1,
|
||||
dash: Sequence[float] = ()):
|
||||
self.shape.draw_polyline(list(points))
|
||||
dashes = f'[{" ".join(f"{i:.2f}" for i in dash)}] 0' if dash else None
|
||||
self.shape.finish(width=width, color=color, closePath=False, stroke_opacity=opacity, dashes=dashes,
|
||||
lineCap=0, oc=self.group)
|
||||
|
||||
def box(self, rect: Sequence[float], fill=None, width: float = 0.5, color=BLACK):
|
||||
self.shape.draw_rect(rect)
|
||||
self.shape.finish(width=width, color=color, fill=fill, oc=self.group)
|
||||
|
||||
def polygon(self, points: Sequence[Tuple[float, float]], fill=BLACK):
|
||||
self.shape.draw_polyline(list(points))
|
||||
self.shape.finish(width=0.3, color=BLACK, fill=fill, closePath=True, oc=self.group)
|
||||
|
||||
def text(self, x: float, y: float, text: str, size: float = LABEL_SIZE, align: str = 'left', font: str = FONT,
|
||||
color=BLACK):
|
||||
"""Write `text` with its baseline at `y`: starting at, ending at, or centered on `x`."""
|
||||
if align != 'left':
|
||||
width = _text_width(text, size, font)
|
||||
x -= width if align == 'right' else width / 2
|
||||
self.shape.insert_text((x, y), text, fontsize=size, fontname=font, color=color, oc=self.group)
|
||||
|
||||
def commit(self):
|
||||
self.shape.commit()
|
||||
|
||||
|
||||
def _draw_graticule(pen: _Pen, plan: SheetPlan):
|
||||
"""The edge of the map, the coordinates of its corners, and ticks of latitude and longitude between them."""
|
||||
x0, y0, x1, y1 = plan.map_rect
|
||||
west, south, east, north = plan.bounds
|
||||
pen.box(plan.map_rect, width=0.75)
|
||||
|
||||
above, below, beside = y0 - 4, y1 + LABEL_SIZE + 3, LABEL_SIZE * 0.35
|
||||
# The corners.
|
||||
for longitude, x, align in ((west, x0, 'left'), (east, x1, 'right')):
|
||||
label = format_angle(longitude, 'E', 'W')
|
||||
pen.text(x, above, label, align=align)
|
||||
pen.text(x, below, label, align=align)
|
||||
for latitude, y in ((north, y0), (south, y1)):
|
||||
label = format_angle(latitude, 'N', 'S')
|
||||
pen.text(x0 - 3, y + beside, label, align='right')
|
||||
pen.text(x1 + 3, y + beside, label)
|
||||
|
||||
longitudes = _multiples(graticule_interval(east - west), west, east)
|
||||
latitudes = _multiples(graticule_interval(north - south), south, north)
|
||||
for longitude in longitudes:
|
||||
x = plan.point(north, longitude)[0]
|
||||
pen.line([(x, y0), (x, y0 + TICK_LENGTH)])
|
||||
pen.line([(x, y1), (x, y1 - TICK_LENGTH)])
|
||||
label = format_angle(longitude, short=True)
|
||||
pen.text(x, above, label, align='center')
|
||||
pen.text(x, below, label, align='center')
|
||||
for latitude in latitudes:
|
||||
y = plan.point(latitude, west)[1]
|
||||
pen.line([(x0, y), (x0 + TICK_LENGTH, y)])
|
||||
pen.line([(x1, y), (x1 - TICK_LENGTH, y)])
|
||||
label = format_angle(latitude, short=True)
|
||||
pen.text(x0 - 3, y + beside, label, align='right')
|
||||
pen.text(x1 + 3, y + beside, label)
|
||||
# A cross where a tick of latitude meets one of longitude.
|
||||
for latitude in latitudes:
|
||||
for longitude in longitudes:
|
||||
x, y = plan.point(latitude, longitude)
|
||||
pen.line([(x - CROSS_LENGTH, y), (x + CROSS_LENGTH, y)])
|
||||
pen.line([(x, y - CROSS_LENGTH), (x, y + CROSS_LENGTH)])
|
||||
|
||||
|
||||
def _graticule_labels(plan: SheetPlan) -> Tuple[List[Tuple[float, float]], List[Tuple[float, float]]]:
|
||||
"""Where along the top and bottom (x), and the sides (y), the margin is taken by a coordinate: each a
|
||||
(low, high) the grid's labels keep out of."""
|
||||
x0, y0, x1, y1 = plan.map_rect
|
||||
west, south, east, north = plan.bounds
|
||||
corner = _text_width(format_angle(-179.875, 'E', 'W'), LABEL_SIZE) + 4
|
||||
tick = _text_width(format_angle(0.125, short=True), LABEL_SIZE) / 2 + 3
|
||||
across = [(x0 - 1, x0 + corner), (x1 - corner, x1 + 1)]
|
||||
for longitude in _multiples(graticule_interval(east - west), west, east):
|
||||
x = plan.point(north, longitude)[0]
|
||||
across.append((x - tick, x + tick))
|
||||
up = [(y0 - LABEL_SIZE, y0 + LABEL_SIZE), (y1 - LABEL_SIZE, y1 + LABEL_SIZE)]
|
||||
for latitude in _multiples(graticule_interval(north - south), south, north):
|
||||
y = plan.point(latitude, west)[1]
|
||||
up.append((y - LABEL_SIZE, y + LABEL_SIZE))
|
||||
return across, up
|
||||
|
||||
|
||||
def _draw_grid(pen: _Pen, plan: SheetPlan):
|
||||
"""The UTM grid over the map, and what each of its lines is in the margin."""
|
||||
x0, y0, x1, y1 = plan.map_rect
|
||||
zone, south = plan.zone, plan.south_hemisphere
|
||||
meters = _grid_meters(plan)
|
||||
(low_e, high_e), (low_n, high_n) = _utm_extent(plan)
|
||||
taken_across, taken_up = _graticule_labels(plan)
|
||||
beside = LABEL_SIZE * 0.35
|
||||
# A line of the grid is not quite straight on the map, so it is drawn through this many places.
|
||||
steps = 24
|
||||
|
||||
def free(position: float, half: float, taken: List[Tuple[float, float]]) -> bool:
|
||||
return all(position + half < low or position - half > high for low, high in taken)
|
||||
|
||||
# On each edge of the map the first line which is named is named in full (339000mE), and the others by their
|
||||
# kilometers (340).
|
||||
named = set()
|
||||
|
||||
def label(value: int, edge: str, letter: str) -> str:
|
||||
return f'{value // 1000}' if edge in named else f'{value}m{letter}'
|
||||
|
||||
for easting in range(math.ceil(low_e / meters) * meters, math.floor(high_e / meters) * meters + 1, meters):
|
||||
northings = [low_n - meters + i * (high_n - low_n + 2 * meters) / steps for i in range(steps + 1)]
|
||||
points = [plan.point(*from_utm(easting, northing, zone, south)) for northing in northings]
|
||||
for piece in _clip(points, plan.map_rect):
|
||||
pen.line(piece, width=0.4, color=GRID_COLOR, opacity=0.7)
|
||||
for x, y in (piece[0], piece[-1]):
|
||||
if abs(y - y0) > 0.01 and abs(y - y1) > 0.01:
|
||||
continue
|
||||
edge = 'top' if abs(y - y0) <= 0.01 else 'bottom'
|
||||
text = label(easting, edge, 'E')
|
||||
if not free(x, _text_width(text, LABEL_SIZE) / 2 + 2, taken_across):
|
||||
continue
|
||||
pen.text(x, y0 - 4 if edge == 'top' else y1 + LABEL_SIZE + 3, text, align='center',
|
||||
color=GRID_COLOR)
|
||||
named.add(edge)
|
||||
|
||||
for northing in range(math.ceil(low_n / meters) * meters, math.floor(high_n / meters) * meters + 1, meters):
|
||||
eastings = [low_e - meters + i * (high_e - low_e + 2 * meters) / steps for i in range(steps + 1)]
|
||||
points = [plan.point(*from_utm(easting, northing, zone, south)) for easting in eastings]
|
||||
for piece in _clip(points, plan.map_rect):
|
||||
pen.line(piece, width=0.4, color=GRID_COLOR, opacity=0.7)
|
||||
for x, y in (piece[0], piece[-1]):
|
||||
if abs(x - x0) > 0.01 and abs(x - x1) > 0.01 or not free(y, LABEL_SIZE / 2, taken_up):
|
||||
continue
|
||||
edge = 'left' if abs(x - x0) <= 0.01 else 'right'
|
||||
text = label(northing, edge, 'N')
|
||||
if edge == 'left':
|
||||
pen.text(x0 - 3, y + beside, text, align='right', color=GRID_COLOR)
|
||||
else:
|
||||
pen.text(x1 + 3, y + beside, text, color=GRID_COLOR)
|
||||
named.add(edge)
|
||||
|
||||
|
||||
def _draw_scale_bar(pen: _Pen, center: float, y: float, unit: float, name: str, most: int, parts: int,
|
||||
available: float, number=str) -> float:
|
||||
"""A bar which is `unit` points for each unit of distance, with its top at `y`. It has one unit left of its
|
||||
zero, divided in `parts`, and as many to the right as there is room for, up to `most`. Returns how long the
|
||||
bar is: nothing, when there is no room for it."""
|
||||
count = min(most, int(available // unit) - 1)
|
||||
if count < 1:
|
||||
return 0
|
||||
left = center - (count + 1) * unit / 2
|
||||
zero = left + unit
|
||||
for i in range(parts):
|
||||
fill = BLACK if i % 2 == 0 else None
|
||||
pen.box((left + i * unit / parts, y, left + (i + 1) * unit / parts, y + BAR_HEIGHT), fill=fill, width=0.4)
|
||||
for i in range(count):
|
||||
fill = BLACK if i % 2 == 0 else None
|
||||
pen.box((zero + i * unit, y, zero + (i + 1) * unit, y + BAR_HEIGHT), fill=fill, width=0.4)
|
||||
pen.text(left, y - 2.5, number(1), align='center')
|
||||
for i in range(count + 1):
|
||||
pen.text(zero + i * unit, y - 2.5, number(i), align='center')
|
||||
pen.text(zero + count * unit + 12, y + BAR_HEIGHT, name)
|
||||
return (count + 1) * unit
|
||||
|
||||
|
||||
# The diagram of the norths: how long the line to each is (points), and the least and the most it is drawn from
|
||||
# straight up (degrees). The diagram shows which side each north is on, not how far: the angles are written.
|
||||
NORTH_LENGTHS = dict(true=62, magnetic=50, grid=38)
|
||||
NORTH_LEAST, NORTH_MOST = 7, 30
|
||||
# How wide the diagram is, with what is written beside its lines.
|
||||
NORTHS_WIDTH = 100
|
||||
|
||||
|
||||
def _north_tip(x: float, y: float, angle: float, length: float) -> Tuple[float, float]:
|
||||
"""Where the line to a north ends: drawn to its side of straight up, but never so near it, or so far from it,
|
||||
that it can not be told apart."""
|
||||
shown = math.radians(math.copysign(min(NORTH_MOST, max(NORTH_LEAST, abs(angle))), angle))
|
||||
return x + length * math.sin(shown), y - length * math.cos(shown)
|
||||
|
||||
|
||||
def _draw_norths(pen: _Pen, plan: SheetPlan, x: float, y: float):
|
||||
"""Which way true north, the grid's north and a compass's north are from each other, from a point at
|
||||
(`x`, `y`), with how far each is from true north written under it."""
|
||||
top = y - NORTH_LENGTHS['true']
|
||||
pen.line([(x, y), (x, top)], width=0.6)
|
||||
# True north is at a star.
|
||||
star = [(x + r * math.sin(math.radians(36 * i)), top - 5 - r * math.cos(math.radians(36 * i)))
|
||||
for i, r in zip(range(10), (5, 2) * 5)]
|
||||
pen.polygon(star)
|
||||
below = y + LABEL_SIZE + 4
|
||||
for name, angle, length in (('MN', plan.magnetic_north, NORTH_LENGTHS['magnetic']),
|
||||
('GN', plan.grid_north, NORTH_LENGTHS['grid'])):
|
||||
if angle is None:
|
||||
continue
|
||||
tip_x, tip_y = _north_tip(x, y, angle, length)
|
||||
pen.line([(x, y), (tip_x, tip_y)], width=0.6)
|
||||
east = angle >= 0
|
||||
pen.text(tip_x + (3 if east else -3), tip_y + 2, name, align='left' if east else 'right')
|
||||
pen.text(x, below, f'{name} {format_angle(_to_the_minute(abs(angle)))} {"E" if east else "W"}'
|
||||
f' {_mils(angle).upper()}', align='center')
|
||||
below += LABEL_SIZE + 2
|
||||
|
||||
|
||||
def _draw_adjoining(pen: _Pen, plan: SheetPlan, x: float, y: float):
|
||||
"""The quadrangles around the map: nine squares with the map the middle one, each of the others with a
|
||||
number, and beside them what each number is called. Its top left is at (`x`, `y`)."""
|
||||
pen.text(x, y + LABEL_SIZE, 'ADJOINING QUADRANGLES')
|
||||
top = y + LABEL_SIZE + 5
|
||||
side = ADJOINING_SQUARE
|
||||
pen.box((x + side, top + side, x + 2 * side, top + 2 * side), fill=ADJOINING_GRAY, width=0.4)
|
||||
for i in range(4):
|
||||
pen.line([(x + i * side, top), (x + i * side, top + 3 * side)], width=0.4)
|
||||
pen.line([(x, top + i * side), (x + 3 * side, top + i * side)], width=0.4)
|
||||
# The names are in two columns: as wide as a long name, or as the room beside the squares allows.
|
||||
left = x + 3 * side + 12
|
||||
column = min(ADJOINING_COLUMN, (plan.map_rect[2] - left) / 2)
|
||||
listed = 0
|
||||
for number, ((columns, rows), name) in enumerate(zip(ADJOINING, plan.adjoining), start=1):
|
||||
if not name:
|
||||
continue
|
||||
pen.text(x + (columns + 1.5) * side, top + (1.5 - rows) * side + LABEL_SIZE / 3, str(number), align='center')
|
||||
while _text_width(f'{number} {name}', LABEL_SIZE) > column - 6 and len(name) > 1:
|
||||
name = name[:-1]
|
||||
pen.text(left + (listed // 4) * column, top + LABEL_SIZE + (listed % 4) * (LABEL_SIZE + 2.5),
|
||||
f'{number} {name}')
|
||||
listed += 1
|
||||
|
||||
|
||||
def _draw_legend(pen: _Pen, plan: SheetPlan, x: float, y: float):
|
||||
"""What the lines of the map are: a piece of each as the map draws it, on the color of the map's land, with
|
||||
what it is called beside it. Its top left is at (`x`, `y`)."""
|
||||
pen.text(x, y + LABEL_SIZE, 'LEGEND')
|
||||
top = y + LABEL_SIZE + 8
|
||||
columns = _legend_columns(plan)
|
||||
for index, line in enumerate(plan.legend):
|
||||
left = x + (index % columns) * LEGEND_ITEM_WIDTH
|
||||
row = top + (index // columns) * LEGEND_ITEM_HEIGHT
|
||||
box = (left, row, left + LEGEND_SAMPLE, row + LEGEND_ITEM_HEIGHT - 3)
|
||||
pen.box(box, fill=plan.legend_ground, width=0.3, color=GRAY)
|
||||
middle = (box[1] + box[3]) / 2
|
||||
ends = [(left + 1, middle), (left + LEGEND_SAMPLE - 1, middle)]
|
||||
if line.casing_color and line.casing_width > line.width:
|
||||
pen.line(ends, width=line.casing_width, color=line.casing_color)
|
||||
pen.line(ends, width=line.width, color=line.color, opacity=line.opacity, dash=line.dash)
|
||||
# A name longer than the room beside its line is cut to it.
|
||||
label = line.label
|
||||
while _text_width(label, LABEL_SIZE) > LEGEND_ITEM_WIDTH - LEGEND_SAMPLE - 10 and len(label) > 1:
|
||||
label = label[:-1]
|
||||
pen.text(left + LEGEND_SAMPLE + 5, middle + LABEL_SIZE / 3, label)
|
||||
|
||||
|
||||
def _draw_margin(pen: _Pen, plan: SheetPlan):
|
||||
"""The title above the map, and the scale and the notes below it."""
|
||||
x0, y0, x1, y1 = plan.map_rect
|
||||
scale = _format_scale(plan.scale)
|
||||
title_y = y0 - 24
|
||||
if not plan.name:
|
||||
pen.text(x1, title_y, scale, size=TITLE_SIZE, font=BOLD, align='right')
|
||||
elif _text_width(plan.name, TITLE_SIZE, BOLD) + _text_width(scale, TITLE_SIZE, BOLD) + TITLE_GAP <= x1 - x0:
|
||||
pen.text(x0, title_y, plan.name, size=TITLE_SIZE, font=BOLD)
|
||||
pen.text(x1, title_y, scale, size=TITLE_SIZE, font=BOLD, align='right')
|
||||
else:
|
||||
# A map too narrow for both (a quadrangle near a pole is two inches wide) has the scale under the name.
|
||||
pen.text(x0, title_y - TITLE_LEADING, plan.name, size=TITLE_SIZE, font=BOLD)
|
||||
pen.text(x0, title_y, scale, size=TITLE_SIZE, font=BOLD)
|
||||
|
||||
center = (x0 + x1) / 2
|
||||
y = y1 + BARS_OFFSET
|
||||
pen.text(center, y - 16, f'SCALE {scale}', size=NOTE_SIZE + 1, align='center')
|
||||
# The room a bar has: the map's width, less the name of its unit on each side (so it stays centered).
|
||||
available = (x1 - x0) - 2 * (_text_width('KILOMETERS', LABEL_SIZE) + 14)
|
||||
meter = 1 / (plan.scale * METERS_PER_POINT)
|
||||
bars = [
|
||||
_draw_scale_bar(pen, center, y, 1000 * meter, 'KILOMETERS', 2, 10, available),
|
||||
_draw_scale_bar(pen, center, y + BAR_SPACING, 1000 * meter, 'METERS', 2, 2, available,
|
||||
number=lambda i: str(i * 1000)),
|
||||
_draw_scale_bar(pen, center, y + 2 * BAR_SPACING, METERS_PER_MILE * meter, 'MILES', 1, 4, available),
|
||||
_draw_scale_bar(pen, center, y + 3 * BAR_SPACING, 1000 * METERS_PER_FOOT * meter, 'FEET', 7, 2, available,
|
||||
number=lambda i: str(i * 1000)),
|
||||
]
|
||||
# The norths are left of the bars, where there is room for them.
|
||||
if (plan.grid_north is not None or plan.magnetic_north is not None) \
|
||||
and center - max(bars) / 2 - x0 >= NORTHS_WIDTH + 10:
|
||||
_draw_norths(pen, plan, x0 + NORTHS_WIDTH / 2, y + (BAR_COUNT - 1) * BAR_SPACING - 12)
|
||||
|
||||
y += BAR_COUNT * BAR_SPACING
|
||||
if plan.contours:
|
||||
pen.text(center, y - 4, plan.contours, size=NOTE_SIZE + 1, align='center')
|
||||
y += CONTOUR_LEADING
|
||||
if plan.adjoining:
|
||||
_draw_adjoining(pen, plan, x0, y - NOTE_LEADING)
|
||||
y += ADJOINING_HEIGHT
|
||||
if plan.legend:
|
||||
_draw_legend(pen, plan, x0, y - NOTE_LEADING)
|
||||
y += _legend_height(plan)
|
||||
for index, note in enumerate(plan.notes):
|
||||
pen.text(x0, y + index * NOTE_LEADING, note, size=NOTE_SIZE)
|
||||
|
||||
|
||||
def draw_sheet(doc, page, plan: SheetPlan):
|
||||
"""Draw the sheet on the page of a map: the grid over the map, and everything around it."""
|
||||
if plan.zone:
|
||||
grid = _Pen(page, doc.add_ocg(GRID_LAYER, on=True))
|
||||
_draw_grid(grid, plan)
|
||||
grid.commit()
|
||||
pen = _Pen(page, doc.add_ocg(SHEET_LAYER, on=True))
|
||||
_draw_graticule(pen, plan)
|
||||
_draw_margin(pen, plan)
|
||||
pen.commit()
|
||||
|
|
@ -294,6 +294,26 @@
|
|||
style: function(file) { return dataPath(file.style_map_path); },
|
||||
};
|
||||
|
||||
// How a terrain file is read (js/terrain.js, shared with the app's map viewer). Until it is
|
||||
// loaded, and if it can not be, a terrain file is read as the one WROLPi offers is.
|
||||
var Terrain = {
|
||||
terrainMaxZoom: function() { return 8; },
|
||||
contourThresholds: function(imperial) {
|
||||
return imperial
|
||||
? {4: [1000, 5000], 5: [500, 2500], 6: [200, 1000], 7: [200, 1000], 8: [100, 500]}
|
||||
: {4: [500, 2500], 5: [200, 1000], 6: [100, 500], 7: [100, 500], 8: [50, 200]};
|
||||
},
|
||||
};
|
||||
var terrainFile = null;
|
||||
var terrainZoom = 8;
|
||||
|
||||
function loadTerrain() {
|
||||
if (!hasTerrain) return Promise.resolve();
|
||||
return import("/js/terrain.js")
|
||||
.then(function(module) { Terrain = module; })
|
||||
.catch(function(err) { console.error("Deeper terrain is not available:", err); });
|
||||
}
|
||||
|
||||
function loadOverlays(files) {
|
||||
if (!files.length) return Promise.resolve();
|
||||
return Promise.all([import("/js/overlays.js"), import("/js/overlayStyle.js")])
|
||||
|
|
@ -409,6 +429,11 @@
|
|||
}
|
||||
}
|
||||
|
||||
// The labels of every basemap file are over the ground of every file (as labelsOverGround in
|
||||
// js/overlays.js, which may not have been loaded yet).
|
||||
allLayers = allLayers.filter(function(l) { return l.type !== "symbol"; })
|
||||
.concat(allLayers.filter(function(l) { return l.type === "symbol"; }));
|
||||
|
||||
// Terrain (hillshade + contours).
|
||||
if (hasTerrain && demSource) {
|
||||
var savedVis = getSavedVisibility();
|
||||
|
|
@ -444,13 +469,10 @@
|
|||
elevationKey: "ele",
|
||||
levelKey: "level",
|
||||
multiplier: isImperial ? 3.28084 : 1,
|
||||
thresholds: isImperial ? {
|
||||
4: [1000, 5000], 5: [500, 2500], 6: [200, 1000], 7: [200, 1000], 8: [100, 500],
|
||||
} : {
|
||||
4: [500, 2500], 5: [200, 1000], 6: [100, 500], 7: [100, 500], 8: [50, 200],
|
||||
},
|
||||
// As fine as the terrain file can bear (js/terrain.js).
|
||||
thresholds: Terrain.contourThresholds(isImperial, terrainZoom),
|
||||
});
|
||||
sources["contours"] = { type: "vector", tiles: [contourUrl], maxzoom: 8 };
|
||||
sources["contours"] = { type: "vector", tiles: [contourUrl], maxzoom: terrainZoom };
|
||||
|
||||
var textColor = flavor === "dark" ? "rgba(210,180,140,0.9)" : "rgba(150,100,50,0.8)";
|
||||
var haloColor = flavor === "dark" ? "rgba(0,0,0,0.8)" : "rgba(255,255,255,0.8)";
|
||||
|
|
@ -954,6 +976,7 @@
|
|||
: (f.name.startsWith(TERRAIN_PREFIX) && f.name.endsWith('.pmtiles'));
|
||||
if (isTerrain) {
|
||||
terrainFileName = f.mapPath;
|
||||
terrainFile = f;
|
||||
hasTerrain = true;
|
||||
} else if (f.kind === "overlay") {
|
||||
// Not the basemap schema: offered in the layer panel, drawn as itself.
|
||||
|
|
@ -986,16 +1009,18 @@
|
|||
.then(function(r) { hasPlanetOverview = r.ok; })
|
||||
.catch(function() { hasPlanetOverview = false; })
|
||||
.then(function() { return loadOverlays(overlayCandidates); })
|
||||
.then(function() { return loadTerrain(); })
|
||||
.then(function() { return pmtilesFiles; });
|
||||
})
|
||||
.then(function(pmtilesFiles) {
|
||||
|
||||
// Initialize contour source if terrain available.
|
||||
if (hasTerrain && !demSource) {
|
||||
terrainZoom = Terrain.terrainMaxZoom(terrainFile);
|
||||
demSource = new mlcontour.DemSource({
|
||||
url: "pmtiles://" + window.location.origin + dataPath(terrainFileName),
|
||||
encoding: "terrarium",
|
||||
maxzoom: 8,
|
||||
maxzoom: terrainZoom,
|
||||
worker: true,
|
||||
});
|
||||
demSource.setupMaplibre(maplibregl);
|
||||
|
|
|
|||
|
|
@ -252,10 +252,17 @@ export function buildOverlayLayers(file, state) {
|
|||
return styleLayers;
|
||||
}
|
||||
|
||||
// The style layers of every overlay, in the order they are drawn. A raster overlay goes under the
|
||||
// basemap's labels (`rasters`) so the map stays readable; vector overlays go on top (`vectors`): an
|
||||
// overlay with its own style in that style's order, then the generic ones, fills under lines under
|
||||
// points.
|
||||
// Whether a layer of an overlay is of its labels: its text, its icons, and the points it marks. The
|
||||
// rest of an overlay is its ground: areas, lines, pictures.
|
||||
export function isOverlayLabelLayer(layer) {
|
||||
return layer?.type === "symbol" || layer?.type === "circle";
|
||||
}
|
||||
|
||||
// The style layers of every overlay, in the order they are drawn. Labels are always on top: the
|
||||
// ground of every overlay goes under the basemap's labels (`under`), so an area an overlay fills
|
||||
// does not cover the name of what is in it, and the labels of every overlay go over them (`over`).
|
||||
// In each, a raster is lowest, then an overlay with its own style in that style's order, then the
|
||||
// generic ones, fills under lines under points.
|
||||
export function orderOverlayLayers(overlays, state) {
|
||||
const rasters = [];
|
||||
const styled = [];
|
||||
|
|
@ -271,7 +278,49 @@ export function orderOverlayLayers(overlays, state) {
|
|||
else generic[layer.type].push(layer);
|
||||
}
|
||||
}
|
||||
return {rasters, vectors: [...styled, ...generic.fill, ...generic.line, ...generic.circle]};
|
||||
const vectors = [...styled, ...generic.fill, ...generic.line, ...generic.circle];
|
||||
return {
|
||||
under: [...rasters, ...vectors.filter(layer => !isOverlayLabelLayer(layer))],
|
||||
over: vectors.filter(isOverlayLabelLayer),
|
||||
};
|
||||
}
|
||||
|
||||
// The layers of a basemap with every label over all of its ground: the ground in the order it was
|
||||
// in, then the labels in the order they were in.
|
||||
//
|
||||
// A map of several basemap files is their layers one file after another, so the labels of each file
|
||||
// but the last are under the land, the water and the roads of the files after it, and under
|
||||
// anything which is put under "the labels". Labels are always on top.
|
||||
export function labelsOverGround(layers) {
|
||||
layers = layers || [];
|
||||
return [...layers.filter(l => l.type !== "symbol"), ...layers.filter(l => l.type === "symbol")];
|
||||
}
|
||||
|
||||
// The source of the contour lines both viewers draw from the terrain. They are added to a style
|
||||
// after the basemap's labels, lines and labels both, and are not of the basemap.
|
||||
const CONTOUR_SOURCE = "contours";
|
||||
|
||||
// Where the basemap's labels begin: the index of the first of the labels which are over all of the
|
||||
// basemap's ground. Where no label is over its ground, the index after the last of its ground.
|
||||
//
|
||||
// Not the map's first label: a map of several basemap files has the labels of the first file under
|
||||
// the ground of the next, and an overlay put there would be under the land and the water of every
|
||||
// file after the first. Nor before the last layer which is not a label: the contour lines are
|
||||
// drawn after the basemap's labels, and an overlay put under them would be over every label.
|
||||
export function basemapLabelsStart(layers) {
|
||||
layers = layers || [];
|
||||
const ofBasemap = layer => !isOverlayLayerId(layer.id) && layer.source !== CONTOUR_SOURCE;
|
||||
let lastGround = -1;
|
||||
for (let i = layers.length - 1; i >= 0; i--) {
|
||||
if (ofBasemap(layers[i]) && layers[i].type !== "symbol") {
|
||||
lastGround = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
for (let i = lastGround + 1; i < layers.length; i++) {
|
||||
if (ofBasemap(layers[i]) && layers[i].type === "symbol") return i;
|
||||
}
|
||||
return lastGround + 1;
|
||||
}
|
||||
|
||||
// Add the overlays to a style's sources and layers (the basemap's are already there).
|
||||
|
|
@ -279,10 +328,9 @@ export function addOverlaysToStyle(styleSources, allLayers, overlays, state, url
|
|||
for (const file of overlays || []) {
|
||||
styleSources[overlaySourceId(file)] = buildOverlaySource(file, urls);
|
||||
}
|
||||
const {rasters, vectors} = orderOverlayLayers(overlays, state);
|
||||
const firstLabel = allLayers.findIndex(l => l.type === "symbol");
|
||||
allLayers.splice(firstLabel === -1 ? allLayers.length : firstLabel, 0, ...rasters);
|
||||
allLayers.push(...vectors);
|
||||
const {under, over} = orderOverlayLayers(overlays, state);
|
||||
allLayers.splice(basemapLabelsStart(allLayers), 0, ...under);
|
||||
allLayers.push(...over);
|
||||
}
|
||||
|
||||
// Add the overlays to a map whose style has loaded, a layer at a time. For a viewer which cannot
|
||||
|
|
@ -295,8 +343,9 @@ export function addOverlaysToMap(map, overlays, state, urls) {
|
|||
const id = overlaySourceId(file);
|
||||
if (!map.getSource(id)) map.addSource(id, buildOverlaySource(file, urls));
|
||||
}
|
||||
const firstLabel = (map.getStyle()?.layers || []).find(l => l.type === "symbol");
|
||||
const {rasters, vectors} = orderOverlayLayers(overlays, state);
|
||||
const mapLayers = map.getStyle()?.layers || [];
|
||||
const firstLabel = mapLayers[basemapLabelsStart(mapLayers)];
|
||||
const {under, over} = orderOverlayLayers(overlays, state);
|
||||
const add = (layer, before) => {
|
||||
if (map.getLayer(layer.id)) return;
|
||||
try {
|
||||
|
|
@ -307,8 +356,8 @@ export function addOverlaysToMap(map, overlays, state, urls) {
|
|||
refused[mapPath] = (refused[mapPath] || 0) + 1;
|
||||
}
|
||||
};
|
||||
for (const layer of rasters) add(layer, firstLabel?.id);
|
||||
for (const layer of vectors) add(layer, undefined);
|
||||
for (const layer of under) add(layer, firstLabel?.id);
|
||||
for (const layer of over) add(layer, undefined);
|
||||
return refused;
|
||||
}
|
||||
|
||||
|
|
|
|||
59
modules/map/static/js/terrain.js
Normal file
59
modules/map/static/js/terrain.js
Normal file
|
|
@ -0,0 +1,59 @@
|
|||
// How the map reads a terrain (elevation) file: how deep into it to look, and how far apart the
|
||||
// contour lines are. Shared by the app's map viewer and the standalone viewer, which loads a copy
|
||||
// of this file as it is: no imports from the app, no dependencies.
|
||||
|
||||
// How deep the terrain file which WROLPi offers goes, and what a file is taken to be when it does
|
||||
// not say.
|
||||
export const DEFAULT_TERRAIN_MAX_ZOOM = 8;
|
||||
// No terrain file is read deeper than this.
|
||||
const DEEPEST_TERRAIN_ZOOM = 15;
|
||||
|
||||
// How far apart the contour lines are at each zoom of the map: [minor, major], in the unit the map
|
||||
// measures in. A zoom between two of these uses the one below it.
|
||||
//
|
||||
// A 1:24,000 sheet has a line every 40 feet (or 20 meters), which is what the deepest have: finer
|
||||
// lines than that are more than the terrain says, and more than a hillside has room for.
|
||||
const CONTOUR_FEET = {
|
||||
4: [1000, 5000], 5: [500, 2500], 6: [200, 1000], 7: [200, 1000], 8: [100, 500],
|
||||
9: [100, 500], 10: [100, 500], 11: [40, 200], 12: [40, 200],
|
||||
};
|
||||
const CONTOUR_METERS = {
|
||||
4: [500, 2500], 5: [200, 1000], 6: [100, 500], 7: [100, 500], 8: [50, 200],
|
||||
9: [50, 200], 10: [50, 200], 11: [20, 100], 12: [20, 100],
|
||||
};
|
||||
|
||||
// How deep a terrain file goes: the deepest zoom it has tiles of. `file` is as the API lists it.
|
||||
export function terrainMaxZoom(file) {
|
||||
const zoom = Number(file && file.max_zoom);
|
||||
if (!Number.isInteger(zoom) || zoom < 1) return DEFAULT_TERRAIN_MAX_ZOOM;
|
||||
return Math.min(zoom, DEEPEST_TERRAIN_ZOOM);
|
||||
}
|
||||
|
||||
// The contour intervals for a terrain file which goes as deep as `maxZoom`.
|
||||
//
|
||||
// Only those the file can bear: lines 40 feet apart drawn from terrain too coarse for them are
|
||||
// drawn where no line is. A map zoomed in past the file's depth keeps the file's finest interval.
|
||||
export function contourThresholds(imperial, maxZoom) {
|
||||
const all = imperial ? CONTOUR_FEET : CONTOUR_METERS;
|
||||
const deepest = Number.isFinite(maxZoom) ? maxZoom : DEFAULT_TERRAIN_MAX_ZOOM;
|
||||
const lowest = Math.min(...Object.keys(all).map(Number));
|
||||
const thresholds = {};
|
||||
for (const [zoom, intervals] of Object.entries(all)) {
|
||||
// A file shallower than every interval still has contours: the coarsest.
|
||||
if (Number(zoom) <= deepest || Number(zoom) === lowest) thresholds[zoom] = intervals;
|
||||
}
|
||||
return thresholds;
|
||||
}
|
||||
|
||||
// How far apart the contour lines are on a map drawn at `zoom` from a terrain file which goes as
|
||||
// deep as `maxZoom`: [minor, major], or null when no line is drawn at that zoom.
|
||||
//
|
||||
// The lines of a map are made a tile at a time: for tiles of the map's zoom, or of the file's
|
||||
// deepest when the map is zoomed in past it, with the interval of the nearest zoom below.
|
||||
export function contourInterval(imperial, maxZoom, zoom) {
|
||||
const thresholds = contourThresholds(imperial, maxZoom);
|
||||
const deepest = Number.isFinite(maxZoom) ? maxZoom : DEFAULT_TERRAIN_MAX_ZOOM;
|
||||
const tileZoom = Math.min(Math.floor(zoom), deepest);
|
||||
const zooms = Object.keys(thresholds).map(Number).filter(i => i <= tileZoom);
|
||||
return zooms.length ? thresholds[Math.max(...zooms)] : null;
|
||||
}
|
||||
581
modules/map/test/test_export.py
Normal file
581
modules/map/test/test_export.py
Normal file
|
|
@ -0,0 +1,581 @@
|
|||
import io
|
||||
import json
|
||||
import math
|
||||
import re
|
||||
import subprocess
|
||||
import sys
|
||||
from http import HTTPStatus
|
||||
from unittest import mock
|
||||
|
||||
import pymupdf
|
||||
import pytest
|
||||
from PIL import Image
|
||||
|
||||
from modules.map import export
|
||||
from modules.map.export import ExportLayer, InvalidExport, build_layered_pdf
|
||||
from wrolpi.jobs import wait_for_job
|
||||
|
||||
WIDTH, HEIGHT = 60, 90
|
||||
|
||||
|
||||
def make_image(color=(200, 80, 20, 255), size=(WIDTH, HEIGHT), image_format='PNG', box=None) -> bytes:
|
||||
"""An image of a layer: transparent, with `color` in `box` (all of it by default)."""
|
||||
image = Image.new('RGBA', size, (0, 0, 0, 0))
|
||||
image.paste(color, box or (0, 0, *size))
|
||||
if image_format == 'JPEG':
|
||||
image = image.convert('RGB')
|
||||
data = io.BytesIO()
|
||||
image.save(data, image_format)
|
||||
return data.getvalue()
|
||||
|
||||
|
||||
BLANK = make_image(color=(0, 0, 0, 0))
|
||||
|
||||
|
||||
def layer_names(pdf: bytes) -> list:
|
||||
doc = pymupdf.open(stream=pdf, filetype='pdf')
|
||||
return [i['name'] for _, i in sorted(doc.get_ocgs().items())]
|
||||
|
||||
|
||||
def test_layers_are_pdf_layers():
|
||||
"""Each image of the map is in a PDF layer of its own, named and in the order given, on one page the size
|
||||
the map is at its DPI."""
|
||||
pdf = build_layered_pdf([
|
||||
ExportLayer('Background', make_image((240, 240, 230, 255))),
|
||||
ExportLayer('Water', make_image((60, 120, 220, 255), box=(0, 0, 30, 90))),
|
||||
ExportLayer('Satellite', make_image(image_format='JPEG')),
|
||||
], WIDTH, HEIGHT, dpi=300, title='40°15′N 105°07′30″W')
|
||||
|
||||
doc = pymupdf.open(stream=pdf, filetype='pdf')
|
||||
assert doc.page_count == 1
|
||||
page = doc[0]
|
||||
# 60x90 pixels at 300 DPI is 0.2x0.3 inches: 14.4x21.6 points.
|
||||
assert (round(page.rect.width, 3), round(page.rect.height, 3)) == (14.4, 21.6)
|
||||
assert layer_names(pdf) == ['Background', 'Water', 'Satellite']
|
||||
assert all(i['on'] for i in doc.get_ocgs().values())
|
||||
assert doc.metadata['title'] == '40°15′N 105°07′30″W'
|
||||
|
||||
# Every image fills the page, and is the picture it was given.
|
||||
images = page.get_image_info(xrefs=True)
|
||||
assert len(images) == 3
|
||||
for image in images:
|
||||
assert (image['width'], image['height']) == (WIDTH, HEIGHT)
|
||||
assert pymupdf.Rect(image['bbox']) == page.rect
|
||||
|
||||
# The page looks like the layers stacked: water over the background on the left... but the satellite image
|
||||
# is on top of both, and is all one color.
|
||||
pixmap = page.get_pixmap(dpi=300)
|
||||
assert pixmap.pixel(5, 5)[:3] == pixmap.pixel(55, 85)[:3]
|
||||
|
||||
|
||||
def test_layers_are_stacked_in_order():
|
||||
"""The first layer is at the bottom: what is above it covers it, and shows it where it is transparent."""
|
||||
pdf = build_layered_pdf([
|
||||
ExportLayer('Background', make_image((255, 255, 255, 255))),
|
||||
ExportLayer('Water', make_image((0, 0, 255, 255), box=(0, 0, 30, 90))),
|
||||
], WIDTH, HEIGHT, dpi=72)
|
||||
pixmap = pymupdf.open(stream=pdf, filetype='pdf')[0].get_pixmap(dpi=72)
|
||||
assert pixmap.pixel(10, 45) == (0, 0, 255)
|
||||
assert pixmap.pixel(50, 45) == (255, 255, 255)
|
||||
|
||||
|
||||
def test_hidden_layer_is_not_drawn():
|
||||
"""A layer of the PDF can be turned off, which is the point of there being layers."""
|
||||
pdf = build_layered_pdf([
|
||||
ExportLayer('Background', make_image((255, 255, 255, 255))),
|
||||
ExportLayer('Water', make_image((0, 0, 255, 255))),
|
||||
], WIDTH, HEIGHT, dpi=72)
|
||||
doc = pymupdf.open(stream=pdf, filetype='pdf')
|
||||
assert doc[0].get_pixmap(dpi=72).pixel(10, 45) == (0, 0, 255)
|
||||
|
||||
# As a reader does it: clear the layer's box in the list of layers.
|
||||
water, = [i['number'] for i in doc.layer_ui_configs() if i['text'] == 'Water']
|
||||
doc.set_layer_ui_config(water, action=2)
|
||||
assert doc[0].get_pixmap(dpi=72).pixel(10, 45) == (255, 255, 255)
|
||||
|
||||
|
||||
def test_blank_layer_is_left_out():
|
||||
"""A layer in which nothing was drawn (no tunnels in this quadrangle) is not a layer of the PDF."""
|
||||
pdf = build_layered_pdf([
|
||||
ExportLayer('Background', make_image()),
|
||||
ExportLayer('Roads - Tunnels', BLANK),
|
||||
ExportLayer('Labels', make_image(box=(1, 1, 2, 2))),
|
||||
], WIDTH, HEIGHT, dpi=300)
|
||||
assert layer_names(pdf) == ['Background', 'Labels']
|
||||
|
||||
with pytest.raises(InvalidExport, match='Nothing is drawn'):
|
||||
build_layered_pdf([ExportLayer('Roads - Tunnels', BLANK)], WIDTH, HEIGHT, dpi=300)
|
||||
|
||||
|
||||
@pytest.mark.parametrize('layers,width,height,dpi,error', [
|
||||
([], WIDTH, HEIGHT, 300, 'no layers'),
|
||||
([ExportLayer('A', make_image())] * (export.MAX_LAYERS + 1), WIDTH, HEIGHT, 300, 'more than'),
|
||||
# Not the size the map is said to be.
|
||||
([ExportLayer('A', make_image(size=(61, 90)))], WIDTH, HEIGHT, 300, '61x90'),
|
||||
# Not an image, and not a kind of image the map is drawn as.
|
||||
([ExportLayer('A', b'not an image')], WIDTH, HEIGHT, 300, 'not a readable image'),
|
||||
([ExportLayer('A', make_image(image_format='GIF'))], WIDTH, HEIGHT, 300, 'not a PNG or JPEG'),
|
||||
# Sizes no map is.
|
||||
([ExportLayer('A', make_image())], 0, HEIGHT, 300, '0x90'),
|
||||
([ExportLayer('A', make_image())], export.MAX_SIDE + 1, 10, 300, 'can not be exported'),
|
||||
([ExportLayer('A', make_image())], 10000, 10000, 300, 'can not be exported'),
|
||||
# Each layer is a size a map is, but all of them together are more than there is memory for.
|
||||
([ExportLayer('A', b'never decoded')] * 30, 6000, 8000, 300, 'too large to export'),
|
||||
([ExportLayer('A', make_image())], WIDTH, HEIGHT, 0, 'DPI'),
|
||||
([ExportLayer('A', make_image())], WIDTH, HEIGHT, 5000, 'DPI'),
|
||||
])
|
||||
def test_invalid_export(layers, width, height, dpi, error):
|
||||
with pytest.raises(InvalidExport, match=error):
|
||||
build_layered_pdf(layers, width, height, dpi)
|
||||
|
||||
|
||||
async def api_export(async_client, images, **meta):
|
||||
"""Export a map through the API, as the browser does: describe it, send the image of each layer, have the PDF
|
||||
made, and fetch it. Returns the response which ended it (the PDF's, or the first to refuse) and the Job's
|
||||
record (None when it did not get as far as a Job)."""
|
||||
meta = dict(dict(width=WIDTH, height=HEIGHT, dpi=300, layers=[name for name, _ in images]), **meta)
|
||||
request, response = await async_client.post('/api/map/export', json=meta)
|
||||
if response.status_code != HTTPStatus.CREATED:
|
||||
return response, None
|
||||
export_id = response.json['export_id']
|
||||
for index, (_, image) in enumerate(images):
|
||||
request, response = await async_client.post(f'/api/map/export/{export_id}/layer/{index}', content=image)
|
||||
if response.status_code != HTTPStatus.NO_CONTENT:
|
||||
return response, None
|
||||
request, response = await async_client.post(f'/api/map/export/{export_id}/start')
|
||||
if response.status_code != HTTPStatus.ACCEPTED:
|
||||
return response, None
|
||||
job = await wait_for_job(response.json['job_id'], timeout=60)
|
||||
request, response = await async_client.get(f'/api/map/export/{export_id}/pdf')
|
||||
return response, job
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_api_export_pdf(async_client):
|
||||
"""The images of a map's layers are sent, a Job makes the PDF of them, and the PDF is fetched."""
|
||||
response, job = await api_export(async_client, [
|
||||
('Background', make_image((240, 240, 230, 255))),
|
||||
('Roads - Tunnels', BLANK),
|
||||
('Water', make_image((60, 120, 220, 255), box=(0, 0, 30, 90))),
|
||||
], title='A quadrangle')
|
||||
assert job['status'] == 'complete', job
|
||||
assert job['progress'] == 100
|
||||
assert job['description'] == 'Map PDF: A quadrangle'
|
||||
assert response.status_code == HTTPStatus.OK, response.text
|
||||
assert response.headers['content-type'] == 'application/pdf'
|
||||
assert response.content.startswith(b'%PDF-')
|
||||
assert layer_names(response.content) == ['Background', 'Water']
|
||||
assert pymupdf.open(stream=response.content, filetype='pdf').metadata['title'] == 'A quadrangle'
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_api_export_pdf_invalid(async_client):
|
||||
"""What is not a map is refused before any image is sent, and why is said."""
|
||||
# No description of the map.
|
||||
request, response = await async_client.post('/api/map/export', content=b'not json')
|
||||
assert response.status_code == HTTPStatus.BAD_REQUEST
|
||||
assert 'description of the map' in response.json['error']
|
||||
request, response = await async_client.post('/api/map/export', json=['a', 'list'])
|
||||
assert response.status_code == HTTPStatus.BAD_REQUEST
|
||||
|
||||
# A description which is not of a map.
|
||||
response, _ = await api_export(async_client, [('A', make_image())], width='wide')
|
||||
assert response.status_code == HTTPStatus.BAD_REQUEST
|
||||
|
||||
# More than a PDF is made of: said at once, with nothing sent.
|
||||
response, _ = await api_export(async_client, [('A', make_image())], width=10000, height=10000)
|
||||
assert response.status_code == HTTPStatus.BAD_REQUEST
|
||||
assert '10000x10000' in response.json['error']
|
||||
response, _ = await api_export(async_client, [], layers=[])
|
||||
assert response.status_code == HTTPStatus.BAD_REQUEST
|
||||
assert 'no layers' in response.json['error']
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_api_export_layers(async_client):
|
||||
"""Only the images of the map's own layers are taken, and the PDF is not made until all of them are sent."""
|
||||
meta = dict(width=WIDTH, height=HEIGHT, dpi=300, layers=['A', 'B'])
|
||||
request, response = await async_client.post('/api/map/export', json=meta)
|
||||
export_id = response.json['export_id']
|
||||
layer, start = f'/api/map/export/{export_id}/layer', f'/api/map/export/{export_id}/start'
|
||||
|
||||
for index, content, error in (
|
||||
(2, make_image(), 'no layer 2'),
|
||||
(0, b'', 'empty'),
|
||||
(0, b'not an image', 'not a PNG or JPEG'),
|
||||
(0, make_image(image_format='GIF'), 'not a PNG or JPEG'),
|
||||
):
|
||||
request, response = await async_client.post(f'{layer}/{index}', content=content)
|
||||
assert response.status_code == HTTPStatus.BAD_REQUEST, error
|
||||
assert error in response.json['error']
|
||||
|
||||
# One of two layers.
|
||||
request, response = await async_client.post(f'{layer}/0', content=make_image())
|
||||
assert response.status_code == HTTPStatus.NO_CONTENT
|
||||
request, response = await async_client.post(start)
|
||||
assert response.status_code == HTTPStatus.CONFLICT
|
||||
assert '1 layers have not been sent: B' in response.json['error']
|
||||
request, response = await async_client.get(f'/api/map/export/{export_id}/pdf')
|
||||
assert response.status_code == HTTPStatus.CONFLICT
|
||||
assert 'not started' in response.json['error']
|
||||
|
||||
request, response = await async_client.post(f'{layer}/1', content=make_image(image_format='JPEG'))
|
||||
assert response.status_code == HTTPStatus.NO_CONTENT
|
||||
request, response = await async_client.post(start)
|
||||
assert response.status_code == HTTPStatus.ACCEPTED
|
||||
job_id = response.json['job_id']
|
||||
# Asked again, it is the same Job; and no more images are taken.
|
||||
request, response = await async_client.post(start)
|
||||
assert response.json['job_id'] == job_id
|
||||
request, response = await async_client.post(f'{layer}/0', content=make_image())
|
||||
assert response.status_code == HTTPStatus.BAD_REQUEST
|
||||
assert 'already being made' in response.json['error']
|
||||
|
||||
# Until the Job is done there is no PDF.
|
||||
request, response = await async_client.get(f'/api/map/export/{export_id}/pdf')
|
||||
assert response.status_code == HTTPStatus.CONFLICT
|
||||
assert (await wait_for_job(job_id, timeout=60))['status'] == 'complete'
|
||||
request, response = await async_client.get(f'/api/map/export/{export_id}/pdf')
|
||||
assert response.status_code == HTTPStatus.OK
|
||||
assert layer_names(response.content) == ['A', 'B']
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_api_export_unknown(async_client):
|
||||
"""An export which there is not, and an id which is not one."""
|
||||
for export_id in ('0' * 32, 'nothing', '..%2F..%2Fetc'):
|
||||
for method, url in (('post', f'/api/map/export/{export_id}/layer/0'),
|
||||
('post', f'/api/map/export/{export_id}/start'),
|
||||
('get', f'/api/map/export/{export_id}/pdf')):
|
||||
request, response = await getattr(async_client, method)(url)
|
||||
assert response.status_code == HTTPStatus.NOT_FOUND, url
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_api_export_job_fails(async_client):
|
||||
"""An image which is not of the map fails the Job, which says why; there is no PDF."""
|
||||
response, job = await api_export(async_client, [('A', make_image()), ('B', make_image(size=(10, 10)))])
|
||||
assert job['status'] == 'failed'
|
||||
assert '10x10' in job['error']
|
||||
assert response.status_code == HTTPStatus.CONFLICT
|
||||
assert 'failed' in response.json['error']
|
||||
|
||||
|
||||
def test_total_pixels_are_limited_before_decoding():
|
||||
"""The memory an export needs is the pixels of all its layers, which a small upload can be a great many of:
|
||||
it is refused without any image being opened."""
|
||||
with mock.patch('modules.map.export.Image.open') as image_open:
|
||||
with pytest.raises(InvalidExport, match='too large to export'):
|
||||
build_layered_pdf([ExportLayer(str(i), BLANK) for i in range(export.MAX_LAYERS)],
|
||||
export.MAX_SIDE // 4, export.MAX_SIDE // 4, dpi=300)
|
||||
image_open.assert_not_called()
|
||||
|
||||
# A quadrangle at 300 DPI near the equator, with every layer of a full layer control on, is within it.
|
||||
assert 24 * 5300 * 6900 <= export.MAX_TOTAL_PIXELS
|
||||
|
||||
|
||||
def test_pymupdf_is_not_imported_with_the_module():
|
||||
"""pymupdf is slow to import, and the API imports this module when it starts."""
|
||||
code = 'import sys, modules.map.api; print("pymupdf" in sys.modules)'
|
||||
result = subprocess.run([sys.executable, '-c', code], capture_output=True, text=True, timeout=120)
|
||||
assert result.returncode == 0, result.stderr
|
||||
assert result.stdout.strip().splitlines()[-1] == 'False'
|
||||
|
||||
|
||||
def test_images_are_compressed_as_they_are_added():
|
||||
"""The pixels of a layer are compressed in the PDF when the layer is added, not kept until it is written:
|
||||
kept, the layers of a quadrangle are more memory than a Raspberry Pi has to spare."""
|
||||
doc = pymupdf.open()
|
||||
page = doc.new_page(width=WIDTH, height=HEIGHT)
|
||||
export._insert_layer(doc, page, page.rect, ExportLayer('Satellite', make_image(image_format='JPEG')), {})
|
||||
export._insert_layer(doc, page, page.rect, ExportLayer('Water', make_image((0, 0, 255, 200), box=(0, 0, 30, 90))), {})
|
||||
|
||||
streams = [xref for xref in range(1, doc.xref_length()) if doc.xref_is_stream(xref)]
|
||||
images = [xref for xref in streams if doc.xref_get_key(xref, 'Subtype')[1] == '/Image']
|
||||
# The picture and its transparency, and the photograph.
|
||||
assert len(images) == 3
|
||||
assert sorted(doc.xref_get_key(xref, 'Filter')[1] for xref in images) \
|
||||
== ['/DCTDecode', '/FlateDecode', '/FlateDecode']
|
||||
|
||||
# And it is still the picture: blue, mostly opaque, over the left of the photograph.
|
||||
pixmap = page.get_pixmap(dpi=72, alpha=False)
|
||||
assert pixmap.pixel(50, 45) != pixmap.pixel(10, 45)
|
||||
|
||||
|
||||
# A quadrangle at Anchorage: west, south, east, north.
|
||||
ANCHORAGE = [-150.0, 61.125, -149.875, 61.25]
|
||||
|
||||
|
||||
def read_viewport(pdf: bytes) -> dict:
|
||||
"""What the first page of a PDF says of where it is: its /VP, as the text of each part."""
|
||||
doc = pymupdf.open(stream=pdf, filetype='pdf')
|
||||
page = doc[0]
|
||||
kind, viewports = doc.xref_get_key(page.xref, 'VP')
|
||||
assert kind == 'array', f'The page has no /VP: {kind} {viewports}'
|
||||
|
||||
def numbers(key):
|
||||
return [float(i) for i in re.search(rf'/{key}\s*\[([^]]*)]', viewports).group(1).split()]
|
||||
|
||||
return dict(
|
||||
text=viewports,
|
||||
bbox=numbers('BBox'), bounds=numbers('Bounds'), gpts=numbers('GPTS'), lpts=numbers('LPTS'),
|
||||
page=(page.rect.width, page.rect.height),
|
||||
)
|
||||
|
||||
|
||||
def test_pdf_says_where_it_is():
|
||||
"""With the edges of the map, the page has a geospatial viewport: all of the page, with the latitude and
|
||||
longitude of each of its corners, in a projection every reader knows."""
|
||||
pdf = build_layered_pdf([ExportLayer('Background', make_image())], WIDTH, HEIGHT, dpi=72,
|
||||
title='1:24,000 61°07′30″N 150°00′W', bounds=ANCHORAGE)
|
||||
viewport = read_viewport(pdf)
|
||||
|
||||
# All of the page.
|
||||
assert viewport['bbox'] == [0, 0, WIDTH, HEIGHT]
|
||||
# The corners, from the lower left of the page: upper left, lower left, lower right, upper right...
|
||||
assert viewport['lpts'] == viewport['bounds'] == [0, 1, 0, 0, 1, 0, 1, 1]
|
||||
# ...and where each is: latitude, then longitude.
|
||||
assert viewport['gpts'] == [61.25, -150, 61.125, -150, 61.125, -149.875, 61.25, -149.875]
|
||||
|
||||
text = viewport['text']
|
||||
assert '/Type/Viewport' in text.replace(' ', '') and '/Subtype/GEO' in text.replace(' ', '')
|
||||
# Mercator on the ellipsoid, in Esri's words: Adobe Acrobat puts every place of a page said to be in Web
|
||||
# Mercator at 0, 0.
|
||||
assert '/Type/PROJCS' in text.replace(' ', '') and '/EPSG 3395' in text
|
||||
assert 'PROJCS["WGS_1984_World_Mercator"' in text and 'PROJECTION["Mercator"]' in text
|
||||
assert '3857' not in text and 'Auxiliary_Sphere' not in text and 'Mercator_1SP' not in text
|
||||
|
||||
# It is still the PDF it was.
|
||||
assert layer_names(pdf) == ['Background']
|
||||
assert pymupdf.open(stream=pdf, filetype='pdf')[0].get_pixmap(dpi=72).pixel(5, 5) == (200, 80, 20)
|
||||
|
||||
|
||||
def test_corner_of_page_is_corner_of_map():
|
||||
"""A reader finds where a point of the page is from the corners: here, as a reader does it, in the
|
||||
projection the page says it is in."""
|
||||
pdf = build_layered_pdf([ExportLayer('Background', make_image())], WIDTH, HEIGHT, dpi=72, bounds=ANCHORAGE)
|
||||
viewport = read_viewport(pdf)
|
||||
|
||||
def mercator(latitude, longitude):
|
||||
return (math.radians(longitude) * 6378137,
|
||||
math.log(math.tan(math.pi / 4 + math.radians(latitude) / 2)) * 6378137)
|
||||
|
||||
def unmercator(x, y):
|
||||
return math.degrees(2 * math.atan(math.exp(y / 6378137)) - math.pi / 2), math.degrees(x / 6378137)
|
||||
|
||||
lpts, gpts = viewport['lpts'], viewport['gpts']
|
||||
corners = {(lpts[i], lpts[i + 1]): mercator(gpts[i], gpts[i + 1]) for i in range(0, 8, 2)}
|
||||
|
||||
def where(across, up):
|
||||
"""The latitude and longitude of a point of the page (0 to 1 from its lower left)."""
|
||||
(x0, y0), (x1, y1) = corners[(0, 0)], corners[(1, 1)]
|
||||
return unmercator(x0 + across * (x1 - x0), y0 + up * (y1 - y0))
|
||||
|
||||
assert where(0, 0) == pytest.approx((61.125, -150))
|
||||
assert where(1, 1) == pytest.approx((61.25, -149.875))
|
||||
# The middle of the page is the middle of the map in longitude, and north of its middle in latitude: the
|
||||
# further north, the more of the page a degree is.
|
||||
latitude, longitude = where(0.5, 0.5)
|
||||
assert longitude == pytest.approx(-149.9375)
|
||||
assert 61.1875 < latitude < 61.1877
|
||||
# The other two corners are the corners of the same rectangle.
|
||||
assert corners[(0, 1)] == pytest.approx((corners[(0, 0)][0], corners[(1, 1)][1]))
|
||||
assert corners[(1, 0)] == pytest.approx((corners[(1, 1)][0], corners[(0, 0)][1]))
|
||||
|
||||
|
||||
def test_pdf_without_edges_says_nothing_of_where_it_is():
|
||||
pdf = build_layered_pdf([ExportLayer('Background', make_image())], WIDTH, HEIGHT, dpi=72)
|
||||
doc = pymupdf.open(stream=pdf, filetype='pdf')
|
||||
assert doc.xref_get_key(doc[0].xref, 'VP')[0] == 'null'
|
||||
|
||||
|
||||
def test_viewport_name():
|
||||
"""The viewport is named as the map is; a name which is not ASCII is written so a PDF can hold it."""
|
||||
viewport = export.geospatial_viewport(10, 10, ANCHORAGE, 'A quadrangle (of a map)')
|
||||
assert '/Name (A quadrangle \\(of a map\\))' in viewport
|
||||
assert '/Name' not in export.geospatial_viewport(10, 10, ANCHORAGE)
|
||||
|
||||
pdf = build_layered_pdf([ExportLayer('Background', make_image())], WIDTH, HEIGHT, dpi=72,
|
||||
title='61°07′30″N', bounds=ANCHORAGE)
|
||||
name = re.search(r'/Name\s*<([0-9A-Fa-f]+)>', read_viewport(pdf)['text']).group(1)
|
||||
assert bytes.fromhex(name).decode('utf-16') == '61°07′30″N'
|
||||
|
||||
|
||||
@pytest.mark.parametrize('bounds', [
|
||||
[-150, 61.125, -149.875], # Three edges.
|
||||
'here',
|
||||
[-150, 61.125, -149.875, 'north'],
|
||||
[-149.875, 61.125, -150, 61.25], # East of its east.
|
||||
[-150, 61.25, -149.875, 61.125], # North of its north.
|
||||
[-150, 61.125, -150, 61.25], # No width.
|
||||
[-190, 61.125, -149.875, 61.25], # Off the world.
|
||||
[179.875, 0, 180.00001, 0.125], # Across the antimeridian, if not by much.
|
||||
[179.9, 0, 180.1, 0.125],
|
||||
[-180.00001, 0, -179.875, 0.125],
|
||||
[-150, 61.125, -149.875, 89], # Further north than the map goes.
|
||||
[-150, float('nan'), -149.875, 61.25],
|
||||
])
|
||||
def test_invalid_bounds(bounds):
|
||||
with pytest.raises(InvalidExport, match='edges'):
|
||||
build_layered_pdf([ExportLayer('Background', make_image())], WIDTH, HEIGHT, dpi=72, bounds=bounds)
|
||||
|
||||
|
||||
@pytest.mark.parametrize('bounds,expected', [
|
||||
# The map's own arithmetic puts the edge of the world a hair past where it is.
|
||||
([179.875, 0, 180.00000000000125, 0.125], [179.875, 0, 180, 0.125]),
|
||||
([-180.00000000000125, 0, -179.875, 0.125], [-180, 0, -179.875, 0.125]),
|
||||
([-180, 0, -179.875, 0.125], [-180, 0, -179.875, 0.125]),
|
||||
])
|
||||
def test_bounds_at_the_antimeridian(bounds, expected):
|
||||
"""A map whose edge is the antimeridian is exported, with that edge at 180 degrees and not at -180."""
|
||||
pdf = build_layered_pdf([ExportLayer('Background', make_image())], WIDTH, HEIGHT, dpi=72, bounds=bounds)
|
||||
west, south, east, north = expected
|
||||
assert read_viewport(pdf)['gpts'] == [north, west, south, west, south, east, north, east]
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_api_export_pdf_georeferenced(async_client):
|
||||
"""The edges of the map are sent with its description, and the PDF says where it is."""
|
||||
images = [('Background', make_image())]
|
||||
response, job = await api_export(async_client, images, bounds=ANCHORAGE)
|
||||
assert response.status_code == HTTPStatus.OK, response.text
|
||||
assert read_viewport(response.content)['gpts'] == [61.25, -150, 61.125, -150, 61.125, -149.875, 61.25, -149.875]
|
||||
|
||||
# Without them it is a PDF all the same.
|
||||
response, job = await api_export(async_client, images)
|
||||
assert response.status_code == HTTPStatus.OK
|
||||
|
||||
# Edges which are not those of a map are refused.
|
||||
response, job = await api_export(async_client, images, bounds=[0, 0, 0, 0])
|
||||
assert response.status_code == HTTPStatus.BAD_REQUEST
|
||||
assert 'edges' in response.json['error']
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_api_export_text_which_is_not_text(async_client):
|
||||
"""What is sent as the title of a map, or the name of a layer, may have in it what is no character (half of
|
||||
a pair, a NUL). It is taken out when the export begins: the Job, after every image is sent, is too late to
|
||||
find that a PDF can not have it."""
|
||||
body = json.dumps(dict(width=WIDTH, height=HEIGHT, dpi=300, title='A \ud800 map\x00', layers=['Ro\x00ads \ud800']))
|
||||
request, response = await async_client.post('/api/map/export', content=body)
|
||||
assert response.status_code == HTTPStatus.CREATED, response.json
|
||||
export_id = response.json['export_id']
|
||||
request, response = await async_client.post(f'/api/map/export/{export_id}/layer/0', content=make_image())
|
||||
assert response.status_code == HTTPStatus.NO_CONTENT
|
||||
request, response = await async_client.post(f'/api/map/export/{export_id}/start')
|
||||
job = await wait_for_job(response.json['job_id'], timeout=60)
|
||||
assert job['status'] == 'complete', job
|
||||
request, response = await async_client.get(f'/api/map/export/{export_id}/pdf')
|
||||
assert layer_names(response.content) == ['Roads ?']
|
||||
assert pymupdf.open(stream=response.content).metadata['title'] == 'A ? map'
|
||||
|
||||
|
||||
def test_images_of_one_name_are_one_pdf_layer():
|
||||
"""A layer of the map may be several images, with other layers drawn between them (the parks of the land
|
||||
are under the water, and its piers are over it). They are one layer of the PDF, and each is drawn where it
|
||||
was given: turning the layer off hides them all."""
|
||||
pdf = build_layered_pdf([
|
||||
ExportLayer('Land Cover', make_image((0, 200, 0, 255))),
|
||||
ExportLayer('Water', make_image((0, 0, 255, 255), box=(0, 0, 30, 90))),
|
||||
ExportLayer('Land Cover', make_image((90, 90, 90, 255), box=(0, 0, 10, 90))),
|
||||
], WIDTH, HEIGHT, dpi=300)
|
||||
assert layer_names(pdf) == ['Land Cover', 'Water']
|
||||
doc = pymupdf.open(stream=pdf, filetype='pdf')
|
||||
page = doc[0]
|
||||
assert len(page.get_images()) == 3
|
||||
|
||||
def color(x):
|
||||
pixmap = page.get_pixmap(dpi=300)
|
||||
return pixmap.pixel(x, 45)
|
||||
|
||||
# From the left: the pier over the water, the water over the park, the park.
|
||||
assert [color(x) for x in (5, 20, 50)] == [(90, 90, 90), (0, 0, 255), (0, 200, 0)]
|
||||
|
||||
|
||||
def _wkt_parameter(wkt: str, name: str) -> float:
|
||||
return float(re.search(rf'PARAMETER\["{name}",([-0-9.]+)]', wkt).group(1))
|
||||
|
||||
|
||||
def _read_as_a_reader_does(viewport: dict, wkt: str, latitude: float, longitude: float):
|
||||
"""Where on the page (across and up, 0 to 1) a reader of the PDF puts a place: it projects the corners it
|
||||
is given (/GPTS) in the projection it is told of (the WKT: Mercator on its spheroid), and the place, and puts
|
||||
the place between the corners as they are on the page (/LPTS)."""
|
||||
assert 'PROJECTION["Mercator"]' in wkt
|
||||
a, inverse_flattening = [float(i) for i in re.search(r'SPHEROID\["[^"]*",([0-9.]+),([0-9.]+)]', wkt).groups()]
|
||||
f = 1 / inverse_flattening
|
||||
e = math.sqrt(f * (2 - f))
|
||||
meridian = _wkt_parameter(wkt, 'Central_Meridian')
|
||||
# Mercator of one standard parallel: the scale is that of the parallel.
|
||||
parallel = math.radians(_wkt_parameter(wkt, 'Standard_Parallel_1'))
|
||||
k = math.cos(parallel) / math.sqrt(1 - (e * math.sin(parallel)) ** 2)
|
||||
|
||||
def project(lat, lon):
|
||||
phi = math.radians(lat)
|
||||
y = math.log(math.tan(math.pi / 4 + phi / 2) * ((1 - e * math.sin(phi)) / (1 + e * math.sin(phi))) ** (e / 2))
|
||||
return (a * k * math.radians(lon - meridian) + _wkt_parameter(wkt, 'False_Easting'),
|
||||
a * k * y + _wkt_parameter(wkt, 'False_Northing'))
|
||||
|
||||
gpts, lpts = viewport['gpts'], viewport['lpts']
|
||||
corners = [(project(gpts[i], gpts[i + 1]), (lpts[i], lpts[i + 1])) for i in range(0, 8, 2)]
|
||||
# The page is a rectangle of the projection, so three corners say where the rest of it is.
|
||||
(upper_left, page_ul), (lower_left, page_ll), (lower_right, page_lr), _ = corners
|
||||
x, y = project(latitude, longitude)
|
||||
across = (x - lower_left[0]) / (lower_right[0] - lower_left[0])
|
||||
up = (y - lower_left[1]) / (upper_left[1] - lower_left[1])
|
||||
return (page_ll[0] + across * (page_lr[0] - page_ll[0]), page_ll[1] + up * (page_ul[1] - page_ll[1]))
|
||||
|
||||
|
||||
def _drawn(bounds, latitude: float, longitude: float):
|
||||
"""Where on the page (across and up, 0 to 1) the map has a place: it is drawn in Web Mercator."""
|
||||
west, south, east, north = bounds
|
||||
|
||||
def y(lat):
|
||||
return math.log(math.tan(math.pi / 4 + math.radians(lat) / 2))
|
||||
|
||||
return (longitude - west) / (east - west), (y(latitude) - y(south)) / (y(north) - y(south))
|
||||
|
||||
|
||||
@pytest.mark.parametrize('west,south', [(-78.5, 0), (-100, 20), (-105.125, 40.25), (-149.625, 61.25), (-156.75, 71.25),
|
||||
(151.125, -33.875), (10, 84.875), (-0.0625, -0.0625)])
|
||||
def test_page_is_where_the_projection_it_is_said_to_be_in_puts_it(west, south):
|
||||
"""The page is drawn in Web Mercator (a sphere), and a reader is told it is Mercator on the ellipsoid, with
|
||||
the latitude and longitude of its corners. A reader puts a place on the page by where that projection has
|
||||
it between the corners: that is within 5 centimeters on the ground of where the map drew it, anywhere on a
|
||||
quadrangle, at any latitude. What the reader is told is what the PDF says: its corners and its WKT."""
|
||||
bounds = [west, south, west + 0.125, south + 0.125]
|
||||
pdf = build_layered_pdf([ExportLayer('Background', make_image())], WIDTH, HEIGHT, dpi=72, bounds=bounds)
|
||||
viewport = read_viewport(pdf)
|
||||
wkt = re.search(r'/WKT\s*\((.*)\)\s*>>', viewport['text'], re.S).group(1)
|
||||
|
||||
# The page is this wide and this tall on the ground.
|
||||
height = 6378137 * math.radians(0.125)
|
||||
width = height * math.cos(math.radians(south + 0.0625))
|
||||
worst = 0
|
||||
for i in range(21):
|
||||
for j in range(21):
|
||||
lat, lon = south + 0.125 * i / 20, west + 0.125 * j / 20
|
||||
read = _read_as_a_reader_does(viewport, wkt, lat, lon)
|
||||
drawn = _drawn(bounds, lat, lon)
|
||||
worst = max(worst, math.hypot((read[0] - drawn[0]) * width, (read[1] - drawn[1]) * height))
|
||||
assert worst < 0.05
|
||||
|
||||
# The same sum finds a page whose corners are not where they are said to be: here, a second of arc south.
|
||||
moved = dict(viewport, gpts=[v - 1 / 3600 if index % 2 == 0 else v for index, v in enumerate(viewport['gpts'])])
|
||||
middle = (south + 0.0625, west + 0.0625)
|
||||
off = _read_as_a_reader_does(moved, wkt, *middle)[1] - _drawn(bounds, *middle)[1]
|
||||
assert abs(off) * height == pytest.approx(31, abs=1)
|
||||
|
||||
|
||||
def test_page_taller_than_a_quadrangle_is_less_well_said():
|
||||
"""What is left between the two projections grows with the square of how tall the page is: centimeters on a
|
||||
quadrangle, more than a meter on a page a degree tall. (A page that tall is not exported yet.)"""
|
||||
def worst(tall):
|
||||
bounds = [-150, 61, -149, 61 + tall]
|
||||
viewport = dict(gpts=[bounds[3], bounds[0], bounds[1], bounds[0], bounds[1], bounds[2], bounds[3], bounds[2]],
|
||||
lpts=[0, 1, 0, 0, 1, 0, 1, 1])
|
||||
height = 6378137 * math.radians(tall)
|
||||
return max(abs(_read_as_a_reader_does(viewport, export.PAGE_PROJECTION_WKT, 61 + tall * i / 40, -149.5)[1]
|
||||
- _drawn(bounds, 61 + tall * i / 40, -149.5)[1]) * height for i in range(41))
|
||||
|
||||
assert worst(0.125) < 0.05
|
||||
assert 1 < worst(1) < 2
|
||||
422
modules/map/test/test_export_job.py
Normal file
422
modules/map/test/test_export_job.py
Normal file
|
|
@ -0,0 +1,422 @@
|
|||
import asyncio
|
||||
import json
|
||||
import os
|
||||
import stat
|
||||
import threading
|
||||
import time
|
||||
from http import HTTPStatus
|
||||
|
||||
import pytest
|
||||
|
||||
from modules.map import export, export_job
|
||||
from modules.map.test.test_export import make_image
|
||||
from wrolpi import jobs
|
||||
|
||||
WIDTH, HEIGHT = 60, 90
|
||||
|
||||
|
||||
def new_export(*names, **kwargs) -> str:
|
||||
return export_job.create_export(list(names), WIDTH, HEIGHT, 300, **kwargs)
|
||||
|
||||
|
||||
def test_create_export(map_export_root):
|
||||
"""An export is a directory which holds what was said of the map."""
|
||||
export_id = new_export('Background', 'Water', title='A quadrangle', bounds=[-150, 61.125, -149.875, 61.25],
|
||||
sheet=export.Sheet(name='A quadrangle', credits=['Somebody'], date='2026-11-15'))
|
||||
assert export_job.EXPORT_ID.match(export_id)
|
||||
meta = json.loads((map_export_root / export_id / 'meta.json').read_text())
|
||||
assert meta['layers'] == ['Background', 'Water']
|
||||
assert meta['sheet'] == dict(name='A quadrangle', credits=['Somebody'], date='2026-11-15',
|
||||
contour_interval=None, contour_unit=None, legend=None)
|
||||
assert meta['job_id'] is None
|
||||
|
||||
# A map which can not be exported is not begun.
|
||||
with pytest.raises(export.InvalidExport, match='no layers'):
|
||||
new_export()
|
||||
with pytest.raises(export.InvalidExport, match='edges of the map are needed'):
|
||||
new_export('A', sheet=export.Sheet())
|
||||
assert len(list(map_export_root.iterdir())) == 1
|
||||
|
||||
|
||||
@pytest.mark.parametrize('export_id', ['0' * 32, '', 'nothing', '../' + '0' * 29, '0' * 31 + '/', None])
|
||||
def test_unknown_export(export_id, map_export_root):
|
||||
"""An id which was not given by an export is of no export, whatever it would be as a path."""
|
||||
map_export_root.mkdir()
|
||||
(map_export_root.parent / 'meta.json').write_text('{}')
|
||||
with pytest.raises(export_job.ExportNotFound):
|
||||
export_job.save_layer(export_id, 0, make_image())
|
||||
with pytest.raises(export_job.ExportNotFound):
|
||||
export_job.get_export_pdf(export_id)
|
||||
|
||||
|
||||
def age(directory, seconds=export_job.EXPORT_KEEP_SECONDS + 60):
|
||||
"""Make an export look as old as that."""
|
||||
then = time.time() - seconds
|
||||
os.utime(directory, (then, then))
|
||||
|
||||
|
||||
def test_remove_old_exports(map_export_root, monkeypatch):
|
||||
"""An export is removed when it is old; a new export is when that is looked for."""
|
||||
old, new = new_export('A'), new_export('A')
|
||||
export_job.save_layer(old, 0, make_image())
|
||||
age(map_export_root / old)
|
||||
(map_export_root / 'a file which is not an export').write_text('left alone')
|
||||
|
||||
newest = new_export('A')
|
||||
assert sorted(i.name for i in map_export_root.iterdir() if i.is_dir()) == sorted([new, newest])
|
||||
assert (map_export_root / 'a file which is not an export').is_file()
|
||||
with pytest.raises(export_job.ExportNotFound):
|
||||
export_job.start_export(old)
|
||||
|
||||
# Nothing to remove, and nowhere to look, are not errors; and looking does not make the directory.
|
||||
export_job.remove_old_exports()
|
||||
monkeypatch.setattr(export_job, 'EXPORT_ROOT', map_export_root / 'not made yet')
|
||||
export_job.remove_old_exports()
|
||||
assert not (map_export_root / 'not made yet').exists()
|
||||
|
||||
|
||||
def test_only_exports_are_removed(map_export_root, tmp_path):
|
||||
"""What is old in the directory of exports, and is not an export, is left: a directory by another name, and a
|
||||
link by an export's name to a directory somewhere else."""
|
||||
new_export('A')
|
||||
other = map_export_root / 'someone-elses-directory'
|
||||
other.mkdir()
|
||||
(other / 'file').write_text('kept')
|
||||
elsewhere = tmp_path / 'elsewhere'
|
||||
elsewhere.mkdir()
|
||||
(elsewhere / 'precious').write_text('kept')
|
||||
link = map_export_root / ('f' * 32)
|
||||
link.symlink_to(elsewhere, target_is_directory=True)
|
||||
for path in (other, elsewhere):
|
||||
age(path)
|
||||
|
||||
export_job.remove_old_exports()
|
||||
assert (other / 'file').read_text() == 'kept'
|
||||
assert (elsewhere / 'precious').read_text() == 'kept'
|
||||
# And a link is not an export.
|
||||
with pytest.raises(export_job.ExportNotFound):
|
||||
export_job.save_layer('f' * 32, 0, make_image())
|
||||
|
||||
|
||||
def test_export_directory_is_this_users(map_export_root, tmp_path, monkeypatch):
|
||||
"""Exports are kept in a directory made for this user alone, and never through a link: anyone may make things
|
||||
in /var/tmp, and a link there would have exports written, and old ones removed, wherever it leads."""
|
||||
export_id = new_export('A')
|
||||
assert stat.S_IMODE(map_export_root.stat().st_mode) == 0o700
|
||||
assert stat.S_IMODE((map_export_root / export_id).stat().st_mode) == 0o700
|
||||
|
||||
# One which others could read is closed to them when it is next used.
|
||||
os.chmod(map_export_root, 0o755)
|
||||
new_export('A')
|
||||
assert stat.S_IMODE(map_export_root.stat().st_mode) == 0o700
|
||||
|
||||
# A link where the directory should be.
|
||||
elsewhere = tmp_path / 'elsewhere'
|
||||
(elsewhere / ('a' * 32)).mkdir(parents=True)
|
||||
age(elsewhere / ('a' * 32))
|
||||
linked = tmp_path / 'linked-root'
|
||||
linked.symlink_to(elsewhere, target_is_directory=True)
|
||||
monkeypatch.setattr(export_job, 'EXPORT_ROOT', linked)
|
||||
with pytest.raises(export_job.ExportStorageError):
|
||||
new_export('A')
|
||||
with pytest.raises(export_job.ExportStorageError):
|
||||
export_job.remove_old_exports()
|
||||
with pytest.raises(export_job.ExportStorageError):
|
||||
export_job.save_layer('a' * 32, 0, make_image())
|
||||
# Nothing was made, or removed, where the link leads.
|
||||
assert [i.name for i in elsewhere.iterdir()] == ['a' * 32]
|
||||
|
||||
# A file where the directory should be.
|
||||
not_a_directory = tmp_path / 'a-file'
|
||||
not_a_directory.write_text('')
|
||||
monkeypatch.setattr(export_job, 'EXPORT_ROOT', not_a_directory)
|
||||
with pytest.raises(export_job.ExportStorageError):
|
||||
new_export('A')
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_exports_of_waiting_jobs_are_kept(async_client, map_export_root):
|
||||
"""An export whose Job is waiting is kept however old it is: it may wait behind another Job for longer than an
|
||||
export is kept, and its images are what the Job is to work from. One whose Job was cancelled is removed at
|
||||
once."""
|
||||
waiting, cancelled, finished = new_export('A'), new_export('A'), new_export('A')
|
||||
for export_id in (waiting, cancelled, finished):
|
||||
export_job.save_layer(export_id, 0, make_image())
|
||||
await jobs.wait_for_job(export_job.start_export(finished), timeout=60)
|
||||
# Queued, and not run: nothing takes Jobs from the queue in a test until one is waited for.
|
||||
waiting_job = export_job.start_export(waiting)
|
||||
jobs.cancel_job(export_job.start_export(cancelled))
|
||||
for export_id in (waiting, finished):
|
||||
age(map_export_root / export_id)
|
||||
|
||||
export_job.remove_old_exports()
|
||||
assert sorted(i.name for i in map_export_root.iterdir()) == [waiting]
|
||||
assert (map_export_root / waiting / 'layer-000').is_file()
|
||||
|
||||
# It is still there for its Job, which makes the PDF.
|
||||
assert (await jobs.wait_for_job(waiting_job, timeout=60))['status'] == 'complete'
|
||||
assert export_job.get_export_pdf(waiting).is_file()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_remove_export(async_client, map_export_root):
|
||||
"""An export which is stopped is removed, with the images which were sent, whatever step it was at."""
|
||||
# Before its PDF was asked for.
|
||||
export_id = new_export('A', 'B')
|
||||
export_job.save_layer(export_id, 0, make_image())
|
||||
request, response = await async_client.delete(f'/api/map/export/{export_id}')
|
||||
assert response.status_code == HTTPStatus.NO_CONTENT
|
||||
assert not (map_export_root / export_id).exists()
|
||||
request, response = await async_client.delete(f'/api/map/export/{export_id}')
|
||||
assert response.status_code == HTTPStatus.NOT_FOUND
|
||||
|
||||
# While its Job waited: the Job is cancelled, and never runs.
|
||||
export_id = new_export('A')
|
||||
export_job.save_layer(export_id, 0, make_image())
|
||||
job_id = export_job.start_export(export_id)
|
||||
export_job.remove_export(export_id)
|
||||
assert not (map_export_root / export_id).exists()
|
||||
assert (await jobs.wait_for_job(job_id, timeout=60))['status'] == 'cancelled'
|
||||
|
||||
# After its PDF was made.
|
||||
export_id = new_export('A')
|
||||
export_job.save_layer(export_id, 0, make_image())
|
||||
await jobs.wait_for_job(export_job.start_export(export_id), timeout=60)
|
||||
export_job.remove_export(export_id)
|
||||
assert not (map_export_root / export_id).exists()
|
||||
|
||||
with pytest.raises(export_job.ExportNotFound):
|
||||
export_job.remove_export('0' * 32)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_job_makes_the_pdf(async_client, map_export_root):
|
||||
"""The Job makes the PDF from the images, says how far along it is, and removes the images."""
|
||||
export_id = new_export('Background', 'Water', title='A quadrangle')
|
||||
export_job.save_layer(export_id, 0, make_image())
|
||||
export_job.save_layer(export_id, 1, make_image((0, 0, 255, 255), image_format='JPEG'))
|
||||
directory = map_export_root / export_id
|
||||
assert sorted(i.name for i in directory.iterdir()) == ['layer-000', 'layer-001', 'meta.json']
|
||||
|
||||
job_id = export_job.start_export(export_id)
|
||||
assert job_id.startswith('map_export_pdf-')
|
||||
job = await jobs.wait_for_job(job_id, timeout=60)
|
||||
assert job['status'] == 'complete', job
|
||||
assert job['progress'] == 100
|
||||
assert job['result']['export_id'] == export_id
|
||||
|
||||
pdf = export_job.get_export_pdf(export_id)
|
||||
assert pdf.read_bytes().startswith(b'%PDF-')
|
||||
assert job['result']['size'] == pdf.stat().st_size
|
||||
# Only what was said of the map, and the PDF, are kept.
|
||||
assert sorted(i.name for i in directory.iterdir()) == ['map.pdf', 'meta.json']
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_job_progress(async_client, map_export_root, monkeypatch):
|
||||
"""The Job says how far along it is as each layer is looked at and then put in the PDF."""
|
||||
seen = []
|
||||
real_set_progress = jobs.JobContext.set_progress
|
||||
|
||||
def set_progress(self, percent):
|
||||
seen.append(percent)
|
||||
real_set_progress(self, percent)
|
||||
|
||||
monkeypatch.setattr(jobs.JobContext, 'set_progress', set_progress)
|
||||
export_id = new_export('A', 'B')
|
||||
for index in range(2):
|
||||
export_job.save_layer(export_id, index, make_image())
|
||||
await jobs.wait_for_job(export_job.start_export(export_id), timeout=60)
|
||||
# And, with every step done, before and after the PDF is written: when the work may still be stopped.
|
||||
assert seen == [0, 25, 50, 75, 100, 100, 100]
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_job_fails(async_client, map_export_root):
|
||||
"""A map which can not be made into a PDF fails the Job; its images are removed all the same."""
|
||||
export_id = new_export('A', 'B')
|
||||
export_job.save_layer(export_id, 0, make_image())
|
||||
export_job.save_layer(export_id, 1, make_image(size=(10, 10)))
|
||||
job = await jobs.wait_for_job(export_job.start_export(export_id), timeout=60)
|
||||
assert job['status'] == 'failed'
|
||||
assert '10x10' in job['error']
|
||||
assert sorted(i.name for i in (map_export_root / export_id).iterdir()) == ['meta.json']
|
||||
with pytest.raises(export_job.ExportNotReady, match='failed'):
|
||||
export_job.get_export_pdf(export_id)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_job_cancelled(async_client, map_export_root, monkeypatch):
|
||||
"""A cancelled Job stops between two layers, makes no PDF, and removes the images. It is not over until the
|
||||
work has stopped: the next Job is not to start beside it."""
|
||||
export_id = new_export('A', 'B', 'C')
|
||||
for index in range(3):
|
||||
export_job.save_layer(export_id, index, make_image())
|
||||
job_id = export_job.start_export(export_id)
|
||||
|
||||
# The work is held while its first layer is looked at.
|
||||
real_check = export._check_layer
|
||||
checked, looking, go_on = [], threading.Event(), threading.Event()
|
||||
|
||||
def check_layer(layer, width, height):
|
||||
checked.append(layer.name)
|
||||
looking.set()
|
||||
assert go_on.wait(30)
|
||||
return real_check(layer, width, height)
|
||||
|
||||
monkeypatch.setattr(export, '_check_layer', check_layer)
|
||||
waiting = asyncio.ensure_future(jobs.wait_for_job(job_id, timeout=60))
|
||||
for _ in range(200):
|
||||
if looking.is_set():
|
||||
break
|
||||
await asyncio.sleep(0.02)
|
||||
assert looking.is_set()
|
||||
|
||||
# Cancelled, as from another process. (Not `cancel_job` here: it logs while it holds the Jobs' lock, and
|
||||
# this test's log is written to the running Job, which takes that lock.)
|
||||
jobs._update_job(job_id, cancel_requested=True)
|
||||
await asyncio.sleep(0.5)
|
||||
# The work has not stopped, so neither has the Job: its images are still there.
|
||||
assert jobs.get_job(job_id)['status'] == 'running'
|
||||
assert not waiting.done()
|
||||
assert (map_export_root / export_id / 'layer-000').is_file()
|
||||
|
||||
go_on.set()
|
||||
job = await waiting
|
||||
assert job['status'] == 'cancelled'
|
||||
# When the Job is over, so is the work: one layer was looked at, and the images are gone.
|
||||
assert checked == ['A']
|
||||
assert sorted(i.name for i in (map_export_root / export_id).iterdir()) == ['meta.json']
|
||||
with pytest.raises(export_job.ExportNotReady, match='cancelled'):
|
||||
export_job.get_export_pdf(export_id)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_job_cancelled_as_the_pdf_is_written(async_client, map_export_root, monkeypatch):
|
||||
"""A Job cancelled after its last layer, while the sheet is drawn or the PDF written, makes no PDF either."""
|
||||
export_id = new_export('A')
|
||||
export_job.save_layer(export_id, 0, make_image())
|
||||
job_id = export_job.start_export(export_id)
|
||||
real_insert = export._insert_layer
|
||||
|
||||
def insert_layer(*args):
|
||||
real_insert(*args)
|
||||
jobs._update_job(job_id, cancel_requested=True)
|
||||
|
||||
monkeypatch.setattr(export, '_insert_layer', insert_layer)
|
||||
job = await jobs.wait_for_job(job_id, timeout=60)
|
||||
assert job['status'] == 'cancelled'
|
||||
assert sorted(i.name for i in (map_export_root / export_id).iterdir()) == ['meta.json']
|
||||
|
||||
|
||||
def test_layers_are_read_one_at_a_time(tmp_path):
|
||||
"""A layer in a file is read when it is needed, not when the map is described."""
|
||||
path = tmp_path / 'layer'
|
||||
layer = export.ExportLayer('A', path=path)
|
||||
path.write_bytes(make_image())
|
||||
assert layer.read() == make_image()
|
||||
assert export.ExportLayer('A', image=b'given').read() == b'given'
|
||||
pdf = export.build_layered_pdf([layer], WIDTH, HEIGHT, 300)
|
||||
assert pdf.startswith(b'%PDF-')
|
||||
|
||||
|
||||
def test_progress_may_stop_the_work():
|
||||
"""What is told how far along the PDF is may stop it."""
|
||||
calls = []
|
||||
|
||||
def progress(done, steps):
|
||||
calls.append((done, steps))
|
||||
if done == 3:
|
||||
raise RuntimeError('enough')
|
||||
|
||||
layers = [export.ExportLayer(str(i), make_image()) for i in range(3)]
|
||||
with pytest.raises(RuntimeError, match='enough'):
|
||||
export.build_layered_pdf(layers, WIDTH, HEIGHT, 300, progress=progress)
|
||||
assert calls == [(0, 6), (1, 6), (2, 6), (3, 6)]
|
||||
|
||||
|
||||
class NeverCancelled:
|
||||
"""A Job which was not cancelled, as one is which ends because the API is stopping."""
|
||||
|
||||
@staticmethod
|
||||
def cancel_requested() -> bool:
|
||||
return False
|
||||
|
||||
@staticmethod
|
||||
def set_progress(_: float):
|
||||
pass
|
||||
|
||||
|
||||
def test_work_stops_when_it_is_told_to(map_export_root):
|
||||
"""The work of a Job which ended without being cancelled (the API is stopping) stops between two layers when
|
||||
it is told to: the API waits for it, and is not to wait for all of a PDF."""
|
||||
export_id = new_export('A', 'B')
|
||||
for index in range(2):
|
||||
export_job.save_layer(export_id, index, make_image())
|
||||
directory = map_export_root / export_id
|
||||
stop = threading.Event()
|
||||
stop.set()
|
||||
with pytest.raises(export_job.ExportCancelled):
|
||||
export_job._make_pdf(directory, NeverCancelled, stop)
|
||||
assert sorted(i.name for i in directory.iterdir()) == ['meta.json']
|
||||
# Not told to, it makes the PDF.
|
||||
export_id = new_export('A')
|
||||
export_job.save_layer(export_id, 0, make_image())
|
||||
export_job._make_pdf(map_export_root / export_id, NeverCancelled, threading.Event())
|
||||
assert sorted(i.name for i in (map_export_root / export_id).iterdir()) == ['map.pdf', 'meta.json']
|
||||
|
||||
|
||||
def test_files_of_an_export_are_written_whole(map_export_root, monkeypatch):
|
||||
"""What is said of an export, and each image, is all there or is what was there before: another request
|
||||
may read it while it is written. A write which fails leaves nothing behind."""
|
||||
export_id = new_export('A')
|
||||
directory = map_export_root / export_id
|
||||
before = (directory / 'meta.json').read_text()
|
||||
|
||||
def replace(*_):
|
||||
raise OSError('The disk is full')
|
||||
|
||||
with monkeypatch.context() as patch:
|
||||
patch.setattr(export_job.os, 'replace', replace)
|
||||
with pytest.raises(OSError):
|
||||
export_job.save_layer(export_id, 0, make_image())
|
||||
with pytest.raises(OSError):
|
||||
export_job._write_meta(directory, {'layers': []})
|
||||
assert sorted(i.name for i in directory.iterdir()) == ['meta.json']
|
||||
assert (directory / 'meta.json').read_text() == before
|
||||
export_job.save_layer(export_id, 0, make_image())
|
||||
assert sorted(i.name for i in directory.iterdir()) == ['layer-000', 'meta.json']
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_job_removes_old_exports(async_client, map_export_root):
|
||||
"""Old exports are removed when a PDF is made, as well as when an export begins: the last export of a day
|
||||
is not to keep the one before it."""
|
||||
old = new_export('A')
|
||||
export_id = new_export('A')
|
||||
age(map_export_root / old)
|
||||
export_job.save_layer(export_id, 0, make_image())
|
||||
job = await jobs.wait_for_job(export_job.start_export(export_id), timeout=60)
|
||||
assert job['status'] == 'complete'
|
||||
assert sorted(i.name for i in map_export_root.iterdir()) == [export_id]
|
||||
|
||||
|
||||
def test_image_which_arrives_after_its_export_is_removed(map_export_root, monkeypatch):
|
||||
"""An export may be removed while the image of a layer is on its way (the person exporting stopped it, and
|
||||
the request was already here). The image is not kept: nothing would ever use it, or remove it soon."""
|
||||
export_id = new_export('A', 'B')
|
||||
directory = map_export_root / export_id
|
||||
real_write = export_job._write_whole
|
||||
|
||||
def write_whole(path, contents):
|
||||
# Removed, as by another request, between this image being let in and being written.
|
||||
if path.name.startswith('layer-'):
|
||||
export_job.remove_export(export_id)
|
||||
path.parent.mkdir()
|
||||
real_write(path, contents)
|
||||
|
||||
monkeypatch.setattr(export_job, '_write_whole', write_whole)
|
||||
with pytest.raises(export_job.ExportNotFound):
|
||||
export_job.save_layer(export_id, 0, make_image())
|
||||
assert not directory.exists()
|
||||
assert list(map_export_root.iterdir()) == []
|
||||
50
modules/map/test/test_magnetic.py
Normal file
50
modules/map/test/test_magnetic.py
Normal file
|
|
@ -0,0 +1,50 @@
|
|||
import pytest
|
||||
|
||||
from modules.map import magnetic
|
||||
|
||||
# From the test values published with the model: year, altitude (km), latitude, longitude, declination, and the
|
||||
# field north, east and down (nT).
|
||||
TEST_VALUES = [
|
||||
(2025.0, 28, 89, -121, -99.77, -255.388723, -1482.460628, 56194.288771),
|
||||
(2025.0, 48, 80, -96, -29.91, 1875.982280, -1079.269389, 55623.044051),
|
||||
(2025.0, 54, 82, 87, 54.89, 1324.336929, 1883.428620, 56740.772059),
|
||||
(2025.0, 65, 43, 93, 0.50, 24299.852822, 210.517066, 50037.923998),
|
||||
(2025.0, 51, -33, 109, -5.49, 21737.778822, -2090.274098, -52710.003920),
|
||||
(2025.0, 39, -59, -8, -15.75, 14358.095523, -4049.107540, -24389.086374),
|
||||
(2025.0, 3, -50, -103, 27.96, 19526.532799, 10362.990980, -31437.562789),
|
||||
(2025.0, 94, -29, -110, 15.74, 23275.471080, 6559.046509, -19063.605287),
|
||||
(2025.0, 66, 14, 143, -0.19, 35003.441364, -116.624818, 7966.315182),
|
||||
(2025.0, 18, 0, 21, 1.29, 29274.811882, 659.800118, -14316.722540),
|
||||
(2025.5, 6, -36, -137, 20.28, 23781.930678, 8786.698927, -32577.518648),
|
||||
(2025.5, 63, 26, 81, 0.51, 34802.613433, 308.431881, 30332.056989),
|
||||
]
|
||||
|
||||
|
||||
def test_load_model():
|
||||
model = magnetic.load_model()
|
||||
assert (model.epoch, model.name, model.degree) == (2025.0, 'WMM-2025', 12)
|
||||
# Every harmonic of degrees 1 to 12.
|
||||
assert len(model.coefficients) == sum(n + 1 for n in range(1, 13))
|
||||
assert model.coefficients[0] == (1, 0, -29351.8, 0.0, 12.0, 0.0)
|
||||
assert model.coefficients[-1] == (12, 12, -0.7, 0.2, -0.1, -0.1)
|
||||
|
||||
|
||||
@pytest.mark.parametrize('year,altitude,latitude,longitude,declination,north,east,down', TEST_VALUES)
|
||||
def test_field(year, altitude, latitude, longitude, declination, north, east, down):
|
||||
"""The field is what the model's own test values say it is."""
|
||||
model = magnetic.load_model()
|
||||
assert model.field(latitude, longitude, year, altitude) == pytest.approx((north, east, down), abs=0.01)
|
||||
assert model.declination(latitude, longitude, year, altitude) == pytest.approx(declination, abs=0.006)
|
||||
|
||||
|
||||
def test_declination():
|
||||
"""A compass in Anchorage points well east of north; in Maine, west."""
|
||||
assert 13 < magnetic.declination(61.19, -149.94, 2026.87) < 16
|
||||
assert -17 < magnetic.declination(45.0, -69.0, 2026.87) < -13
|
||||
|
||||
|
||||
def test_declination_is_not_guessed():
|
||||
"""There is no declination in a year the model is not of."""
|
||||
assert magnetic.declination(61.19, -149.94, 2024.99) is None
|
||||
assert magnetic.declination(61.19, -149.94, 2030.0) is None
|
||||
assert magnetic.declination(61.19, -149.94, 2029.99) is not None
|
||||
112
modules/map/test/test_quads.py
Normal file
112
modules/map/test/test_quads.py
Normal file
|
|
@ -0,0 +1,112 @@
|
|||
from http import HTTPStatus
|
||||
|
||||
import pytest
|
||||
|
||||
from modules.map import quads
|
||||
|
||||
|
||||
def test_load_index():
|
||||
souths, rows = quads.load_index()
|
||||
assert souths == sorted(souths) == sorted(rows)
|
||||
count = 0
|
||||
for south in souths:
|
||||
wests, cells = quads._row(south)
|
||||
assert wests == sorted(wests) == [i[0] for i in cells]
|
||||
count += len(cells)
|
||||
assert count > 65_000
|
||||
|
||||
|
||||
@pytest.mark.parametrize('west,south,name,state', [
|
||||
(-105.125, 40.25, 'Berthoud', 'Colorado'),
|
||||
(-108.5, 37.75, 'South Mountain', 'Colorado'),
|
||||
(-76.375, 36.375, 'South Mills', 'North Carolina'),
|
||||
(-95.25, 37.375, 'South Mound', 'Kansas'),
|
||||
])
|
||||
def test_quad_name(west, south, name, state):
|
||||
"""A quadrangle of the grid has the name the USGS gives it."""
|
||||
assert quads.quad_name(west, south, west + 0.125, south + 0.125) == quads.QuadName(name, state, True)
|
||||
# Asked with the edges the map has, which are not quite those.
|
||||
assert quads.quad_name(west + 1e-7, south - 1e-7, west + 0.125, south + 0.125).exact
|
||||
|
||||
|
||||
def test_quad_name_in_alaska():
|
||||
"""A quadrangle in Alaska is wider than 7.5 minutes, so an area 7.5 minutes each way is a part of one."""
|
||||
assert quads.quad_name(-150, 61.125, -149.875, 61.25) == quads.QuadName('Anchorage A-8 NW', 'Alaska', False)
|
||||
# All of it, by its own edges.
|
||||
assert quads.quad_name(-150, 61.125, -149.8125, 61.25) == quads.QuadName('Anchorage A-8 NW', 'Alaska', True)
|
||||
# The area east of the first is the rest of that quadrangle, and the start of the next.
|
||||
assert quads.quad_name(-149.875, 61.125, -149.75, 61.25).name == 'Anchorage A-8 NE'
|
||||
|
||||
|
||||
@pytest.mark.parametrize('west,south,name,state', [
|
||||
# A quadrangle 11.25 minutes wide, which ends at the middle of this area: there is none east of it.
|
||||
(-153.25, 59.0, 'Iliamna A-1 SW', 'Alaska'),
|
||||
(-151.375, 59.0, 'Seldovia A-4 SW', 'Alaska'),
|
||||
# A quadrangle moved to fit an island, which ends at the middle of this area: there is none north of it.
|
||||
(145.625, 18.75, 'Agrigan Island', 'Northern Mariana Islands'),
|
||||
])
|
||||
def test_quad_name_at_an_outer_edge(west, south, name, state):
|
||||
"""An area half of which is a quadrangle, and the other half no quadrangle, is a part of that quadrangle:
|
||||
its middle is on the quadrangle's edge, not outside it."""
|
||||
found = quads.quad_name(west, south, west + 0.125, south + 0.125)
|
||||
assert found is not None
|
||||
assert (found.name, found.state, found.exact) == (name, state, False)
|
||||
|
||||
|
||||
def test_quad_name_at_a_shared_edge():
|
||||
"""A place on the edge two quadrangles share is in the one east, or north, of that edge."""
|
||||
assert quads.quad_name(-105.25, 40.25, -105, 40.375).name == 'Berthoud'
|
||||
assert quads.quad_name(-105.125, 40.125, -105, 40.375).name == 'Berthoud'
|
||||
|
||||
|
||||
def test_quad_name_at_a_shared_edge_the_map_gives():
|
||||
"""The edges the map gives are a hair from where they are. An area whose middle is that near the edge two
|
||||
quadrangles share is in the one east, or north, of that edge, whichever side of it the hair is."""
|
||||
assert quads.quad_name(-149.875, 61.125, -149.75, 61.25).name == 'Anchorage A-8 NE'
|
||||
# What the map gave for those edges.
|
||||
given = (-149.87500000000014, 61.12499878064878, -149.75000000000023, 61.25000121452442)
|
||||
assert quads.quad_name(*given).name == 'Anchorage A-8 NE'
|
||||
assert quads.quad_name(-105.25 - 1e-9, 40.25 - 1e-9, -105, 40.375).name == 'Berthoud'
|
||||
|
||||
|
||||
@pytest.mark.parametrize('west,south', [
|
||||
(0, 0),
|
||||
(151.125, -33.875), # Sydney.
|
||||
(-105.125, 30), # Mexico.
|
||||
(-40, 40), # The Atlantic.
|
||||
(-180, 84.875),
|
||||
])
|
||||
def test_quad_without_a_name(west, south):
|
||||
assert quads.quad_name(west, south, west + 0.125, south + 0.125) is None
|
||||
|
||||
|
||||
def test_every_quad_is_found():
|
||||
"""The middle of each quadrangle of the index is in a quadrangle of that name, or (where two lie over each
|
||||
other) of its neighbor's."""
|
||||
souths, rows = quads.load_index()
|
||||
missed = 0
|
||||
for south in souths[::7]:
|
||||
wests, cells = quads._row(south)
|
||||
for west, east, north, name, state in cells[::5]:
|
||||
found = quads.quad_name(west / 3600, south / 3600, east / 3600, north / 3600)
|
||||
assert found is not None, (name, state)
|
||||
missed += found.name != name
|
||||
assert missed <= 2
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_api_quad_name(async_client):
|
||||
request, response = await async_client.get('/api/map/quad?west=-105.125&south=40.25&east=-105&north=40.375')
|
||||
assert response.status_code == HTTPStatus.OK
|
||||
assert response.json == {'quad': {'name': 'Berthoud', 'state': 'Colorado', 'exact': True}}
|
||||
|
||||
# Somewhere the USGS has no name for is not an error.
|
||||
request, response = await async_client.get('/api/map/quad?west=0&south=0&east=0.125&north=0.125')
|
||||
assert response.status_code == HTTPStatus.OK
|
||||
assert response.json == {'quad': None}
|
||||
|
||||
for query in ('', '?west=-105.125&south=40.25&east=-105', '?west=a&south=b&east=c&north=d',
|
||||
'?west=-105.125&south=40.25&east=-113&north=40.375', '?west=nan&south=0&east=1&north=1',
|
||||
'?west=-500&south=0&east=1&north=1'):
|
||||
request, response = await async_client.get(f'/api/map/quad{query}')
|
||||
assert response.status_code == HTTPStatus.BAD_REQUEST, query
|
||||
737
modules/map/test/test_sheet.py
Normal file
737
modules/map/test/test_sheet.py
Normal file
|
|
@ -0,0 +1,737 @@
|
|||
import json
|
||||
import math
|
||||
import re
|
||||
from http import HTTPStatus
|
||||
|
||||
import pymupdf
|
||||
import pytest
|
||||
|
||||
from modules.map import export, magnetic, quads, sheet
|
||||
from modules.map.export import ExportLayer, InvalidExport, Sheet, build_layered_pdf
|
||||
from modules.map.test.test_export import api_export, layer_names, make_image, read_viewport
|
||||
|
||||
# A quadrangle of Anchorage, and the size of its image: 11 by 22.9 inches of paper at 36 DPI.
|
||||
ANCHORAGE = [-150, 61.125, -149.875, 61.25]
|
||||
WIDTH, HEIGHT, DPI = 397, 824, 36
|
||||
MAP_WIDTH, MAP_HEIGHT = WIDTH * 72 / DPI, HEIGHT * 72 / DPI
|
||||
SHEET = Sheet(name='61°07′30″N 150°00′W', credits=['© OpenStreetMap contributors', 'Protomaps'],
|
||||
date='2026-11-15')
|
||||
|
||||
|
||||
def build(bounds=None, sheet_=SHEET, **kwargs) -> bytes:
|
||||
return build_layered_pdf([ExportLayer('Background', make_image(size=(WIDTH, HEIGHT)))], WIDTH, HEIGHT, DPI,
|
||||
bounds=bounds or ANCHORAGE, sheet=sheet_, **kwargs)
|
||||
|
||||
|
||||
def page_text(pdf: bytes) -> str:
|
||||
return pymupdf.open(stream=pdf, filetype='pdf')[0].get_text()
|
||||
|
||||
|
||||
@pytest.mark.parametrize('latitude,longitude,zone,south,easting,northing', [
|
||||
# As PROJ has them (gdaltransform, EPSG:326xx and 327xx).
|
||||
(61.2181, -149.9003, 6, False, 344247.206470396, 6790536.87132859),
|
||||
(61.125, -150, 6, False, 338419.895396155, 6780416.03492079),
|
||||
(40.31, -105.0595, 13, False, 494944.139497354, 4462166.80845969),
|
||||
(-33.87, 151.21, 56, True, 334435.70614183, 6250816.39780466),
|
||||
])
|
||||
def test_utm(latitude, longitude, zone, south, easting, northing):
|
||||
"""A place has the UTM coordinates PROJ gives it, to a millimeter, and they are of that place."""
|
||||
assert sheet.utm_zone(longitude) == zone
|
||||
assert sheet.to_utm(latitude, longitude, zone, south) == pytest.approx((easting, northing), abs=0.001)
|
||||
assert sheet.from_utm(easting, northing, zone, south) == pytest.approx((latitude, longitude), abs=1e-8)
|
||||
|
||||
|
||||
def test_utm_zone():
|
||||
assert [sheet.utm_zone(i) for i in (-180, -174.001, -174, 0, 179.999, 180)] == [1, 1, 2, 31, 60, 60]
|
||||
|
||||
|
||||
def test_format_angle():
|
||||
assert sheet.format_angle(61.125, 'N', 'S') == '61°07\'30"N'
|
||||
assert sheet.format_angle(-150, 'E', 'W') == "150°00'W"
|
||||
assert sheet.format_angle(-33.875, 'N', 'S') == '33°52\'30"S'
|
||||
assert sheet.format_angle(61.125, short=True) == '07\'30"'
|
||||
assert sheet.format_angle(-149.9166666667, short=True) == "55'"
|
||||
# Seconds which round up to a minute.
|
||||
assert sheet.format_angle(2.9999999) == "3°00'"
|
||||
|
||||
|
||||
def test_graticule_interval():
|
||||
"""A 7.5 minute map has a tick every 2.5 minutes; a larger map has them further apart."""
|
||||
assert sheet.graticule_interval(0.125) == pytest.approx(2.5 / 60)
|
||||
assert sheet.graticule_interval(0.25) == pytest.approx(5 / 60)
|
||||
assert sheet.graticule_interval(1) == pytest.approx(15 / 60)
|
||||
assert sheet.graticule_interval(1e-9) == pytest.approx(1 / 3600)
|
||||
|
||||
|
||||
def test_map_scale():
|
||||
"""The quadrangle the browser draws for a 1:24,000 sheet is 1:24,000."""
|
||||
assert sheet.map_scale(MAP_WIDTH, ANCHORAGE) == pytest.approx(24000, rel=0.005)
|
||||
assert sheet.map_scale(MAP_WIDTH * 2, ANCHORAGE) == pytest.approx(12000, rel=0.005)
|
||||
|
||||
|
||||
def test_plan():
|
||||
plan = sheet.plan_sheet(MAP_WIDTH, MAP_HEIGHT, ANCHORAGE, SHEET)
|
||||
x0, y0, x1, y1 = plan.map_rect
|
||||
assert (x1 - x0, y1 - y0) == pytest.approx((MAP_WIDTH, MAP_HEIGHT))
|
||||
# There is a margin on every side, and the most of it is under the map.
|
||||
assert x0 > 36 and y0 > 36 and plan.width - x1 > 36
|
||||
assert plan.height - y1 > y0
|
||||
assert plan.zone == 6 and not plan.south_hemisphere
|
||||
# The corners of the map are the corners of its rectangle.
|
||||
assert plan.point(61.25, -150) == pytest.approx((x0, y0))
|
||||
assert plan.point(61.125, -149.875) == pytest.approx((x1, y1))
|
||||
notes = ' '.join(plan.notes)
|
||||
assert 'Scale 1:24,000' in notes
|
||||
assert 'zone 6N' in notes and 'west (46 mils) of true north' in notes
|
||||
assert 'Map data: © OpenStreetMap contributors; Protomaps' in notes
|
||||
assert 'Made with WROLPi, 2026-11-15.' in notes
|
||||
|
||||
|
||||
def test_plan_notes_fit_the_map():
|
||||
"""Notes too long for the map are on more lines, and the page is longer for them."""
|
||||
short = sheet.plan_sheet(MAP_WIDTH, MAP_HEIGHT, ANCHORAGE, Sheet())
|
||||
long = sheet.plan_sheet(MAP_WIDTH, MAP_HEIGHT, ANCHORAGE, Sheet(credits=['Somebody who made a map'] * 20))
|
||||
assert len(long.notes) > len(short.notes)
|
||||
assert long.height > short.height
|
||||
assert all(pymupdf.get_text_length(i, fontsize=sheet.NOTE_SIZE) <= MAP_WIDTH for i in long.notes)
|
||||
|
||||
|
||||
class FakePen:
|
||||
def __init__(self):
|
||||
self.lines, self.texts = [], []
|
||||
|
||||
def line(self, points, **kwargs):
|
||||
self.lines.append(list(points))
|
||||
|
||||
def text(self, x, y, text, **kwargs):
|
||||
self.texts.append((x, y, text, kwargs.get('align', 'left')))
|
||||
|
||||
def box(self, rect, **kwargs):
|
||||
pass
|
||||
|
||||
|
||||
def place_at(plan, x, y):
|
||||
"""The latitude and longitude of a point of the page."""
|
||||
x0, y0, x1, y1 = plan.map_rect
|
||||
west, south, east, north = plan.bounds
|
||||
top, bottom = (math.log(math.tan(math.pi / 4 + math.radians(i) / 2)) for i in (north, south))
|
||||
mercator = top - (y - y0) / (y1 - y0) * (top - bottom)
|
||||
return math.degrees(2 * math.atan(math.exp(mercator)) - math.pi / 2), west + (x - x0) / (x1 - x0) * (east - west)
|
||||
|
||||
|
||||
@pytest.mark.parametrize('bounds,zone,south', [
|
||||
(ANCHORAGE, 6, False),
|
||||
([151.125, -33.875, 151.25, -33.75], 56, True),
|
||||
([0, 0, 0.125, 0.125], 31, False),
|
||||
])
|
||||
def test_grid_lines_are_where_they_say(bounds, zone, south):
|
||||
"""Every line of the grid is on a whole kilometer of UTM along all of it, and is nowhere off the map."""
|
||||
plan = sheet.plan_sheet(MAP_WIDTH, MAP_HEIGHT, bounds, Sheet())
|
||||
assert (plan.zone, plan.south_hemisphere) == (zone, south)
|
||||
pen = FakePen()
|
||||
sheet._draw_grid(pen, plan)
|
||||
x0, y0, x1, y1 = plan.map_rect
|
||||
eastings, northings = set(), set()
|
||||
for line in pen.lines:
|
||||
places = [sheet.to_utm(*place_at(plan, x, y), zone, south) for x, y in line]
|
||||
for x, y in line:
|
||||
assert x0 - 1e-6 <= x <= x1 + 1e-6 and y0 - 1e-6 <= y <= y1 + 1e-6
|
||||
spread_e = max(i[0] for i in places) - min(i[0] for i in places)
|
||||
value = places[0][0] if spread_e < 1 else places[0][1]
|
||||
assert value == pytest.approx(round(value / 1000) * 1000, abs=0.5)
|
||||
for easting, northing in places:
|
||||
assert (easting if spread_e < 1 else northing) == pytest.approx(value, abs=0.5)
|
||||
(eastings if spread_e < 1 else northings).add(round(value))
|
||||
# A quadrangle is several kilometers each way, and every kilometer has its line.
|
||||
for values in (eastings, northings):
|
||||
assert len(values) >= 5
|
||||
assert sorted(values) == list(range(min(values), max(values) + 1, 1000))
|
||||
|
||||
# Each line is named in the margin: the first in full, the others by their kilometers.
|
||||
labels = [text for _, _, text, _ in pen.texts]
|
||||
for letter in ('mE', 'mN'):
|
||||
assert len([i for i in labels if i.endswith(letter)]) == 2, labels
|
||||
assert len([i for i in labels if i.isdigit()]) >= 12, labels
|
||||
# And where the line meets the edge of the map.
|
||||
for x, y, text, align in pen.texts:
|
||||
if align == 'center':
|
||||
edge = y0 if y < y0 else y1
|
||||
meters = int(text[:-2]) if text.endswith('mE') else int(text) * 1000
|
||||
assert sheet.to_utm(*place_at(plan, x, edge), zone, south)[0] == pytest.approx(meters, abs=0.5)
|
||||
|
||||
|
||||
def test_grid_labels_keep_clear_of_coordinates():
|
||||
"""A line of the grid which meets the edge where a coordinate is written is not named there."""
|
||||
plan = sheet.plan_sheet(MAP_WIDTH, MAP_HEIGHT, ANCHORAGE, Sheet())
|
||||
pen = FakePen()
|
||||
sheet._draw_grid(pen, plan)
|
||||
across, up = sheet._graticule_labels(plan)
|
||||
for x, y, text, align in pen.texts:
|
||||
if align == 'center':
|
||||
assert all(not low < x < high for low, high in across), text
|
||||
else:
|
||||
assert all(not low < y - sheet.LABEL_SIZE * 0.35 < high for low, high in up), text
|
||||
|
||||
|
||||
def test_no_tick_at_a_corner():
|
||||
"""The edges of the picture the browser draws are a hair outside the quadrangle's. The corner is still the
|
||||
corner: it is not also a tick, written over the corner's own coordinate."""
|
||||
plan = sheet.plan_sheet(MAP_WIDTH, MAP_HEIGHT, [-149.87500012, 61.12499878, -149.74999988, 61.25000121],
|
||||
Sheet())
|
||||
pen = FakePen()
|
||||
sheet._draw_graticule(pen, plan)
|
||||
labels = sorted(text for _, _, text, _ in pen.texts)
|
||||
assert labels == sorted(2 * ["10'", '12\'30"', "50'", '47\'30"', "149°52'30\"W", "149°45'W", "61°15'N",
|
||||
'61°07\'30"N'])
|
||||
# Two ticks on each edge, and a cross (two lines) where each tick of latitude meets one of longitude.
|
||||
assert len(pen.lines) == 4 * 2 + 4 * 2
|
||||
|
||||
|
||||
def test_clip():
|
||||
rect = (0, 0, 10, 10)
|
||||
assert sheet._clip([(-5, 5), (15, 5)], rect) == [[(0, 5), (10, 5)]]
|
||||
assert sheet._clip([(2, 2), (4, 4), (6, 2)], rect) == [[(2, 2), (4, 4), (6, 2)]]
|
||||
# Out of the rectangle and in again is two lines.
|
||||
assert sheet._clip([(2, 5), (5, 15), (8, 5)], rect) == [[(2, 5), (3.5, 10)], [(6.5, 10), (8, 5)]]
|
||||
assert sheet._clip([(-5, -5), (-1, 20)], rect) == []
|
||||
assert sheet._clip([(5, 5)], rect) == []
|
||||
|
||||
|
||||
def test_sheet_pdf():
|
||||
"""A map on a sheet is in the middle of a larger page, with its grid and its margin in layers of their own."""
|
||||
plain = build_layered_pdf([ExportLayer('Background', make_image(size=(WIDTH, HEIGHT)))], WIDTH, HEIGHT, DPI,
|
||||
bounds=ANCHORAGE)
|
||||
pdf = build()
|
||||
assert layer_names(plain) == ['Background']
|
||||
assert layer_names(pdf) == ['Background', 'UTM grid', 'Sheet']
|
||||
|
||||
doc = pymupdf.open(stream=pdf, filetype='pdf')
|
||||
page = doc[0]
|
||||
plan = sheet.plan_sheet(MAP_WIDTH, MAP_HEIGHT, ANCHORAGE, SHEET)
|
||||
assert (page.rect.width, page.rect.height) == pytest.approx((plan.width, plan.height), abs=0.01)
|
||||
# The map is as large as it is without the sheet.
|
||||
image = page.get_image_rects(page.get_images()[0][0])[0]
|
||||
assert tuple(image) == pytest.approx(plan.map_rect, abs=0.01)
|
||||
|
||||
text = page.get_text()
|
||||
# The name and the scale, the corners, the ticks between them, the grid, the bars and the notes.
|
||||
for expected in ('61°07\'30"N 150°00\'W', '1:24,000', "150°00'W", '149°52\'30"W', "61°15'N", '61°07\'30"N',
|
||||
"55'", '57\'30"', "10'", '12\'30"', '6790', '342', 'mE', 'mN', 'SCALE 1:24,000', 'KILOMETERS',
|
||||
'METERS', '2000', 'MILES', 'FEET', '7000', 'zone 6N', '© OpenStreetMap contributors; Protomaps',
|
||||
'Made with WROLPi, 2026-11-15.'):
|
||||
assert expected in text, expected
|
||||
|
||||
|
||||
def test_sheet_layers_can_be_hidden():
|
||||
"""The grid and the margin are drawn only in their own layers."""
|
||||
doc = pymupdf.open(stream=build(), filetype='pdf')
|
||||
full = doc[0].get_pixmap(dpi=36)
|
||||
for config in doc.layer_ui_configs():
|
||||
if config['text'] in ('UTM grid', 'Sheet'):
|
||||
doc.set_layer_ui_config(config['number'], action=2)
|
||||
hidden = doc[0].get_pixmap(dpi=36)
|
||||
assert full.samples != hidden.samples
|
||||
# Only the map is left: the margin is as white as paper.
|
||||
assert hidden.pixel(5, 5) == (255, 255, 255)
|
||||
assert hidden.color_count() == 2
|
||||
|
||||
|
||||
def test_sheet_georeference_is_of_the_map():
|
||||
"""The PDF says where the map is, not where the page is."""
|
||||
pdf = build()
|
||||
viewport = read_viewport(pdf)
|
||||
plan = sheet.plan_sheet(MAP_WIDTH, MAP_HEIGHT, ANCHORAGE, SHEET)
|
||||
x0, y0, x1, y1 = plan.map_rect
|
||||
assert viewport['bbox'] == pytest.approx([x0, plan.height - y1, x1, plan.height - y0], abs=0.01)
|
||||
assert viewport['lpts'] == [0, 1, 0, 0, 1, 0, 1, 1]
|
||||
assert viewport['gpts'] == [61.25, -150, 61.125, -150, 61.125, -149.875, 61.25, -149.875]
|
||||
|
||||
|
||||
def test_sheet_near_a_pole_has_no_grid():
|
||||
"""UTM stops at 84 degrees north and 80 south."""
|
||||
pdf = build(bounds=[0, 84.5, 0.125, 84.625])
|
||||
assert layer_names(pdf) == ['Background', 'Sheet']
|
||||
assert 'Universal Transverse Mercator' not in page_text(pdf)
|
||||
assert 'UTM grid' in layer_names(build(bounds=[0, -80, 0.125, -79.875]))
|
||||
|
||||
|
||||
def test_sheet_of_a_narrow_map():
|
||||
"""A map too narrow for a scale bar goes without it."""
|
||||
narrow = build_layered_pdf([ExportLayer('Background', make_image(size=(90, 400)))], 90, 400, DPI,
|
||||
bounds=[0, 84.5, 0.125, 84.625], sheet=Sheet())
|
||||
assert 'MILES' not in page_text(narrow)
|
||||
|
||||
|
||||
@pytest.mark.parametrize('bounds,name', [
|
||||
# The narrowest quadrangles there are, with the longest names.
|
||||
([-179.875, 84.875, -179.75, 85], '84°52′30″N 179°52′30″W'),
|
||||
([-179.875, -84.875, -179.75, -84.75], '84°52′30″S 179°52′30″W'),
|
||||
([10, 84.875, 10.125, 85], '84°52′30″N 10°00′E'),
|
||||
(ANCHORAGE, '61°07′30″N 150°00′W'),
|
||||
])
|
||||
def test_sheet_title_of_a_narrow_map(bounds, name):
|
||||
"""The name of a map and its scale are not written over each other, however narrow the map is."""
|
||||
# As wide as the paper of a 1:24,000 sheet is.
|
||||
map_width = sheet.map_scale(1, bounds) / 24000
|
||||
width, height = round(map_width * DPI / 72), 400
|
||||
pdf = build_layered_pdf([ExportLayer('Background', make_image(size=(width, height)))], width, height, DPI,
|
||||
bounds=bounds, sheet=Sheet(name=name))
|
||||
page = pymupdf.open(stream=pdf, filetype='pdf')[0]
|
||||
titles = [pymupdf.Rect(span['bbox']) for block in page.get_text('dict')['blocks'] for line in block.get('lines', [])
|
||||
for span in line['spans'] if span['size'] == pytest.approx(sheet.TITLE_SIZE)]
|
||||
assert len(titles) == 2, titles
|
||||
assert not titles[0].intersects(titles[1]), titles
|
||||
# Both are on the page, above the map and what is written along its top edge.
|
||||
top = sheet.plan_sheet(map_width, height * 72 / DPI, bounds, Sheet(name=name)).map_rect[1]
|
||||
for title in titles:
|
||||
assert title in page.rect
|
||||
assert title.y1 <= top - sheet.LABEL_SIZE
|
||||
|
||||
|
||||
def test_plan_norths():
|
||||
"""A sheet says how far the grid's north and a compass's north are from true north, at the middle of it."""
|
||||
plan = sheet.plan_sheet(MAP_WIDTH, MAP_HEIGHT, ANCHORAGE, SHEET)
|
||||
# West of the middle of its zone the grid leans west; a compass in Alaska points well east.
|
||||
assert plan.grid_north == pytest.approx(-2.571, abs=0.001)
|
||||
assert plan.magnetic_north == pytest.approx(magnetic.declination(61.1875, -149.9375, 2026 + 318 / 365), abs=0.01)
|
||||
assert 13 < plan.magnetic_north < 15
|
||||
notes = ' '.join(plan.notes)
|
||||
assert "Grid north is 2°34' west (46 mils) of true north" in notes
|
||||
assert re.search(r"Magnetic north is 13°5\d' east \(24\d mils\) of true north at the middle of the map on 2026-11-15,"
|
||||
r" and moves about 0°1\d' west each year \(WMM-2025\)\.", notes), notes
|
||||
|
||||
|
||||
def test_plan_compass_which_passes_south():
|
||||
"""Near the south magnetic pole a compass points almost due south, and within a year passes from a little
|
||||
west of south to a little east of it. It has moved a little, not most of the way around."""
|
||||
plan = sheet.plan_sheet(MAP_WIDTH, MAP_HEIGHT, [140.5, -74, 140.625, -73.875], Sheet(date='2026-11-15'))
|
||||
assert plan.magnetic_north == pytest.approx(-179.94, abs=0.01)
|
||||
assert magnetic.load_model().declination(-73.9375, 140.5625, sheet._decimal_year('2027-11-15')) > 179
|
||||
notes = ' '.join(plan.notes)
|
||||
assert "Magnetic north is 179°56' west (3199 mils) of true north" in notes
|
||||
assert "moves about 0°21' west each year" in notes
|
||||
|
||||
|
||||
@pytest.mark.parametrize('date', [None, 'yesterday', '', '2024-12-31', '2030-01-01', '2026-13-45'])
|
||||
def test_plan_without_a_compass(date):
|
||||
"""Where a compass points is not said when the day is not known, or is not one the model is of."""
|
||||
plan = sheet.plan_sheet(MAP_WIDTH, MAP_HEIGHT, ANCHORAGE, Sheet(date=date))
|
||||
assert plan.magnetic_north is None
|
||||
assert 'Magnetic' not in ' '.join(plan.notes)
|
||||
assert plan.grid_north is not None
|
||||
|
||||
|
||||
def test_decimal_year():
|
||||
assert sheet._decimal_year('2026-01-01') == 2026
|
||||
assert sheet._decimal_year('2026-07-02') == pytest.approx(2026.4986, abs=0.0001)
|
||||
assert sheet._decimal_year('2028-12-31T10:00:00') == pytest.approx(2028 + 365 / 366)
|
||||
|
||||
|
||||
def test_norths_are_on_their_own_sides():
|
||||
"""In the diagram a north is drawn on the side of true north it is on, and apart from it however near it
|
||||
is."""
|
||||
assert sheet._north_tip(0, 0, 14, 50)[0] > 0 > sheet._north_tip(0, 0, -2.5, 50)[0]
|
||||
# A north a tenth of a degree off, and one eighty off, are both drawn where they can be seen.
|
||||
near, far = sheet._north_tip(0, 0, 0.1, 50), sheet._north_tip(0, 0, -80, 50)
|
||||
assert near[0] == pytest.approx(50 * math.sin(math.radians(7)))
|
||||
assert far == pytest.approx((-25, -50 * math.cos(math.radians(30))))
|
||||
|
||||
|
||||
def test_sheet_norths_diagram():
|
||||
"""The diagram of the norths is beside the scale bars, with each angle written; a sheet too narrow for it,
|
||||
or with nothing to put in it, goes without."""
|
||||
text = page_text(build())
|
||||
assert 'MN 13°' in text and 'E\n' in text
|
||||
assert 'GN 2°34\' W 46 MILS' in text
|
||||
assert re.search(r"MN 13°5\d' E 24\d MILS", text), text
|
||||
|
||||
# No compass: the grid's north is still drawn.
|
||||
text = page_text(build(sheet_=Sheet()))
|
||||
assert 'GN 2°34\' W' in text and 'MN' not in text
|
||||
|
||||
# No grid near a pole, but a compass points somewhere; the quadrangle is too narrow for the diagram.
|
||||
narrow = build_layered_pdf([ExportLayer('Background', make_image(size=(90, 400)))], 90, 400, DPI,
|
||||
bounds=[0, 84.5, 0.125, 84.625], sheet=Sheet(date='2026-11-15'))
|
||||
text = page_text(narrow)
|
||||
assert 'Magnetic north is' in text
|
||||
assert 'MN ' not in text and 'GN ' not in text
|
||||
|
||||
|
||||
def test_sheet_text_which_the_font_can_not_write():
|
||||
pdf = build(sheet_=Sheet(name='Карта “map” – 地図', credits=['<b>© Somebody</b>\n\nelse']))
|
||||
text = page_text(pdf)
|
||||
assert '"map" -' in text
|
||||
assert '<b>© Somebody</b> else' in text
|
||||
|
||||
|
||||
def test_sheet_needs_bounds():
|
||||
with pytest.raises(InvalidExport, match='edges of the map are needed'):
|
||||
build_layered_pdf([ExportLayer('Background', make_image())], 60, 90, 72, sheet=Sheet())
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_api_export_pdf_sheet(async_client):
|
||||
images = [('Background', make_image(size=(WIDTH, HEIGHT)))]
|
||||
size = dict(width=WIDTH, height=HEIGHT, dpi=DPI)
|
||||
response, job = await api_export(
|
||||
async_client, images, bounds=ANCHORAGE, **size,
|
||||
sheet=dict(name='A quadrangle', credits=['Somebody', 'x' * 500] + ['More'] * 50, date='2026-11-15'))
|
||||
assert response.status_code == HTTPStatus.OK, response.text
|
||||
assert layer_names(response.content) == ['Background', 'UTM grid', 'Sheet']
|
||||
text = page_text(response.content)
|
||||
assert 'A quadrangle' in text and 'Somebody' in text
|
||||
# What is written on a sheet is limited.
|
||||
assert len(re.findall('More', text)) == 38
|
||||
assert 'x' * 301 not in text.replace('\n', '')
|
||||
|
||||
# An empty sheet is a sheet.
|
||||
response, job = await api_export(async_client, images, bounds=ANCHORAGE, sheet={}, **size)
|
||||
assert response.status_code == HTTPStatus.OK, response.text
|
||||
assert 'Sheet' in layer_names(response.content)
|
||||
|
||||
# A sheet which is not one, and a sheet of a map which is nowhere.
|
||||
for meta in (dict(bounds=ANCHORAGE, sheet='yes'), dict(sheet={})):
|
||||
response, job = await api_export(async_client, images, **size, **meta)
|
||||
assert response.status_code == HTTPStatus.BAD_REQUEST, json.dumps(meta)
|
||||
|
||||
|
||||
def test_mils():
|
||||
"""A compass marked in mils has 6,400 of them around."""
|
||||
assert sheet.mils(360) == 6400
|
||||
assert sheet.mils(90) == 1600
|
||||
assert sheet.mils(-2.57) == 46
|
||||
assert sheet.mils(0) == 0
|
||||
|
||||
|
||||
def test_sheet_scale_bars():
|
||||
"""The bars are of kilometers, meters, miles and feet, from the top down."""
|
||||
doc = pymupdf.open(stream=build(), filetype='pdf')
|
||||
tops = {word[4]: word[1] for word in doc[0].get_text('words')
|
||||
if word[4] in ('KILOMETERS', 'METERS', 'MILES', 'FEET')}
|
||||
assert sorted(tops, key=tops.get) == ['KILOMETERS', 'METERS', 'MILES', 'FEET']
|
||||
gaps = [tops[b] - tops[a] for a, b in (('KILOMETERS', 'METERS'), ('METERS', 'MILES'), ('MILES', 'FEET'))]
|
||||
assert gaps == pytest.approx([sheet.BAR_SPACING] * 3, abs=0.01)
|
||||
|
||||
|
||||
@pytest.mark.parametrize('interval,unit,expected', [
|
||||
(40, 'feet', 'CONTOUR INTERVAL 40 FEET'),
|
||||
(20.0, 'meters', 'CONTOUR INTERVAL 20 METERS'),
|
||||
(1000, 'feet', 'CONTOUR INTERVAL 1,000 FEET'),
|
||||
(2.5, 'meters', 'CONTOUR INTERVAL 2.5 METERS'),
|
||||
])
|
||||
def test_sheet_contour_interval(interval, unit, expected):
|
||||
"""A map with contour lines says how far apart they are, under its scale bars and over its notes."""
|
||||
plain = sheet.plan_sheet(MAP_WIDTH, MAP_HEIGHT, ANCHORAGE, SHEET)
|
||||
with_contours = Sheet(name=SHEET.name, credits=SHEET.credits, date=SHEET.date,
|
||||
contour_interval=interval, contour_unit=unit)
|
||||
plan = sheet.plan_sheet(MAP_WIDTH, MAP_HEIGHT, ANCHORAGE, with_contours)
|
||||
assert plan.contours == expected
|
||||
assert plain.contours is None
|
||||
# The page is longer by the room it takes.
|
||||
assert plan.height == pytest.approx(plain.height + sheet.CONTOUR_LEADING)
|
||||
|
||||
doc = pymupdf.open(stream=build(sheet_=with_contours), filetype='pdf')
|
||||
lines = {line.strip(): y for _, y, _, _, text, *_ in doc[0].get_text('blocks') for line in text.splitlines()}
|
||||
assert expected in lines
|
||||
feet = min(y for line, y in lines.items() if line == 'FEET')
|
||||
notes = min(y for line, y in lines.items() if line.startswith('Scale 1:24,000'))
|
||||
assert feet < lines[expected] < notes
|
||||
assert 'CONTOUR INTERVAL' not in page_text(build())
|
||||
|
||||
|
||||
@pytest.mark.parametrize('interval,unit', [
|
||||
(None, 'feet'), (40, None), (40, 'furlongs'), (0, 'feet'), (-40, 'feet'), (math.nan, 'feet'), (math.inf, 'meters'),
|
||||
('40', 'feet'),
|
||||
])
|
||||
def test_sheet_contour_interval_which_is_not_one(interval, unit):
|
||||
"""What is not an interval of contour lines is not written."""
|
||||
plan = sheet.plan_sheet(MAP_WIDTH, MAP_HEIGHT, ANCHORAGE, Sheet(contour_interval=interval, contour_unit=unit))
|
||||
assert plan.contours is None
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_api_export_pdf_sheet_contours(async_client):
|
||||
"""The browser says how far apart the contour lines of a map are, and the sheet says it."""
|
||||
images = [('Background', make_image(size=(WIDTH, HEIGHT)))]
|
||||
size = dict(width=WIDTH, height=HEIGHT, dpi=DPI, bounds=ANCHORAGE)
|
||||
response, job = await api_export(async_client, images, **size,
|
||||
sheet=dict(contours=dict(interval=40, unit='feet')))
|
||||
assert response.status_code == HTTPStatus.OK, response.text
|
||||
assert 'CONTOUR INTERVAL 40 FEET' in page_text(response.content)
|
||||
|
||||
# What is not an interval is not written, and the map is exported.
|
||||
for contours in (None, 'yes', {}, dict(interval='40', unit='feet'), dict(interval=True, unit='feet'),
|
||||
dict(interval=40), dict(interval=40, unit='furlongs'), dict(interval=-1, unit='meters'),
|
||||
dict(interval=40, unit=['feet'])):
|
||||
response, job = await api_export(async_client, images, **size, sheet=dict(contours=contours))
|
||||
assert response.status_code == HTTPStatus.OK, json.dumps(contours)
|
||||
assert 'CONTOUR INTERVAL' not in page_text(response.content), json.dumps(contours)
|
||||
|
||||
|
||||
BERTHOUD = [-105.125, 40.25, -105.0, 40.375]
|
||||
BERTHOUD_NEIGHBORS = ['Masonville', 'Loveland', 'Windsor', 'Carter Lake Reservoir', 'Johnstown', 'Hygiene',
|
||||
'Longmont', 'Gowanda']
|
||||
|
||||
|
||||
def test_adjoining_quads():
|
||||
"""The eight quadrangles around a map, from the northwest across and down."""
|
||||
assert sheet.adjoining_quads(BERTHOUD) == BERTHOUD_NEIGHBORS
|
||||
# The edges of what the browser drew are a hair outside the quadrangle.
|
||||
assert sheet.adjoining_quads([-105.1250004, 40.2499998, -104.9999996, 40.3750002]) == BERTHOUD_NEIGHBORS
|
||||
# Where the USGS has no quadrangles there is nothing to say.
|
||||
assert sheet.adjoining_quads([2.25, 48.75, 2.375, 48.875]) is None
|
||||
# At the edge of the land only some of the eight have a name: those out to sea have none.
|
||||
coast = sheet.adjoining_quads([-124.25, 40.75, -124.125, 40.875])
|
||||
assert coast is not None and None in coast and any(coast)
|
||||
|
||||
|
||||
def test_sheet_adjoining_quads():
|
||||
"""A sheet says what the quadrangles around it are called, in a diagram under its bars."""
|
||||
size = (630, 820)
|
||||
pdf = build_layered_pdf([ExportLayer('Background', make_image(size=size))], *size, DPI, bounds=BERTHOUD,
|
||||
sheet=SHEET)
|
||||
plan = sheet.plan_sheet(size[0] * 72 / DPI, size[1] * 72 / DPI, BERTHOUD, SHEET)
|
||||
assert plan.adjoining == BERTHOUD_NEIGHBORS
|
||||
doc = pymupdf.open(stream=pdf, filetype='pdf')
|
||||
assert doc[0].rect.height == pytest.approx(plan.height, abs=0.01)
|
||||
lines = {line.strip(): y for _, y, _, _, text, *_ in doc[0].get_text('blocks') for line in text.splitlines()}
|
||||
assert 'ADJOINING QUADRANGLES' in lines
|
||||
for number, name in enumerate(BERTHOUD_NEIGHBORS, start=1):
|
||||
assert f'{number} {name}' in lines, name
|
||||
# Under the bars, and over the notes.
|
||||
notes = min(y for line, y in lines.items() if line.startswith('Scale 1:'))
|
||||
assert lines['FEET'] < lines['ADJOINING QUADRANGLES'] < lines['8 Gowanda'] < notes
|
||||
|
||||
# The page is longer by the room the diagram takes.
|
||||
nowhere = [2.25, 48.75, 2.375, 48.875]
|
||||
without = sheet.plan_sheet(size[0] * 72 / DPI, size[1] * 72 / DPI, nowhere, Sheet())
|
||||
with_ = sheet.plan_sheet(size[0] * 72 / DPI, size[1] * 72 / DPI, BERTHOUD, Sheet())
|
||||
assert without.adjoining is None
|
||||
assert with_.height - with_.map_rect[3] == pytest.approx(
|
||||
without.height - without.map_rect[3] + sheet.ADJOINING_HEIGHT, abs=0.01)
|
||||
|
||||
|
||||
def test_sheet_adjoining_quads_where_there_are_none():
|
||||
"""A map of where the USGS names nothing, and a map too narrow for the diagram, go without it."""
|
||||
assert 'ADJOINING' not in page_text(build(bounds=[2.25, 48.75, 2.375, 48.875]))
|
||||
narrow = build_layered_pdf([ExportLayer('Background', make_image(size=(90, 400)))], 90, 400, DPI,
|
||||
bounds=BERTHOUD, sheet=Sheet())
|
||||
assert 'ADJOINING' not in page_text(narrow)
|
||||
|
||||
|
||||
def test_sheet_adjoining_quads_some_unnamed():
|
||||
"""A quadrangle with no name has no number in the diagram, and the others keep theirs."""
|
||||
plan = sheet.plan_sheet(MAP_WIDTH, MAP_HEIGHT, BERTHOUD, Sheet())
|
||||
plan.adjoining = ['Northwest', None, None, None, 'East', None, None, 'A name ' + 'far too long ' * 20]
|
||||
pen = FakePen()
|
||||
sheet._draw_adjoining(pen, plan, 54, 100)
|
||||
written = [text for _, _, text, _ in pen.texts]
|
||||
assert '1 Northwest' in written and '5 East' in written
|
||||
assert '1' in written and '5' in written and '8' in written
|
||||
assert not {'2', '3', '4', '6', '7'} & set(written)
|
||||
# A name too long for its column is cut to fit it.
|
||||
long = next(text for text in written if text.startswith('8 A name'))
|
||||
assert pymupdf.get_text_length(long, fontsize=sheet.LABEL_SIZE) <= sheet.ADJOINING_COLUMN
|
||||
|
||||
|
||||
@pytest.mark.parametrize('bounds', [
|
||||
[-149.875, 61.125, -149.75, 61.25],
|
||||
[-147.75, 64.75, -147.625, 64.875],
|
||||
[-156.875, 71.25, -156.75, 71.375],
|
||||
ANCHORAGE,
|
||||
])
|
||||
def test_adjoining_quads_are_never_the_map_itself(bounds):
|
||||
"""Where a quadrangle is wider than the map (Alaska), the map beside this one may be more of the same
|
||||
quadrangle. The quadrangle on that side is the next one."""
|
||||
own = quads.quad_name(*bounds)
|
||||
around = sheet.adjoining_quads(bounds)
|
||||
assert own.name not in around
|
||||
|
||||
|
||||
def test_adjoining_quads_of_the_edges_the_map_gives():
|
||||
"""The edges of an exported map are a hair from those of its quadrangle. What is around it is the same."""
|
||||
around = sheet.adjoining_quads([-149.875, 61.125, -149.75, 61.25])
|
||||
given = [-149.87500000000014, 61.12499878064878, -149.75000000000023, 61.25000121452442]
|
||||
assert sheet.adjoining_quads(given) == around
|
||||
assert around[3:5] == ['Anchorage A-8 NW', 'Anchorage A-7 NW']
|
||||
|
||||
|
||||
def test_adjoining_quads_step_past_the_map():
|
||||
"""The east of a map in the west of a wide quadrangle is the quadrangle after it, not the rest of it."""
|
||||
bounds = [-149.875, 61.125, -149.75, 61.25]
|
||||
assert quads.quad_name(*bounds).name == 'Anchorage A-8 NE'
|
||||
# One map east is still Anchorage A-8 NE.
|
||||
assert quads.quad_name(-149.75, 61.125, -149.625, 61.25).name == 'Anchorage A-8 NE'
|
||||
around = sheet.adjoining_quads(bounds)
|
||||
assert around[3:5] == ['Anchorage A-8 NW', 'Anchorage A-7 NW']
|
||||
|
||||
|
||||
LEGEND = dict(ground=[0.9, 0.88, 0.85], lines=[
|
||||
dict(label='Highway', color=[1, 1, 1], width=1.2, opacity=1, casing_color=[0.8, 0.8, 0.8], casing_width=2.4),
|
||||
dict(label='Railway', color=[0.6, 0.7, 0.7], width=0.5, opacity=0.5, dash=[0.15, 0.4]),
|
||||
dict(label='Contour', color=[0.6, 0.4, 0.2], width=0.25, opacity=0.3),
|
||||
])
|
||||
|
||||
|
||||
def test_legend_lines():
|
||||
"""The lines of a legend are what a browser sent of them, as far as they are lines."""
|
||||
ground, lines = sheet.legend_lines(LEGEND)
|
||||
assert ground == (0.9, 0.88, 0.85)
|
||||
assert [i.label for i in lines] == ['Highway', 'Railway', 'Contour']
|
||||
assert lines[0] == sheet.LegendLine(label='Highway', color=(1, 1, 1), width=1.2, opacity=1,
|
||||
casing_color=(0.8, 0.8, 0.8), casing_width=2.4)
|
||||
assert lines[1].dash == (0.15, 0.4) and lines[1].opacity == 0.5 and lines[1].casing_color is None
|
||||
# As it is sent again (to the Job which makes the PDF), it is the same legend.
|
||||
assert sheet.legend_lines(sheet.legend_as_sent(LEGEND)) == (ground, lines)
|
||||
assert json.loads(json.dumps(sheet.legend_as_sent(LEGEND)))['lines'][0]['label'] == 'Highway'
|
||||
|
||||
|
||||
@pytest.mark.parametrize('legend', [
|
||||
None, 'yes', [], {}, dict(lines='roads'), dict(lines=[]), dict(lines=['Highway', None, 7]),
|
||||
dict(lines=[dict(label='', color=[1, 1, 1], width=1)]),
|
||||
dict(lines=[dict(label='No color', width=1)]),
|
||||
dict(lines=[dict(label='No width', color=[1, 1, 1])]),
|
||||
dict(lines=[dict(label='Two parts', color=[1, 1], width=1)]),
|
||||
dict(lines=[dict(label='Not numbers', color=['red', 0, 0], width=1)]),
|
||||
dict(lines=[dict(label='Not a width', color=[1, 0, 0], width='wide')]),
|
||||
dict(lines=[dict(label='Not a width', color=[1, 0, 0], width=math.nan)]),
|
||||
dict(lines=[dict(label='Not a width', color=[1, 0, 0], width=True)]),
|
||||
# Too thin to be seen on the map.
|
||||
dict(lines=[dict(label='Path or track', color=[1, 0, 0], width=0.02, dash=[0.06, 0.02])]),
|
||||
dict(lines=[dict(label='Nothing', color=[1, 0, 0], width=0)]),
|
||||
])
|
||||
def test_legend_lines_which_are_not(legend):
|
||||
"""What is not a legend has no lines, and is on white."""
|
||||
assert sheet.legend_lines(legend) == (sheet.WHITE, [])
|
||||
assert sheet.legend_as_sent(legend) is None
|
||||
|
||||
|
||||
def test_legend_lines_are_limited():
|
||||
"""A legend has only so many lines, each named in only so many letters and drawn only so wide."""
|
||||
line = dict(label='x' * 500, color=[2, -1, 0.5], width=900, opacity=7, dash=[0, 900] * 20,
|
||||
casing_color=[0, 0, 0], casing_width=900)
|
||||
ground, lines = sheet.legend_lines(dict(ground=[5, 5, 5], lines=[line] * 100))
|
||||
assert ground == (1, 1, 1)
|
||||
assert len(lines) == sheet.LEGEND_LINES
|
||||
assert lines[0].label == 'x' * sheet.LEGEND_LABEL
|
||||
assert lines[0].color == (1, 0, 0.5) and lines[0].opacity == 1
|
||||
assert lines[0].width == sheet.LEGEND_WIDTHS[1] and lines[0].casing_width == 8
|
||||
assert lines[0].dash == (0.1, sheet.LEGEND_SAMPLE) * 3
|
||||
# A casing with no color, or no width, is no casing; dashes which are not numbers are no dashes.
|
||||
ground, lines = sheet.legend_lines(dict(lines=[
|
||||
dict(label='A', color=[0, 0, 0], width=1, casing_width=2),
|
||||
dict(label='B', color=[0, 0, 0], width=1, casing_color=[1, 1, 1]),
|
||||
dict(label='C', color=[0, 0, 0], width=1, dash=[1, 'long']),
|
||||
]))
|
||||
assert [(i.casing_color, i.casing_width, i.dash) for i in lines] == [(None, 0, ())] * 3
|
||||
|
||||
|
||||
def test_sheet_legend():
|
||||
"""A sheet with a legend has what each line is called beside a piece of it, under the bars and over the
|
||||
notes, and is longer for it."""
|
||||
with_legend = Sheet(name=SHEET.name, credits=SHEET.credits, date=SHEET.date, legend=LEGEND)
|
||||
plain = sheet.plan_sheet(MAP_WIDTH, MAP_HEIGHT, ANCHORAGE, SHEET)
|
||||
plan = sheet.plan_sheet(MAP_WIDTH, MAP_HEIGHT, ANCHORAGE, with_legend)
|
||||
assert [i.label for i in plan.legend] == ['Highway', 'Railway', 'Contour'] and not plain.legend
|
||||
assert plan.legend_ground == (0.9, 0.88, 0.85)
|
||||
# One row of lines: the map is wide enough for the three side by side.
|
||||
assert plan.height == pytest.approx(
|
||||
plain.height + sheet.LABEL_SIZE + 8 + sheet.LEGEND_ITEM_HEIGHT + 8)
|
||||
|
||||
doc = pymupdf.open(stream=build(sheet_=with_legend), filetype='pdf')
|
||||
words = {word[4]: (word[0], word[1]) for word in doc[0].get_text('words')}
|
||||
assert words['LEGEND'][1] < words['Highway'][1] == words['Railway'][1] == words['Contour'][1]
|
||||
assert words['FEET'][1] < words['LEGEND'][1] and words['Highway'][1] < words['Scale'][1]
|
||||
assert words['Railway'][0] - words['Highway'][0] == pytest.approx(sheet.LEGEND_ITEM_WIDTH, abs=0.01)
|
||||
assert 'LEGEND' not in page_text(build())
|
||||
# The lines are drawn in their own colors: the page has the brown of a contour line.
|
||||
colors = {tuple(round(c, 2) for c in d['color']) for d in doc[0].get_drawings() if d.get('color')}
|
||||
assert (0.6, 0.4, 0.2) in colors and (0.6, 0.7, 0.7) in colors
|
||||
|
||||
|
||||
def test_sheet_legend_of_many_lines_is_in_rows():
|
||||
lines = [dict(label=f'Line {i}', color=[0, 0, 0], width=1) for i in range(9)]
|
||||
plan = sheet.plan_sheet(MAP_WIDTH, MAP_HEIGHT, ANCHORAGE, Sheet(legend=dict(lines=lines)))
|
||||
columns = int(MAP_WIDTH // sheet.LEGEND_ITEM_WIDTH)
|
||||
assert 1 < columns < 9
|
||||
pen = FakePen()
|
||||
sheet._draw_legend(pen, plan, 54, 100)
|
||||
places = {text: (x, y) for x, y, text, _ in pen.texts}
|
||||
# The line after the last of a row is under the first of it.
|
||||
assert places[f'Line {columns}'][0] == places['Line 0'][0]
|
||||
assert places[f'Line {columns}'][1] == pytest.approx(places['Line 0'][1] + sheet.LEGEND_ITEM_HEIGHT)
|
||||
assert places[f'Line {columns - 1}'][1] == places['Line 0'][1]
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_api_export_pdf_sheet_legend(async_client):
|
||||
"""The browser says how the lines of a map are drawn, and the sheet has a legend of them."""
|
||||
images = [('Background', make_image(size=(WIDTH, HEIGHT)))]
|
||||
size = dict(width=WIDTH, height=HEIGHT, dpi=DPI, bounds=ANCHORAGE)
|
||||
response, job = await api_export(async_client, images, **size, sheet=dict(legend=LEGEND))
|
||||
assert response.status_code == HTTPStatus.OK, response.text
|
||||
text = page_text(response.content)
|
||||
assert 'LEGEND' in text and 'Highway' in text and 'Railway' in text
|
||||
|
||||
# What is not a legend is not drawn, and the map is exported.
|
||||
for legend in (None, 'yes', [], {}, dict(lines='roads'), dict(lines=[dict(label='No color', width=1)])):
|
||||
response, job = await api_export(async_client, images, **size, sheet=dict(legend=legend))
|
||||
assert response.status_code == HTTPStatus.OK, json.dumps(legend)
|
||||
assert 'LEGEND' not in page_text(response.content), json.dumps(legend)
|
||||
|
||||
|
||||
def test_sheet_legend_name_too_long_for_its_column():
|
||||
"""What a line is called is cut to the room beside the line, so it is not under the next line."""
|
||||
lines = [dict(label='A name which is far too long for it ' + str(i), color=[0, 0, 0], width=1) for i in range(3)]
|
||||
plan = sheet.plan_sheet(MAP_WIDTH, MAP_HEIGHT, ANCHORAGE, Sheet(legend=dict(lines=lines)))
|
||||
pen = FakePen()
|
||||
sheet._draw_legend(pen, plan, 54, 100)
|
||||
written = [(x, text) for x, _, text, _ in pen.texts if text.startswith('A name')]
|
||||
assert len(written) == 3
|
||||
for x, text in written:
|
||||
assert len(text) < len(lines[0]['label'])
|
||||
left = x - sheet.LEGEND_SAMPLE - 5
|
||||
assert x + pymupdf.get_text_length(text, fontsize=sheet.LABEL_SIZE) <= left + sheet.LEGEND_ITEM_WIDTH
|
||||
|
||||
|
||||
def test_format_angle_of_no_angle():
|
||||
"""An edge on the equator, or on the prime meridian, is on neither side of it; nor is one a hair from it."""
|
||||
assert sheet.format_angle(0, 'N', 'S') == "0°00'"
|
||||
assert sheet.format_angle(-1e-7, 'E', 'W') == "0°00'"
|
||||
assert sheet.format_angle(1e-7, 'N', 'S') == "0°00'"
|
||||
assert sheet.format_angle(-0.125, 'N', 'S') == "0°07'30\"S"
|
||||
|
||||
|
||||
@pytest.mark.parametrize('bounds,zone', [
|
||||
# The edges the map gives are a hair outside the quadrangle.
|
||||
([10, 83.8749999, 10.125, 84.0000001], 32),
|
||||
([10, -80.0000001, 10.125, -79.875], 32),
|
||||
# Past where the zones end.
|
||||
([10, 84, 10.125, 84.125], None),
|
||||
([10, -80.125, 10.125, -80], None),
|
||||
])
|
||||
def test_sheet_grid_where_the_zones_end(bounds, zone):
|
||||
"""A map which ends where the UTM zones do (84 north, 80 south) has a grid; one past there has none."""
|
||||
plan = sheet.plan_sheet(300, 600, bounds, sheet.Sheet())
|
||||
assert plan.zone == zone
|
||||
|
||||
|
||||
@pytest.mark.parametrize('date', ['9999-12-31', '0000-01-01', 'yesterday', '', None])
|
||||
def test_sheet_of_no_such_day(date):
|
||||
"""A sheet whose day is not one is a sheet which does not say where magnetic north is."""
|
||||
plan = sheet.plan_sheet(300, 600, BERTHOUD, sheet.Sheet(date=date))
|
||||
assert plan.magnetic_north is None
|
||||
|
||||
|
||||
def test_one_mil_is_a_mil():
|
||||
"""An angle of one mil is "1 mil", in the notes and under the norths; more are "mils"."""
|
||||
# Grid north at Berthoud is 0°02' west of true north: one mil.
|
||||
plan = sheet.plan_sheet(300, 600, BERTHOUD, sheet.Sheet(date='2026-11-19'))
|
||||
assert sheet.mils(plan.grid_north) == 1
|
||||
assert '(1 mil) of true north' in ' '.join(plan.notes)
|
||||
text = page_text(build_layered_pdf(
|
||||
[ExportLayer('Background', make_image(size=(WIDTH, HEIGHT)))], WIDTH, HEIGHT, DPI, bounds=BERTHOUD,
|
||||
sheet=sheet.Sheet(date='2026-11-19')))
|
||||
assert '1 MIL' in text and '1 MILS' not in text
|
||||
# Magnetic north there is many.
|
||||
assert re.search(r'MN .* \d{2,} MILS', text)
|
||||
93
modules/map/wmm/WMM2025.COF
Normal file
93
modules/map/wmm/WMM2025.COF
Normal file
|
|
@ -0,0 +1,93 @@
|
|||
2025.0 WMM-2025 11/13/2024
|
||||
1 0 -29351.8 0.0 12.0 0.0
|
||||
1 1 -1410.8 4545.4 9.7 -21.5
|
||||
2 0 -2556.6 0.0 -11.6 0.0
|
||||
2 1 2951.1 -3133.6 -5.2 -27.7
|
||||
2 2 1649.3 -815.1 -8.0 -12.1
|
||||
3 0 1361.0 0.0 -1.3 0.0
|
||||
3 1 -2404.1 -56.6 -4.2 4.0
|
||||
3 2 1243.8 237.5 0.4 -0.3
|
||||
3 3 453.6 -549.5 -15.6 -4.1
|
||||
4 0 895.0 0.0 -1.6 0.0
|
||||
4 1 799.5 278.6 -2.4 -1.1
|
||||
4 2 55.7 -133.9 -6.0 4.1
|
||||
4 3 -281.1 212.0 5.6 1.6
|
||||
4 4 12.1 -375.6 -7.0 -4.4
|
||||
5 0 -233.2 0.0 0.6 0.0
|
||||
5 1 368.9 45.4 1.4 -0.5
|
||||
5 2 187.2 220.2 0.0 2.2
|
||||
5 3 -138.7 -122.9 0.6 0.4
|
||||
5 4 -142.0 43.0 2.2 1.7
|
||||
5 5 20.9 106.1 0.9 1.9
|
||||
6 0 64.4 0.0 -0.2 0.0
|
||||
6 1 63.8 -18.4 -0.4 0.3
|
||||
6 2 76.9 16.8 0.9 -1.6
|
||||
6 3 -115.7 48.8 1.2 -0.4
|
||||
6 4 -40.9 -59.8 -0.9 0.9
|
||||
6 5 14.9 10.9 0.3 0.7
|
||||
6 6 -60.7 72.7 0.9 0.9
|
||||
7 0 79.5 0.0 -0.0 0.0
|
||||
7 1 -77.0 -48.9 -0.1 0.6
|
||||
7 2 -8.8 -14.4 -0.1 0.5
|
||||
7 3 59.3 -1.0 0.5 -0.8
|
||||
7 4 15.8 23.4 -0.1 0.0
|
||||
7 5 2.5 -7.4 -0.8 -1.0
|
||||
7 6 -11.1 -25.1 -0.8 0.6
|
||||
7 7 14.2 -2.3 0.8 -0.2
|
||||
8 0 23.2 0.0 -0.1 0.0
|
||||
8 1 10.8 7.1 0.2 -0.2
|
||||
8 2 -17.5 -12.6 0.0 0.5
|
||||
8 3 2.0 11.4 0.5 -0.4
|
||||
8 4 -21.7 -9.7 -0.1 0.4
|
||||
8 5 16.9 12.7 0.3 -0.5
|
||||
8 6 15.0 0.7 0.2 -0.6
|
||||
8 7 -16.8 -5.2 -0.0 0.3
|
||||
8 8 0.9 3.9 0.2 0.2
|
||||
9 0 4.6 0.0 -0.0 0.0
|
||||
9 1 7.8 -24.8 -0.1 -0.3
|
||||
9 2 3.0 12.2 0.1 0.3
|
||||
9 3 -0.2 8.3 0.3 -0.3
|
||||
9 4 -2.5 -3.3 -0.3 0.3
|
||||
9 5 -13.1 -5.2 0.0 0.2
|
||||
9 6 2.4 7.2 0.3 -0.1
|
||||
9 7 8.6 -0.6 -0.1 -0.2
|
||||
9 8 -8.7 0.8 0.1 0.4
|
||||
9 9 -12.9 10.0 -0.1 0.1
|
||||
10 0 -1.3 0.0 0.1 0.0
|
||||
10 1 -6.4 3.3 0.0 0.0
|
||||
10 2 0.2 0.0 0.1 -0.0
|
||||
10 3 2.0 2.4 0.1 -0.2
|
||||
10 4 -1.0 5.3 -0.0 0.1
|
||||
10 5 -0.6 -9.1 -0.3 -0.1
|
||||
10 6 -0.9 0.4 0.0 0.1
|
||||
10 7 1.5 -4.2 -0.1 0.0
|
||||
10 8 0.9 -3.8 -0.1 -0.1
|
||||
10 9 -2.7 0.9 -0.0 0.2
|
||||
10 10 -3.9 -9.1 -0.0 -0.0
|
||||
11 0 2.9 0.0 0.0 0.0
|
||||
11 1 -1.5 0.0 -0.0 -0.0
|
||||
11 2 -2.5 2.9 0.0 0.1
|
||||
11 3 2.4 -0.6 0.0 -0.0
|
||||
11 4 -0.6 0.2 0.0 0.1
|
||||
11 5 -0.1 0.5 -0.1 -0.0
|
||||
11 6 -0.6 -0.3 0.0 -0.0
|
||||
11 7 -0.1 -1.2 -0.0 0.1
|
||||
11 8 1.1 -1.7 -0.1 -0.0
|
||||
11 9 -1.0 -2.9 -0.1 0.0
|
||||
11 10 -0.2 -1.8 -0.1 0.0
|
||||
11 11 2.6 -2.3 -0.1 0.0
|
||||
12 0 -2.0 0.0 0.0 0.0
|
||||
12 1 -0.2 -1.3 0.0 -0.0
|
||||
12 2 0.3 0.7 -0.0 0.0
|
||||
12 3 1.2 1.0 -0.0 -0.1
|
||||
12 4 -1.3 -1.4 -0.0 0.1
|
||||
12 5 0.6 -0.0 -0.0 -0.0
|
||||
12 6 0.6 0.6 0.1 -0.0
|
||||
12 7 0.5 -0.1 -0.0 -0.0
|
||||
12 8 -0.1 0.8 0.0 0.0
|
||||
12 9 -0.4 0.1 0.0 -0.0
|
||||
12 10 -0.2 -1.0 -0.1 -0.0
|
||||
12 11 -1.3 0.1 -0.0 0.0
|
||||
12 12 -0.7 0.2 -0.1 -0.1
|
||||
999999999999999999999999999999999999999999999999
|
||||
999999999999999999999999999999999999999999999999
|
||||
Loading…
Add table
Add a link
Reference in a new issue