Some grammar correction and text improvements in the docs (#1201)

willemarcel · web-flow · commit ccb5c0eff2f4 · 2025-08-06T17:10:08.000+02:00
diff --git a/RELEASING.md b/RELEASING.md
@@ -3,7 +3,9 @@
 This is a checklist for releasing a new version of **titiler**.
 
 1. Determine the next version
+
    We currently do not have published versioning guidelines. We usually use `minor` version update when pushing breaking changes and `patch` for every other updates
+
 2. Create a release branch named `release/vX.Y.Z`, where `X.Y.Z` is the new version
 3. Search and replace all instances of the current version number with the new version
 
@@ -16,7 +18,10 @@ This is a checklist for releasing a new version of **titiler**.
 5. Update [CHANGES.md](./CHANGES.md) for the new version
 6. Push your release branch, create a PR, and get approval
 7. Once the PR is merged, create a new (annotated, signed) tag on the appropriate commit
+
    Name the tag `X.Y.Z`, and include `vX.Y.Z` as its annotation message
+
 8. Push your tag to Github, which will kick off the publishing workflow
 9. Create a [new release](https://github.com/stac-utils/stac-fastapi/releases/new) targeting the new tag, and use the "Generate release notes" feature to populate the description.
-    Publish the release and mark it as the latest.
+
+   Publish the release and mark it as the latest.
diff --git a/SECURITY.md b/SECURITY.md
@@ -2,9 +2,9 @@
 
 ## Reporting a Vulnerability
 
-If there are any vulnerabilities in `titiler`, don't hesitate to _report them_.
+If you find any vulnerabilities in `titiler`, don't hesitate to _report them_.
 
-1. Use Github's security reporting tools.
+1. Use GitHub's security reporting tools.
 
 see https://docs.github.com/en/code-security/security-advisories/guidance-on-reporting-and-writing-information-about-vulnerabilities/privately-reporting-a-security-vulnerability#privately-reporting-a-security-vulnerability
 
diff --git a/deployment/azure/README.md b/deployment/azure/README.md
@@ -2,7 +2,7 @@
 
 TiTiler is built on top of [FastAPI](https://github.com/tiangolo/fastapi), a modern, fast, Python web framework for building APIs. We can make our FastAPI application work as an Azure Function by wrapping it within the [Azure Function Python worker](https://github.com/Azure/azure-functions-python-worker).
 
-If you are not familiar with **Azure functions** we recommend checking https://docs.microsoft.com/en-us/azure/azure-functions/ first.
+If you are not familiar with **Azure functions**, we recommend checking https://docs.microsoft.com/en-us/azure/azure-functions/ first.
 
 Minimal TiTiler Azure function code:
 ```python
diff --git a/deployment/k8s/README.md b/deployment/k8s/README.md
@@ -1,6 +1,6 @@
 ## k8s / Helm Deployment
 
-Try locally
+Try locally:
 
 ```
 minikube start
@@ -11,4 +11,4 @@ helm init --wait
 helm install -f titiler/Chart.yaml titiler
 ```
 
-For more info about K8S cluster and node configuration please see: https://github.com/developmentseed/titiler/issues/212
+For more info about K8S cluster and node configuration, please see: https://github.com/developmentseed/titiler/issues/212
diff --git a/docs/src/advanced/customization.md b/docs/src/advanced/customization.md
@@ -1,5 +1,5 @@
 
-`TiTiler` is designed to help user customize input/output for each endpoint. This section goes over some simple customization examples.
+`TiTiler` is designed to help users customize input/output for each endpoint. This section goes over some simple customization examples.
 
 ### Custom Colormap
 
diff --git a/docs/src/advanced/performance_tuning.md b/docs/src/advanced/performance_tuning.md
@@ -1,6 +1,6 @@
 ## Overview
 
-Titiler makes use of several great underlying libraries, including [GDAL][gdal]
+TiTiler makes use of several great underlying libraries, including [GDAL][gdal]
 and [Python bindings to GDAL][rasterio]. An effective deployment of titiler
 generally requires tweaking GDAL configuration settings. This document provides
 an overview of relevant settings. Full documentation from GDAL is available
@@ -15,7 +15,7 @@ an overview of relevant settings. Full documentation from GDAL is available
 ### Setting a config variable
 
 GDAL configuration is modified using environment variables. Thus in order to
-change a setting you'll need to set environment variables through your
+change a setting, you'll need to set environment variables through your
 deployment mechanism. For example, in order to test locally you'd set an
 environment variable in bash:
 
@@ -66,10 +66,10 @@ files, so if you wished to read this data, you'd want
 
 #### `GDAL_INGESTED_BYTES_AT_OPEN`
 
-Gives the number of initial bytes GDAL should read when opening a file and
+Defines the number of initial bytes GDAL should read when opening a file and
 inspecting its metadata.
 
-Titiler works best with Cloud-Optimized GeoTIFFs (COGs) because they have a
+TiTiler works best with Cloud-Optimized GeoTIFFs (COGs) because they have a
 tiled internal structure that supports efficient random reads. These files have
 an initial metadata section that describes the location (byte range) within the
 file of each internal tile. The more internal tiles the COG has, the more data
diff --git a/docs/src/user_guide/algorithms.md b/docs/src/user_guide/algorithms.md
@@ -90,7 +90,7 @@ This base class defines that algorithm:
 
 - can have`parameters` (enabled by `extra = "allow"` pydantic config)
 
-Here is a simple example of a custom Algorithm:
+Here is a simple example of a custom algorithm:
 
 ```python
 from titiler.core.algorithm import BaseAlgorithm
@@ -121,7 +121,7 @@ class Multiply(BaseAlgorithm):
 
 Using a Pydantic's `BaseModel` class to construct the custom algorithm enables two things **parametrization** and **type casting/validation**.
 
-If we look at the `Multiply` algorithm, we can see it needs a `factor` parameter. In Titiler (in the post_process dependency) we will pass this parameter via query string (e.g `/preview.png?algo=multiply&algo_parameter={"factor":3}`) and pydantic will make sure we use the right types/values.
+If we look at the `Multiply` algorithm, we can see it needs a `factor` parameter. In TiTiler (in the post_process dependency) we will pass this parameter via query string (e.g `/preview.png?algo=multiply&algo_parameter={"factor":3}`) and pydantic will make sure we use the right types/values.
 
 ```python
 # Available algorithm
@@ -143,7 +143,7 @@ def post_process_dependency(
 
 ## Dependency
 
-To be able to use your own algorithm in titiler's endpoint you need to create a `Dependency` to tell the application what algorithm are available.
+To be able to use your own algorithm in TiTiler's endpoint, you need to create a `Dependency` to tell the application which algorithms are available.
 
 To ease the dependency creation, we added a `dependency` property in the `titiler.core.algorithm.Algorithms` class, which will return a FastAPI dependency to be added to the endpoints.
 
@@ -166,7 +166,7 @@ endpoints = TilerFactory(process_dependency=PostProcessParams)
 
 ### Order of operation
 
-When creating a map tile (or other images), we will fist apply the `algorithm` then the `rescaling` and finally the `color_formula`.
+When creating a map tile (or other images), we will first apply the `algorithm`, then the `rescaling`, and finally the `color_formula`.
 
 ```python
 with reader(url as src_dst:
diff --git a/docs/src/user_guide/dynamic_tiling.md b/docs/src/user_guide/dynamic_tiling.md
@@ -5,9 +5,9 @@
 
 TiTiler's first goal is to create a lightweight but performant dynamic tile server... but what do we mean by this?
 
-When you zoom/pan on a web map, you are visualizing either vector or raster data that is loaded by your web client (e.g Chrome). Vector Tiles are rendered **On the Fly**, meaning the map library (e.g MapboxGL) will apply styling on the vector it receives to create a visual representation on the map. This is possible because vector data can be encoded and compressed very efficiently and result in each tile being only couple of kilo octets.
+When you zoom/pan on a web map, you are visualizing either vector or raster data that is loaded by your web client (e.g Chrome). Vector Tiles are rendered **On the Fly**, meaning the map library (e.g Mapbox GL-JS) will apply the styling on the vector it receives to create a visual representation on the map. This is possible because vector data can be encoded and compressed very efficiently and result in each tile being only a couple of kilo octets.
 
-On the other side, raster data is a really dense format, a `256 x 256 x 3` tile (True color image) needs to encode `196 608` values, and depending on the data type (Integer, Float, Complex), a raster tile can be really heavy. Depending on the dataset data type, some operations might be needed in order to obtain a visual representation (e.g. rescaling, colormap, ... ). Map library will almost only accept Uint8 RGB(A) tile encoded as PNG, JPEG or Webp.
+On the other side, raster data is a really dense format, a `256 x 256 x 3` tile (True color image) needs to encode `196 608` values, and depending on the data type (Integer, Float, Complex), a raster tile can be really heavy. Depending on the dataset data type, some operations might be needed in order to obtain a visual representation (e.g. rescaling, colormap, ... ). The map library will almost only accept Uint8 RGB(A) tile encoded as PNG, JPEG or Webp.
 
 ## **Static tiling**
 
@@ -68,9 +68,9 @@ The goal of the `Dynamic Tiling` process is to get rid of all the pre-processing
 
 ## Summary
 
-With `Static` tile generation you are often limited because you are visualizing data that is fixed and stored somewhere on a disk. With `Dynamic tiling`, users have the possibility to apply their own choice of processing (e.g rescaling, masking) before creating the `image`.
+With `Static` tile generation, you are often limited because you are visualizing data that is fixed and stored somewhere on a disk. With `Dynamic tiling`, users have the possibility to apply their own choice of processing (e.g rescaling, masking) before creating the `image`.
 
-Static tiling will always be faster than dynamic tiling, but a cache layer can be set up in front of the dynamic tiler, but using a dynamic tiler often means that same tile won't be serve twice (because users can set multiple options).
+Static tiling will always be faster to load than dynamic tiling, but a cache layer can be set up in front of the dynamic tiler. Using a dynamic tiler often means that the same tile won't be served twice (because users can set multiple options).
 
 ## Links
 [https://medium.com/devseed/cog-talk-part-1-whats-new-941facbcd3d1](https://medium.com/devseed/cog-talk-part-1-whats-new-941facbcd3d1)
diff --git a/docs/src/user_guide/getting_started.md b/docs/src/user_guide/getting_started.md
@@ -6,9 +6,9 @@ In the past, putting maps on websites was a real pain. Developers had to use bul
 
 ## Dynamic vs. Static Tiles: What's the Difference?
 
-Static tiles are like pre-printed map pieces stored in folders. Once created, they're locked—changing anything means starting over. They use lots of storage but load quickly.
+Static tiles are like pre-printed map pieces stored in folders. Once created, they're locked—changing anything means starting over. They use lots of storage, but load quickly.
 
-TiTiler's dynamic tiles work like a chef cooking to order. When someone views your map, TiTiler grabs just the data needed and creates tiles on the spot. This lets you instantly change colors, adjust contrast, or highlight different features. Your map becomes flexible and responsive, adapting to what users need right now rather than being stuck with choices made earlier.
+TiTiler's dynamic tiles work like a chef cooking to order. When someone views your map, TiTiler grabs just the data needed and creates tiles on the spot. This lets you instantly change colors, adjust contrast, or highlight different features. Your map becomes flexible and responsive, adapting to what users need right now, rather than being stuck with choices made earlier.
 
 More on [Dynamic Tiling](dynamic_tiling.md)
 
@@ -102,7 +102,7 @@ Run the following command to start the server:
 ```bash
 uvicorn main:app --reload
 ```
-You should see output similar to this:
+You should see an output similar to this:
 
 ![server logs](../img/server_logs.png)
 
@@ -303,7 +303,7 @@ uvicorn titiler.application.main:app
 > INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
 
-See default endpoints documentation pages:
+See the default endpoints documentation pages:
 
 * [`/cog` - Cloud Optimized GeoTIFF](../endpoints/cog.md)
 * [`/mosaicjson` - MosaicJSON](../endpoints/mosaic.md)
@@ -340,7 +340,6 @@ python -m pip install titiler.application uvicorn # also installs titiler.core a
 
 These can then be used like:
 
-
 ```py
 # Add private COG endpoints requiring token validation
 from fastapi import APIRouter, Depends, HTTPException, Security
diff --git a/docs/src/user_guide/output_format.md b/docs/src/user_guide/output_format.md
@@ -2,7 +2,7 @@
 `TiTiler` supports the common output format for map tiles: JPEG, PNG and WEBP.
 
 While some formats (e.g PNG) are able to encode Uint16 or Float datatypes, most web browsers only supports 8 bit data (meaning that it has to be between 0 and 255).
-It's on the user to know what datatype is the input source (COG), and what kind of `post processing` there is to do to create a valid web map tile.
+It's on the user to know what datatype is the input source (COG), and what kind of `post processing` is required to create a valid web map tile.
 
 `TiTiler` also has support for more complex output data formats, such as JPEG2000 or GeoTIFF. While it might not be useful for FrontEnd display (most browsers can't decode GeoTIFF natively), some users could want to transmit the data as `raw` values to some applications (non-web display).
 
diff --git a/docs/src/user_guide/rendering.md b/docs/src/user_guide/rendering.md
@@ -2,17 +2,17 @@
 
 When using Titiler to visualize imagery, there are some helper options that change how the data appears on the screen. You can:
 
-1. Adjust band values using basic color-oriented image operations
+1. Adjust the band values using basic color-oriented image operations
 2. Apply color maps to create heat maps, colorful terrain based on band value
 3. Rescale images on a per-band basis
 
 ## Color Map
 
-Color maps are arrays of colors, used to map pixel values to specific colors. For example, it is possible to map a single band DEM, where pixel values denote height, to a color map which shows higher values as white:
+Color maps are arrays of colors, used to map pixel values to specific colors. For example, it is possible to map a single band DEM, where the pixel values denote height, to a color map which shows higher values as white:
 
 ![color map example](../img/colormap.png)
 
-Titiler supports both default colormaps (each with a name) and custom color maps.
+TiTiler supports both default colormaps (each with a name) and custom color maps.
 
 ### Default Colormaps
 
@@ -57,7 +57,7 @@ response = httpx.get(
 )
 ```
 
-Titiler supports colormaps that are both discrete (where pixels will be one of the colors that you specify) and linear (where pixel colors will blend between the given colors).
+TiTiler supports colormaps that are both discrete (where pixels will be one of the colors that you specify) and linear (where pixel colors will blend between the given colors).
 
 For more information, please check out [rio-tiler's docs](https://cogeotiff.github.io/rio-tiler/colormap/).
 
@@ -70,13 +70,13 @@ Color formulae are simple commands that apply color corrections to images. This
 
 Titiler supports color formulae as defined in [Mapbox's `rio-color` plugin](https://github.com/mapbox/rio-color). These include the operations ([taken from the `rio-color` docs](https://github.com/mapbox/rio-color#operations)):
 
-- **Gamma** adjustment adjusts RGB values according to a power law, effectively brightening or darkening the midtones. It can be very effective in satellite imagery for reducing atmospheric haze in the blue and green bands.
+- **Gamma** adjustment: adjusts RGB values according to a power law, effectively brightening or darkening the midtones. It can be very effective in satellite imagery for reducing atmospheric haze in the blue and green bands.
 
-- **Sigmoidal** contrast adjustment can alter the contrast and brightness of an image in a way that matches human's non-linear visual perception. It works well to increase contrast without blowing out the very dark shadows or already-bright parts of the image.
+- **Sigmoidal** contrast adjustment: can alter the contrast and brightness of an image in a way that matches human's non-linear visual perception. It works well to increase contrast without blowing out the very dark shadows or already-bright parts of the image.
 
-- **Saturation** can be thought of as the "colorfulness" of a pixel. Highly saturated colors are intense and almost cartoon-like, low saturation is more muted, closer to black and white. You can adjust saturation independently of brightness and hue but the data must be transformed into a different color space.
+- **Saturation**: can be thought of as the "colorfulness" of a pixel. Highly saturated colors are intense and almost cartoon-like, low saturation is more muted, closer to black and white. You can adjust saturation independently of brightness and hue, but the data must be transformed into a different color space.
 
-In Titiler, color_formulae are applied through the `color_formula` parameter as a string. An example of this option in action:
+In TiTiler, color_formulae are applied through the `color_formula` parameter as a string. An example of this option in action:
 
 ```python
 import httpx
@@ -94,7 +94,7 @@ response = httpx.get(
 
 Rescaling is the act of adjusting the minimum and maximum values when rendering an image. In an image with a single band, the rescaled minimum value will be set to black, and the rescaled maximum value will be set to white. This is useful if you want to accentuate features that only appear at a certain pixel value (e.g. you have a DEM, but you want to highlight how the terrain changes between sea level and 100m).
 
-All titiler endpoinds returning *image* support `rescale` parameter. The parameter should be in form of `"rescale={min},{max}"`.
+All TiTiler endpoinds returning *image* support `rescale` parameter. The parameter should be in form of `"rescale={min},{max}"`.
 
 ```python
 import httpx
@@ -108,7 +108,7 @@ response = httpx.get(
 )
 ```
 
-Titiler supports rescaling on a per-band basis, using multiple `rescale` parameters.
+TiTiler supports rescaling on a per-band basis, using multiple `rescale` parameters.
 
 ```python
 import httpx
@@ -124,10 +124,9 @@ response = httpx.get(
 )
 ```
 
-By default, Titiler will rescale the bands using the min/max values of the input datatype. For example, PNG images 8- or 16-bit unsigned pixels,
-giving a possible range of 0 to 255 or 0 to 65,536, so Titiler will use these ranges to rescale to the output format.
+By default, TiTiler will rescale the bands using the min/max values of the input datatype. For example, PNG images 8 or 16-bit unsigned pixels, giving a possible range of 0 to 255 or 0 to 65,536, so Titiler will use these ranges to rescale to the output format.
 
-For certain datasets (e.g. DEMs) this default behaviour can make the image seem washed out (or even entirely one color),
+For certain datasets (e.g. DEMs), this default behaviour can make the image seem washed out (or even entirely one color),
 so if you see this happen look into rescaling your images to something that makes sense for your data.
 
 It is also possible to add a [rescaling dependency](../api/titiler/core/dependencies/#ImageRenderingParams) to automatically apply

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`
`2`		-`TiTiler` is designed to help user customize input/output for each endpoint. This section goes over some simple customization examples.
	`2`	+`TiTiler` is designed to help users customize input/output for each endpoint. This section goes over some simple customization examples.
`3`	`3`
`4`	`4`	`### Custom Colormap`
`5`	`5`