mirror of
https://github.com/lrnselfreliance/wrolpi.git
synced 2026-11-20 23:16:17 -05:00
* 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>
871 lines
41 KiB
Python
871 lines
41 KiB
Python
"""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()
|