Formato dell'algoritmo polilinea codificato
Mantieni tutto organizzato con le raccolte
Salva e classifica i contenuti in base alle tue preferenze.
La codifica polilinea è un algoritmo di compressione con perdita di dati che consente di archiviare una serie
come una singola stringa. Le coordinate dei punti sono codificate utilizzando valori con segno.
Se hai solo pochi punti statici, potresti anche usare lo strumento interattivo
utilità di codifica delle polilinee.
Il processo di codifica converte un valore binario in una serie di codici di caratteri per
Caratteri ASCII che utilizzano lo schema di codifica Base64 familiare per garantire una visualizzazione corretta
di questi caratteri, i valori codificati vengono sommati con 63 (il carattere ASCII "?")
prima di convertirli in ASCII. L'algoritmo controlla anche la presenza di
per un determinato punto controllando il bit meno significativo di ogni
gruppo di byte; se questo bit è impostato su 1, il punto non è ancora completamente formato e
devono seguire altri dati.
Inoltre, per risparmiare spazio, i punti includono solo l'offset
punto precedente (tranne, ovviamente, il primo punto). Tutti i punti sono codificati
in Base64 come numeri interi firmati, mentre latitudini e longitudini sono valori firmati.
Il formato di codifica all'interno di una polilinea deve rappresentare due coordinate
che rappresentano la latitudine e la longitudine con una precisione ragionevole. Dato un valore massimo
longitudine di +/- 180 gradi a una precisione di 5 cifre decimali
(da 180,00000 a -180,00000), ciò comporta la necessità di un token
un valore intero binario.
Tieni presente che la barra rovesciata è interpretata come un carattere di escape
all'interno dei valori letterali stringa. Qualsiasi output di questa utilità deve convertire la barra rovesciata
alle doppie barre rovesciate all'interno dei valori letterali stringa.
I passaggi per la codifica di questo valore con segno sono specificati di seguito.
- Prendi il valore firmato iniziale:
-179.9832104
- Prendi il valore decimale e moltiplicalo per 1e5, arrotondando il risultato:
-17998321
- Converti il valore decimale in binario. Tieni presente che un valore negativo deve essere
calcolato utilizzando la sua funzione
il complemento di due invertendo il valore binario e aggiungendo uno al risultato:
00000001 00010010 10100001 11110001
11111110 11101101 01011110 00001110
11111110 11101101 01011110 00001111
- Sposta il valore binario di un bit a sinistra:
11111101 11011010 10111100 00011110
- Se il valore decimale originale è negativo, inverti questa codifica:
00000010 00100101 01000011 11100001
- Suddividi il valore binario in blocchi da 5 bit (a partire dal lato destro):
00001 00010 01010 10000 11111 00001
- Posiziona i blocchi a 5 bit in ordine inverso:
00001 11111 10000 01010 00010 00001
- OPPURE ogni valore con 0x20 se segue un altro blocco di bit:
100001 111111 110000 101010 100010 000001
- Converti ogni valore in decimale:
33 63 48 42 34 1
- Aggiungi 63 a ciascun valore:
96 126 111 105 97 64
- Converti ogni valore nel relativo equivalente ASCII:
`~oia@
La tabella seguente mostra alcuni esempi di punti codificati, che mostrano le
come una serie di offset da punti precedenti.
Esempio
Punti: (38.5, -120.2), (40.7, -120.95), (43.252, -126.453)
| 38,5 |
-120,2 |
3850000 |
-12020000 |
+3850000 |
-12020000 |
_p~iF |
~ps|U |
_p~iF~ps|U |
| 40,7 |
-120,95 |
4070000 |
-12095000 |
+220000 |
-75000 |
_ulL |
nnqC |
_ulLnnqC |
| 43,252 |
-126,453 |
4325200 |
-12645300 |
+255200 |
-550300 |
_mqN |
vxq`@ |
_mqNvxq`@ |
Polilinea codificata: _p~iF~ps|U_ulLnnqC_mqNvxq`@
Salvo quando diversamente specificato, i contenuti di questa pagina sono concessi in base alla licenza Creative Commons Attribution 4.0, mentre gli esempi di codice sono concessi in base alla licenza Apache 2.0. Per ulteriori dettagli, consulta le norme del sito di Google Developers. Java è un marchio registrato di Oracle e/o delle sue consociate.
Ultimo aggiornamento 2025-08-29 UTC.
[null,null,["Ultimo aggiornamento 2025-08-29 UTC."],[[["\u003cp\u003ePolyline encoding is a lossy compression algorithm that represents a series of coordinates as a single string.\u003c/p\u003e\n"],["\u003cp\u003eThe algorithm uses signed values, Base64 encoding, and offsets from the previous point to compress the data.\u003c/p\u003e\n"],["\u003cp\u003ePoints are encoded by converting latitude and longitude to binary, applying bitwise operations, and converting the result to ASCII characters.\u003c/p\u003e\n"],["\u003cp\u003eEncoded polylines are strings that consist of these ASCII characters, representing the sequence of geographical points.\u003c/p\u003e\n"]]],["Polyline encoding compresses coordinates into a single string. It encodes points as signed integers representing offsets from the previous point. The process involves multiplying the decimal by 1e5, converting to binary (using two's complement for negative values), left-shifting, inverting if negative, dividing into 5-bit chunks, reversing chunk order, OR-ing with 0x20, adding 63, and converting to ASCII. Points are represented in Base64 and latitude/longitude are paired, encoded sequentially. The result is a compact string representing the sequence of points.\n"],null,["# Encoded Polyline Algorithm Format\n\nPolyline encoding is a lossy compression algorithm that allows you to store a series of\ncoordinates as a single string. Point coordinates are encoded using signed values.\nIf you only have a few static points, you may also wish to use the interactive\n[polyline encoding utility](/maps/documentation/utilities/polylineutility).\n\nThe encoding process converts a binary value into a series of character codes for\nASCII characters using the familiar base64 encoding scheme: to ensure proper display\nof these characters, encoded values are summed with 63 (the ASCII character '?')\nbefore converting them into ASCII. The algorithm also checks for additional\ncharacter codes for a given point by checking the least significant bit of each\nbyte group; if this bit is set to 1, the point is not yet fully formed and\nadditional data must follow.\n\nAdditionally, to conserve space, **points only include the offset from the\nprevious point** (except of course for the first point). All points are encoded\nin Base64 as signed integers, as latitudes and longitudes are signed values.\nThe encoding format within a polyline needs to represent two coordinates\nrepresenting latitude and longitude to a reasonable precision. Given a maximum\nlongitude of +/- 180 degrees to a precision of 5 decimal places\n(180.00000 to -180.00000), this results in the need for a 32 bit signed\nbinary integer value.\n\nNote that the backslash is interpreted as an escape character within string literals. Any output of this utility should convert backslash\ncharacters to double-backslashes within string literals.\n\nThe steps for encoding such a signed value are specified below.\n\n1. Take the initial signed value: \n `-179.9832104`\n2. Take the decimal value and multiply it by 1e5, rounding the result: \n `-17998321`\n3. Convert the decimal value to binary. Note that a negative value must be calculated using its [two's complement](https://en.wikipedia.org/wiki/Two%27s_complement) by inverting the binary value and adding one to the result: \n\n ```\n 00000001 00010010 10100001 11110001\n 11111110 11101101 01011110 00001110\n 11111110 11101101 01011110 00001111\n ```\n4. Left-shift the binary value one bit: \n `11111101 11011010 10111100 00011110`\n5. If the original decimal value is negative, invert this encoding: \n `00000010 00100101 01000011 11100001`\n6. Break the binary value out into 5-bit chunks (starting from the right hand side): \n `00001 00010 01010 10000 11111 00001`\n7. Place the 5-bit chunks into reverse order: \n `00001 11111 10000 01010 00010 00001`\n8. OR each value with 0x20 if another bit chunk follows: \n `100001 111111 110000 101010 100010 000001`\n9. Convert each value to decimal: \n `33 63 48 42 34 1`\n10. Add 63 to each value: \n `96 126 111 105 97 64`\n11. Convert each value to its ASCII equivalent: \n ```~oia@``\n\nThe table below shows some examples of encoded points, showing the\nencodings as a series of offsets from previous points. \n\n### Example\n\nPoints: (38.5, -120.2), (40.7, -120.95), (43.252, -126.453)\n\n|----------|-----------|----------------|-----------------|--------------------|---------------------|------------------|-------------------|---------------|\n| Latitude | Longitude | Latitude in E5 | Longitude in E5 | Change In Latitude | Change In Longitude | Encoded Latitude | Encoded Longitude | Encoded Point |\n| 38.5 | -120.2 | 3850000 | -12020000 | +3850000 | -12020000 | `_p~iF` | `~ps|U` | `_p~iF~ps|U` |\n| 40.7 | -120.95 | 4070000 | -12095000 | +220000 | -75000 | `_ulL` | `nnqC` | `_ulLnnqC` |\n| 43.252 | -126.453 | 4325200 | -12645300 | +255200 | -550300 | `_mqN` | ``vxq`@`` | ``_mqNvxq`@`` |\n\n**Encoded polyline** : ``_p~iF~ps|U_ulLnnqC_mqNvxq`@``"]]
