> For the complete documentation index, see [llms.txt](https://mapir.gitbook.io/chloros/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://mapir.gitbook.io/chloros/readme.md).

# Getting Started

<div data-full-width="false"><figure><img src="https://1328410239-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FOlCbgXiWzMtaOKj49kpf%2Fuploads%2Fgit-blob-9f6a2a8df812802a15e314556af14da6b520053b%2Fchloros_logo_transparent.png?alt=media" alt=""><figcaption></figcaption></figure></div>

Chloros is a software application from [MAPIR](https://www.mapir.camera) to process multispectral imagery, live-control MAPIR hardware, and record sensor data. Chloros 1.3.0 supports the full MAPIR product family:

* **Survey3 cameras** — process RAW+JPG captures into calibrated reflectance and vegetation-index maps. See [Supported Cameras](https://mapir.gitbook.io/chloros/supported-cameras.md).
* **LATTICE cameras** — connect the GigE multispectral camera modules live, singly or as synchronized multi-camera arrays: preview, capture, and process into calibrated radiance and reflectance products. See the [LATTICE section](https://mapir.gitbook.io/chloros/lattice-cameras/lattice.md).
* **DAQ light sensors** — DAQ-U (USB), DAQ-M (Bluetooth), and DAQ-E and DAQ-E-S (Ethernet) spectral sensors: live calibrated spectra, `.daq` recordings, and downwelling illumination for reflectance processing. See the [DAQ section](https://mapir.gitbook.io/chloros/daq-light-sensors/daq.md).

{% hint style="success" %}
**What's New in Chloros 1.3.0**: AI assistants can drive Chloros through `chloros-mcp`, and the CLI, the SDK and `chloros-mcp` offer the same features. LATTICE index products are improved, full-sensor arrays are faster and work on any network, and the backend keeps running between commands. See the What's New list below, and [Download](https://mapir.gitbook.io/chloros/download.md) for the installers.
{% endhint %}

{% hint style="info" %}
**Using Chloros with an AI assistant?** This manual is built for it. Point your assistant at:

* `https://mapir.gitbook.io/chloros/llms.txt` — machine-readable index of every page.
* Any page as raw Markdown — append `.md` to its URL (e.g. `https://mapir.gitbook.io/chloros/reference/cli-reference.md`).
* The [CLI Reference](https://mapir.gitbook.io/chloros/reference-cli-and-sdk/cli-reference.md) and [SDK Reference](https://mapir.gitbook.io/chloros/reference-cli-and-sdk/sdk-reference.md) — complete, exact-value reference pages written for LLM consumption.

Example prompt: *"Read <https://mapir.gitbook.io/chloros/reference/cli-reference.md>, then write a script that logs in and processes the folder \~/flights/flight\_001 into reflectance + NDVI GeoTIFFs."*

Or let it run Chloros directly: `chloros-mcp`, an MCP server installed with the SDK, works with Claude Desktop, Claude Code, Cursor and other MCP clients.

Full guide: [Using Chloros with AI Assistants](https://mapir.gitbook.io/chloros/ai-assistants.md).
{% endhint %}

***

## What's New in Chloros 1.3.0

* **AI assistants can drive Chloros.** `chloros-mcp`, an MCP server installed with the Python SDK, lets Claude Desktop, Claude Code, Cursor and other MCP clients process imagery and run LATTICE cameras, arrays and DAQ light sensors. See [Using Chloros with AI Assistants](https://mapir.gitbook.io/chloros/ai-assistants.md).
* **The CLI, the SDK and `chloros-mcp` offer the same features.** Only sign-in, DAQ-E provisioning and the direct DAQ servers stay with the CLI, for security. Some 1.2.0 scripts need changes: see **Changed in 1.3.0** at the top of the [CLI Reference](https://mapir.gitbook.io/chloros/reference-cli-and-sdk/cli-reference.md) and the [SDK Reference](https://mapir.gitbook.io/chloros/reference-cli-and-sdk/sdk-reference.md).
* **Improved LATTICE index products.** NDVI and the other index products exported from LATTICE captures are improved, in every processing mode.
* **Windows installer options.** Under **System settings** the installer offers **Enable Windows long paths** and **Exclude the Chloros backend from Microsoft Defender scanning**, both checked by default. The first lets project folders sit deeper than 260 characters; the second stops real-time scanning from slowing camera capture (about 30% of the capture rate at high rates). The installer now also adds the CLI folder to `PATH` only once, and removes the duplicate entries earlier installers left. See [Download](https://mapir.gitbook.io/chloros/download.md).
* **Deep project folders are refused up front.** With Windows long paths turned off (the Windows default), a project folder too deep for the 260-character path limit is refused before anything runs, with the longest project folder that fits and how to turn long paths on. Before, such a run wrote no products. With long paths on, products in very deep folders now keep their metadata (GPS and XMP tags).
* **Clamp masks.** When the band unmix of a LATTICE radiance or reflectance product produces a negative band value, that value is clipped to zero, and a per-pixel mask in a `clamp_masks/` folder beside the product folders records which pixels and bands were affected. The product names its mask in the `Chloros:UnmixClampMask` tag. Live views now clip exactly as the export does. See [Output Image Formats](https://mapir.gitbook.io/chloros/output-image-formats.md).
* **Products describe themselves.** Index products carry their own processing tags (`Chloros:ProcessingLevel=index`, the index expression, and whether they were computed from radiance or reflectance) instead of the source raw's. Survey3 products carry Chloros processing tags in every processing mode. LATTICE raw and debayered files stay in the sensor's native orientation and record their orientation in XMP; the Image Viewer turns them for display only.
* **Linux packages ship unpacked.** The backend and CLI are installed as folders under `/usr/lib/chloros/`, so they no longer unpack themselves at every launch. On x86\_64 the backend no longer spends about 100 seconds starting, and the `.deb` is about half its former size. The bundled ExifTool now runs on a clean Ubuntu install. The `.deb` now also installs the Python SDK for the system `python3` (install it with `sudo apt install ./chloros_1.3.0_<arch>.deb`), raises the kernel's socket receive buffers that camera streams need, and adds a backend service that runs as your user. The Jetson package, `chloros_1.3.0_arm64_jp6.deb`, is built for JetPack 6 and processes on the Jetson's GPU with JetPack's CUDA build of PyTorch. On Linux each exported image now reaches the disk once (written and tagged in memory, then copied into place): on a Jetson, where the disk sets the pace, a 288-image LATTICE run takes 14 minutes instead of 24. See [Linux Installation](https://mapir.gitbook.io/chloros/linux-and-edge-computing/linux-installation.md).
* **LATTICE OCN cameras read more accurately in sunlight.** Radiance, reflectance and indices get a fleet correction after the band unmix, so a grey target reads close to neutral NDVI in sun. RGN cameras are unchanged.
* **In-app bug reports.** A bug icon at the top of the Debug Log tab sends MAPIR a description, up to 10 images, the logs and system details. See [GUI : Navigation](https://mapir.gitbook.io/chloros/navigation.md).
* **LATTICE arrays.** Arrays keep the full sensor by default, and packed 12-bit transport (`--packed`, default `auto`) raises full-sensor frame rates by about a third; an array works on any network at the frame rate it allows (a slow link lowers the frame rate instead of refusing the array or shrinking its frames); an array whose cameras power-cycle recovers by itself, with PTP back on; auto exposure no longer lowers that rate in dim light (it fills the period, then raises gain); Continuous capture keeps up with fast arrays; a **Highlights** control for RGB cameras; and the SDK's `ArraySession` gains `grab()`, `frame_stream()` and `continuous()`. See the [LATTICE section](https://mapir.gitbook.io/chloros/lattice-cameras/lattice.md).
* **Steadier auto exposure.** Exposure holds at constant light and settles within a few seconds of a change, small highlights no longer darken the scene, a manual exposure leaves gain on Auto, and a camera that stops responding in bright sun is held at the level for its light, read by the light sensor or, with none connected, by the camera's own frames. See [Camera Settings](https://mapir.gitbook.io/chloros/lattice-cameras/camera-settings.md).
* **Light sensors.** **DAQ-E-S support:** its fixed diffuser takes no cap correction, and each reading carries the unit's tilt, roll and pitch. A recording says whether its cap was chosen or assumed, and processing warns on an assumed one: DAQ-U, DAQ-M and DAQ-E ship with no cap, so name the one fitted. Live `.daq` recordings survive a power cut (keep a `.daq-journal` file with its `.daq`), and a DAQ-E that stops delivering is reconnected with the gap marked in its recording. A project that holds only light-sensor recordings lists them and processes from the app and the CLI, and a recording made with the `chloros_scripts` is listed as the DAQ that made it, with a cap you can set. Every capture saves the DAQ reading it used. See the [DAQ section](https://mapir.gitbook.io/chloros/daq-light-sensors/daq.md).
* **Processing.** LATTICE frames start processing during target detection. Target and DAQ references are decided per band. A moved project relinks its files. An 8-bit capture's exports are 8-bit, with a new **TIFF (8-bit)** format. A Survey3 run with no calibration target is filed as its fallback product (`Vignette_Corrected_Images` or `Sensor_Response_Images`), not as reflectance. A reflectance image's per-band DLS tags are always its own frame's. Texture Aware is refused for LATTICE captures, which always get the standard debayer.
* **CLI & SDK.** Relative output paths now land in the folder you run the command or script from (an installed backend used to resolve them in its own install folder and fail). The backend keeps running between commands and scripts and stops itself after 30 minutes unused; `chloros-cli backend status` and `backend stop` manage it. Capture commands name every file they could not write and exit with code 1, and repeating captures stop on a full drive. A successful `process` run reports `Image products written: N (plus M clamp masks)`. On Windows the SDK's `ChlorosLocal` / `process_folder` find the installed backend (and use one that is already running), and `read_image_audit_tags` works from a plain `pip install`.

***

## What's New in Chloros 1.2.0

* **Live camera control — new Cameras tab.** Connect LATTICE cameras one at a time or as synchronized multi-camera arrays (PTP time sync, hardware-triggered capture), with live preview overlays, per-band histograms, smart auto-exposure, a live index calculator, and in-app camera firmware updates.
* **Light sensors — new Light Sensors tab.** Connect DAQ-U (USB), DAQ-M (Bluetooth), and DAQ-E (Ethernet) sensors; view live calibrated spectra (W/m²/nm), record `.daq` files into your project, pick cap-correction profiles, and update DAQ-E firmware over the network.
* **Capture modes and recorders.** Single / Continuous / Interval capture plus a raw-only Fastest Capture mode; per-project selection of which cameras and export types "Capture All" produces; array recorders for monitoring-grade index video and analysis-grade raw bursts with offline video builds.
* **LATTICE processing pipeline.** Import LATTICE capture folders and fan each raw frame out into debayered, preview, float32 radiance (W/m²/sr/nm), and reflectance products with per-product toggles. Reflectance can come from an in-frame calibration target or DAQ downwelling; array alignment is applied to exports; missing factory calibration is downloaded automatically by camera serial.
* **Projects remember hardware.** Connected cameras and light sensors are saved with the project (`cameras.json` / `sensors.json`) and reconnect with their saved settings when you reopen the project. See [GUI : Projects](https://mapir.gitbook.io/chloros/projects.md).
* **Image viewer upgrades.** Cursor pixel/index readout with correct per-file reflectance scaling, layer histograms, a GSD binning slider, Per Trigger / Per Camera grid modes, LATTICE product views, and Index/LUT sandbox exports to disk.
* **CLI & SDK, greatly expanded.** New `lattice`, `daq pool-*`, `project`, and `time-sync` command families; new `process` options (`--input-level`, per-product toggles, `--reflectance-source`, array-alignment flags); SDK smart-connect handles (`connect_camera` / `connect_array` / `connect_daq_sensor`) that auto-start the backend; `open_project()` automation; the SDK wheel is bundled with the installers and published to PyPI as `chloros-sdk`.
* **Honest failure semantics.** A `chloros-cli process` run that requested products but wrote none now fails loudly and exits non-zero; successful runs report how many image products they wrote.
* **New output layout.** Products land in `<project>/<camera>/<format>/<Product>_Images/` folders and keep the source filename — the folder, not a filename suffix, identifies the product. See [Output Image Formats](https://mapir.gitbook.io/chloros/output-image-formats.md).
* **More inputs, plans, and languages.** `.dng` input support; all 38 interface languages fully populated; per-plan hardware limits with free (no-login) use of up to 4 cameras and 2 light sensors.
* **Reliability.** Stop Processing stops cleanly with an honest run summary, multi-camera projects export every camera, and installer upgrades no longer sign you out.

***

Chloros is available in 3 application surfaces:

## Chloros: Desktop GUI application

Standalone separate window with all features, including the live Cameras and Light Sensors tabs. *Windows only.*

## [Chloros CLI: Command line interface](https://mapir.gitbook.io/chloros/cli.md)

Command-line batch processing plus live `lattice`, `daq pool-*`, `project`, and `time-sync` commands. Perfect for automation, scripting, and headless operation. Available on **Windows, Linux amd64, and Linux arm64 (NVIDIA Jetson)**. *CLI requires a paid Chloros+ tier to access.*

## [Chloros API: Python SDK](https://mapir.gitbook.io/chloros/api-python-sdk.md)

Programmatic Python interface for automation and custom workflows: full-pipeline processing, live camera/array sessions, DAQ sensor sessions, and saved-project automation. Installed with the desktop/CLI package and also published as `pip install chloros-sdk`. *API requires a paid Chloros+ tier to access.*

***

## Supported Platforms

| Platform                        | GUI | CLI | Python SDK |
| ------------------------------- | --- | --- | ---------- |
| **Windows 10/11 (x64)**         | Yes | Yes | Yes        |
| **Linux amd64 (x86\_64)**       | No  | Yes | Yes        |
| **Linux arm64 (NVIDIA Jetson)** | No  | Yes | Yes        |

For Linux installation instructions, see the [Linux & Edge Computing](https://mapir.gitbook.io/chloros/linux-and-edge-computing/linux-overview.md) section.

***

## Get Started in Three Steps

1. **Install** — download and run the installer for your platform. See [Download](https://mapir.gitbook.io/chloros/download.md).
2. **Log in (optional for the GUI)** — the GUI processes images for free without an account. A [Chloros+ login](https://mapir.gitbook.io/chloros/chloros+-login.md) unlocks parallel processing, GPU acceleration, higher device limits, and CLI/SDK access.
3. **Create your first project** — open Chloros, create a [New Project](https://mapir.gitbook.io/chloros/projects.md), [add your images](https://mapir.gitbook.io/chloros/processing-images-gui/adding-files-to-a-project.md), and [start processing](https://mapir.gitbook.io/chloros/processing-images-gui/starting-the-processing.md). To drive live hardware instead, open the Cameras or Light Sensors tab — see [GUI : Navigation](https://mapir.gitbook.io/chloros/navigation.md).

***

## Chloros+

While Chloros is free to use for most tasks, you may find you want more. That is where a paid license for Chloros+ can benefit you. With a Chloros+ license you can unlock new features such as:

* **Multi-threaded Processing**: greatly speed up image processing for larger projects by simultaneously processing images through the pipeline.
* **GPU (CUDA) Acceleration**: take advantage of today's higher GPU memory options to further speed up the image processing pipeline. We recommend 4GB or more of VRAM for best results.
* **Chloros+** [**CLI**](https://mapir.gitbook.io/chloros/cli.md) **Access**: run Chloros+ from the command line to automate and integrate into your own software. Available on any paid tier; enforced server-side.
* **Chloros+** [**API**](https://mapir.gitbook.io/chloros/api-python-sdk.md) **Access:** run Chloros+ from Python for programmatic control, enabling seamless integration with your research pipelines, data analysis workflows, and custom applications. Available on any paid tier; enforced server-side.
* **Higher Hardware Limits**: connect more cameras and light sensors at once. Without a login the GUI connects up to 4 cameras and 2 DAQ light sensors; paid tiers raise both caps:

| Plan                  | Cameras | DAQ light sensors |
| --------------------- | ------- | ----------------- |
| Iron (free, no login) | 4       | 2                 |
| Copper / Bronze       | 6       | 3                 |
| Silver                | 10      | 6                 |
| Gold                  | 20      | 12                |

* **Multiple Device Usage**: each Chloros+ license allows for 2+ devices to be registered. Use your MAPIR Cloud account to manage registered devices. Add support for more devices by upgrading your Chloros+ license.
* **Advanced Texture Aware Debayer Method:** a high-quality edge-aware debayer combined with an AI/ML denoising model which removes nearly all the debayering noise.
* **Custom Multispectral Index Formulas:** enter in custom multispectral indices in the Chloros raster calculators, both for processing and the image viewing sandbox.
* **Linux & Edge Computing:** run Chloros on Linux x86\_64 and ARM64 platforms including NVIDIA Jetson for field and edge processing. See [Linux Overview](https://mapir.gitbook.io/chloros/linux-and-edge-computing/linux-overview.md).

<p align="center"><a href="https://cloud.mapir.camera/pricing" class="button primary" data-icon="envira">Chloros+ Pricing &#x26; Signup</a></p>

<figure><img src="https://1328410239-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FOlCbgXiWzMtaOKj49kpf%2Fuploads%2Fgit-blob-61121df1683cf2bd43b076572a72172674f478fb%2Fplus_prog.JPG?alt=media" alt=""><figcaption></figcaption></figure>

<figure><img src="https://1328410239-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FOlCbgXiWzMtaOKj49kpf%2Fuploads%2Fedf9k1LHyjUc4EPHzCAL%2Fchloros_grid_zoom.gif?alt=media&amp;token=1ac1ed69-9879-4021-b468-f57389ab8d5e" alt=""><figcaption></figcaption></figure>

<figure><img src="https://1328410239-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FOlCbgXiWzMtaOKj49kpf%2Fuploads%2FONsJEbBWLyCoS4IsJboc%2Fchloros_grid_mode.gif?alt=media&amp;token=dd444b62-efe0-4942-acf8-0b2569aa70d4" alt=""><figcaption></figcaption></figure>

<figure><img src="https://1328410239-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FOlCbgXiWzMtaOKj49kpf%2Fuploads%2FaQRyXSCnaYj5Hc6hxiAp%2Fchloros_grid_meta.gif?alt=media&amp;token=8d9c6e7e-84eb-407c-95d8-4b9db5de7c5f" alt=""><figcaption></figcaption></figure>

<figure><img src="https://1328410239-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FOlCbgXiWzMtaOKj49kpf%2Fuploads%2F9U7pLVZDxTnxRjaPCqW2%2Fchloros_map_markers.gif?alt=media&amp;token=e16a18b6-520a-4434-b1f2-223c45adf2e0" alt=""><figcaption></figcaption></figure>

<figure><img src="https://1328410239-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FOlCbgXiWzMtaOKj49kpf%2Fuploads%2F2ofAl3bm9R9unfBTS40M%2Fcli.JPG?alt=media&amp;token=b9a50ce8-b3ad-408b-8edc-f97da3649d23" alt=""><figcaption></figcaption></figure>
