# Table of Contents
- [* NOTICE * — cugraph-docs 25.02.00 documentation](#-notice-cugraph-docs-25-02-00-documentation)
- [nx-cugraph — cugraph-docs 25.02.00 documentation](#nx-cugraph-cugraph-docs-25-02-00-documentation)
- [Welcome to the cuDF documentation! — cudf 25.02.00 documentation](#welcome-to-the-cudf-documentation-cudf-25-02-00-documentation)
- [API Docs - RAPIDS Docs](#api-docs-rapids-docs)
- [References — cugraph-docs 25.02.00 documentation](#references-cugraph-docs-25-02-00-documentation)
- [Installation — cugraph-docs 25.02.00 documentation](#installation-cugraph-docs-25-02-00-documentation)
- [Graph Support — cugraph-docs 25.02.00 documentation](#graph-support-cugraph-docs-25-02-00-documentation)
- [cuGraph Introduction — cugraph-docs 25.02.00 documentation](#cugraph-introduction-cugraph-docs-25-02-00-documentation)
- [Tutorials — cugraph-docs 25.02.00 documentation](#tutorials-cugraph-docs-25-02-00-documentation)
- [Developer Resources — cugraph-docs 25.02.00 documentation](#developer-resources-cugraph-docs-25-02-00-documentation)
- [WholeGraph — cugraph-docs 25.02.00 documentation](#wholegraph-cugraph-docs-25-02-00-documentation)
- [Welcome to cuCIM’s documentation! — cuCIM 25.02.00 documentation](#welcome-to-cucim-s-documentation-cucim-25-02-00-documentation)
- [API Reference — cugraph-docs 25.02.00 documentation](#api-reference-cugraph-docs-25-02-00-documentation)
- [Welcome to cuML’s documentation! — cuml 25.02.00 documentation](#welcome-to-cuml-s-documentation-cuml-25-02-00-documentation)
- [Welcome to cuSpatial’s documentation! — cuspatial 25.02.00 documentation](#welcome-to-cuspatial-s-documentation-cuspatial-25-02-00-documentation)
- [Welcome to Dask cuDF’s documentation! — dask-cudf 25.02.00 documentation](#welcome-to-dask-cudf-s-documentation-dask-cudf-25-02-00-documentation)
- [Welcome to KvikIO’s Python documentation! — kvikio 25.02.00 documentation](#welcome-to-kvikio-s-python-documentation-kvikio-25-02-00-documentation)
- [cuML C++ API: Main Page](#cuml-c-api-main-page)
- [cuProj: GPU-Accelerated Cartographic Projections and Coordinate Transformations — cuProj 25.02.00 documentation](#cuproj-gpu-accelerated-cartographic-projections-and-coordinate-transformations-cuproj-25-02-00-documentation)
- [cuVS: Vector Search and Clustering on the GPU — cuvs](#cuvs-vector-search-and-clustering-on-the-gpu-cuvs)
- [libcuspatial: libcuspatial](#libcuspatial-libcuspatial)
- [RMM: librmm](#rmm-librmm)
- [Dask-CUDA — dask-cuda 25.02.00a26 documentation](#dask-cuda-dask-cuda-25-02-00a26-documentation)
- [Welcome to rapids-cmake’s documentation! — rapids-cmake 25.02.00 documentation](#welcome-to-rapids-cmake-s-documentation-rapids-cmake-25-02-00-documentation)
- [libcuproj: libcuproj](#libcuproj-libcuproj)
- [* NOTICE * — cugraph-docs 25.04.00 documentation](#-notice-cugraph-docs-25-04-00-documentation)
- [libucxx: Main Page](#libucxx-main-page)
- [libkvikio: Welcome to KvikIO's C++ documentation!](#libkvikio-welcome-to-kvikio-s-c-documentation-)
- [RAPIDS RAFT: Reusable Accelerated Functions and Tools for Vector Search and More — raft 25.02.00 documentation](#rapids-raft-reusable-accelerated-functions-and-tools-for-vector-search-and-more-raft-25-02-00-documentation)
- [Welcome to rmm’s documentation! — rmm 25.02.00 documentation](#welcome-to-rmm-s-documentation-rmm-25-02-00-documentation)
- [Unknown](#unknown)
- [Search - cugraph-docs 25.02.00 documentation](#search-cugraph-docs-25-02-00-documentation)
- [RAPIDS Graph documentation — cugraph 24.12.00 documentation](#rapids-graph-documentation-cugraph-24-12-00-documentation)
- [WholeGraph — cugraph-docs 25.04.00 documentation](#wholegraph-cugraph-docs-25-04-00-documentation)
- [cuDF User Guide — cudf 25.02.00 documentation](#cudf-user-guide-cudf-25-02-00-documentation)
- [Welcome to cuML’s documentation! — cuml 24.12.00 documentation](#welcome-to-cuml-s-documentation-cuml-24-12-00-documentation)
- [Welcome to Dask cuDF’s documentation! — dask-cudf 25.04.00 documentation](#welcome-to-dask-cudf-s-documentation-dask-cudf-25-04-00-documentation)
- [Welcome to Dask cuDF’s documentation! — dask-cudf 24.12.00 documentation](#welcome-to-dask-cudf-s-documentation-dask-cudf-24-12-00-documentation)
- [Index — cugraph-docs 25.02.00 documentation](#index-cugraph-docs-25-02-00-documentation)
- [Welcome to cuML’s documentation! — cuml 25.04.00 documentation](#welcome-to-cuml-s-documentation-cuml-25-04-00-documentation)
- [How To Guides — cugraph-docs 25.02.00 documentation](#how-to-guides-cugraph-docs-25-02-00-documentation)
- [Welcome to cuxfilter’s documentation — cuxfilter 25.04.00 documentation](#welcome-to-cuxfilter-s-documentation-cuxfilter-25-04-00-documentation)
- [Welcome to cuxfilter’s documentation — cuxfilter 24.12.00 documentation](#welcome-to-cuxfilter-s-documentation-cuxfilter-24-12-00-documentation)
- [Welcome to cuSpatial’s documentation! — cuspatial 25.04.00 documentation](#welcome-to-cuspatial-s-documentation-cuspatial-25-04-00-documentation)
- [Welcome to cuSpatial’s documentation! — cuspatial 24.12.00 documentation](#welcome-to-cuspatial-s-documentation-cuspatial-24-12-00-documentation)
- [Basics — cugraph-docs 25.02.00 documentation](#basics-cugraph-docs-25-02-00-documentation)
- [Contributing to cuGraph — cugraph-docs 25.02.00 documentation](#contributing-to-cugraph-cugraph-docs-25-02-00-documentation)
- [cuProj: GPU-Accelerated Cartographic Projections and Coordinate Transformations — cuProj 25.04.00 documentation](#cuproj-gpu-accelerated-cartographic-projections-and-coordinate-transformations-cuproj-25-04-00-documentation)
- [cuGraph Blogs and Presentations — cugraph-docs 25.02.00 documentation](#cugraph-blogs-and-presentations-cugraph-docs-25-02-00-documentation)
- [Installation — cugraph-docs 25.02.00 documentation](#installation-cugraph-docs-25-02-00-documentation)
- [API — cugraph-docs 25.02.00 documentation](#api-cugraph-docs-25-02-00-documentation)
- [Commmunity Resources — cugraph-docs 25.02.00 documentation](#commmunity-resources-cugraph-docs-25-02-00-documentation)
- [cuProj: GPU-Accelerated Cartographic Projections and Coordinate Transformations — cuProj 24.12.00 documentation](#cuproj-gpu-accelerated-cartographic-projections-and-coordinate-transformations-cuproj-24-12-00-documentation)
- [License — cugraph-docs 25.02.00 documentation](#license-cugraph-docs-25-02-00-documentation)
- [CuGraph Service — cugraph-docs 25.02.00 documentation](#cugraph-service-cugraph-docs-25-02-00-documentation)
- [cuGraph Notebooks — cugraph-docs 25.02.00 documentation](#cugraph-notebooks-cugraph-docs-25-02-00-documentation)
- [Welcome to cuCIM’s documentation! — cuCIM 25.04.00 documentation](#welcome-to-cucim-s-documentation-cucim-25-04-00-documentation)
- [Building from Source — cugraph-docs 25.02.00 documentation](#building-from-source-cugraph-docs-25-02-00-documentation)
- [cuVS: Vector Search and Clustering on the GPU — cuvs 24.12.00 documentation](#cuvs-vector-search-and-clustering-on-the-gpu-cuvs-24-12-00-documentation)
- [cuVS: Vector Search and Clustering on the GPU — cuvs](#cuvs-vector-search-and-clustering-on-the-gpu-cuvs)
- [Welcome to cuCIM’s documentation! — cuCIM 24.12.00 documentation](#welcome-to-cucim-s-documentation-cucim-24-12-00-documentation)
- [Welcome to KvikIO’s Python documentation! — kvikio 24.12.00 documentation](#welcome-to-kvikio-s-python-documentation-kvikio-24-12-00-documentation)
- [RAPIDS RAFT: Reusable Accelerated Functions and Tools for Vector Search and More — raft 25.04.00 documentation](#rapids-raft-reusable-accelerated-functions-and-tools-for-vector-search-and-more-raft-25-04-00-documentation)
- [RAPIDS RAFT: Reusable Accelerated Functions and Tools for Vector Search and More — raft 24.12.00 documentation](#rapids-raft-reusable-accelerated-functions-and-tools-for-vector-search-and-more-raft-24-12-00-documentation)
- [Dask-CUDA — dask-cuda 25.04.00a24 documentation](#dask-cuda-dask-cuda-25-04-00a24-documentation)
- [Dask-CUDA — dask-cuda 24.12.00a16 documentation](#dask-cuda-dask-cuda-24-12-00a16-documentation)
- [Welcome to rmm’s documentation! — rmm 25.04.00 documentation](#welcome-to-rmm-s-documentation-rmm-25-04-00-documentation)
- [libcudf: libcudf](#libcudf-libcudf)
- [Welcome to rmm’s documentation! — rmm 24.12.00 documentation](#welcome-to-rmm-s-documentation-rmm-24-12-00-documentation)
- [libcudf: libcudf](#libcudf-libcudf)
- [libcuspatial: libcuspatial](#libcuspatial-libcuspatial)
- [libcuspatial: libcuspatial](#libcuspatial-libcuspatial)
- [libcuproj: libcuproj](#libcuproj-libcuproj)
- [libcuproj: libcuproj](#libcuproj-libcuproj)
- [cuML C++ API: Main Page](#cuml-c-api-main-page)
- [cuML C++ API: Main Page](#cuml-c-api-main-page)
- [libkvikio: Welcome to KvikIO's C++ documentation!](#libkvikio-welcome-to-kvikio-s-c-documentation-)
- [libucxx: Main Page](#libucxx-main-page)
- [libucxx: Main Page](#libucxx-main-page)
- [Welcome to rapids-cmake’s documentation! — rapids-cmake 25.04.00 documentation](#welcome-to-rapids-cmake-s-documentation-rapids-cmake-25-04-00-documentation)
- [cudf.pandas — cudf 25.02.00 documentation](#cudf-pandas-cudf-25-02-00-documentation)
- [Welcome to rapids-cmake’s documentation! — rapids-cmake 24.12.00 documentation](#welcome-to-rapids-cmake-s-documentation-rapids-cmake-24-12-00-documentation)
- [Introduction — cuml 25.02.00 documentation](#introduction-cuml-25-02-00-documentation)
- [Polars GPU engine — cudf 25.02.00 documentation](#polars-gpu-engine-cudf-25-02-00-documentation)
- [pylibcudf documentation — cudf 25.02.00 documentation](#pylibcudf-documentation-cudf-25-02-00-documentation)
- [User Guide — cuml 25.02.00 documentation](#user-guide-cuml-25-02-00-documentation)
- [libcudf documentation — cudf 25.02.00 documentation](#libcudf-documentation-cudf-25-02-00-documentation)
- [Blogs and other references — cuml 25.02.00 documentation](#blogs-and-other-references-cuml-25-02-00-documentation)
- [Python Module Index — cuCIM 25.02.00 documentation](#python-module-index-cucim-25-02-00-documentation)
- [Developer Guide — cudf 25.02.00 documentation](#developer-guide-cudf-25-02-00-documentation)
- [Search - cuCIM 25.02.00 documentation](#search-cucim-25-02-00-documentation)
- [Index — cuCIM 25.02.00 documentation](#index-cucim-25-02-00-documentation)
- [Welcome to the cuDF documentation! — cudf 25.04.00 documentation](#welcome-to-the-cudf-documentation-cudf-25-04-00-documentation)
- [cuCIM API Reference — cuCIM 25.02.00 documentation](#cucim-api-reference-cucim-25-02-00-documentation)
---
# * NOTICE * — cugraph-docs 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cugraph
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cugraph/nightly)
[stable (25.02)](/api/cugraph/stable)
[legacy (24.12)](/api/cugraph/legacy)
* [GitHub](https://github.com/rapidsai/cugraph "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
**\* NOTICE \***[#](#notice "Link to this heading")
====================================================
The cuGraph repository has been refactored to make it more efficient to build, maintain and use.
Libraries supporting GNNs are now located in the [cugraph-gnn repository](https://github.com/rapidsai/cugraph-gnn)
* [pylibwholegraph](https://github.com/rapidsai/cugraph-gnn/tree/main/python/)
- the [Wholegraph](https://docs.rapids.ai/api/cugraph/nightly/wholegraph/)
library for client memory management supporting both cuGraph-DGL and cuGraph-PyG for even greater scalability
* [cugraph\_dgl](https://github.com/rapidsai/cugraph-gnn/blob/main/readme_pages/cugraph_dgl.md)
enables the ability to use cugraph Property Graphs with Deep Graph Library (DGL)
* [cugraph\_pyg](https://github.com/rapidsai/cugraph-gnn/blob/main/readme_pages/cugraph_pyg.md)
enables the ability to use cugraph Property Graphs with PyTorch Geometric (PyG).
[RAPIDS nx-cugraph](https://rapids.ai/nx-cugraph/)
is now located in the [nx-cugraph repository](https://github.com/rapidsai/nx-cugraph)
containing a backend to NetworkX for running supported algorithms with GPU acceleration.
The [cugraph-docs repository](https://github.com/rapidsai/cugraph-docs)
contains code to generate cuGraph documentation.
—
RAPIDS Graph documentation[#](#rapids-graph-documentation "Link to this heading")
==================================================================================
[](_images/cugraph_logo_2.png)
Introduction[#](#introduction "Link to this heading")
------------------------------------------------------
cuGraph is a library of graph algorithms that seamlessly integrates into the RAPIDS data science ecosystem and allows data scientists to easily call graph algorithms using data stored in cuDF/Pandas DataFrames or CuPy/SciPy sparse matrices.
### cuGraph Using NetworkX Code[#](#cugraph-using-networkx-code "Link to this heading")
cuGraph is now available as a NetworkX backend using [nx-cugraph](https://rapids.ai/nx-cugraph/)
. Our major integration effort with NetworkX offers NetworkX users a **zero code change** option to accelerate their existing NetworkX code using an NVIDIA GPU and cuGraph.
Check out [zero code change accelerated NetworkX](nx_cugraph/)
. If you would like to continue using standard cuGraph, then continue down below.
### Getting started with cuGraph[#](#getting-started-with-cugraph "Link to this heading")
Required hardware/software for [cuGraph and RAPIDS](https://docs.rapids.ai/install/#system-req)
#### Installation[#](#installation "Link to this heading")
Please see the latest [RAPIDS System Requirements documentation](https://docs.rapids.ai/install#system-req)
.
This includes several ways to set up cuGraph
* On Unix
* [Conda](https://docs.rapids.ai/install/#conda)
* [Docker](https://docs.rapids.ai/install/#docker)
* [pip](https://docs.rapids.ai/install/#pip)
**Note: Windows use of RAPIDS depends on prior installation of** [WSL2](https://learn.microsoft.com/en-us/windows/wsl/install)
.
* On Windows
* [Conda](https://docs.rapids.ai/install#wsl2-conda)
* [Docker](https://docs.rapids.ai/install#wsl2-docker)
* [pip](https://docs.rapids.ai/install#wsl2-pip)
> Cugraph API Example
>
> import cugraph
> import cudf
>
> \# Create an instance of the popular Zachary Karate Club graph
> from cugraph.datasets import karate
> G \= karate.get\_graph()
>
> \# Call cugraph.degree\_centrality
> vertex\_bc \= cugraph.degree\_centrality(G)
>
> There are several resources containing cuGraph examples, the cuGraph [notebook repository](https://github.com/rapidsai/cugraph/blob/HEAD/notebooks/README.md)
> has many examples of loading graph data and running algorithms in Jupyter notebooks. The cuGraph [test code](https://github.com/rapidsai/cugraph/tree/main/python/cugraph/cugraph/tests)
> contains script examples of setting up and calling cuGraph algorithms.
>
> A simple example of [testing the degree centrality algorithm](https://github.com/rapidsai/cugraph/blob/HEAD/python/cugraph/cugraph/tests/centrality/test_degree_centrality.py)
> is a good place to start. There are also [multi-GPU examples](https://github.com/rapidsai/cugraph/blob/HEAD/python/cugraph/cugraph/tests/centrality/test_degree_centrality_mg.py)
> with larger data sets as well.
* * *
Table of Contents[#](#table-of-contents "Link to this heading")
----------------------------------------------------------------
* [cuGraph Introduction](basics/)
* [nx-cugraph](nx_cugraph/)
* [Installation](installation/)
* [Tutorials](tutorials/)
* [Graph Support](graph_support/)
* [WholeGraph](wholegraph/)
* [References](references/)
* [Developer Resources](dev_resources/)
* [API Reference](api_docs/)
Indices and tables[#](#indices-and-tables "Link to this heading")
------------------------------------------------------------------
* [Index](genindex/)
* [Search Page](search/)
On this page
### This Page
* [Show Source](_sources/index.rst.txt)
---
# nx-cugraph — cugraph-docs 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cugraph
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cugraph/nightly)
[stable (25.02)](/api/cugraph/stable)
[legacy (24.12)](/api/cugraph/legacy)
* [GitHub](https://github.com/rapidsai/cugraph "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
nx-cugraph[#](#nx-cugraph "Link to this heading")
==================================================
`nx-cugraph` is a NetworkX backend that provides **GPU acceleration** to many popular NetworkX algorithms.
By simply [installing and enabling nx-cugraph](https://docs.rapids.ai/api/cugraph/stable/nx_cugraph/installation/)
, users can see significant speedup on workflows where performance is hindered by the default NetworkX implementation.
Users can have GPU-based, large-scale performance **without** changing their familiar and easy-to-use NetworkX code.
**Timed result from running the following code snippet (called `demo.ipy`, showing NetworkX with vs. without `nx-cugraph`)**
import pandas as pd
import networkx as nx
url \= "https://data.rapids.ai/cugraph/datasets/cit-Patents.csv"
df \= pd.read\_csv(url, sep\=" ", names\=\["src", "dst"\], dtype\="int32")
G \= nx.from\_pandas\_edgelist(df, source\="src", target\="dst")
%time result \= nx.betweenness\_centrality(G, k\=10)
user@machine:/\# ipython demo.ipy
CPU times: user 7min 36s, sys: 5.22 s, total: 7min 41s
Wall time: 7min 41s
user@machine:/\# NX\_CUGRAPH\_AUTOCONFIG=True ipython demo.ipy
CPU times: user 4.14 s, sys: 1.13 s, total: 5.27 s
Wall time: 5.32 s
[](https://nvda.ws/4drM4re)
Try it on Google Colab
| |
| --- |
| **Zero Code Change Acceleration**
Just set the environment variable `NX_CUGRAPH_AUTOCONFIG=True` to enable `nx-cugraph` in NetworkX. |
| **Run the same code on CPU or GPU**
Nothing changes, not even your `import` statements, when going from CPU to GPU. |
`nx-cugraph` is now Generally Available (GA) as part of the `RAPIDS` package. See [RAPIDS Quick Start](https://rapids.ai/#quick-start)
to get up-and-running with `nx-cugraph`.
Contents:
* [How it Works](how-it-works/)
* [Installing nx-cugraph](installation/)
* [Supported Algorithms](supported-algorithms/)
* [Benchmarks](benchmarks/)
### This Page
* [Show Source](../_sources/nx_cugraph/index.rst.txt)
---
# Welcome to the cuDF documentation! — cudf 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cudf
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cudf/nightly/)
[stable (25.02)](/api/cudf/stable/)
[legacy (24.12)](/api/cudf/legacy/)
* [GitHub](https://github.com/rapidsai/cudf "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
Welcome to the cuDF documentation
=================================================================================================
[](_images/RAPIDS-logo-purple.png)
**cuDF** (pronounced “KOO-dee-eff”) is a Python GPU DataFrame library (built on the [Apache Arrow](https://arrow.apache.org/)
columnar memory format) for loading, joining, aggregating, filtering, and otherwise manipulating data. cuDF also provides a pandas-like API that will be familiar to data engineers & data scientists, so they can use it to easily accelerate their workflows without going into the details of CUDA programming.
`cudf.pandas` is built on cuDF and accelerates pandas code on the GPU. It supports 100% of the pandas API, using the GPU for supported operations, and automatically falling back to pandas for other operations.
[](_images/duckdb-benchmark-groupby-join.png)
Results of the [Database-like ops benchmark](https://duckdblabs.github.io/db-benchmark/)
including cudf.pandas. See details [here](cudf_pandas/benchmarks.html)
.[#](#id1 "Link to this image")
Contents:
* [cuDF User Guide](user_guide/)
* [cudf.pandas](cudf_pandas/)
* [Polars GPU engine](cudf_polars/)
* [pylibcudf documentation](pylibcudf/)
* [libcudf documentation](libcudf_docs/)
* [Indices and tables](libcudf_docs/#indices-and-tables)
* [Developer Guide](developer_guide/)
### This Page
* [Show Source](_sources/index.rst.txt)
---
# API Docs - RAPIDS Docs
[RAPIDS Docs](/)
Menu
* [View Docs on GitHub](https://github.com/rapidsai/docs)
RAPIDS API Docs
===============
Access our current docs for the RAPIDS projects below. Docs are available in both “stable” and “nightly” versions. The description of each is below to help select the docs that fit your needs.
STABLE
Current release docs; considered to be stable.
NIGHTLY
Work-in-progress release docs; considered to be unstable and released nightly.
LEGACY
Previous release docs; available for reference.
RAPIDS APIs
-----------
### cuDF
cuDF is a Python GPU DataFrame library (built on the [Apache Arrow](http://arrow.apache.org/)
columnar memory format) for loading, joining, aggregating, filtering, and otherwise manipulating data.
#### DOCS **[stable (25.02)](/api/cudf/stable)
** | **[nightly (25.04)](/api/cudf/nightly)
** | **[legacy (24.12)](/api/cudf/legacy)
**
#### LINKS **[changelog](https://github.com/rapidsai/cudf/blob/main/CHANGELOG.md)
** | **[github](https://github.com/rapidsai/cudf)
**
### dask-cuDF
Dask-cuDF extends Dask where necessary to allow its DataFrame partitions to be processed using cuDF GPU DataFrames instead of Pandas DataFrames. Dask-cuDF is used to leverage multiple gpus and multiple nodes for more performance at larger scales
#### DOCS **[stable (25.02)](/api/dask-cudf/stable)
** | **[nightly (25.04)](/api/dask-cudf/nightly)
** | **[legacy (24.12)](/api/dask-cudf/legacy)
**
#### LINKS **[changelog](https://github.com/rapidsai/cudf/blob/main/CHANGELOG.md)
** | **[github](https://github.com/rapidsai/cudf)
**
### cuML
cuML is a suite of libraries that implement machine learning algorithms and mathematical primitives functions that share compatible APIs with other RAPIDS projects.
#### DOCS **[stable (25.02)](/api/cuml/stable)
** | **[nightly (25.04)](/api/cuml/nightly)
** | **[legacy (24.12)](/api/cuml/legacy)
**
#### LINKS **[changelog](https://github.com/rapidsai/cuml/blob/main/CHANGELOG.md)
** | **[github](https://github.com/rapidsai/cuml)
**
### cuGraph
cuGraph is a GPU accelerated graph analytics library, with functionality like NetworkX, which is seamlessly integrated into the RAPIDS data science platform. cuGraph supports GNNs with PyG, DGL packages, cugraph-service for analytics on a remote graph, and WHOLEGRAPH for memory management.
#### DOCS **[stable (25.02)](/api/cugraph/stable)
** | **[nightly (25.04)](/api/cugraph/nightly)
** | **[legacy (24.12)](/api/cugraph/legacy)
**
#### LINKS **[changelog](https://github.com/rapidsai/cugraph/blob/main/CHANGELOG.md)
** | **[github](https://github.com/rapidsai/cugraph)
**
### cuxfilter
cuxfilter acts as a connector library, which provides the connections between different visualization libraries and a GPU dataframe without much hassle. This also allows the user to use charts from different libraries in a single dashboard, while also providing the interaction.
#### DOCS **[stable (25.02)](/api/cuxfilter/stable)
** | **[nightly (25.04)](/api/cuxfilter/nightly)
** | **[legacy (24.12)](/api/cuxfilter/legacy)
**
#### LINKS **[changelog](https://github.com/rapidsai/cuxfilter/blob/main/CHANGELOG.md)
** | **[github](https://github.com/rapidsai/cuxfilter)
**
### cuSpatial
cuSpatial is a GPU-accelerated vector GIS library including binary predicates (DE-9IM), point-in-polygon, spatial join, distances, and trajectory analysis.
#### DOCS **[stable (25.02)](/api/cuspatial/stable)
** | **[nightly (25.04)](/api/cuspatial/nightly)
** | **[legacy (24.12)](/api/cuspatial/legacy)
**
#### LINKS **[changelog](https://github.com/rapidsai/cuspatial/blob/main/CHANGELOG.md)
** | **[github](https://github.com/rapidsai/cuspatial)
**
### cuProj
cuProj is a GPU-accelerated geographic and geodetic coordinate transformation library which supports projecting coordinates between coordinate reference systems (CRSes), compatible with PyProj.
#### DOCS **[stable (25.02)](/api/cuProj/stable)
** | **[nightly (25.04)](/api/cuProj/nightly)
** | **[legacy (24.12)](/api/cuProj/legacy)
**
#### LINKS **[changelog](https://github.com/rapidsai/cuspatial/blob/main/CHANGELOG.md)
** | **[github](https://github.com/rapidsai/cuspatial/tree/main/python/cuproj)
**
### cusignal
cuSignal functionality has been moved to CuPy. Please see the CuPy documentation for more information.
#### DOCS
#### LINKS **[changelog](https://docs.cupy.dev/en/latest/reference/scipy_signal.html)
** | **[github](https://github.com/cupy/cupy)
**
### Java + cuDF
Java bindings for the cuDF library.
#### DOCS **[stable (25.02)](/api/cudf-java/stable)
** | **[legacy (24.12)](/api/cudf-java/legacy)
**
#### LINKS **[changelog](https://github.com/rapidsai/cudf/blob/main/CHANGELOG.md)
** | **[github](https://github.com/rapidsai/cudf/tree/main/java)
**
### cuCIM
The RAPIDS cuCIM is an extensible toolkit designed to provide GPU accelerated I/O, computer vision & image processing primitives for N-Dimensional images with a focus on biomedical imaging.
#### DOCS **[stable (25.02)](/api/cucim/stable)
** | **[nightly (25.04)](/api/cucim/nightly)
** | **[legacy (24.12)](/api/cucim/legacy)
**
#### LINKS **[changelog](https://github.com/rapidsai/cucim/blob/main/CHANGELOG.md)
** | **[github](https://github.com/rapidsai/cucim)
**
### cuVS
cuVS is a library for GPU-accelerated vector search and clustering.
#### DOCS **[stable (25.02)](/api/cuvs/stable)
** | **[nightly (25.04)](/api/cuvs/nightly)
** | **[legacy (24.12)](/api/cuvs/legacy)
**
#### LINKS **[changelog](https://github.com/rapidsai/cuvs/blob/main/CHANGELOG.md)
** | **[github](https://github.com/rapidsai/cuvs)
**
### KvikIO
KvikIO is a Python and C++ library for high performance file IO using GPUDirect Storage (GDS).
#### DOCS **[stable (25.02)](/api/kvikio/stable)
** | **[nightly (25.04)](/api/kvikio/nightly)
** | **[legacy (24.12)](/api/kvikio/legacy)
**
#### LINKS **[changelog](https://github.com/rapidsai/kvikio/blob/main/CHANGELOG.md)
** | **[github](https://github.com/rapidsai/kvikio)
**
### RAFT
RAFT contains fundamental widely-used algorithms and primitives for vector search, machine learning, and information retrieval.
#### DOCS **[stable (25.02)](/api/raft/stable)
** | **[nightly (25.04)](/api/raft/nightly)
** | **[legacy (24.12)](/api/raft/legacy)
**
#### LINKS **[changelog](https://github.com/rapidsai/raft/blob/main/CHANGELOG.md)
** | **[github](https://github.com/rapidsai/raft)
**
### Dask-CUDA
Various utilities to improve deployment and management of Dask workers on CUDA-enabled systems.
#### DOCS **[stable (25.02)](/api/dask-cuda/stable)
** | **[nightly (25.04)](/api/dask-cuda/nightly)
** | **[legacy (24.12)](/api/dask-cuda/legacy)
**
#### LINKS **[changelog](https://github.com/rapidsai/dask-cuda/blob/main/CHANGELOG.md)
** | **[github](https://github.com/rapidsai/dask-cuda)
**
### RMM
RAPIDS Memory Manager (RMM) is a central place for all device memory allocations in cuDF (C++ and Python) and other RAPIDS libraries. In addition, it is a replacement allocator for CUDA Device Memory (and CUDA Managed Memory) and a pool allocator to make CUDA device memory allocation / deallocation faster and asynchronous.
#### DOCS **[stable (25.02)](/api/rmm/stable)
** | **[nightly (25.04)](/api/rmm/nightly)
** | **[legacy (24.12)](/api/rmm/legacy)
**
#### LINKS **[changelog](https://github.com/rapidsai/rmm/blob/main/CHANGELOG.md)
** | **[github](https://github.com/rapidsai/rmm)
**
RAPIDS Libraries
----------------
### libcudf
libcudf is a C/C++ CUDA library for implementing standard dataframe operations.
#### DOCS **[stable (25.02)](/api/libcudf/stable)
** | **[nightly (25.04)](/api/libcudf/nightly)
** | **[legacy (24.12)](/api/libcudf/legacy)
**
#### LINKS **[changelog](https://github.com/rapidsai/cudf/blob/main/CHANGELOG.md)
** | **[github](https://github.com/rapidsai/cudf)
**
### libcuspatial
libcuspatial is a GPU-accelerated header-only C++ vector GIS library including binary predicates (DE-9IM), point-in-polygon, spatial join, distances, and trajectory analysis.
#### DOCS **[stable (25.02)](/api/libcuspatial/stable)
** | **[nightly (25.04)](/api/libcuspatial/nightly)
** | **[legacy (24.12)](/api/libcuspatial/legacy)
**
#### LINKS **[changelog](https://github.com/rapidsai/cuspatial/blob/main/CHANGELOG.md)
** | **[github](https://github.com/rapidsai/cuspatial)
**
### libcuproj
libcuproj is a C++ header-only library for GPU-accelerated geographic and geodetic coordinate transformation library which supports projecting coordinates between coordinate reference systems (CRSes), similar to PROJ.
#### DOCS **[stable (25.02)](/api/libcuproj/stable)
** | **[nightly (25.04)](/api/libcuproj/nightly)
** | **[legacy (24.12)](/api/libcuproj/legacy)
**
#### LINKS **[changelog](https://github.com/rapidsai/cuspatial/blob/main/CHANGELOG.md)
** | **[github](https://github.com/rapidsai/cuspatial/tree/main/cpp/cuproj)
**
### libcuml
libcuml is a C/C++ CUDA library for cuML.
#### DOCS **[stable (25.02)](/api/libcuml/stable)
** | **[nightly (25.04)](/api/libcuml/nightly)
** | **[legacy (24.12)](/api/libcuml/legacy)
**
#### LINKS **[changelog](https://github.com/rapidsai/cuml/blob/main/CHANGELOG.md)
** | **[github](https://github.com/rapidsai/cuml)
**
### libkvikio
libkvikio is a C++ header-only library providing bindings to cuFile, which enables GPUDirect Storage (GDS).
#### DOCS **[stable (25.02)](/api/libkvikio/stable)
** | **[nightly (25.04)](/api/libkvikio/nightly)
** | **[legacy (24.12)](/api/libkvikio/legacy)
**
#### LINKS **[changelog](https://github.com/rapidsai/kvikio/blob/main/CHANGELOG.md)
** | **[github](https://github.com/rapidsai/kvikio)
**
### libucxx
UCXX is an object-oriented C++ interface for UCX, with native support for Python bindings.
#### DOCS **[stable (0.42)](/api/libucxx/stable)
** | **[nightly (0.43)](/api/libucxx/nightly)
** | **[legacy (0.41)](/api/libucxx/legacy)
**
#### LINKS **[github](https://github.com/rapidsai/ucxx)
**
### rapids-cmake
This is a collection of CMake modules that are useful for all CUDA RAPIDS projects. By sharing the code in a single place it makes rolling out CMake fixes easier.
#### DOCS **[stable (25.02)](/api/rapids-cmake/stable)
** | **[nightly (25.04)](/api/rapids-cmake/nightly)
** | **[legacy (24.12)](/api/rapids-cmake/legacy)
**
#### LINKS **[changelog](https://github.com/rapidsai/rapids-cmake/blob/main/CHANGELOG.md)
** | **[github](https://github.com/rapidsai/rapids-cmake)
**
---
# References — cugraph-docs 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cugraph
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cugraph/nightly)
[stable (25.02)](/api/cugraph/stable)
[legacy (24.12)](/api/cugraph/legacy)
* [GitHub](https://github.com/rapidsai/cugraph "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
References[#](#references "Link to this heading")
==================================================
* [References](cugraph_ref/)
* [Architecture](cugraph_ref/#architecture)
* [Algorithms](cugraph_ref/#algorithms)
* [Betweenness Centrality](cugraph_ref/#betweenness-centrality)
* [Katz](cugraph_ref/#katz)
* [K-Truss](cugraph_ref/#k-truss)
* [Hungarian Algorithm](cugraph_ref/#hungarian-algorithm)
* [Leiden](cugraph_ref/#leiden)
* [Louvain](cugraph_ref/#louvain)
* [Other Papers](cugraph_ref/#other-papers)
* [Data Sets](datasets/)
* [karate](datasets/#karate)
* [dolphins](datasets/#dolphins)
* [netscience](datasets/#netscience)
* [email-Eu-core](datasets/#email-eu-core)
* [polbooks](datasets/#polbooks)
* [amazon](datasets/#amazon)
* [cit-patents](datasets/#cit-patents)
* [cyber](datasets/#cyber)
* [dining\_prefs](datasets/#dining-prefs)
* [europe\_osm](datasets/#europe-osm)
* [hollywood](datasets/#hollywood)
* [soc-livejournal1](datasets/#soc-livejournal1)
* [soc-twitter-2010](datasets/#soc-twitter-2010)
* [License](licenses/)
### This Page
* [Show Source](../_sources/references/index.rst.txt)
---
# Installation — cugraph-docs 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cugraph
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cugraph/nightly)
[stable (25.02)](/api/cugraph/stable)
[legacy (24.12)](/api/cugraph/legacy)
* [GitHub](https://github.com/rapidsai/cugraph "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
Installation[#](#installation "Link to this heading")
======================================================
* [Getting cuGraph Packages](getting_cugraph/)
* [Docker](getting_cugraph/#docker)
* [Conda](getting_cugraph/#conda)
* [PIP](getting_cugraph/#pip)
* [Building from Source](source_build/)
* [Prerequisites](source_build/#prerequisites)
* [Setting up the development environment](source_build/#setting-up-the-development-environment)
* [Clone the repository:](source_build/#clone-the-repository)
* [Create the conda environment](source_build/#create-the-conda-environment)
* [Build and Install](source_build/#build-and-install)
* [Run tests](source_build/#run-tests)
* [(OPTIONAL) Set environment variable on activation](source_build/#optional-set-environment-variable-on-activation)
* [Creating documentation](source_build/#creating-documentation)
* [Attribution](source_build/#attribution)
### This Page
* [Show Source](../_sources/installation/index.rst.txt)
---
# Graph Support — cugraph-docs 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cugraph
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cugraph/nightly)
[stable (25.02)](/api/cugraph/stable)
[legacy (24.12)](/api/cugraph/legacy)
* [GitHub](https://github.com/rapidsai/cugraph "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
Graph Support[#](#graph-support "Link to this heading")
========================================================
* [Algorithms](graph_algorithms/)
* [List of Supported and Planned Algorithms](algorithms/)
* [Supported Graph](algorithms/#supported-graph)
* [Supported Algorithms](algorithms/#supported-algorithms)
* [Compatibility](compatibility/)
* [Cugraph C++](cugraph_cpp/)
* [cuGraph C++ Overview](cugraph_cpp_support/)
* [Lexicon](cugraph_cpp_support/#lexicon)
* [Directory Structure and File Naming](cugraph_cpp_support/#directory-structure-and-file-naming)
* [File extensions](cugraph_cpp_support/#file-extensions)
* [Code and Documentation Style and Formatting](cugraph_cpp_support/#code-and-documentation-style-and-formatting)
* [cuGraph Data Structures](cugraph_cpp_support/#cugraph-data-structures)
* [Views and Ownership](cugraph_cpp_support/#views-and-ownership)
* [`rmm::device_memory_resource`](cugraph_cpp_support/#rmm-device-memory-resource-a-name-memory-resource-a)
* [Streams](cugraph_cpp_support/#streams)
* [Namespaces](cugraph_cpp_support/#namespaces)
* [Error Handling](cugraph_cpp_support/#error-handling)
* [Runtime Conditions](cugraph_cpp_support/#runtime-conditions)
* [Compile-Time Conditions](cugraph_cpp_support/#compile-time-conditions)
* [Graph Neural Network Support](gnn_support/)
* [cugraph\_pyg](PyG_support/)
* [cugraph\_dgl](DGL_support/)
* [Description](DGL_support/#description)
* [Conda](DGL_support/#conda)
* [Build from Source](DGL_support/#build-from-source)
* [Usage](DGL_support/#usage)
* [WholeGraph](wholegraph_support/)
* [Blogs to explain how RAPIDS cuGraph supports GNN’S](gnn_support/#blogs-to-explain-how-rapids-cugraph-supports-gnn-s)
* [Data Stores](datastores/)
* [Property Graph](property_graph/)
* [Knowledge Store](knowledge_stores/)
* [Feature Store](feature_stores/)
* [CuGraph Service](cugraph_service/)
### This Page
* [Show Source](../_sources/graph_support/index.rst.txt)
---
# cuGraph Introduction — cugraph-docs 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cugraph
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cugraph/nightly)
[stable (25.02)](/api/cugraph/stable)
[legacy (24.12)](/api/cugraph/legacy)
* [GitHub](https://github.com/rapidsai/cugraph "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
cuGraph Introduction[#](#cugraph-introduction "Link to this heading")
======================================================================
The Data Scientist has a collection of techniques within their proverbial toolbox. Data engineering, statistical analysis, and machine learning are among the most commonly known. However, there are numerous cases where the focus of the analysis is on the relationship between data elements. In those cases, the data is best represented as a graph. Graph analysis, also called network analysis, is a collection of algorithms for answering questions posed against graph data. Graph analysis is not new.
The first graph problem was posed by Euler in 1736, the [Seven Bridges of Konigsberg](https://en.wikipedia.org/wiki/Seven_Bridges_of_K%C3%B6nigsberg)
, and laid the foundation for the mathematical field of graph theory. The application of graph analysis covers a wide variety of fields, including marketing, biology, physics, computer science, sociology, and cyber to name a few.
RAPIDS cuGraph is a library of graph algorithms that seamlessly integrates into the RAPIDS data science ecosystem and allows the data scientist to easily call graph algorithms using data stored in a GPU DataFrame, NetworkX Graphs, or even CuPy or SciPy sparse Matrix.
Vision[#](#vision "Link to this heading")
------------------------------------------
The vision of RAPIDS cuGraph is to _**make graph analysis ubiquitous to the point that users just think in terms of analysis and not technologies or frameworks**_. This is a goal that many of us on the cuGraph team have been working on for almost twenty years. Many of the early attempts focused on solving one problem or using one technique. Those early attempts worked for the initial goal but tended to break as the scope changed (e.g., shifting to solving a dynamic graph problem with a static graph solution). The limiting factors usually came down to compute power, ease-of-use, or choosing a data structure that was not suited for all problems. NVIDIA GPUs, CUDA, and RAPIDS have totally changed the paradigm and the goal of an accelerated unified graph analytic library is now possible.
The compute power of the latest NVIDIA GPUs (RAPIDS supports Pascal and later GPU architectures) make graph analytics 1000x faster on average over NetworkX. Moreover, the internal memory speed within a GPU allows cuGraph to rapidly switch the data structure to best suit the needs of the analytic rather than being restricted to a single data structure. cuGraph is working with several frameworks for both static and dynamic graph data structures so that we always have a solution to any graph problem. Since Python has emerged as the de facto language for data science, allowing interactivity and the ability to run graph analytics in Python makes cuGraph familiar and approachable. RAPIDS wraps all the graph analytic goodness mentioned above with the ability to perform high-speed ETL, statistics, and machine learning. To make things even better, RAPIDS and DASK allows cuGraph to scale to multiple GPUs to support multi-billion edge graphs.
Terminology[#](#terminology "Link to this heading")
----------------------------------------------------
cuGraph is a collection of GPU accelerated graph algorithms and graph utility functions. The application of graph analysis covers a lot of areas. For Example:
* [Network Science](https://en.wikipedia.org/wiki/Network_science)
* [Complex Network](https://en.wikipedia.org/wiki/Complex_network)
* [Graph Theory](https://en.wikipedia.org/wiki/Graph_theory)
* [Social Network Analysis](https://en.wikipedia.org/wiki/Social_network_analysis)
cuGraph does not favor one field over another. Our developers span the breadth of fields with the focus being to produce the best graph library possible. However, each field has its own argot (jargon) for describing the graph (or network). In our documentation, we try to be consistent. In Python documentation we will mostly use the terms **Node** and **Edge** to better match NetworkX preferred term use, as well as other Python-based tools. At the CUDA/C layer, we favor the mathematical terms of **Vertex** and **Edge**.
On this page
### This Page
* [Show Source](../_sources/basics/index.md.txt)
---
# Tutorials — cugraph-docs 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cugraph
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cugraph/nightly)
[stable (25.02)](/api/cugraph/stable)
[legacy (24.12)](/api/cugraph/legacy)
* [GitHub](https://github.com/rapidsai/cugraph "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
Tutorials[#](#tutorials "Link to this heading")
================================================
* [How To Guides](how_to_guides/)
* [cuGraph Blogs and Presentations](cugraph_blogs/)
* [Blogs & Conferences](cugraph_blogs/#blogs-conferences)
* [2025](cugraph_blogs/#id1)
* [2024](cugraph_blogs/#id2)
* [2022](cugraph_blogs/#id3)
* [2021](cugraph_blogs/#id4)
* [2020](cugraph_blogs/#id5)
* [2019](cugraph_blogs/#id6)
* [2018](cugraph_blogs/#id7)
* [Media](cugraph_blogs/#media)
* [Academic Papers](cugraph_blogs/#academic-papers)
* [Other Blogs](cugraph_blogs/#other-blogs)
* [RAPIDS Event Notebooks](cugraph_blogs/#rapids-event-notebooks)
* [Commmunity Resources](community_resources/)
* [cuGraph Notebooks](cugraph_notebooks/)
* [Summary](cugraph_notebooks/#summary)
* [RAPIDS notebooks](cugraph_notebooks/#rapids-notebooks)
* [Requirements](cugraph_notebooks/#requirements)
* [Copyright](cugraph_notebooks/#copyright)
### This Page
* [Show Source](../_sources/tutorials/index.rst.txt)
---
# Developer Resources — cugraph-docs 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cugraph
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cugraph/nightly)
[stable (25.02)](/api/cugraph/stable)
[legacy (24.12)](/api/cugraph/legacy)
* [GitHub](https://github.com/rapidsai/cugraph "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
Developer Resources[#](#developer-resources "Link to this heading")
====================================================================
* [https://docs.rapids.ai/maintainers](https://docs.rapids.ai/maintainers)
* [Contributing to cuGraph](contributing/)
* [API](API/)
### This Page
* [Show Source](../_sources/dev_resources/index.rst.txt)
---
# WholeGraph — cugraph-docs 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cugraph
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cugraph/nightly)
[stable (25.02)](/api/cugraph/stable)
[legacy (24.12)](/api/cugraph/legacy)
* [GitHub](https://github.com/rapidsai/cugraph "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
WholeGraph[#](#wholegraph "Link to this heading")
==================================================
RAPIDS WholeGraph has following package:
* pylibwholegraph: shared memory-based GPU-accelerated GNN training
Contents:
* [Basics](basics/)
* [WholeGraph Introduction](basics/wholegraph_intro/)
* [WholeMemory](basics/wholememory_intro/)
* [WholeMemory Implementation Details](basics/wholememory_implementation_details/)
* [Installation](installation/)
* [Getting the WholeGraph Packages](installation/getting_wholegraph/)
* [Build Container for WholeGraph](installation/container/)
* [Building from Source](installation/source_build/)
### This Page
* [Show Source](../_sources/wholegraph/index.rst.txt)
---
# Welcome to cuCIM’s documentation! — cuCIM 25.02.00 documentation
[Skip to main content](#main-content)
Back to top
Ctrl+K
[Home](/api)
cucim
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cucim/nightly)
[stable (25.02)](/api/cucim/stable)
[legacy (24.12)](/api/cucim/legacy)
Welcome to cuCIM’s documentation
====================================================================================================
cuCIM (Compute Unified Device Architecture Clara IMage) is an open-source, accelerated computer vision and image processing software library for multidimensional images used in biomedical, geospatial, material and life science, and remote sensing use cases.
cuCIM provides GPU-accelearted I/O, computer vision and image processing primitives for N-Dimensional images including:
* color conversion
* exposure
* feature extraction
* filters
* measure
* metrics
* morphology
* registration
* restoration
* segmentation
* transforms
cuCIM supports the following formats:
* Aperio ScanScope Virtual Slide (SVS)
* Philips TIFF
* Generic Tiled, Multi-resolution RGB TIFF files with the following compression schemes:
* No Compression
* JPEG
* JPEG2000
* Lempel-Ziv-Welch (LZW)
* Deflate
Our API mirrors [scikit-image](https://scikit-image.org/)
for image manipulation and [OpenSlide](https://openslide.org/)
for image loading.
cuCIM is interoperable with the following workflows:
* Albumentations
* cuPY
* Data Loading Library (DALI)
* JFX
* MONAI
* Numba
* NumPy
* PyTorch
* Tensorflow
* Triton
cuCIM is fully open sourced under the Apache-2.0 license, and the Clara and RAPIDS teams welcomes new and seasoned contributors, users and hobbyists! You may download cuCIM via Anaconda [Conda](https://anaconda.org/rapidsai-nightly/cucim)
or [PyPI](https://pypi.org/project/cucim/)
Thank you for your wonderful support! Below, we provide some resources to help get you started.
**Blogs**
* [Accelerating Scikit-Image API with cuCIM: n-Dimensional Image Processing and IO on GPUs](https://developer.nvidia.com/blog/cucim-rapid-n-dimensional-image-processing-and-i-o-on-gpus/)
* [Accelerating Digital Pathology Pipelines with NVIDIA Clara™ Deploy](https://developer.nvidia.com/blog/accelerating-digital-pathology-pipelines-with-nvidia-clara-deploy-2/)
**Webinars**
* [cuCIM: a GPU Image IO and Processing Library](https://www.youtube.com/watch?v=G46kOOM9xbQ)
Contents[#](#contents "Permalink to this heading")
===================================================
* [cuCIM API Reference](api/)
* [Clara Submodules](api/#module-cucim.clara)
* [`CuImage`](api/#cucim.clara.CuImage)
* [`CuImage.associated_image()`](api/#cucim.clara.CuImage.associated_image)
* [`CuImage.associated_images`](api/#cucim.clara.CuImage.associated_images)
* [`CuImage.cache()`](api/#cucim.clara.CuImage.cache)
* [`CuImage.channel_names`](api/#cucim.clara.CuImage.channel_names)
* [`CuImage.close()`](api/#cucim.clara.CuImage.close)
* [`CuImage.coord_sys`](api/#cucim.clara.CuImage.coord_sys)
* [`CuImage.device`](api/#cucim.clara.CuImage.device)
* [`CuImage.dims`](api/#cucim.clara.CuImage.dims)
* [`CuImage.direction`](api/#cucim.clara.CuImage.direction)
* [`CuImage.dtype`](api/#cucim.clara.CuImage.dtype)
* [`CuImage.is_loaded`](api/#cucim.clara.CuImage.is_loaded)
* [`CuImage.is_trace_enabled`](api/#cucim.clara.CuImage.is_trace_enabled)
* [`CuImage.metadata`](api/#cucim.clara.CuImage.metadata)
* [`CuImage.ndim`](api/#cucim.clara.CuImage.ndim)
* [`CuImage.origin`](api/#cucim.clara.CuImage.origin)
* [`CuImage.path`](api/#cucim.clara.CuImage.path)
* [`CuImage.profiler()`](api/#cucim.clara.CuImage.profiler)
* [`CuImage.raw_metadata`](api/#cucim.clara.CuImage.raw_metadata)
* [`CuImage.read_region()`](api/#cucim.clara.CuImage.read_region)
* [`CuImage.resolutions`](api/#cucim.clara.CuImage.resolutions)
* [`CuImage.save()`](api/#cucim.clara.CuImage.save)
* [`CuImage.shape`](api/#cucim.clara.CuImage.shape)
* [`CuImage.size()`](api/#cucim.clara.CuImage.size)
* [`CuImage.spacing()`](api/#cucim.clara.CuImage.spacing)
* [`CuImage.spacing_units()`](api/#cucim.clara.CuImage.spacing_units)
* [`CuImage.typestr`](api/#cucim.clara.CuImage.typestr)
* [`DLDataType`](api/#cucim.clara.DLDataType)
* [`DLDataType.bits`](api/#cucim.clara.DLDataType.bits)
* [`DLDataType.code`](api/#cucim.clara.DLDataType.code)
* [`DLDataType.lanes`](api/#cucim.clara.DLDataType.lanes)
* [`DLDataTypeCode`](api/#cucim.clara.DLDataTypeCode)
* [`DLDataTypeCode.DLBfloat`](api/#cucim.clara.DLDataTypeCode.DLBfloat)
* [`DLDataTypeCode.DLFloat`](api/#cucim.clara.DLDataTypeCode.DLFloat)
* [`DLDataTypeCode.DLInt`](api/#cucim.clara.DLDataTypeCode.DLInt)
* [`DLDataTypeCode.DLUInt`](api/#cucim.clara.DLDataTypeCode.DLUInt)
* [`DLDataTypeCode.name`](api/#cucim.clara.DLDataTypeCode.name)
* [`DLDataTypeCode.value`](api/#cucim.clara.DLDataTypeCode.value)
* [cache](api/#module-cucim.clara.cache)
* [`CacheType`](api/#cucim.clara.cache.CacheType)
* [`ImageCache`](api/#cucim.clara.cache.ImageCache)
* [`preferred_memory_capacity()`](api/#cucim.clara.cache.preferred_memory_capacity)
* [filesystem](api/#module-cucim.clara.filesystem)
* [`CuFileDriver`](api/#cucim.clara.filesystem.CuFileDriver)
* [`close()`](api/#cucim.clara.filesystem.close)
* [`discard_page_cache()`](api/#cucim.clara.filesystem.discard_page_cache)
* [`open()`](api/#cucim.clara.filesystem.open)
* [`pread()`](api/#cucim.clara.filesystem.pread)
* [`pwrite()`](api/#cucim.clara.filesystem.pwrite)
* [io](api/#module-cucim.clara.io)
* [`Device`](api/#cucim.clara.io.Device)
* [`DeviceType`](api/#cucim.clara.io.DeviceType)
* [core Submodules](api/#core-submodules)
* [color](api/#module-cucim.core.operations.color)
* [`color_jitter()`](api/#cucim.core.operations.color.color_jitter)
* [`image_to_absorbance()`](api/#cucim.core.operations.color.image_to_absorbance)
* [`normalize_colors_pca()`](api/#cucim.core.operations.color.normalize_colors_pca)
* [`stain_extraction_pca()`](api/#cucim.core.operations.color.stain_extraction_pca)
* [expose](api/#module-cucim.core.operations.expose)
* [intensity](api/#module-cucim.core.operations.intensity)
* [`normalize_data()`](api/#cucim.core.operations.intensity.normalize_data)
* [`rand_zoom()`](api/#cucim.core.operations.intensity.rand_zoom)
* [`scale_intensity_range()`](api/#cucim.core.operations.intensity.scale_intensity_range)
* [`zoom()`](api/#cucim.core.operations.intensity.zoom)
* [morphology](api/#module-cucim.core.operations.morphology)
* [`distance_transform_edt()`](api/#cucim.core.operations.morphology.distance_transform_edt)
* [spatial](api/#module-cucim.core.operations.spatial)
* [`image_flip()`](api/#cucim.core.operations.spatial.image_flip)
* [`image_rotate_90()`](api/#cucim.core.operations.spatial.image_rotate_90)
* [`rand_image_flip()`](api/#cucim.core.operations.spatial.rand_image_flip)
* [`rand_image_rotate_90()`](api/#cucim.core.operations.spatial.rand_image_rotate_90)
* [skimage Submodules](api/#skimage-submodules)
* [color](api/#id13)
* [`combine_stains()`](api/#cucim.skimage.color.combine_stains)
* [`convert_colorspace()`](api/#cucim.skimage.color.convert_colorspace)
* [`deltaE_cie76()`](api/#cucim.skimage.color.deltaE_cie76)
* [`deltaE_ciede2000()`](api/#cucim.skimage.color.deltaE_ciede2000)
* [`deltaE_ciede94()`](api/#cucim.skimage.color.deltaE_ciede94)
* [`deltaE_cmc()`](api/#cucim.skimage.color.deltaE_cmc)
* [`gray2rgb()`](api/#cucim.skimage.color.gray2rgb)
* [`gray2rgba()`](api/#cucim.skimage.color.gray2rgba)
* [`hed2rgb()`](api/#cucim.skimage.color.hed2rgb)
* [`hsv2rgb()`](api/#cucim.skimage.color.hsv2rgb)
* [`lab2lch()`](api/#cucim.skimage.color.lab2lch)
* [`lab2rgb()`](api/#cucim.skimage.color.lab2rgb)
* [`lab2xyz()`](api/#cucim.skimage.color.lab2xyz)
* [`label2rgb()`](api/#cucim.skimage.color.label2rgb)
* [`lch2lab()`](api/#cucim.skimage.color.lch2lab)
* [`luv2rgb()`](api/#cucim.skimage.color.luv2rgb)
* [`luv2xyz()`](api/#cucim.skimage.color.luv2xyz)
* [`rgb2gray()`](api/#cucim.skimage.color.rgb2gray)
* [`rgb2hed()`](api/#cucim.skimage.color.rgb2hed)
* [`rgb2hsv()`](api/#cucim.skimage.color.rgb2hsv)
* [`rgb2lab()`](api/#cucim.skimage.color.rgb2lab)
* [`rgb2luv()`](api/#cucim.skimage.color.rgb2luv)
* [`rgb2rgbcie()`](api/#cucim.skimage.color.rgb2rgbcie)
* [`rgb2xyz()`](api/#cucim.skimage.color.rgb2xyz)
* [`rgb2ycbcr()`](api/#cucim.skimage.color.rgb2ycbcr)
* [`rgb2ydbdr()`](api/#cucim.skimage.color.rgb2ydbdr)
* [`rgb2yiq()`](api/#cucim.skimage.color.rgb2yiq)
* [`rgb2ypbpr()`](api/#cucim.skimage.color.rgb2ypbpr)
* [`rgb2yuv()`](api/#cucim.skimage.color.rgb2yuv)
* [`rgba2rgb()`](api/#cucim.skimage.color.rgba2rgb)
* [`rgbcie2rgb()`](api/#cucim.skimage.color.rgbcie2rgb)
* [`separate_stains()`](api/#cucim.skimage.color.separate_stains)
* [`xyz2lab()`](api/#cucim.skimage.color.xyz2lab)
* [`xyz2luv()`](api/#cucim.skimage.color.xyz2luv)
* [`xyz2rgb()`](api/#cucim.skimage.color.xyz2rgb)
* [`xyz_tristimulus_values()`](api/#cucim.skimage.color.xyz_tristimulus_values)
* [`ycbcr2rgb()`](api/#cucim.skimage.color.ycbcr2rgb)
* [`ydbdr2rgb()`](api/#cucim.skimage.color.ydbdr2rgb)
* [`yiq2rgb()`](api/#cucim.skimage.color.yiq2rgb)
* [`ypbpr2rgb()`](api/#cucim.skimage.color.ypbpr2rgb)
* [`yuv2rgb()`](api/#cucim.skimage.color.yuv2rgb)
* [data](api/#module-cucim.skimage.data)
* [`binary_blobs()`](api/#cucim.skimage.data.binary_blobs)
* [exposure](api/#module-cucim.skimage.exposure)
* [`adjust_gamma()`](api/#cucim.skimage.exposure.adjust_gamma)
* [`adjust_log()`](api/#cucim.skimage.exposure.adjust_log)
* [`adjust_sigmoid()`](api/#cucim.skimage.exposure.adjust_sigmoid)
* [`cumulative_distribution()`](api/#cucim.skimage.exposure.cumulative_distribution)
* [`equalize_adapthist()`](api/#cucim.skimage.exposure.equalize_adapthist)
* [`equalize_hist()`](api/#cucim.skimage.exposure.equalize_hist)
* [`histogram()`](api/#cucim.skimage.exposure.histogram)
* [`is_low_contrast()`](api/#cucim.skimage.exposure.is_low_contrast)
* [`match_histograms()`](api/#cucim.skimage.exposure.match_histograms)
* [`rescale_intensity()`](api/#cucim.skimage.exposure.rescale_intensity)
* [feature](api/#module-cucim.skimage.feature)
* [`blob_dog()`](api/#cucim.skimage.feature.blob_dog)
* [`blob_doh()`](api/#cucim.skimage.feature.blob_doh)
* [`blob_log()`](api/#cucim.skimage.feature.blob_log)
* [`canny()`](api/#cucim.skimage.feature.canny)
* [`corner_foerstner()`](api/#cucim.skimage.feature.corner_foerstner)
* [`corner_harris()`](api/#cucim.skimage.feature.corner_harris)
* [`corner_kitchen_rosenfeld()`](api/#cucim.skimage.feature.corner_kitchen_rosenfeld)
* [`corner_peaks()`](api/#cucim.skimage.feature.corner_peaks)
* [`corner_shi_tomasi()`](api/#cucim.skimage.feature.corner_shi_tomasi)
* [`daisy()`](api/#cucim.skimage.feature.daisy)
* [`hessian_matrix()`](api/#cucim.skimage.feature.hessian_matrix)
* [`hessian_matrix_det()`](api/#cucim.skimage.feature.hessian_matrix_det)
* [`hessian_matrix_eigvals()`](api/#cucim.skimage.feature.hessian_matrix_eigvals)
* [`match_descriptors()`](api/#cucim.skimage.feature.match_descriptors)
* [`match_template()`](api/#cucim.skimage.feature.match_template)
* [`multiscale_basic_features()`](api/#cucim.skimage.feature.multiscale_basic_features)
* [`peak_local_max()`](api/#cucim.skimage.feature.peak_local_max)
* [`shape_index()`](api/#cucim.skimage.feature.shape_index)
* [`structure_tensor()`](api/#cucim.skimage.feature.structure_tensor)
* [`structure_tensor_eigenvalues()`](api/#cucim.skimage.feature.structure_tensor_eigenvalues)
* [filters](api/#module-cucim.skimage.filters)
* [`LPIFilter2D`](api/#cucim.skimage.filters.LPIFilter2D)
* [`apply_hysteresis_threshold()`](api/#cucim.skimage.filters.apply_hysteresis_threshold)
* [`butterworth()`](api/#cucim.skimage.filters.butterworth)
* [`correlate_sparse()`](api/#cucim.skimage.filters.correlate_sparse)
* [`difference_of_gaussians()`](api/#cucim.skimage.filters.difference_of_gaussians)
* [`farid()`](api/#cucim.skimage.filters.farid)
* [`farid_h()`](api/#cucim.skimage.filters.farid_h)
* [`farid_v()`](api/#cucim.skimage.filters.farid_v)
* [`filter_forward()`](api/#cucim.skimage.filters.filter_forward)
* [`filter_inverse()`](api/#cucim.skimage.filters.filter_inverse)
* [`frangi()`](api/#cucim.skimage.filters.frangi)
* [`gabor()`](api/#cucim.skimage.filters.gabor)
* [`gabor_kernel()`](api/#cucim.skimage.filters.gabor_kernel)
* [`gaussian()`](api/#cucim.skimage.filters.gaussian)
* [`hessian()`](api/#cucim.skimage.filters.hessian)
* [`laplace()`](api/#cucim.skimage.filters.laplace)
* [`median()`](api/#cucim.skimage.filters.median)
* [`meijering()`](api/#cucim.skimage.filters.meijering)
* [`prewitt()`](api/#cucim.skimage.filters.prewitt)
* [`prewitt_h()`](api/#cucim.skimage.filters.prewitt_h)
* [`prewitt_v()`](api/#cucim.skimage.filters.prewitt_v)
* [`rank_order()`](api/#cucim.skimage.filters.rank_order)
* [`roberts()`](api/#cucim.skimage.filters.roberts)
* [`roberts_neg_diag()`](api/#cucim.skimage.filters.roberts_neg_diag)
* [`roberts_pos_diag()`](api/#cucim.skimage.filters.roberts_pos_diag)
* [`sato()`](api/#cucim.skimage.filters.sato)
* [`scharr()`](api/#cucim.skimage.filters.scharr)
* [`scharr_h()`](api/#cucim.skimage.filters.scharr_h)
* [`scharr_v()`](api/#cucim.skimage.filters.scharr_v)
* [`sobel()`](api/#cucim.skimage.filters.sobel)
* [`sobel_h()`](api/#cucim.skimage.filters.sobel_h)
* [`sobel_v()`](api/#cucim.skimage.filters.sobel_v)
* [`threshold_isodata()`](api/#cucim.skimage.filters.threshold_isodata)
* [`threshold_li()`](api/#cucim.skimage.filters.threshold_li)
* [`threshold_local()`](api/#cucim.skimage.filters.threshold_local)
* [`threshold_mean()`](api/#cucim.skimage.filters.threshold_mean)
* [`threshold_minimum()`](api/#cucim.skimage.filters.threshold_minimum)
* [`threshold_multiotsu()`](api/#cucim.skimage.filters.threshold_multiotsu)
* [`threshold_niblack()`](api/#cucim.skimage.filters.threshold_niblack)
* [`threshold_otsu()`](api/#cucim.skimage.filters.threshold_otsu)
* [`threshold_sauvola()`](api/#cucim.skimage.filters.threshold_sauvola)
* [`threshold_triangle()`](api/#cucim.skimage.filters.threshold_triangle)
* [`threshold_yen()`](api/#cucim.skimage.filters.threshold_yen)
* [`try_all_threshold()`](api/#cucim.skimage.filters.try_all_threshold)
* [`unsharp_mask()`](api/#cucim.skimage.filters.unsharp_mask)
* [`wiener()`](api/#cucim.skimage.filters.wiener)
* [`window()`](api/#cucim.skimage.filters.window)
* [measure](api/#module-cucim.skimage.measure)
* [`approximate_polygon()`](api/#cucim.skimage.measure.approximate_polygon)
* [`block_reduce()`](api/#cucim.skimage.measure.block_reduce)
* [`blur_effect()`](api/#cucim.skimage.measure.blur_effect)
* [`centroid()`](api/#cucim.skimage.measure.centroid)
* [`euler_number()`](api/#cucim.skimage.measure.euler_number)
* [`inertia_tensor()`](api/#cucim.skimage.measure.inertia_tensor)
* [`inertia_tensor_eigvals()`](api/#cucim.skimage.measure.inertia_tensor_eigvals)
* [`intersection_coeff()`](api/#cucim.skimage.measure.intersection_coeff)
* [`label()`](api/#cucim.skimage.measure.label)
* [`manders_coloc_coeff()`](api/#cucim.skimage.measure.manders_coloc_coeff)
* [`manders_overlap_coeff()`](api/#cucim.skimage.measure.manders_overlap_coeff)
* [`moments()`](api/#cucim.skimage.measure.moments)
* [`moments_central()`](api/#cucim.skimage.measure.moments_central)
* [`moments_coords()`](api/#cucim.skimage.measure.moments_coords)
* [`moments_coords_central()`](api/#cucim.skimage.measure.moments_coords_central)
* [`moments_hu()`](api/#cucim.skimage.measure.moments_hu)
* [`moments_normalized()`](api/#cucim.skimage.measure.moments_normalized)
* [`pearson_corr_coeff()`](api/#cucim.skimage.measure.pearson_corr_coeff)
* [`perimeter()`](api/#cucim.skimage.measure.perimeter)
* [`perimeter_crofton()`](api/#cucim.skimage.measure.perimeter_crofton)
* [`profile_line()`](api/#cucim.skimage.measure.profile_line)
* [`regionprops()`](api/#cucim.skimage.measure.regionprops)
* [`regionprops_table()`](api/#cucim.skimage.measure.regionprops_table)
* [`shannon_entropy()`](api/#cucim.skimage.measure.shannon_entropy)
* [`subdivide_polygon()`](api/#cucim.skimage.measure.subdivide_polygon)
* [metrics](api/#module-cucim.skimage.metrics)
* [`adapted_rand_error()`](api/#cucim.skimage.metrics.adapted_rand_error)
* [`contingency_table()`](api/#cucim.skimage.metrics.contingency_table)
* [`mean_squared_error()`](api/#cucim.skimage.metrics.mean_squared_error)
* [`normalized_mutual_information()`](api/#cucim.skimage.metrics.normalized_mutual_information)
* [`normalized_root_mse()`](api/#cucim.skimage.metrics.normalized_root_mse)
* [`peak_signal_noise_ratio()`](api/#cucim.skimage.metrics.peak_signal_noise_ratio)
* [`structural_similarity()`](api/#cucim.skimage.metrics.structural_similarity)
* [`variation_of_information()`](api/#cucim.skimage.metrics.variation_of_information)
* [morphology](api/#id263)
* [`ball()`](api/#cucim.skimage.morphology.ball)
* [`binary_closing()`](api/#cucim.skimage.morphology.binary_closing)
* [`binary_dilation()`](api/#cucim.skimage.morphology.binary_dilation)
* [`binary_erosion()`](api/#cucim.skimage.morphology.binary_erosion)
* [`binary_opening()`](api/#cucim.skimage.morphology.binary_opening)
* [`black_tophat()`](api/#cucim.skimage.morphology.black_tophat)
* [`closing()`](api/#cucim.skimage.morphology.closing)
* [`diamond()`](api/#cucim.skimage.morphology.diamond)
* [`dilation()`](api/#cucim.skimage.morphology.dilation)
* [`disk()`](api/#cucim.skimage.morphology.disk)
* [`erosion()`](api/#cucim.skimage.morphology.erosion)
* [`footprint_from_sequence()`](api/#cucim.skimage.morphology.footprint_from_sequence)
* [`footprint_rectangle()`](api/#cucim.skimage.morphology.footprint_rectangle)
* [`isotropic_closing()`](api/#cucim.skimage.morphology.isotropic_closing)
* [`isotropic_dilation()`](api/#cucim.skimage.morphology.isotropic_dilation)
* [`isotropic_erosion()`](api/#cucim.skimage.morphology.isotropic_erosion)
* [`isotropic_opening()`](api/#cucim.skimage.morphology.isotropic_opening)
* [`medial_axis()`](api/#cucim.skimage.morphology.medial_axis)
* [`octagon()`](api/#cucim.skimage.morphology.octagon)
* [`octahedron()`](api/#cucim.skimage.morphology.octahedron)
* [`opening()`](api/#cucim.skimage.morphology.opening)
* [`reconstruction()`](api/#cucim.skimage.morphology.reconstruction)
* [`remove_small_holes()`](api/#cucim.skimage.morphology.remove_small_holes)
* [`remove_small_objects()`](api/#cucim.skimage.morphology.remove_small_objects)
* [`star()`](api/#cucim.skimage.morphology.star)
* [`thin()`](api/#cucim.skimage.morphology.thin)
* [`white_tophat()`](api/#cucim.skimage.morphology.white_tophat)
* [registration](api/#module-cucim.skimage.registration)
* [`optical_flow_ilk()`](api/#cucim.skimage.registration.optical_flow_ilk)
* [`optical_flow_tvl1()`](api/#cucim.skimage.registration.optical_flow_tvl1)
* [`phase_cross_correlation()`](api/#cucim.skimage.registration.phase_cross_correlation)
* [restoration](api/#module-cucim.skimage.restoration)
* [`calibrate_denoiser()`](api/#cucim.skimage.restoration.calibrate_denoiser)
* [`denoise_invariant()`](api/#cucim.skimage.restoration.denoise_invariant)
* [`denoise_tv_chambolle()`](api/#cucim.skimage.restoration.denoise_tv_chambolle)
* [`richardson_lucy()`](api/#cucim.skimage.restoration.richardson_lucy)
* [`unsupervised_wiener()`](api/#cucim.skimage.restoration.unsupervised_wiener)
* [`wiener()`](api/#cucim.skimage.restoration.wiener)
* [segmentation](api/#module-cucim.skimage.segmentation)
* [`chan_vese()`](api/#cucim.skimage.segmentation.chan_vese)
* [`checkerboard_level_set()`](api/#cucim.skimage.segmentation.checkerboard_level_set)
* [`clear_border()`](api/#cucim.skimage.segmentation.clear_border)
* [`disk_level_set()`](api/#cucim.skimage.segmentation.disk_level_set)
* [`expand_labels()`](api/#cucim.skimage.segmentation.expand_labels)
* [`find_boundaries()`](api/#cucim.skimage.segmentation.find_boundaries)
* [`inverse_gaussian_gradient()`](api/#cucim.skimage.segmentation.inverse_gaussian_gradient)
* [`join_segmentations()`](api/#cucim.skimage.segmentation.join_segmentations)
* [`mark_boundaries()`](api/#cucim.skimage.segmentation.mark_boundaries)
* [`morphological_chan_vese()`](api/#cucim.skimage.segmentation.morphological_chan_vese)
* [`morphological_geodesic_active_contour()`](api/#cucim.skimage.segmentation.morphological_geodesic_active_contour)
* [`random_walker()`](api/#cucim.skimage.segmentation.random_walker)
* [`relabel_sequential()`](api/#cucim.skimage.segmentation.relabel_sequential)
* [transform](api/#module-cucim.skimage.transform)
* [`AffineTransform`](api/#cucim.skimage.transform.AffineTransform)
* [`EssentialMatrixTransform`](api/#cucim.skimage.transform.EssentialMatrixTransform)
* [`EuclideanTransform`](api/#cucim.skimage.transform.EuclideanTransform)
* [`FundamentalMatrixTransform`](api/#cucim.skimage.transform.FundamentalMatrixTransform)
* [`PiecewiseAffineTransform`](api/#cucim.skimage.transform.PiecewiseAffineTransform)
* [`PolynomialTransform`](api/#cucim.skimage.transform.PolynomialTransform)
* [`ProjectiveTransform`](api/#cucim.skimage.transform.ProjectiveTransform)
* [`SimilarityTransform`](api/#cucim.skimage.transform.SimilarityTransform)
* [`downscale_local_mean()`](api/#cucim.skimage.transform.downscale_local_mean)
* [`estimate_transform()`](api/#cucim.skimage.transform.estimate_transform)
* [`integral_image()`](api/#cucim.skimage.transform.integral_image)
* [`integrate()`](api/#cucim.skimage.transform.integrate)
* [`matrix_transform()`](api/#cucim.skimage.transform.matrix_transform)
* [`pyramid_expand()`](api/#cucim.skimage.transform.pyramid_expand)
* [`pyramid_gaussian()`](api/#cucim.skimage.transform.pyramid_gaussian)
* [`pyramid_laplacian()`](api/#cucim.skimage.transform.pyramid_laplacian)
* [`pyramid_reduce()`](api/#cucim.skimage.transform.pyramid_reduce)
* [`rescale()`](api/#cucim.skimage.transform.rescale)
* [`resize()`](api/#cucim.skimage.transform.resize)
* [`resize_local_mean()`](api/#cucim.skimage.transform.resize_local_mean)
* [`rotate()`](api/#cucim.skimage.transform.rotate)
* [`swirl()`](api/#cucim.skimage.transform.swirl)
* [`warp()`](api/#cucim.skimage.transform.warp)
* [`warp_coords()`](api/#cucim.skimage.transform.warp_coords)
* [`warp_polar()`](api/#cucim.skimage.transform.warp_polar)
* [util](api/#module-cucim.skimage.util)
* [`crop()`](api/#cucim.skimage.util.crop)
* [`dtype_limits()`](api/#cucim.skimage.util.dtype_limits)
* [`img_as_bool()`](api/#cucim.skimage.util.img_as_bool)
* [`img_as_float()`](api/#cucim.skimage.util.img_as_float)
* [`img_as_float32()`](api/#cucim.skimage.util.img_as_float32)
* [`img_as_float64()`](api/#cucim.skimage.util.img_as_float64)
* [`img_as_int()`](api/#cucim.skimage.util.img_as_int)
* [`img_as_ubyte()`](api/#cucim.skimage.util.img_as_ubyte)
* [`img_as_uint()`](api/#cucim.skimage.util.img_as_uint)
* [`invert()`](api/#cucim.skimage.util.invert)
* [`map_array()`](api/#cucim.skimage.util.map_array)
* [`random_noise()`](api/#cucim.skimage.util.random_noise)
* [`view_as_blocks()`](api/#cucim.skimage.util.view_as_blocks)
* [`view_as_windows()`](api/#cucim.skimage.util.view_as_windows)
* [Submodule Contents](api/#submodule-contents)
* [skimage](api/#module-cucim.skimage)
* [Subpackages](api/#subpackages)
* [Utility Functions](api/#utility-functions)
Indices and tables[#](#indices-and-tables "Permalink to this heading")
=======================================================================
* [Index](genindex/)
* [Module Index](py-modindex/)
* [Search Page](search/)
On this page
[Show Source](_sources/index.rst.txt)
---
# API Reference — cugraph-docs 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cugraph
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cugraph/nightly)
[stable (25.02)](/api/cugraph/stable)
[legacy (24.12)](/api/cugraph/legacy)
* [GitHub](https://github.com/rapidsai/cugraph "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
API Reference[#](#api-reference "Link to this heading")
========================================================
This page provides a list of all publicly accessible Python modules with in the Graph collection
Core Graph API Documentation[#](#core-graph-api-documentation "Link to this heading")
--------------------------------------------------------------------------------------
Core Graph API Documentation
* [cugraph API Reference](cugraph/)
* [Graph Classes](cugraph/structure/)
* [Constructors](cugraph/structure/#constructors)
* [Adding Data](cugraph/structure/#adding-data)
* [Checks](cugraph/structure/#checks)
* [Symmetrize](cugraph/structure/#symmetrize)
* [Conversion from Other Formats](cugraph/structure/#conversion-from-other-formats)
* [NumberMap](cugraph/structure/#numbermap)
* [Other](cugraph/structure/#other)
* [Graph Implementation](cugraph/graph_implementation/)
* [Graph Implementation](cugraph/graph_implementation/#id1)
* [Property Graph](cugraph/property_graph/)
* [Property Graph](cugraph/property_graph/#id1)
* [Centrality](cugraph/centrality/)
* [Betweenness Centrality](cugraph/centrality/#betweenness-centrality)
* [Katz Centrality](cugraph/centrality/#katz-centrality)
* [Degree Centrality](cugraph/centrality/#degree-centrality)
* [Eigenvector Centrality](cugraph/centrality/#eigenvector-centrality)
* [Community](cugraph/community/)
* [EgoNet](cugraph/community/#egonet)
* [Ensemble clustering for graphs (ECG)](cugraph/community/#ensemble-clustering-for-graphs-ecg)
* [K-Truss](cugraph/community/#k-truss)
* [Leiden](cugraph/community/#leiden)
* [Louvain](cugraph/community/#louvain)
* [Louvain (MG)](cugraph/community/#louvain-mg)
* [Spectral Clustering](cugraph/community/#spectral-clustering)
* [Subgraph Extraction](cugraph/community/#subgraph-extraction)
* [Triangle Counting](cugraph/community/#triangle-counting)
* [Components](cugraph/components/)
* [Connected Components](cugraph/components/#connected-components)
* [Connected Components (MG)](cugraph/components/#connected-components-mg)
* [Cores](cugraph/cores/)
* [Core Number](cugraph/cores/#core-number)
* [K-Core](cugraph/cores/#k-core)
* [Layout](cugraph/layout/)
* [Force Atlas 2](cugraph/layout/#force-atlas-2)
* [Linear Assignment](cugraph/linear_assignment/)
* [Hungarian](cugraph/linear_assignment/#hungarian)
* [Link Analysis](cugraph/link_analysis/)
* [HITS](cugraph/link_analysis/#hits)
* [HITS (MG)](cugraph/link_analysis/#hits-mg)
* [Pagerank](cugraph/link_analysis/#pagerank)
* [Pagerank (MG)](cugraph/link_analysis/#pagerank-mg)
* [Link Prediction](cugraph/link_prediction/)
* [Jaccard Coefficient](cugraph/link_prediction/#jaccard-coefficient)
* [Overlap Coefficient](cugraph/link_prediction/#overlap-coefficient)
* [Sorensen Coefficient](cugraph/link_prediction/#sorensen-coefficient)
* [Sampling](cugraph/sampling/)
* [Random Walks](cugraph/sampling/#random-walks)
* [Node2Vec](cugraph/sampling/#node2vec)
* [Traversal](cugraph/traversal/)
* [Breadth-first-search](cugraph/traversal/#breadth-first-search)
* [Breadth-first-search (MG)](cugraph/traversal/#breadth-first-search-mg)
* [Single-source-shortest-path](cugraph/traversal/#single-source-shortest-path)
* [Single-source-shortest-path (MG)](cugraph/traversal/#single-source-shortest-path-mg)
* [Tree](cugraph/tree/)
* [Minimum Spanning Tree](cugraph/tree/#minimum-spanning-tree)
* [Maximum Spanning Tree](cugraph/tree/#maximum-spanning-tree)
* [Generators](cugraph/generators/)
* [RMAT](cugraph/generators/#rmat)
* [DASK MG Helper functions](cugraph/helper_functions/)
* [Methods](cugraph/helper_functions/#methods)
* [Multi-GPU with cuGraph](cugraph/dask-cugraph/)
* [Distributed graph analytics](cugraph/dask-cugraph/#distributed-graph-analytics)
* [Example](cugraph/dask-cugraph/#example)
* [pylibcugraph API reference](plc/pylibcugraph/)
* [Methods](plc/pylibcugraph/#methods)
* [pylibcugraph.eigenvector\_centrality](api/plc/pylibcugraph.eigenvector_centrality/)
* [pylibcugraph.katz\_centrality](api/plc/pylibcugraph.katz_centrality/)
* [pylibcugraph.strongly\_connected\_components](api/plc/pylibcugraph.strongly_connected_components/)
* [pylibcugraph.weakly\_connected\_components](api/plc/pylibcugraph.weakly_connected_components/)
* [pylibcugraph.pagerank](api/plc/pylibcugraph.pagerank/)
* [pylibcugraph.hits](api/plc/pylibcugraph.hits/)
* [pylibcugraph.node2vec](api/plc/pylibcugraph.node2vec/)
* [pylibcugraph.bfs](api/plc/pylibcugraph.bfs/)
* [pylibcugraph.sssp](api/plc/pylibcugraph.sssp/)
* [cuGraph C API documentation](cugraph_c/)
* [Centrality](cugraph_c/centrality/)
* [PageRank](cugraph_c/centrality/#pagerank)
* [Personalized PageRank](cugraph_c/centrality/#personalized-pagerank)
* [Eigenvector Centrality](cugraph_c/centrality/#eigenvector-centrality)
* [Katz Centrality](cugraph_c/centrality/#katz-centrality)
* [Betweenness Centrality](cugraph_c/centrality/#betweenness-centrality)
* [Edge Betweenness Centrality](cugraph_c/centrality/#edge-betweenness-centrality)
* [HITS Centrality](cugraph_c/centrality/#hits-centrality)
* [Centrality Support Functions](cugraph_c/centrality/#centrality-support-functions)
* [Community](cugraph_c/community/)
* [Triangle Counting](cugraph_c/community/#triangle-counting)
* [Louvain](cugraph_c/community/#louvain)
* [Leiden](cugraph_c/community/#leiden)
* [ECG](cugraph_c/community/#ecg)
* [Extract Egonet](cugraph_c/community/#extract-egonet)
* [Balanced Cut](cugraph_c/community/#balanced-cut)
* [Spectral Clustering - Modularity Maximization](cugraph_c/community/#spectral-clustering-modularity-maximization)
* [Spectral Clustering - Edge Cut](cugraph_c/community/#spectral-clustering-edge-cut)
* [Community Support Functions](cugraph_c/community/#community-support-functions)
* [Core](cugraph_c/core/)
* [Core Number](cugraph_c/core/#core-number)
* [K-Core](cugraph_c/core/#k-core)
* [Core Support Functions](cugraph_c/core/#core-support-functions)
* [Components](cugraph_c/labeling/)
* [Weakly Connected Components](cugraph_c/labeling/#weakly-connected-components)
* [Strongly Connected Components](cugraph_c/labeling/#strongly-connected-components)
* [Labeling Support Functions](cugraph_c/labeling/#labeling-support-functions)
* [Sampling](cugraph_c/sampling/)
* [Uniform Random Walks](cugraph_c/sampling/#uniform-random-walks)
* [Biased Random Walks](cugraph_c/sampling/#biased-random-walks)
* [Random Walks via Node2Vec](cugraph_c/sampling/#random-walks-via-node2vec)
* [Node2Vec](cugraph_c/sampling/#node2vec)
* [Uniform Neighbor Sampling](cugraph_c/sampling/#uniform-neighbor-sampling)
* [Sampling Support Functions](cugraph_c/sampling/#sampling-support-functions)
* [Similarity](cugraph_c/similarity/)
* [Jaccard](cugraph_c/similarity/#jaccard)
* [Sorensen](cugraph_c/similarity/#sorensen)
* [Overlap](cugraph_c/similarity/#overlap)
* [Similarty Support Functions](cugraph_c/similarity/#similarty-support-functions)
* [Traversal](cugraph_c/traversal/)
* [Breadth First Search (BFS)](cugraph_c/traversal/#breadth-first-search-bfs)
* [Single-Source Shortest-Path (SSSP)](cugraph_c/traversal/#single-source-shortest-path-sssp)
* [Path Extraction](cugraph_c/traversal/#path-extraction)
* [Extract Max Path Length](cugraph_c/traversal/#extract-max-path-length)
* [Traversal Support Functions](cugraph_c/traversal/#traversal-support-functions)
* [cuGraph C++ API](cugraph_cpp/)
* [Algorithmns](cugraph_cpp/algorithms_cpp/)
* [Centrality](cugraph_cpp/algorithms/centrality_cpp/)
* [Community](cugraph_cpp/algorithms/community_cpp/)
* [Sampling](cugraph_cpp/algorithms/sampling_cpp/)
* [Similarity](cugraph_cpp/algorithms/similarity_cpp/)
* [Traversal](cugraph_cpp/algorithms/traversal_cpp/)
* [Linear](cugraph_cpp/algorithms/linear_cpp/)
* [Link Analysis](cugraph_cpp/algorithms/link_analysis_cpp/)
* [Layout](cugraph_cpp/algorithms/layout_cpp/)
* [Tree](cugraph_cpp/algorithms/tree_cpp/)
* [Utility Functions](cugraph_cpp/algorithms/utility_cpp/)
* [Graph Functions](cugraph_cpp/graph_functions_cpp/)
* [`renumber_edgelist()`](cugraph_cpp/graph_functions_cpp/#_CPPv4I00_bE17renumber_edgelistNSt11enable_if_tI9multi_gpuNSt5tupleIN3rmm14device_uvectorI8vertex_tEE15renumber_meta_tI8vertex_t6edge_t9multi_gpuEEEEERKN4raft8handle_tERRNSt8optionalIN3rmm14device_uvectorI8vertex_tEEEERKNSt6vectorIP8vertex_tEERKNSt6vectorIP8vertex_tEERKNSt6vectorI6edge_tEERKNSt8optionalINSt6vectorINSt6vectorI6edge_tEEEEEEbb)
* [`renumber_edgelist()`](cugraph_cpp/graph_functions_cpp/#_CPPv4I00_bE17renumber_edgelistNSt11enable_if_tIXnt9multi_gpuENSt5tupleIN3rmm14device_uvectorI8vertex_tEE15renumber_meta_tI8vertex_t6edge_t9multi_gpuEEEEERKN4raft8handle_tERRNSt8optionalIN3rmm14device_uvectorI8vertex_tEEEEP8vertex_tP8vertex_t6edge_tbb)
* [`renumber_ext_vertices()`](cugraph_cpp/graph_functions_cpp/#_CPPv4I0_bE21renumber_ext_verticesvRKN4raft8handle_tEP8vertex_t6size_tPK8vertex_t8vertex_t8vertex_tb)
* [`unrenumber_local_int_vertices()`](cugraph_cpp/graph_functions_cpp/#_CPPv4I0E29unrenumber_local_int_verticesvRKN4raft8handle_tEP8vertex_t6size_tPK8vertex_t8vertex_t8vertex_tb)
* [`unrenumber_int_vertices()`](cugraph_cpp/graph_functions_cpp/#_CPPv4I0_bE23unrenumber_int_verticesvRKN4raft8handle_tEP8vertex_t6size_tPK8vertex_tRKNSt6vectorI8vertex_tEEb)
* [`unrenumber_local_int_edges()`](cugraph_cpp/graph_functions_cpp/#_CPPv4I0_b_bE26unrenumber_local_int_edgesNSt11enable_if_tI9multi_gpuvEERKN4raft8handle_tERKNSt6vectorIP8vertex_tEERKNSt6vectorIP8vertex_tEERKNSt6vectorI6size_tEEPK8vertex_tRKNSt6vectorI8vertex_tEERKNSt8optionalINSt6vectorINSt6vectorI6size_tEEEEEEb)
* [`unrenumber_local_int_edges()`](cugraph_cpp/graph_functions_cpp/#_CPPv4I0_b_bE26unrenumber_local_int_edgesNSt11enable_if_tIXnt9multi_gpuEvEERKN4raft8handle_tEP8vertex_tP8vertex_t6size_tPK8vertex_t8vertex_tb)
* [`renumber_local_ext_vertices()`](cugraph_cpp/graph_functions_cpp/#_CPPv4I0_bE27renumber_local_ext_verticesvRKN4raft8handle_tEP8vertex_t6size_tPK8vertex_t8vertex_t8vertex_tb)
* [`decompress_to_edgelist()`](cugraph_cpp/graph_functions_cpp/#_CPPv4I0000_b_bE22decompress_to_edgelistNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI6edge_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEEEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEENSt8optionalI20edge_property_view_tI6edge_tPK6edge_tEEENSt8optionalI20edge_property_view_tI6edge_tPK11edge_type_tEEENSt8optionalIN4raft11device_spanIK8vertex_tEEEEb)
* [`symmetrize_edgelist()`](cugraph_cpp/graph_functions_cpp/#_CPPv4I00000_bE19symmetrize_edgelistNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI6edge_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_time_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_time_tEEEEEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEERRNSt8optionalIN3rmm14device_uvectorI8weight_tEEEERRNSt8optionalIN3rmm14device_uvectorI6edge_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_time_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_time_tEEEEb)
* [`symmetrize_graph()`](cugraph_cpp/graph_functions_cpp/#_CPPv4I000_b_bE16symmetrize_graphNSt5tupleI7graph_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE8weight_tEEENSt8optionalIN3rmm14device_uvectorI8vertex_tEEEEEERKN4raft8handle_tERR7graph_tI8vertex_t6edge_t16store_transposed9multi_gpuERRNSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE8weight_tEEERRNSt8optionalIN3rmm14device_uvectorI8vertex_tEEEEbb)
* [`transpose_graph()`](cugraph_cpp/graph_functions_cpp/#_CPPv4I000_b_bE15transpose_graphNSt5tupleI7graph_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE8weight_tEEENSt8optionalIN3rmm14device_uvectorI8vertex_tEEEEEERKN4raft8handle_tERR7graph_tI8vertex_t6edge_t16store_transposed9multi_gpuERRNSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE8weight_tEEERRNSt8optionalIN3rmm14device_uvectorI8vertex_tEEEEb)
* [`transpose_graph_storage()`](cugraph_cpp/graph_functions_cpp/#_CPPv4I000_b_bE23transpose_graph_storageNSt5tupleI7graph_tI8vertex_t6edge_tXnt16store_transposedE9multi_gpuENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_tXnt16store_transposedE9multi_gpuE8weight_tEEENSt8optionalIN3rmm14device_uvectorI8vertex_tEEEEEERKN4raft8handle_tERR7graph_tI8vertex_t6edge_t16store_transposed9multi_gpuERRNSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE8weight_tEEERRNSt8optionalIN3rmm14device_uvectorI8vertex_tEEEEb)
* [`coarsen_graph()`](cugraph_cpp/graph_functions_cpp/#_CPPv4I000_b_bE13coarsen_graphNSt5tupleI7graph_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE8weight_tEEENSt8optionalIN3rmm14device_uvectorI8vertex_tEEEEEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEEPK8vertex_tbb)
* [`relabel()`](cugraph_cpp/graph_functions_cpp/#_CPPv4I0_bE7relabelvRKN4raft8handle_tENSt5tupleIPK8vertex_tPK8vertex_tEE8vertex_tP8vertex_t8vertex_tbb)
* [`extract_induced_subgraphs()`](cugraph_cpp/graph_functions_cpp/#_CPPv4I000_b_bE25extract_induced_subgraphsNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEEN3rmm14device_uvectorI6size_tEEEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEEN4raft11device_spanIK6size_tEEN4raft11device_spanIK8vertex_tEEb)
* [`create_graph_from_edgelist()`](cugraph_cpp/graph_functions_cpp/#_CPPv4I0000_b_bE26create_graph_from_edgelistNSt5tupleI7graph_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE8weight_tEEENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE6edge_tEEENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE11edge_type_tEEENSt8optionalIN3rmm14device_uvectorI8vertex_tEEEEEERKN4raft8handle_tERRNSt8optionalIN3rmm14device_uvectorI8vertex_tEEEERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEERRNSt8optionalIN3rmm14device_uvectorI8weight_tEEEERRNSt8optionalIN3rmm14device_uvectorI6edge_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEE18graph_properties_tbb)
* [`create_graph_from_edgelist()`](cugraph_cpp/graph_functions_cpp/#_CPPv4I00000_b_bE26create_graph_from_edgelistNSt5tupleI7graph_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE8weight_tEEENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE6edge_tEEENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE11edge_type_tEEENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE11edge_time_tEEENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE11edge_time_tEEENSt8optionalIN3rmm14device_uvectorI8vertex_tEEEEEERKN4raft8handle_tERRNSt8optionalIN3rmm14device_uvectorI8vertex_tEEEERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEERRNSt8optionalIN3rmm14device_uvectorI8weight_tEEEERRNSt8optionalIN3rmm14device_uvectorI6edge_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_time_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_time_tEEEE18graph_properties_tbb)
* [`create_graph_from_edgelist()`](cugraph_cpp/graph_functions_cpp/#_CPPv4I0000_b_bE26create_graph_from_edgelistNSt5tupleI7graph_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE8weight_tEEENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE6edge_tEEENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE11edge_type_tEEENSt8optionalIN3rmm14device_uvectorI8vertex_tEEEEEERKN4raft8handle_tERRNSt8optionalIN3rmm14device_uvectorI8vertex_tEEEERRNSt6vectorIN3rmm14device_uvectorI8vertex_tEEEERRNSt6vectorIN3rmm14device_uvectorI8vertex_tEEEERRNSt8optionalINSt6vectorIN3rmm14device_uvectorI8weight_tEEEEEERRNSt8optionalINSt6vectorIN3rmm14device_uvectorI6edge_tEEEEEERRNSt8optionalINSt6vectorIN3rmm14device_uvectorI11edge_type_tEEEEEE18graph_properties_tbb)
* [`create_graph_from_edgelist()`](cugraph_cpp/graph_functions_cpp/#_CPPv4I00000_b_bE26create_graph_from_edgelistNSt5tupleI7graph_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE8weight_tEEENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE6edge_tEEENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE11edge_type_tEEENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE11edge_time_tEEENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE11edge_time_tEEENSt8optionalIN3rmm14device_uvectorI8vertex_tEEEEEERKN4raft8handle_tERRNSt8optionalIN3rmm14device_uvectorI8vertex_tEEEERRNSt6vectorIN3rmm14device_uvectorI8vertex_tEEEERRNSt6vectorIN3rmm14device_uvectorI8vertex_tEEEERRNSt8optionalINSt6vectorIN3rmm14device_uvectorI8weight_tEEEEEERRNSt8optionalINSt6vectorIN3rmm14device_uvectorI6edge_tEEEEEERRNSt8optionalINSt6vectorIN3rmm14device_uvectorI11edge_type_tEEEEEERRNSt8optionalINSt6vectorIN3rmm14device_uvectorI11edge_time_tEEEEEERRNSt8optionalINSt6vectorIN3rmm14device_uvectorI11edge_time_tEEEEEE18graph_properties_tbb)
* [`get_two_hop_neighbors()`](cugraph_cpp/graph_functions_cpp/#_CPPv4I00_b_bE21get_two_hop_neighborsNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalIN4raft11device_spanIK8vertex_tEEEE)
* [`compute_in_weight_sums()`](cugraph_cpp/graph_functions_cpp/#_CPPv4I000_b_bE22compute_in_weight_sumsN3rmm14device_uvectorI8weight_tEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE20edge_property_view_tI6edge_tPK8weight_tE)
* [`compute_out_weight_sums()`](cugraph_cpp/graph_functions_cpp/#_CPPv4I000_b_bE23compute_out_weight_sumsN3rmm14device_uvectorI8weight_tEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE20edge_property_view_tI6edge_tPK8weight_tE)
* [`compute_max_in_weight_sum()`](cugraph_cpp/graph_functions_cpp/#_CPPv4I000_b_bE25compute_max_in_weight_sum8weight_tRKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE20edge_property_view_tI6edge_tPK8weight_tE)
* [`compute_max_out_weight_sum()`](cugraph_cpp/graph_functions_cpp/#_CPPv4I000_b_bE26compute_max_out_weight_sum8weight_tRKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE20edge_property_view_tI6edge_tPK8weight_tE)
* [`compute_total_edge_weight()`](cugraph_cpp/graph_functions_cpp/#_CPPv4I000_b_bE25compute_total_edge_weight8weight_tRKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE20edge_property_view_tI6edge_tPK8weight_tE)
* [`select_random_vertices()`](cugraph_cpp/graph_functions_cpp/#_CPPv4I00_b_bE22select_random_verticesN3rmm14device_uvectorI8vertex_tEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalIN4raft11device_spanIK8vertex_tEEEERN4raft6random8RngStateE6size_tbbb)
* [`remove_self_loops()`](cugraph_cpp/graph_functions_cpp/#_CPPv4I00000E17remove_self_loopsNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI6edge_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_time_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_time_tEEEEEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEERRNSt8optionalIN3rmm14device_uvectorI8weight_tEEEERRNSt8optionalIN3rmm14device_uvectorI6edge_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_time_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_time_tEEEE)
* [`remove_multi_edges()`](cugraph_cpp/graph_functions_cpp/#_CPPv4I00000E18remove_multi_edgesNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI6edge_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_time_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_time_tEEEEEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEERRNSt8optionalIN3rmm14device_uvectorI8weight_tEEEERRNSt8optionalIN3rmm14device_uvectorI6edge_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_time_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_time_tEEEEb)
* [`shuffle_external_vertices()`](cugraph_cpp/graph_functions_cpp/#_CPPv4I0E25shuffle_external_verticesN3rmm14device_uvectorI8vertex_tEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEE)
* [`shuffle_external_vertex_value_pairs()`](cugraph_cpp/graph_functions_cpp/#_CPPv4I00E35shuffle_external_vertex_value_pairsNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI7value_tEEEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI7value_tEE)
* [`shuffle_external_edges()`](cugraph_cpp/graph_functions_cpp/#_CPPv4I0000E22shuffle_external_edgesNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI6edge_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEENSt6vectorI6size_tEEEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEERRNSt8optionalIN3rmm14device_uvectorI8weight_tEEEERRNSt8optionalIN3rmm14device_uvectorI6edge_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEE)
* [Graph Generators](cugraph_cpp/graph_generators_cpp/)
* [`generate_rmat_edgelist()`](cugraph_cpp/graph_generators_cpp/#_CPPv4I0E22generate_rmat_edgelistNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEERKN4raft8handle_tE6size_t6size_tddd8uint64_tbb)
* [`generate_rmat_edgelist()`](cugraph_cpp/graph_generators_cpp/#_CPPv4I0E22generate_rmat_edgelistNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEERKN4raft8handle_tERN4raft6random8RngStateE6size_t6size_tdddbb)
* [`generate_bipartite_rmat_edgelist()`](cugraph_cpp/graph_generators_cpp/#_CPPv4I0E32generate_bipartite_rmat_edgelistNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEERKN4raft8handle_tERN4raft6random8RngStateE6size_t6size_t6size_tddd)
* [`generate_rmat_edgelists()`](cugraph_cpp/graph_generators_cpp/#_CPPv4I0E23generate_rmat_edgelistsNSt6vectorINSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEEEERKN4raft8handle_tE6size_t6size_t6size_t6size_t24generator_distribution_t24generator_distribution_t8uint64_tbb)
* [`generate_rmat_edgelists()`](cugraph_cpp/graph_generators_cpp/#_CPPv4I0E23generate_rmat_edgelistsNSt6vectorINSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEEEERKN4raft8handle_tERN4raft6random8RngStateE6size_t6size_t6size_t6size_t24generator_distribution_t24generator_distribution_tbb)
* [`generate_path_graph_edgelist()`](cugraph_cpp/graph_generators_cpp/#_CPPv4I0E28generate_path_graph_edgelistNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEERKN4raft8handle_tERKNSt6vectorINSt5tupleI8vertex_t8vertex_tEEEE)
* [`generate_2d_mesh_graph_edgelist()`](cugraph_cpp/graph_generators_cpp/#_CPPv4I0E31generate_2d_mesh_graph_edgelistNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEERKN4raft8handle_tERKNSt6vectorINSt5tupleI8vertex_t8vertex_t8vertex_tEEEE)
* [`generate_3d_mesh_graph_edgelist()`](cugraph_cpp/graph_generators_cpp/#_CPPv4I0E31generate_3d_mesh_graph_edgelistNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEERKN4raft8handle_tERKNSt6vectorINSt5tupleI8vertex_t8vertex_t8vertex_t8vertex_tEEEE)
* [`generate_complete_graph_edgelist()`](cugraph_cpp/graph_generators_cpp/#_CPPv4I0E32generate_complete_graph_edgelistNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEERKN4raft8handle_tERKNSt6vectorINSt5tupleI8vertex_t8vertex_tEEEE)
* [`generate_erdos_renyi_graph_edgelist_gnp()`](cugraph_cpp/graph_generators_cpp/#_CPPv4I0E39generate_erdos_renyi_graph_edgelist_gnpNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEERKN4raft8handle_tE8vertex_tf8vertex_t8uint64_t)
* [`generate_erdos_renyi_graph_edgelist_gnm()`](cugraph_cpp/graph_generators_cpp/#_CPPv4I0E39generate_erdos_renyi_graph_edgelist_gnmNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEERKN4raft8handle_tE8vertex_t6size_t8vertex_t8uint64_t)
* [`symmetrize_edgelist_from_triangular()`](cugraph_cpp/graph_generators_cpp/#_CPPv4I00E35symmetrize_edgelist_from_triangularNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEEEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEERRNSt8optionalIN3rmm14device_uvectorI8weight_tEEEEb)
* [`scramble_vertex_ids()`](cugraph_cpp/graph_generators_cpp/#_CPPv4I0E19scramble_vertex_idsN3rmm14device_uvectorI8vertex_tEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEE6size_t)
* [`scramble_vertex_ids()`](cugraph_cpp/graph_generators_cpp/#_CPPv4I0E19scramble_vertex_idsNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEE6size_t)
* [`combine_edgelists()`](cugraph_cpp/graph_generators_cpp/#_CPPv4I00E17combine_edgelistsNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEEEERKN4raft8handle_tERRNSt6vectorIN3rmm14device_uvectorI8vertex_tEEEERRNSt6vectorIN3rmm14device_uvectorI8vertex_tEEEERRNSt8optionalINSt6vectorIN3rmm14device_uvectorI8weight_tEEEEEEb)
* [Legacy Graph Functions](cugraph_cpp/graph_legacy_cpp/)
* [`get_vertex_identifiers()`](cugraph_cpp/graph_legacy_cpp/#_CPPv4NK22get_vertex_identifiersEP8vertex_t)
* [`degree()`](cugraph_cpp/graph_legacy_cpp/#_CPPv4NK6degreeEP6edge_t15DegreeDirection)
* [`GraphCOOView()`](cugraph_cpp/graph_legacy_cpp/#_CPPv412GraphCOOViewP8vertex_tP8vertex_tP8weight_t8vertex_t6edge_t)
* [`get_source_indices()`](cugraph_cpp/graph_legacy_cpp/#_CPPv4NK18get_source_indicesEP8vertex_t)
* [`GraphCompressedSparseBaseView()`](cugraph_cpp/graph_legacy_cpp/#_CPPv429GraphCompressedSparseBaseViewP6edge_tP8vertex_tP8weight_t8vertex_t6edge_t)
* [`GraphCSRView()`](cugraph_cpp/graph_legacy_cpp/#_CPPv412GraphCSRViewP6edge_tP8vertex_tP8weight_t8vertex_t6edge_t)
* [`GraphCOO()`](cugraph_cpp/graph_legacy_cpp/#_CPPv48GraphCOO8vertex_t6edge_tb12cudaStream_tN3rmm25device_async_resource_refE)
* [`GraphCompressedSparseBase()`](cugraph_cpp/graph_legacy_cpp/#_CPPv425GraphCompressedSparseBase8vertex_t6edge_tb12cudaStream_tN3rmm25device_async_resource_refE)
* [`GraphCSR()`](cugraph_cpp/graph_legacy_cpp/#_CPPv48GraphCSRv)
* [`GraphCSR()`](cugraph_cpp/graph_legacy_cpp/#_CPPv48GraphCSR8vertex_t6edge_tb12cudaStream_tN3rmm25device_async_resource_refE)
* [`cugraph::legacy::GraphViewBase`](cugraph_cpp/graph_legacy_cpp/#_CPPv4I000EN7cugraph6legacy13GraphViewBaseE)
* [`cugraph::legacy::GraphCOOView`](cugraph_cpp/graph_legacy_cpp/#_CPPv4I000EN7cugraph6legacy12GraphCOOViewE)
* [`cugraph::legacy::GraphCompressedSparseBaseView`](cugraph_cpp/graph_legacy_cpp/#_CPPv4I000EN7cugraph6legacy29GraphCompressedSparseBaseViewE)
* [`cugraph::legacy::GraphCSRView`](cugraph_cpp/graph_legacy_cpp/#_CPPv4I000EN7cugraph6legacy12GraphCSRViewE)
* [`cugraph::legacy::GraphCOOContents`](cugraph_cpp/graph_legacy_cpp/#_CPPv4I000EN7cugraph6legacy16GraphCOOContentsE)
* [`cugraph::legacy::GraphCOO`](cugraph_cpp/graph_legacy_cpp/#_CPPv4I000EN7cugraph6legacy8GraphCOOE)
* [`cugraph::legacy::GraphCompressedSparseBase`](cugraph_cpp/graph_legacy_cpp/#_CPPv4I000EN7cugraph6legacy25GraphCompressedSparseBaseE)
* [`cugraph::legacy::GraphCSR`](cugraph_cpp/graph_legacy_cpp/#_CPPv4I000EN7cugraph6legacy8GraphCSRE)
* [Sampling Functions](cugraph_cpp/graph_sampling_cpp/)
* [`prior_sources_behavior_t`](cugraph_cpp/graph_sampling_cpp/#_CPPv424prior_sources_behavior_t)
* [`uniform_neighbor_sample()`](cugraph_cpp/graph_sampling_cpp/#_CPPv4I00000_b_bE23uniform_neighbor_sampleNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI6edge_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEENSt8optionalIN3rmm14device_uvectorI7int32_tEEEENSt8optionalIN3rmm14device_uvectorI7label_tEEEENSt8optionalIN3rmm14device_uvectorI6size_tEEEEEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEENSt8optionalI20edge_property_view_tI6edge_tPK6edge_tEEENSt8optionalI20edge_property_view_tI6edge_tPK11edge_type_tEEEN4raft11device_spanIK8vertex_tEENSt8optionalIN4raft11device_spanIK7label_tEEEENSt8optionalINSt5tupleIN4raft11device_spanIK7label_tEEN4raft11device_spanIK7int32_tEEEEEEN4raft9host_spanIK7int32_tEERN4raft6random8RngStateEbb24prior_sources_behavior_tbb)
* [`biased_neighbor_sample()`](cugraph_cpp/graph_sampling_cpp/#_CPPv4I000000_b_bE22biased_neighbor_sampleNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI6edge_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEENSt8optionalIN3rmm14device_uvectorI7int32_tEEEENSt8optionalIN3rmm14device_uvectorI7label_tEEEENSt8optionalIN3rmm14device_uvectorI6size_tEEEEEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEENSt8optionalI20edge_property_view_tI6edge_tPK6edge_tEEENSt8optionalI20edge_property_view_tI6edge_tPK11edge_type_tEEE20edge_property_view_tI6edge_tPK6bias_tEN4raft11device_spanIK8vertex_tEENSt8optionalIN4raft11device_spanIK7label_tEEEENSt8optionalINSt5tupleIN4raft11device_spanIK7label_tEEN4raft11device_spanIK7int32_tEEEEEEN4raft9host_spanIK7int32_tEERN4raft6random8RngStateEbb24prior_sources_behavior_tbb)
* [`homogeneous_uniform_neighbor_sample()`](cugraph_cpp/graph_sampling_cpp/#_CPPv4I0000_b_bE35homogeneous_uniform_neighbor_sampleNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI6edge_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEENSt8optionalIN3rmm14device_uvectorI7int32_tEEEENSt8optionalIN3rmm14device_uvectorI6size_tEEEEEERKN4raft8handle_tERN4raft6random8RngStateERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEENSt8optionalI20edge_property_view_tI6edge_tPK6edge_tEEENSt8optionalI20edge_property_view_tI6edge_tPK11edge_type_tEEEN4raft11device_spanIK8vertex_tEENSt8optionalIN4raft11device_spanIK7int32_tEEEENSt8optionalIN4raft11device_spanIK7int32_tEEEEN4raft9host_spanIK7int32_tEE16sampling_flags_tb)
* [`homogeneous_biased_neighbor_sample()`](cugraph_cpp/graph_sampling_cpp/#_CPPv4I00000_b_bE34homogeneous_biased_neighbor_sampleNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI6edge_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEENSt8optionalIN3rmm14device_uvectorI7int32_tEEEENSt8optionalIN3rmm14device_uvectorI6size_tEEEEEERKN4raft8handle_tERN4raft6random8RngStateERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEENSt8optionalI20edge_property_view_tI6edge_tPK6edge_tEEENSt8optionalI20edge_property_view_tI6edge_tPK11edge_type_tEEE20edge_property_view_tI6edge_tPK6bias_tEN4raft11device_spanIK8vertex_tEENSt8optionalIN4raft11device_spanIK7int32_tEEEENSt8optionalIN4raft11device_spanIK7int32_tEEEEN4raft9host_spanIK7int32_tEE16sampling_flags_tb)
* [`heterogeneous_uniform_neighbor_sample()`](cugraph_cpp/graph_sampling_cpp/#_CPPv4I0000_b_bE37heterogeneous_uniform_neighbor_sampleNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI6edge_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEENSt8optionalIN3rmm14device_uvectorI7int32_tEEEENSt8optionalIN3rmm14device_uvectorI6size_tEEEEEERKN4raft8handle_tERN4raft6random8RngStateERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEENSt8optionalI20edge_property_view_tI6edge_tPK6edge_tEEENSt8optionalI20edge_property_view_tI6edge_tPK11edge_type_tEEEN4raft11device_spanIK8vertex_tEENSt8optionalIN4raft11device_spanIK7int32_tEEEENSt8optionalIN4raft11device_spanIK7int32_tEEEEN4raft9host_spanIK7int32_tEE11edge_type_t16sampling_flags_tb)
* [`heterogeneous_biased_neighbor_sample()`](cugraph_cpp/graph_sampling_cpp/#_CPPv4I00000_b_bE36heterogeneous_biased_neighbor_sampleNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI6edge_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEENSt8optionalIN3rmm14device_uvectorI7int32_tEEEENSt8optionalIN3rmm14device_uvectorI6size_tEEEEEERKN4raft8handle_tERN4raft6random8RngStateERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEENSt8optionalI20edge_property_view_tI6edge_tPK6edge_tEEENSt8optionalI20edge_property_view_tI6edge_tPK11edge_type_tEEE20edge_property_view_tI6edge_tPK6bias_tEN4raft11device_spanIK8vertex_tEENSt8optionalIN4raft11device_spanIK7int32_tEEEENSt8optionalIN4raft11device_spanIK7int32_tEEEEN4raft9host_spanIK7int32_tEE11edge_type_t16sampling_flags_tb)
* [`renumber_and_compress_sampled_edgelist()`](cugraph_cpp/graph_sampling_cpp/#_CPPv4I0000E38renumber_and_compress_sampled_edgelistNSt5tupleINSt8optionalIN3rmm14device_uvectorI8vertex_tEEEEN3rmm14device_uvectorI6size_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI9edge_id_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEENSt8optionalIN3rmm14device_uvectorI6size_tEEEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI6size_tEEEEEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEERRNSt8optionalIN3rmm14device_uvectorI8weight_tEEEERRNSt8optionalIN3rmm14device_uvectorI9edge_id_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEERRNSt8optionalIN3rmm14device_uvectorI7int32_tEEEENSt8optionalIN4raft11device_spanIK8vertex_tEEEENSt8optionalIN4raft11device_spanIK6size_tEEEENSt8optionalIN4raft11device_spanIK6size_tEEEE6size_t6size_tbbbb)
* [`renumber_and_sort_sampled_edgelist()`](cugraph_cpp/graph_sampling_cpp/#_CPPv4I0000E34renumber_and_sort_sampled_edgelistNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI9edge_id_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEENSt8optionalIN3rmm14device_uvectorI6size_tEEEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI6size_tEEEEEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEERRNSt8optionalIN3rmm14device_uvectorI8weight_tEEEERRNSt8optionalIN3rmm14device_uvectorI9edge_id_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEERRNSt8optionalIN3rmm14device_uvectorI7int32_tEEEENSt8optionalIN4raft11device_spanIK8vertex_tEEEENSt8optionalIN4raft11device_spanIK6size_tEEEENSt8optionalIN4raft11device_spanIK6size_tEEEE6size_t6size_tbb)
* [`heterogeneous_renumber_and_sort_sampled_edgelist()`](cugraph_cpp/graph_sampling_cpp/#_CPPv4I0000E48heterogeneous_renumber_and_sort_sampled_edgelistNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI9edge_id_tEEEENSt8optionalIN3rmm14device_uvectorI6size_tEEEEN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI6size_tEENSt8optionalIN3rmm14device_uvectorI9edge_id_tEEEENSt8optionalIN3rmm14device_uvectorI6size_tEEEEEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEERRNSt8optionalIN3rmm14device_uvectorI8weight_tEEEERRNSt8optionalIN3rmm14device_uvectorI9edge_id_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEERRNSt8optionalIN3rmm14device_uvectorI7int32_tEEEENSt8optionalIN4raft11device_spanIK8vertex_tEEEENSt8optionalIN4raft11device_spanIK6size_tEEEENSt8optionalIN4raft11device_spanIK6size_tEEEEN4raft11device_spanIK8vertex_tEE6size_t6size_t6size_t6size_tbb)
* [`sort_sampled_edgelist()`](cugraph_cpp/graph_sampling_cpp/#_CPPv4I0000E21sort_sampled_edgelistNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI9edge_id_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEENSt8optionalIN3rmm14device_uvectorI6size_tEEEEEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEERRNSt8optionalIN3rmm14device_uvectorI8weight_tEEEERRNSt8optionalIN3rmm14device_uvectorI9edge_id_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEERRNSt8optionalIN3rmm14device_uvectorI7int32_tEEEENSt8optionalIN4raft11device_spanIK6size_tEEEE6size_t6size_tbb)
* [`build_edge_id_and_type_to_src_dst_lookup_map()`](cugraph_cpp/graph_sampling_cpp/#_CPPv4I000_bE44build_edge_id_and_type_to_src_dst_lookup_map18lookup_container_tI6edge_t11edge_type_t8vertex_tERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuE20edge_property_view_tI6edge_tPK6edge_tE20edge_property_view_tI6edge_tPK11edge_type_tE)
* [`lookup_endpoints_from_edge_ids_and_single_type()`](cugraph_cpp/graph_sampling_cpp/#_CPPv4I000_bE46lookup_endpoints_from_edge_ids_and_single_typeNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEERKN4raft8handle_tERK18lookup_container_tI6edge_t11edge_type_t8vertex_tEN4raft11device_spanIK6edge_tEE11edge_type_t)
* [`lookup_endpoints_from_edge_ids_and_types()`](cugraph_cpp/graph_sampling_cpp/#_CPPv4I000_bE40lookup_endpoints_from_edge_ids_and_typesNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEERKN4raft8handle_tERK18lookup_container_tI6edge_t11edge_type_t8vertex_tEN4raft11device_spanIK6edge_tEEN4raft11device_spanIK11edge_type_tEE)
* [`negative_sampling()`](cugraph_cpp/graph_sampling_cpp/#_CPPv4I000_b_bE17negative_samplingNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEERKN4raft8handle_tERN4raft6random8RngStateERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalIN4raft11device_spanIK8weight_tEEEENSt8optionalIN4raft11device_spanIK8weight_tEEEE6size_tbbbb)
* [Collection Wrappers](cugraph_cpp/collect_comm_wrapper_cpp/)
* [`device_allgatherv()`](cugraph_cpp/collect_comm_wrapper_cpp/#_CPPv4I0E17device_allgathervN3rmm14device_uvectorI1TEERKN4raft8handle_tERKN4raft5comms7comms_tEN4raft11device_spanIK1TEE)
* [Low Level cuGraph C++ API](cugraph_cpp/full_api/)
* [`cugraph`](cugraph_cpp/full_api/#_CPPv47cugraph)
Graph Neural Networks API Documentation[#](#graph-neural-networks-api-documentation "Link to this heading")
------------------------------------------------------------------------------------------------------------
Graph Neural Networks API Documentation
* [cugraph-dgl API Reference](cugraph-dgl/cugraph_dgl/)
* [Methods](cugraph-dgl/cugraph_dgl/#methods)
* [cugraph\_dgl.convert.cugraph\_storage\_from\_heterograph](api/cugraph-dgl/cugraph_dgl.convert.cugraph_storage_from_heterograph/)
* [cugraph\_dgl.cugraph\_storage.CuGraphStorage](api/cugraph-dgl/cugraph_dgl.cugraph_storage.CuGraphStorage/)
* [cugraph-pyg API Reference](cugraph-pyg/cugraph_pyg/)
* [Graph Storage](cugraph-pyg/cugraph_pyg/#graph-storage)
* [cugraph\_pyg.data.dask\_graph\_store.DaskGraphStore](api/cugraph-pyg/cugraph_pyg.data.dask_graph_store.DaskGraphStore/)
* [cugraph\_pyg.data.graph\_store.GraphStore](api/cugraph-pyg/cugraph_pyg.data.graph_store.GraphStore/)
* [Feature Storage](cugraph-pyg/cugraph_pyg/#feature-storage)
* [cugraph\_pyg.data.feature\_store.TensorDictFeatureStore](api/cugraph-pyg/cugraph_pyg.data.feature_store.TensorDictFeatureStore/)
* [cugraph\_pyg.data.feature\_store.WholeFeatureStore](api/cugraph-pyg/cugraph_pyg.data.feature_store.WholeFeatureStore/)
* [Data Loaders](cugraph-pyg/cugraph_pyg/#data-loaders)
* [cugraph\_pyg.loader.dask\_node\_loader.DaskNeighborLoader](api/cugraph-pyg/cugraph_pyg.loader.dask_node_loader.DaskNeighborLoader/)
* [cugraph\_pyg.loader.dask\_node\_loader.BulkSampleLoader](api/cugraph-pyg/cugraph_pyg.loader.dask_node_loader.BulkSampleLoader/)
* [cugraph\_pyg.loader.node\_loader.NodeLoader](api/cugraph-pyg/cugraph_pyg.loader.node_loader.NodeLoader/)
* [cugraph\_pyg.loader.neighbor\_loader.NeighborLoader](api/cugraph-pyg/cugraph_pyg.loader.neighbor_loader.NeighborLoader/)
* [Samplers](cugraph-pyg/cugraph_pyg/#samplers)
* [cugraph\_pyg.sampler.sampler.BaseSampler](api/cugraph-pyg/cugraph_pyg.sampler.sampler.BaseSampler/)
* [cugraph\_pyg.sampler.sampler.SampleReader](api/cugraph-pyg/cugraph_pyg.sampler.sampler.SampleReader/)
* [cugraph\_pyg.sampler.sampler.HomogeneousSampleReader](api/cugraph-pyg/cugraph_pyg.sampler.sampler.HomogeneousSampleReader/)
* [cugraph\_pyg.sampler.sampler.SampleIterator](api/cugraph-pyg/cugraph_pyg.sampler.sampler.SampleIterator/)
Additional Graph Packages API Documentation[#](#additional-graph-packages-api-documentation "Link to this heading")
--------------------------------------------------------------------------------------------------------------------
Additional Graph Packages API Documentation
* [cugraph-service API Reference](service/)
* [cugraph-service-client API Reference](service/cugraph_service_client/)
* [cugraph-service-server API Reference](service/cugraph_service_server/)
On this page
### This Page
* [Show Source](../_sources/api_docs/index.rst.txt)
---
# Welcome to cuML’s documentation! — cuml 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cuml
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cuml/nightly)
[stable (25.02)](/api/cuml/stable)
[legacy (24.12)](/api/cuml/legacy)
* [GitHub](https://github.com/rapidsai/cuml "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
Welcome to cuML’s documentation
=============================================================================================
cuML is a suite of fast, GPU-accelerated machine learning algorithms designed for data science and analytical tasks. Our API mirrors Sklearn’s, and we provide practitioners with the easy fit-predict-transform paradigm without ever having to program on a GPU.
As data gets larger, algorithms running on a CPU becomes slow and cumbersome. RAPIDS provides users a streamlined approach where data is initially loaded in the GPU, and compute tasks can be performed on it directly.
cuML is fully open source, and the RAPIDS team welcomes new and seasoned contributors, users and hobbyists! Thank you for your wonderful support!
An installation requirement for cuML is that your system must be Linux-like. Support for Windows is possible in the near future.
Contents:
* [Introduction](cuml_intro/)
* [1\. Where possible, match the scikit-learn API](cuml_intro/#where-possible-match-the-scikit-learn-api)
* [2\. Accept flexible input types, return predictable output types](cuml_intro/#accept-flexible-input-types-return-predictable-output-types)
* [3\. Be fast!](cuml_intro/#be-fast)
* [Learn more](cuml_intro/#learn-more)
* [API Reference](api/)
* [Module Configuration](api/#module-configuration)
* [Preprocessing, Metrics, and Utilities](api/#preprocessing-metrics-and-utilities)
* [Regression and Classification](api/#regression-and-classification)
* [Clustering](api/#clustering)
* [Dimensionality Reduction and Manifold Learning](api/#dimensionality-reduction-and-manifold-learning)
* [Neighbors](api/#neighbors)
* [Time Series](api/#time-series)
* [Model Explainability](api/#model-explainability)
* [Multi-Node, Multi-GPU Algorithms](api/#multi-node-multi-gpu-algorithms)
* [Experimental](api/#experimental)
* [User Guide](user_guide/)
* [Training and Evaluating Machine Learning Models](estimator_intro/)
* [Pickling Models for Persistence](pickling_cuml_models/)
* [cuML on GPU and CPU](execution_device_interoperability/)
* [Blogs and other references](cuml_blogs/)
* [Integrations, applications, and general concepts](cuml_blogs/#integrations-applications-and-general-concepts)
* [Tree and forest models](cuml_blogs/#tree-and-forest-models)
* [Other popular models](cuml_blogs/#other-popular-models)
* [Academic Papers](cuml_blogs/#academic-papers)
Indices and tables[#](#indices-and-tables "Link to this heading")
==================================================================
* [Index](genindex/)
* [Module Index](py-modindex/)
* [Search Page](search/)
On this page
### This Page
* [Show Source](_sources/index.rst.txt)
---
# Welcome to cuSpatial’s documentation! — cuspatial 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cuspatial
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cuspatial/nightly)
[stable (25.02)](/api/cuspatial/stable)
[legacy (24.12)](/api/cuspatial/legacy)
* [GitHub](https://github.com/rapidsai/cuspatial "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
Welcome to cuSpatial’s documentation
=======================================================================================================
cuSpatial is a general, vector-based, GPU accelerated GIS library that provides functionalities to spatial computation, indexing, joins and trajectory computations. Example functions include:
* Spatial indexing and joins supported by GPU accelerated point-in-polygon
* Trajectory identification and reconstruction
* Haversine distance and grid projection
cuSpatial integrate neatly with [GeoPandas](https://geopandas.org/en/stable/)
and [cuDF](https://docs.rapids.ai/api/cuspatial/stable/)
. This enables you to accelerate performance critical sections in your `GeoPandas` workflow using and `cuSpatial` and `cuDF`.
Contents
* [User Guide](user_guide/)
* [cuSpatial Python User’s Guide](user_guide/cuspatial_api_examples/)
* [API Reference](api_docs/)
* [Spatial](api_docs/spatial/)
* [Trajectory](api_docs/trajectory/)
* [GeoPandas Compatibility](api_docs/geopandas_compatibility/)
* [IO](api_docs/io/)
* [Developer Guide](developer_guide/)
* [Creating a Development Environment](developer_guide/development_environment/)
* [Build and Install cuSpatial From Source](developer_guide/build/)
* [How to Contribute to cuSpatial](developer_guide/contributing_guide/)
* [cuSpatial Library Design](developer_guide/library_design/)
* [Benchmarking cuSpatial](developer_guide/benchmarking/)
Indices and tables[#](#indices-and-tables "Link to this heading")
==================================================================
* [Index](genindex/)
* [Search Page](search/)
On this page
### This Page
* [Show Source](_sources/index.md.txt)
---
# Welcome to Dask cuDF’s documentation! — dask-cudf 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
dask-cudf
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/dask-cudf/nightly)
[stable (25.02)](/api/dask-cudf/stable)
[legacy (24.12)](/api/dask-cudf/legacy)
* [GitHub](https://github.com/rapidsai/cudf "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
Welcome to Dask cuDF’s documentation
=======================================================================================================
**Dask cuDF** (pronounced “DASK KOO-dee-eff”) is an extension library for the [Dask](https://dask.org)
parallel computing framework. When installed, Dask cuDF is automatically registered as the `"cudf"` dataframe backend for [Dask DataFrame](https://docs.dask.org/en/stable/dataframe.html)
.
Note
Neither Dask cuDF nor Dask DataFrame provide support for multi-GPU or multi-node execution on their own. You must also deploy a [dask.distributed](https://distributed.dask.org/en/stable/)
cluster to leverage multiple GPUs. We strongly recommend using [Dask-CUDA](https://docs.rapids.ai/api/dask-cuda/stable/ "(in dask-cuda v25.02)")
to simplify the setup of the cluster, taking advantage of all features of the GPU and networking hardware.
If you are familiar with Dask and [pandas](pandas.pydata.org)
or [cuDF](https://docs.rapids.ai/api/cudf/stable/)
, then Dask cuDF should feel familiar to you. If not, we recommend starting with [10 minutes to Dask](https://docs.dask.org/en/stable/10-minutes-to-dask.html)
followed by [10 minutes to cuDF and Dask cuDF](https://docs.rapids.ai/api/cudf/stable/user_guide/10min.html)
.
After reviewing the sections below, please see the [Best Practices](best_practices/#best-practices)
page for further guidance on using Dask cuDF effectively.
Using Dask cuDF[#](#using-dask-cudf "Link to this heading")
------------------------------------------------------------
### The Dask DataFrame API (Recommended)[#](#the-dask-dataframe-api-recommended "Link to this heading")
Simply use the [Dask configuration](https://docs.dask.org/en/stable/how-to/selecting-the-collection-backend.html)
system to set the `"dataframe.backend"` option to `"cudf"`. From Python, this can be achieved like so:
import dask
dask.config.set({"dataframe.backend": "cudf"})
Alternatively, you can set `DASK_DATAFRAME__BACKEND=cudf` in the environment before running your code.
Once this is done, the public Dask DataFrame API will leverage `cudf` automatically when a new DataFrame collection is created from an on-disk format using any of the following `dask.dataframe` functions:
* `read_parquet()`
* `read_json()`
* `read_csv()`
* `read_orc()`
* `read_hdf()`
* `from_dict()`
For example:
import dask.dataframe as dd
\# By default, we obtain a pandas-backed dataframe
df \= dd.read\_parquet("data.parquet", ...)
import dask
dask.config.set({"dataframe.backend": "cudf"})
\# This now gives us a cuDF-backed dataframe
df \= dd.read\_parquet("data.parquet", ...)
When other functions are used to create a new collection (e.g. `from_map()`, `from_pandas()`, `from_delayed()`, and `from_array()`), the backend of the new collection will depend on the inputs to those functions. For example:
import pandas as pd
import cudf
\# This gives us a pandas-backed dataframe
dd.from\_pandas(pd.DataFrame({"a": range(10)}))
\# This gives us a cuDF-backed dataframe
dd.from\_pandas(cudf.DataFrame({"a": range(10)}))
An existing collection can always be moved to a specific backend using the `dask.dataframe.DataFrame.to_backend()` API:
\# This ensures that we have a cuDF-backed dataframe
df \= df.to\_backend("cudf")
\# This ensures that we have a pandas-backed dataframe
df \= df.to\_backend("pandas")
### The explicit Dask cuDF API[#](#the-explicit-dask-cudf-api "Link to this heading")
In addition to providing the `"cudf"` backend for Dask DataFrame, Dask cuDF also provides an explicit `dask_cudf` API:
import dask\_cudf
\# This always gives us a cuDF-backed dataframe
df \= dask\_cudf.read\_parquet("data.parquet", ...)
This API is used implicitly by the Dask DataFrame API when the `"cudf"` backend is enabled. Therefore, using it directly will not provide any performance benefit over the CPU/GPU-portable `dask.dataframe` API. Also, using some parts of the explicit API are incompatible with automatic query planning (see the next section).
### Query Planning[#](#query-planning "Link to this heading")
Dask cuDF now provides automatic query planning by default (RAPIDS 24.06+). As long as the `"dataframe.query-planning"` configuration is set to `True` (the default) when `dask.dataframe` is first imported, [Dask Expressions](https://github.com/dask/dask-expr)
will be used under the hood.
For example, the following code will automatically benefit from predicate pushdown when the result is computed:
df \= dd.read\_parquet("/my/parquet/dataset/")
result \= df.sort\_values('B')\['A'\]
Unoptimized expression graph (`df.pprint()`):
Projection: columns\='A'
SortValues: by\=\['B'\] shuffle\_method\='tasks' options\={}
ReadParquetFSSpec: path\='/my/parquet/dataset/' ...
Simplified expression graph (`df.simplify().pprint()`):
Projection: columns\='A'
SortValues: by\=\['B'\] shuffle\_method\='tasks' options\={}
ReadParquetFSSpec: path\='/my/parquet/dataset/' columns\=\['A', 'B'\] ...
Note
Dask will automatically simplify the expression graph (within `optimize()`) when the result is converted to a task graph (via `compute()` or `persist()`). You do not need to call `simplify()` yourself.
### Using Multiple GPUs and Multiple Nodes[#](#using-multiple-gpus-and-multiple-nodes "Link to this heading")
Whenever possible, Dask cuDF (i.e. Dask DataFrame) will automatically try to partition your data into small-enough tasks to fit comfortably in the memory of a single GPU. This means the necessary compute tasks needed to compute a query can often be streamed to a single GPU process for out-of-core computing. This also means that the compute tasks can be executed in parallel over a multi-GPU cluster.
In order to execute your Dask workflow on multiple GPUs, you will typically need to use [Dask-CUDA](https://docs.rapids.ai/api/dask-cuda/stable/ "(in dask-cuda v25.02)")
to deploy distributed Dask cluster, and [Distributed](https://distributed.dask.org/en/stable/client.html)
to define a client object. For example:
from dask\_cuda import LocalCUDACluster
from distributed import Client
if \_\_name\_\_ \== "\_\_main\_\_":
client \= Client(
LocalCUDACluster(
CUDA\_VISIBLE\_DEVICES\="0,1", \# Use two workers (on devices 0 and 1)
rmm\_pool\_size\=0.9, \# Use 90% of GPU memory as a pool for faster allocations
enable\_cudf\_spill\=True, \# Improve device memory stability
local\_directory\="/fast/scratch/", \# Use fast local storage for spilling
)
)
df \= dd.read\_parquet("/my/parquet/dataset/")
agg \= df.groupby('B').sum()
agg.compute() \# This will use the cluster defined above
Note
This example uses `compute()` to materialize a concrete `cudf.DataFrame` object in local memory. Never call `compute()` on a large collection that cannot fit comfortably in the memory of a single GPU! See Dask’s [documentation on managing computation](https://distributed.dask.org/en/stable/manage-computation.html)
for more details.
Please see the [Dask-CUDA](https://docs.rapids.ai/api/dask-cuda/stable/ "(in dask-cuda v25.02)")
documentation for more information about deploying GPU-aware clusters (including [best practices](https://docs.rapids.ai/api/dask-cuda/stable/examples/best-practices/)
).
API Reference[#](#api-reference "Link to this heading")
--------------------------------------------------------
Generally speaking, Dask cuDF tries to offer exactly the same API as Dask DataFrame. There are, however, some minor differences mostly because cuDF does not [perfectly mirror](https://docs.rapids.ai/api/cudf/stable/user_guide/PandasCompat/ "(in cudf v25.02)")
the pandas API, or because cuDF provides additional configuration flags (these mostly occur in data reading and writing interfaces).
As a result, straightforward workflows can be migrated without too much trouble, but more complex ones that utilise more features may need a bit of tweaking. The API documentation describes details of the differences and all functionality that Dask cuDF supports.
* [API reference](api/)
* [Creating and storing DataFrames](api/#creating-and-storing-dataframes)
* [Grouping](api/#grouping)
* [DataFrames and Series](api/#dataframes-and-series)
Indices and tables[#](#indices-and-tables "Link to this heading")
==================================================================
* [Index](genindex/)
* [Module Index](py-modindex/)
* [Search Page](search/)
On this page
### This Page
* [Show Source](_sources/index.rst.txt)
---
# Welcome to KvikIO’s Python documentation! — kvikio 25.02.00 documentation
* [](#)
* Welcome to KvikIO’s Python documentation!
* [View page source](_sources/index.rst.txt)
* * *
Welcome to KvikIO’s Python documentation
===============================================================================================================
KvikIO is a Python and C++ library for high performance file IO. It provides C++ and Python bindings to [cuFile](https://docs.nvidia.com/gpudirect-storage/api-reference-guide/index.html)
, which enables [GPUDirect Storage](https://developer.nvidia.com/blog/gpudirect-storage/)
(GDS). KvikIO also works efficiently when GDS isn’t available and can read/write both host and device data seamlessly.
KvikIO is a part of the [RAPIDS](https://rapids.ai/)
suite of open-source software libraries for GPU-accelerated data science.
Note
This is the documentation for the Python library. For the C++ documentation, see under [libkvikio](https://docs.rapids.ai/api/libkvikio/nightly/)
.
Contents[](#contents "Link to this heading")
----------------------------------------------
Getting Started
* [Installation](install/)
* [Quickstart](quickstart/)
* [Zarr](zarr/)
* [Remote File](remote_file/)
* [Runtime Settings](runtime_settings/)
* [API](api/)
* [Index](genindex/)
---
# cuML C++ API: Main Page
[Home](/api)
libcuml
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/libcuml/nightly)
[stable (25.02)](/api/libcuml/stable)
[legacy (24.12)](/api/libcuml/legacy)
---
# cuProj: GPU-Accelerated Cartographic Projections and Coordinate Transformations — cuProj 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cuproj
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cuproj/nightly)
[stable (25.02)](/api/cuproj/stable)
[legacy (24.12)](/api/cuproj/legacy)
* [GitHub](https://github.com/rapidsai/cuspatial "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
cuProj: GPU-Accelerated Cartographic Projections and Coordinate Transformations[#](#cuproj-gpu-accelerated-cartographic-projections-and-coordinate-transformations "Link to this heading")
===========================================================================================================================================================================================
cuProj is a generic coordinate transformation library that transforms geospatial coordinates from one coordinate reference system (CRS) to another. This includes cartographic projections as well as geodetic transformations. cuProj is implemented in CUDA C++ to run on GPUs to provide the highest performance.
cuProj provides a Python API that closely matches the [PyProj](https://pyproj4.github.io/pyproj/stable/)
API.
Currently cuProj only supports a subset of the Proj transformations. The following transformations are supported:
* WGS84 to/from UTM
Contents
* [User Guide](user_guide/)
* [cuProj Python User’s Guide](user_guide/cuproj_api_examples/)
* [API Reference](api_docs/)
* [Transformer](api_docs/transformer/)
* [Developer Guide](developer_guide/)
Indices and tables[#](#indices-and-tables "Link to this heading")
==================================================================
* [Index](genindex/)
* [Search Page](search/)
On this page
### This Page
* [Show Source](_sources/index.md.txt)
---
# cuVS: Vector Search and Clustering on the GPU — cuvs
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cuvs
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cuvs/nightly)
[stable (25.02)](/api/cuvs/stable)
[legacy (24.12)](/api/cuvs/legacy)
[ \
\
cuvs](#)
* [GitHub](https://github.com/rapidsai/cuvs "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
cuVS: Vector Search and Clustering on the GPU[#](#cuvs-vector-search-and-clustering-on-the-gpu "Link to this heading")
=======================================================================================================================
Welcome to cuVS, the premier library for GPU-accelerated vector search and clustering! cuVS provides several core building blocks for constructing new algorithms, as well as end-to-end vector search and clustering algorithms for use either standalone or through a growing list of [integrations](integrations/)
.
Useful Resources[#](#useful-resources "Link to this heading")
--------------------------------------------------------------
* [Example Notebooks](https://github.com/rapidsai/cuvs/tree/HEAD/notebooks)
: Example notebooks
* [Code Examples](https://github.com/rapidsai/cuvs/tree/HEAD/examples)
: Self-contained code examples
* [RAPIDS Community](https://rapids.ai/community.html)
: Get help, contribute, and collaborate.
* [GitHub repository](https://github.com/rapidsai/cuvs)
: Download the cuVS source code.
* [Issue tracker](https://github.com/rapidsai/cuvs/issues)
: Report issues or request features.
What is cuVS?[#](#what-is-cuvs "Link to this heading")
-------------------------------------------------------
cuVS contains state-of-the-art implementations of several algorithms for running approximate and exact nearest neighbors and clustering on the GPU. It can be used directly or through the various databases and other libraries that have integrated it. The primary goal of cuVS is to simplify the use of GPUs for vector similarity search and clustering.
Vector search is an information retrieval method that has been growing in popularity over the past few years, partly because of the rising importance of multimedia embeddings created from unstructured data and the need to perform semantic search on the embeddings to find items which are semantically similar to each other.
Vector search is also used in _data mining and machine learning_ tasks and comprises an important step in many _clustering_ and _visualization_ algorithms like [UMAP](https://arxiv.org/abs/2008.00325)
, [t-SNE](https://lvdmaaten.github.io/tsne/)
, K-means, and [HDBSCAN](https://hdbscan.readthedocs.io/en/latest/how_hdbscan_works.html)
.
Finally, faster vector search enables interactions between dense vectors and graphs. Converting a pile of dense vectors into nearest neighbors graphs unlocks the entire world of graph analysis algorithms, such as those found in [GraphBLAS](https://graphblas.org/)
and [cuGraph](https://github.com/rapidsai/cugraph)
.
Below are some common use-cases for vector search
### Semantic search[#](#semantic-search "Link to this heading")
* Generative AI & Retrieval augmented generation (RAG)
* Recommender systems
* Computer vision
* Image search
* Text search
* Audio search
* Molecular search
* Model training
### Data mining[#](#data-mining "Link to this heading")
* Clustering algorithms
* Visualization algorithms
* Sampling algorithms
* Class balancing
* Ensemble methods
* k-NN graph construction
Why cuVS?[#](#why-cuvs "Link to this heading")
-----------------------------------------------
There are several benefits to using cuVS and GPUs for vector search, including
1. Fast index build
2. Latency critical and high throughput search
3. Parameter tuning
4. Cost savings
5. Interoperability (build on GPU, deploy on CPU)
6. Multiple language support
7. Building blocks for composing new or accelerating existing algorithms
In addition to the items above, cuVS shoulders the responsibility of keeping non-trivial accelerated code up to date as new NVIDIA architectures and CUDA versions are released. This provides a deslightful development experimence, guaranteeing that any libraries, databases, or applications built on top of it will always be receiving the best performance and scale.
cuVS Technology Stack[#](#cuvs-technology-stack "Link to this heading")
------------------------------------------------------------------------
cuVS is built on top of the RAPIDS RAFT library of high performance machine learning primitives and provides all the necessary routines for vector search and clustering on the GPU.
[](_images/tech_stack.png)
Contents[#](#contents "Link to this heading")
----------------------------------------------
* [Installation](build/)
* [Installing Pre-compiled Packages](build/#installing-pre-compiled-packages)
* [C, C++, and Python through Conda](build/#c-c-and-python-through-conda)
* [C/C++ Package](build/#c-c-package)
* [Python Package](build/#python-package)
* [Python through Pip](build/#python-through-pip)
* [Build from source](build/#build-from-source)
* [Prerequisites](build/#prerequisites)
* [Create a build environment](build/#create-a-build-environment)
* [C and C++ libraries](build/#c-and-c-libraries)
* [Multi-GPU features](build/#multi-gpu-features)
* [Building the Googletests](build/#building-the-googletests)
* [Python library](build/#python-library)
* [Rust library](build/#rust-library)
* [Using CMake directly](build/#using-cmake-directly)
* [Build documentation](build/#build-documentation)
* [Getting Started](getting_started/)
* [New to vector search?](getting_started/#new-to-vector-search)
* [Supported indexes](getting_started/#supported-indexes)
* [Using cuVS APIs](getting_started/#using-cuvs-apis)
* [Where to next?](getting_started/#where-to-next)
* [Social media](getting_started/#social-media)
* [Blogs](getting_started/#blogs)
* [Research](getting_started/#research)
* [Get involved](getting_started/#get-involved)
* [Integrations](integrations/)
* [FAISS](integrations/faiss/)
* [Milvus](integrations/milvus/)
* [Lucene](integrations/lucene/)
* [Kinetica](integrations/kinetica/)
* [cuVS Bench](cuvs_bench/)
* [Installing the benchmarks](cuvs_bench/#installing-the-benchmarks)
* [Conda](cuvs_bench/#conda)
* [Docker](cuvs_bench/#docker)
* [Running the benchmarks](cuvs_bench/#running-the-benchmarks)
* [End-to-end: smaller-scale benchmarks (<1M to 10M)](cuvs_bench/#end-to-end-smaller-scale-benchmarks-1m-to-10m)
* [End-to-end: large-scale benchmarks (>10M vectors)](cuvs_bench/#end-to-end-large-scale-benchmarks-10m-vectors)
* [Running with Docker containers](cuvs_bench/#running-with-docker-containers)
* [End-to-end run on GPU](cuvs_bench/#end-to-end-run-on-gpu)
* [End-to-end run on CPU](cuvs_bench/#end-to-end-run-on-cpu)
* [Manually run the scripts inside the container](cuvs_bench/#manually-run-the-scripts-inside-the-container)
* [Evaluating the results](cuvs_bench/#evaluating-the-results)
* [Creating and customizing dataset configurations](cuvs_bench/#creating-and-customizing-dataset-configurations)
* [Multi-GPU benchmarks](cuvs_bench/#multi-gpu-benchmarks)
* [Adding a new index algorithm](cuvs_bench/#adding-a-new-index-algorithm)
* [Implementation and configuration](cuvs_bench/#implementation-and-configuration)
* [Adding a Cmake target](cuvs_bench/#adding-a-cmake-target)
* [API Reference](api_docs/)
* [C API Documentation](c_api/)
* [Core Routines](c_api/core_c_api/)
* [Resources Handle](c_api/core_c_api/#resources-handle)
* [Error Handling](c_api/core_c_api/#error-handling)
* [Nearest Neighbors](c_api/neighbors/)
* [Bruteforce](c_api/neighbors_bruteforce_c/)
* [IVF-Flat](c_api/neighbors_ivf_flat_c/)
* [IVF-PQ](c_api/neighbors_ivf_pq_c/)
* [CAGRA](c_api/neighbors_cagra_c/)
* [HNSW](c_api/neighbors_hnsw_c/)
* [C++ API Documentation](cpp_api/)
* [Cluster](cpp_api/cluster/)
* [Cluster](cpp_api/cluster_kmeans/)
* [Cluster](cpp_api/cluster_agglomerative/)
* [Distance](cpp_api/distance/)
* [Distance Types](cpp_api/distance/#distance-types)
* [Pairwise Distances](cpp_api/distance/#pairwise-distances)
* [Nearest Neighbors](cpp_api/neighbors/)
* [Bruteforce](cpp_api/neighbors_bruteforce/)
* [CAGRA](cpp_api/neighbors_cagra/)
* [Dynamic Batching](cpp_api/neighbors_dynamic_batching/)
* [Filtering](cpp_api/neighbors_filter/)
* [HNSW](cpp_api/neighbors_hnsw/)
* [IVF-Flat](cpp_api/neighbors_ivf_flat/)
* [IVF-PQ](cpp_api/neighbors_ivf_pq/)
* [NN-Descent](cpp_api/neighbors_nn_descent/)
* [Refinement](cpp_api/neighbors_refine/)
* [Distributed ANN](cpp_api/neighbors_mg/)
* [Vamana](cpp_api/neighbors_vamana/)
* [Preprocessing](cpp_api/preprocessing/)
* [Quantize](cpp_api/preprocessing_quantize/)
* [Selection](cpp_api/selection/)
* [Select-K](cpp_api/selection/#select-k)
* [Stats](cpp_api/stats/)
* [Silhouette Score](cpp_api/stats/#silhouette-score)
* [Trustworthiness Score](cpp_api/stats/#trustworthiness-score)
* [Python API Documentation](python_api/)
* [Distance](python_api/distance/)
* [Pairwise Distance](python_api/distance/#pairwise-distance)
* [Nearest Neighbors](python_api/neighbors/)
* [Brute Force KNN](python_api/neighbors_brute_force/)
* [CAGRA](python_api/neighbors_cagra/)
* [HNSW](python_api/neighbors_hnsw/)
* [IVF-Flat](python_api/neighbors_ivf_flat/)
* [IVF-PQ](python_api/neighbors_ivf_pq/)
* [NN-Descent](python_api/neighbors_nn_decent/)
* [Preprocessing](python_api/preprocessing/)
* [Scalar Quantizer](python_api/preprocessing/#scalar-quantizer)
* [Rust API Documentation](rust_api/)
* [Contributing](contributing/)
* [Code contributions](contributing/#code-contributions)
* [Your first issue](contributing/#your-first-issue)
* [Python / Pre-commit hooks](contributing/#python-pre-commit-hooks)
* [Seasoned developers](contributing/#seasoned-developers)
* [Attribution](contributing/#attribution)
On this page
---
# libcuspatial: libcuspatial
[Home](/api)
libcuspatial
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/libcuspatial/nightly)
[stable (25.02)](/api/libcuspatial/stable)
[legacy (24.12)](/api/libcuspatial/legacy)
Loading...
Searching...
No Matches
libcuspatial is a GPU-accelerated C++ library for spatial data analysis including distance and trajectory computations, spatial data indexing and spatial join operations. libcuspatial is the high-performance backend for the cuSpatial Python library.
libcuspatial has two interfaces. The generic header-only C++ API represents data as arrays of structures (e.g. 2D points). The header-only API uses iterators for input and output, and is similar in style to the C++ Standard Template Library (STL) and Thrust. All cuSpatial algorithms are implemented in this API.
The libcuspatial "column-based API" is a C++ API based on data types from libcudf, [the CUDA Dataframe library C++ API](https://docs.rapids.ai/api/libcudf/nightly/)
. The column-based API represents spatial data as cuDF tables of type-erased columns, and layers on top of the header-only API.
Useful Links
------------
* [cuSpatial Github Repository](https://github.com/rapidsai/cuspatial)
* [cuSpatial C++ Developer Guide](/api/libcuspatial/stable/developer_guide)
* [cuSpatial Python API Documentation](https://docs.rapids.ai/api/cuspatial/stable/)
* [cuSpatial Python Developer Guide](https://docs.rapids.ai/api/cuspatial/stable/developer_guide/)
\]
* [RAPIDS Home Page](https://rapids.ai)
[](/api/libcuspatial/stable/doxygen_crawl)
---
# RMM: librmm
[Home](/api)
librmm
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/librmm/nightly)
[stable (25.02)](/api/librmm/stable)
[legacy (24.12)](/api/librmm/legacy)
Achieving optimal performance in GPU-centric workflows frequently requires customizing how host and device memory are allocated. For example, using "pinned" host memory for asynchronous host <-> device memory transfers, or using a device memory pool sub-allocator to reduce the cost of dynamic device memory allocation.
The goal of the RAPIDS Memory Manager (RMM) is to provide:
* A common interface that allows customizing device and host memory allocation
* A collection of implementations of the interface
* A collection of data structures that use the interface for memory allocation
For more information on APIs provided by rmm, see [the modules page](/api/librmm/stable/modules)
.
---
# Dask-CUDA — dask-cuda 25.02.00a26 documentation
* [](#)
* Dask-CUDA
* [View page source](_sources/index.rst.txt)
* * *
Dask-CUDA[](#dask-cuda "Link to this heading")
================================================
Dask-CUDA is a library extending [Dask.distributed](https://distributed.dask.org/en/latest/)
’s single-machine [LocalCluster](https://docs.dask.org/en/latest/setup/single-distributed.html#localcluster)
and [Worker](https://distributed.dask.org/en/latest/worker.html)
for use in distributed GPU workloads. It is a part of the [RAPIDS](https://rapids.ai/)
suite of open-source software libraries for GPU-accelerated data science.
Motivation[](#motivation "Link to this heading")
--------------------------------------------------
While Distributed can be used to leverage GPU workloads through libraries such as [cuDF](https://docs.rapids.ai/api/cudf/stable/)
, [CuPy](https://cupy.dev/)
, and [Numba](https://numba.pydata.org/)
, Dask-CUDA offers several unique features unavailable to Distributed:
* **Automatic instantiation of per-GPU workers** – Using Dask-CUDA’s LocalCUDACluster or `dask cuda worker` CLI will automatically launch one worker for each GPU available on the executing node, avoiding the need to explicitly select GPUs.
* **Automatic setting of CPU affinity** – The setting of CPU affinity for each GPU is done automatically, preventing memory transfers from taking suboptimal paths.
* **Automatic selection of InfiniBand devices** – When UCX communication is enabled over InfiniBand, Dask-CUDA automatically selects the optimal InfiniBand device for each GPU (see [UCX Integration](ucx)
for instructions on configuring UCX communication).
* **Memory spilling from GPU** – For memory-intensive workloads, Dask-CUDA supports spilling from GPU to host memory when a GPU reaches the default or user-specified memory utilization limit.
* **Allocation of GPU memory** – when using UCX communication, per-GPU memory pools can be allocated using [RAPIDS Memory Manager](https://github.com/rapidsai/rmm)
to circumvent the costly memory buffer mappings that would be required otherwise.
Contents[](#contents "Link to this heading")
----------------------------------------------
Getting Started
* [Installation](install/)
* [Quickstart](quickstart/)
* [Troubleshooting](troubleshooting/)
* [API](api/)
Additional Features
* [UCX Integration](ucx/)
* [Explicit-comms](explicit_comms/)
* [Spilling from device](spilling/)
Examples
* [Best Practices](examples/best-practices/)
* [Controlling number of workers](examples/worker_count/)
* [Enabling UCX communication](examples/ucx/)
---
# Welcome to rapids-cmake’s documentation! — rapids-cmake 25.02.00 documentation
* [](#)
* Welcome to rapids-cmake’s documentation!
* [View page source](_sources/index.rst.txt)
* * *
Welcome to rapids-cmake’s documentation
=============================================================================================================
This is a collection of CMake modules that are useful for all RAPIDS projects. By sharing the code in a single place it makes rolling out CMake fixes easier.
Contents:
* [API Reference](api/)
* [RAPIDS-CMake Basics](basics/)
* [CPM Reference](cpm/)
* [rapids-cmake package defaults](cpm/#rapids-cmake-package-defaults)
* [rapids-cmake package override](cpm/#rapids-cmake-package-override)
* [Reproducible rapids-cmake builds](cpm/#reproducible-rapids-cmake-builds)
* [rapids-cpm command line controls](cpm/#rapids-cpm-command-line-controls)
* [rapids-cmake package version format](cpm/#rapids-cmake-package-version-format)
* [rapids-cmake package versions](cpm/#rapids-cmake-package-versions)
* [Dependency Tracking](dependency_tracking/)
* [Hardware Resources and Testing](hardware_resources_and_testing/)
Indices and tables[](#indices-and-tables "Link to this heading")
==================================================================
* [Index](genindex/)
* [Search Page](search/)
---
# libcuproj: libcuproj
[Home](/api)
libcuproj
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/libcuproj/nightly)
[stable (25.02)](/api/libcuproj/stable)
[legacy (24.12)](/api/libcuproj/legacy)
Loading...
Searching...
No Matches
cuProj is a generic coordinate transformation library that transforms geospatial coordinates from one coordinate reference system (CRS) to another. This includes cartographic projections as well as geodetic transformations. cuProj is implemented in CUDA C++ to run on GPUs to provide the highest performance.
libcuproj is a CUDA C++ library that provides the header-only C++ API for cuProj. It is designed to implement coordinate projections and transforms compatible with the [Proj](https://proj.org/)
library. The C++ API does not match the API of Proj, but it is designed to eventually expand to support many of the same features and transformations that Proj supports.
Currently libcuproj only supports a subset of the Proj transformations. The following transformations are supported:
* WGS84 to/from UTM
There are some basic examples of using the libcuproj C++ API in the [cuProj README](https://github.com/rapidsai/cuspatial/cpp/cuproj/README.md)
.
Useful Links
------------
* [RAPIDS Home Page](https://rapids.ai)
* [cuSpatial Github](https://github.com/rapidsai/cuspatial)
[](/api/libcuproj/stable/doxygen_crawl)
---
# * NOTICE * — cugraph-docs 25.04.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cugraph
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
nightly (25.04)
[nightly (25.04)](/api/cugraph/nightly)
[stable (25.02)](/api/cugraph/stable)
[legacy (24.12)](/api/cugraph/legacy)
* [GitHub](https://github.com/rapidsai/cugraph "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
**\* NOTICE \***[#](#notice "Link to this heading")
====================================================
The cuGraph repository has been refactored to make it more efficient to build, maintain and use.
Libraries supporting GNNs are now located in the [cugraph-gnn repository](https://github.com/rapidsai/cugraph-gnn)
* [pylibwholegraph](https://github.com/rapidsai/cugraph-gnn/tree/main/python/)
- the [Wholegraph](https://docs.rapids.ai/api/cugraph/nightly/wholegraph/)
library for client memory management supporting both cuGraph-DGL and cuGraph-PyG for even greater scalability
* [cugraph\_dgl](https://github.com/rapidsai/cugraph-gnn/blob/main/readme_pages/cugraph_dgl.md)
enables the ability to use cugraph Property Graphs with Deep Graph Library (DGL)
* [cugraph\_pyg](https://github.com/rapidsai/cugraph-gnn/blob/main/readme_pages/cugraph_pyg.md)
enables the ability to use cugraph Property Graphs with PyTorch Geometric (PyG).
[RAPIDS nx-cugraph](https://rapids.ai/nx-cugraph/)
is now located in the [nx-cugraph repository](https://github.com/rapidsai/nx-cugraph)
containing a backend to NetworkX for running supported algorithms with GPU acceleration.
The [cugraph-docs repository](https://github.com/rapidsai/cugraph-docs)
contains code to generate cuGraph documentation.
—
RAPIDS Graph documentation[#](#rapids-graph-documentation "Link to this heading")
==================================================================================
[](_images/cugraph_logo_2.png)
Introduction[#](#introduction "Link to this heading")
------------------------------------------------------
cuGraph is a library of graph algorithms that seamlessly integrates into the RAPIDS data science ecosystem and allows data scientists to easily call graph algorithms using data stored in cuDF/Pandas DataFrames or CuPy/SciPy sparse matrices.
### cuGraph Using NetworkX Code[#](#cugraph-using-networkx-code "Link to this heading")
cuGraph is now available as a NetworkX backend using [nx-cugraph](https://rapids.ai/nx-cugraph/)
. Our major integration effort with NetworkX offers NetworkX users a **zero code change** option to accelerate their existing NetworkX code using an NVIDIA GPU and cuGraph.
Check out [zero code change accelerated NetworkX](nx_cugraph/)
. If you would like to continue using standard cuGraph, then continue down below.
### Getting started with cuGraph[#](#getting-started-with-cugraph "Link to this heading")
Required hardware/software for [cuGraph and RAPIDS](https://docs.rapids.ai/install/#system-req)
#### Installation[#](#installation "Link to this heading")
Please see the latest [RAPIDS System Requirements documentation](https://docs.rapids.ai/install#system-req)
.
This includes several ways to set up cuGraph
* On Unix
* [Conda](https://docs.rapids.ai/install/#conda)
* [Docker](https://docs.rapids.ai/install/#docker)
* [pip](https://docs.rapids.ai/install/#pip)
**Note: Windows use of RAPIDS depends on prior installation of** [WSL2](https://learn.microsoft.com/en-us/windows/wsl/install)
.
* On Windows
* [Conda](https://docs.rapids.ai/install#wsl2-conda)
* [Docker](https://docs.rapids.ai/install#wsl2-docker)
* [pip](https://docs.rapids.ai/install#wsl2-pip)
> Cugraph API Example
>
> import cugraph
> import cudf
>
> \# Create an instance of the popular Zachary Karate Club graph
> from cugraph.datasets import karate
> G \= karate.get\_graph()
>
> \# Call cugraph.degree\_centrality
> vertex\_bc \= cugraph.degree\_centrality(G)
>
> There are several resources containing cuGraph examples, the cuGraph [notebook repository](https://github.com/rapidsai/cugraph/blob/HEAD/notebooks/README.md)
> has many examples of loading graph data and running algorithms in Jupyter notebooks. The cuGraph [test code](https://github.com/rapidsai/cugraph/tree/main/python/cugraph/cugraph/tests)
> contains script examples of setting up and calling cuGraph algorithms.
>
> A simple example of [testing the degree centrality algorithm](https://github.com/rapidsai/cugraph/blob/HEAD/python/cugraph/cugraph/tests/centrality/test_degree_centrality.py)
> is a good place to start. There are also [multi-GPU examples](https://github.com/rapidsai/cugraph/blob/HEAD/python/cugraph/cugraph/tests/centrality/test_degree_centrality_mg.py)
> with larger data sets as well.
* * *
Table of Contents[#](#table-of-contents "Link to this heading")
----------------------------------------------------------------
* [cuGraph Introduction](basics/)
* [nx-cugraph](nx_cugraph/)
* [Installation](installation/)
* [Tutorials](tutorials/)
* [Graph Support](graph_support/)
* [WholeGraph](wholegraph/)
* [References](references/)
* [Developer Resources](dev_resources/)
* [API Reference](api_docs/)
Indices and tables[#](#indices-and-tables "Link to this heading")
------------------------------------------------------------------
* [Index](genindex/)
* [Search Page](search/)
On this page
### This Page
* [Show Source](_sources/index.rst.txt)
---
# libucxx: Main Page
[Home](/api)
libucxx
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (0.42)
[nightly (0.43)](/api/libucxx/nightly)
[stable (0.42)](/api/libucxx/stable)
[legacy (0.41)](/api/libucxx/legacy)
---
# libkvikio: Welcome to KvikIO's C++ documentation!
[Home](/api)
libkvikio
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/libkvikio/nightly)
[stable (25.02)](/api/libkvikio/stable)
[legacy (24.12)](/api/libkvikio/legacy)
KvikIO is a Python and C++ library for high performance file IO. It provides C++ and Python bindings to [cuFile](https://docs.nvidia.com/gpudirect-storage/api-reference-guide/index.html)
which enables [GPUDirect Storage (GDS)](https://developer.nvidia.com/blog/gpudirect-storage/)
. KvikIO also works efficiently when GDS isn't available and can read/write both host and device data seamlessly.
KvikIO C++ is part of the [RAPIDS](https://rapids.ai/)
suite of open-source software libraries for GPU-accelerated data science.
* * *
**Notice** this is the documentation for the C++ library. For the Python documentation, see under [kvikio](https://docs.rapids.ai/api/kvikio/nightly/)
.
* * *
Features
========
* Object Oriented API.
* Exception handling.
* Concurrent reads and writes using an internal thread pool.
* Non-blocking API.
* Handle both host and device IO seamlessly.
Installation
============
For convenience we release Conda packages that makes it easy to include KvikIO in your CMake projects.
Conda/Mamba
-----------
We strongly recommend using [mamba](https://github.com/mamba-org/mamba)
in place of conda, which we will do throughout the documentation.
Install the **stable release** from the `rapidsai` channel with the following:
\# Install in existing environment
mamba install -c rapidsai -c conda-forge libkvikio
\# Create new environment (CUDA 12)
mamba create -n libkvikio-env -c rapidsai -c conda-forge cuda-version=12.8 libkvikio
\# Create new environment (CUDA 11)
mamba create -n libkvikio-env -c rapidsai -c conda-forge cuda-version=11.8 libkvikio
Install the **nightly release** from the `rapidsai-nightly` channel with the following:
\# Install in existing environment
mamba install -c rapidsai-nightly -c conda-forge libkvikio
\# Create new environment (CUDA 12)
mamba create -n libkvikio-env -c rapidsai-nightly -c conda-forge python=3.12 cuda-version=12.8 libkvikio
\# Create new environment (CUDA 11)
mamba create -n libkvikio-env -c rapidsai-nightly -c conda-forge python=3.12 cuda-version=11.8 libkvikio
* * *
**Notice** if the nightly install doesn't work, set `channel_priority: flexible` in your `.condarc`.
* * *
Include KvikIO in a CMake project
---------------------------------
An example of how to include KvikIO in an existing CMake project can be found here: [https://github.com/rapidsai/kvikio/blob/HEAD/cpp/examples/downstream/](https://github.com/rapidsai/kvikio/blob/HEAD/cpp/examples/downstream/)
.
Build from source
-----------------
To build the C++ example run:
./build.sh libkvikio
Then run the example:
./examples/basic\_io
Runtime Settings
================
### Compatibility Mode (KVIKIO\_COMPAT\_MODE)
When KvikIO is running in compatibility mode, it doesn't load `libcufile.so`. Instead, reads and writes are done using POSIX. Notice, this is not the same as the compatibility mode in cuFile. It is possible that KvikIO performs I/O in the non-compatibility mode by using the cuFile library, but the cuFile library itself is configured to operate in its own compatibility mode. For more details, refer to [cuFile compatibility mode](https://docs.nvidia.com/gpudirect-storage/api-reference-guide/index.html#cufile-compatibility-mode)
and [cuFile environment variables](https://docs.nvidia.com/gpudirect-storage/troubleshooting-guide/index.html#environment-variables)
The environment variable `KVIKIO_COMPAT_MODE` has three options (case-insensitive):
* `ON` (aliases: `TRUE`, `YES`, `1`): Enable the compatibility mode.
* `OFF` (aliases: `FALSE`, `NO`, `0`): Disable the compatibility mode, and enforce cuFile I/O. GDS will be activated if the system requirements for cuFile are met and cuFile is properly configured. However, if the system is not suited for cuFile, I/O operations under the `OFF` option may error out, crash or hang.
* `AUTO`: Try cuFile I/O first, and fall back to POSIX I/O if the system requirements for cuFile are not met.
Under `AUTO`, KvikIO falls back to the compatibility mode:
* when `libcufile.so` cannot be found.
* when running in Windows Subsystem for Linux (WSL).
* when `/run/udev` isn't readable, which typically happens when running inside a docker image not launched with `--volume /run/udev:/run/udev:ro`.
This setting can also be programmatically controlled by `defaults::set_compat_mode()` and `defaults::compat_mode_reset()`.
### Thread Pool (KVIKIO\_NTHREADS)
KvikIO can use multiple threads for IO automatically. Set the environment variable `KVIKIO_NTHREADS` to the number of threads in the thread pool. If not set, the default value is 1.
This setting can also be controlled by `defaults::thread_pool_nthreads()` and `defaults::thread_pool_nthreads_reset()`.
### Task Size (KVIKIO\_TASK\_SIZE)
KvikIO splits parallel IO operations into multiple tasks. Set the environment variable `KVIKIO_TASK_SIZE` to the maximum task size (in bytes). If not set, the default value is 4194304 (4 MiB).
This setting can also be controlled by `defaults::task_size()` and `defaults::task_size_reset()`.
### GDS Threshold (KVIKIO\_GDS\_THRESHOLD)
To improve performance of small IO requests, `.pread()` and `.pwrite()` implement a shortcut that circumvents the threadpool and uses the POSIX backend directly. Set the environment variable `KVIKIO_GDS_THRESHOLD` to the minimum size (in bytes) to use GDS. If not set, the default value is 1048576 (1 MiB).
This setting can also be controlled by `defaults::gds_threshold()` and `defaults::gds_threshold_reset()`.
### Size of the Bounce Buffer (KVIKIO\_GDS\_THRESHOLD)
KvikIO might have to use intermediate host buffers (one per thread) when copying between files and device memory. Set the environment variable `KVIKIO_BOUNCE_BUFFER_SIZE` to the size (in bytes) of these "bounce" buffers. If not set, the default value is 16777216 (16 MiB).
This setting can also be controlled by `defaults::bounce_buffer_size()` and `defaults::bounce_buffer_size_reset()`.
Example
=======
#include
#include
#include
using namespace std;
int main()
{
// Create two arrays \`a\` and \`b\`
constexpr std::size\_t size = 100;
void \*a = nullptr;
void \*b = nullptr;
cudaMalloc(&a, size);
cudaMalloc(&b, size);
// Write \`a\` to file
[kvikio::FileHandle](/api/libkvikio/stable/classkvikio_1_1filehandle)
fw("test-file", "w");
size\_t written = fw.write(a, size);
fw.close();
// Read file into \`b\`
[kvikio::FileHandle](/api/libkvikio/stable/classkvikio_1_1filehandle)
fr("test-file", "r");
size\_t read = fr.read(b, size);
fr.close();
// Read file into \`b\` in parallel using 16 threads
kvikio::default\_thread\_pool::reset(16);
{
[kvikio::FileHandle](/api/libkvikio/stable/classkvikio_1_1filehandle)
f("test-file", "r");
future future = f.pread(b\_dev, sizeof(a), 0); // Non-blocking
size\_t read = future.get(); // Blocking
// Notice, \`f\` closes automatically on destruction.
}
}
[kvikio::FileHandle](/api/libkvikio/stable/classkvikio_1_1filehandle)
Handle of an open file registered with cufile.
**Definition:** [file\_handle.hpp:44](/api/libkvikio/stable/file__handle_8hpp_source#l00044)
For a full runnable example see [https://github.com/rapidsai/kvikio/blob/HEAD/cpp/examples/basic\_io.cpp](https://github.com/rapidsai/kvikio/blob/HEAD/cpp/examples/basic_io.cpp)
.
---
# RAPIDS RAFT: Reusable Accelerated Functions and Tools for Vector Search and More — raft 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
raft
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/raft/nightly)
[stable (25.02)](/api/raft/stable)
[legacy (24.12)](/api/raft/legacy)
* [GitHub](https://github.com/rapidsai/raft "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
Attention
The vector search and clustering algorithms in RAFT are being migrated to a new library dedicated to vector search called [cuVS](https://github.com/rapidsai/cuvs)
. We will continue to support the vector search algorithms in RAFT during this move, but will no longer update them after the RAPIDS 24.06 (June) release. We plan to complete the migration by RAPIDS 24.10 (October) release and they will be removed from RAFT altogether in the 24.12 (December) release.
RAPIDS RAFT: Reusable Accelerated Functions and Tools for Vector Search and More[#](#rapids-raft-reusable-accelerated-functions-and-tools-for-vector-search-and-more "Link to this heading")
=============================================================================================================================================================================================
[](_images/raft-tech-stack-vss.png)
Useful Resources[#](#useful-resources "Link to this heading")
--------------------------------------------------------------
* [RAPIDS Community](https://rapids.ai/community.html)
: Get help, contribute, and collaborate.
* [GitHub repository](https://github.com/rapidsai/raft)
: Download the RAFT source code.
* [Issue tracker](https://github.com/rapidsai/raft/issues)
: Report issues or request features.
What is RAFT?[#](#what-is-raft "Link to this heading")
-------------------------------------------------------
RAFT contains fundamental widely-used algorithms and primitives for machine learning and information retrieval. The algorithms are CUDA-accelerated and form building blocks for more easily writing high performance applications.
By taking a primitives-based approach to algorithm development, RAFT
* accelerates algorithm construction time
* reduces the maintenance burden by maximizing reuse across projects, and
* centralizes core reusable computations, allowing future optimizations to benefit all algorithms that use them.
While not exhaustive, the following general categories help summarize the accelerated building blocks that RAFT contains:
| Category | Examples |
| --- | --- |
| Data Formats | sparse & dense, conversions, data generation |
| Dense Operations | linear algebra, matrix and vector operations, slicing, norms, factorization, least squares, svd & eigenvalue problems |
| Sparse Operations | linear algebra, eigenvalue problems, slicing, norms, reductions, factorization, symmetrization, components & labeling |
| Solvers | combinatorial optimization, iterative solvers |
| Statistics | sampling, moments and summary statistics, metrics |
| Tools & Utilities | common utilities for developing CUDA applications, multi-node multi-gpu infrastructure |
Contents:
* [Quick Start](quick_start/)
* [Installation](build/)
* [C++ API](cpp_api/)
* [Python API](pylibraft_api/)
* [RAFT Dask API](raft_dask_api/)
* [Using RAFT Comms](using_raft_comms/)
* [Developer Guide](developer_guide/)
* [Contributing](contributing/)
Indices and tables[#](#indices-and-tables "Link to this heading")
==================================================================
* [Index](genindex/)
* [Module Index](py-modindex/)
* [Search Page](search/)
On this page
### This Page
* [Show Source](_sources/index.rst.txt)
---
# Welcome to rmm’s documentation! — rmm 25.02.00 documentation
* [](#)
* Welcome to rmm’s documentation!
* [View page source](_sources/index.rst.txt)
* * *
Welcome to rmm’s documentation
===========================================================================================
Contents:
* [Python](python/)
* [User Guide](guide/)
* [API Reference](python_api/)
* [C++](cpp/)
* [API Reference](cpp_api/)
Indices and tables[](#indices-and-tables "Link to this heading")
==================================================================
* [Index](genindex/)
* [Module Index](py-modindex/)
* [Search Page](search/)
---
# Unknown
\*\*\* NOTICE \*\*\* ============== The cuGraph repository has been refactored to make it more efficient to build, maintain and use. Libraries supporting GNNs are now located in the \`cugraph-gnn repository \`\_ \* \`pylibwholegraph \`\_ - the \`Wholegraph \`\_ library for client memory management supporting both cuGraph-DGL and cuGraph-PyG for even greater scalability \* \`cugraph\_dgl \`\_ enables the ability to use cugraph Property Graphs with Deep Graph Library (DGL) \* \`cugraph\_pyg \`\_ enables the ability to use cugraph Property Graphs with PyTorch Geometric (PyG). \`RAPIDS nx-cugraph \`\_ is now located in the \`nx-cugraph repository \`\_ containing a backend to NetworkX for running supported algorithms with GPU acceleration. The \`cugraph-docs repository \`\_ contains code to generate cuGraph documentation. --- RAPIDS Graph documentation ========================== .. image:: images/cugraph\_logo\_2.png :width: 600 ~~~~~~~~~~~~ Introduction ~~~~~~~~~~~~ cuGraph is a library of graph algorithms that seamlessly integrates into the RAPIDS data science ecosystem and allows data scientists to easily call graph algorithms using data stored in cuDF/Pandas DataFrames or CuPy/SciPy sparse matrices. --------------------------- cuGraph Using NetworkX Code --------------------------- cuGraph is now available as a NetworkX backend using \`nx-cugraph \`\_. Our major integration effort with NetworkX offers NetworkX users a \*\*zero code change\*\* option to accelerate their existing NetworkX code using an NVIDIA GPU and cuGraph. Check out \`zero code change accelerated NetworkX \`\_. If you would like to continue using standard cuGraph, then continue down below. ---------------------------- Getting started with cuGraph ---------------------------- Required hardware/software for \`cuGraph and RAPIDS \`\_ ++++++++++++ Installation ++++++++++++ Please see the latest \`RAPIDS System Requirements documentation \`\_. This includes several ways to set up cuGraph \* On Unix \* \`Conda \`\_ \* \`Docker \`\_ \* \`pip \`\_ \*\*Note: Windows use of RAPIDS depends on prior installation of\*\* \`WSL2 \`\_. \* On Windows \* \`Conda \`\_ \* \`Docker \`\_ \* \`pip \`\_ Cugraph API Example .. code-block:: python import cugraph import cudf # Create an instance of the popular Zachary Karate Club graph from cugraph.datasets import karate G = karate.get\_graph() # Call cugraph.degree\_centrality vertex\_bc = cugraph.degree\_centrality(G) There are several resources containing cuGraph examples, the cuGraph \`notebook repository \`\_ has many examples of loading graph data and running algorithms in Jupyter notebooks. The cuGraph \`test code \`\_ contains script examples of setting up and calling cuGraph algorithms. A simple example of \`testing the degree centrality algorithm \`\_ is a good place to start. There are also \`multi-GPU examples \`\_ with larger data sets as well. ---- ~~~~~~~~~~~~~~~~~ Table of Contents ~~~~~~~~~~~~~~~~~ .. toctree:: :maxdepth: 1 basics/index nx\_cugraph/index installation/index tutorials/index graph\_support/index wholegraph/index references/index dev\_resources/index api\_docs/index ~~~~~~~~~~~~~~~~~~ Indices and tables ~~~~~~~~~~~~~~~~~~ \* :ref:\`genindex\` \* :ref:\`search\`
---
# Search - cugraph-docs 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cugraph
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cugraph/nightly)
[stable (25.02)](/api/cugraph/stable)
[legacy (24.12)](/api/cugraph/legacy)
* [GitHub](https://github.com/rapidsai/cugraph "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
Search
======
Ctrl+K
---
# RAPIDS Graph documentation — cugraph 24.12.00 documentation
[Skip to main content](#main-content)
Back to top
Ctrl+K
[Home](/api)
cugraph
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
legacy (24.12)
[nightly (25.04)](/api/cugraph/nightly)
[stable (25.02)](/api/cugraph/stable)
[legacy (24.12)](/api/cugraph/legacy)
* [GitHub](https://github.com/rapidsai/cugraph "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
RAPIDS Graph documentation[#](#rapids-graph-documentation "Permalink to this heading")
=======================================================================================
[](_images/cugraph_logo_2.png)
Introduction[#](#introduction "Permalink to this heading")
-----------------------------------------------------------
cuGraph is a library of graph algorithms that seamlessly integrates into the RAPIDS data science ecosystem and allows the data scientist to easily call graph algorithms using data stored in cuDF/Pandas DataFrames or CuPy/SciPy sparse matrices.
### cuGraph Using NetworkX Code[#](#cugraph-using-networkx-code "Permalink to this heading")
cuGraph is now available as a NetworkX backend using [nx-cugraph](https://rapids.ai/nx-cugraph/)
. Our major integration effort with NetworkX offers NetworkX users a **zero code change** option to accelerate their existing NetworkX code using an NVIDIA GPU and cuGraph.
Check out [zero code change accelerated NetworkX](nx_cugraph/)
. If you would like to continue using standard cuGraph, then continue down below.
### Getting started with cuGraph[#](#getting-started-with-cugraph "Permalink to this heading")
Required hardware/software for cuGraph and [RAPIDS](https://docs.rapids.ai/user-guide)
* NVIDIA GPU, Volta architecture or later, with [compute capability 7.0+](https://developer.nvidia.com/cuda-gpus)
* CUDA 11.2-11.8, 12.0-12.5
* Python version 3.10, 3.11, or 3.12
#### Installation[#](#installation "Permalink to this heading")
Please see the latest [RAPIDS System Requirements documentation](https://docs.rapids.ai/install#system-req)
.
This includes several ways to set up cuGraph
* From Unix
* [Conda](https://docs.rapids.ai/install/#conda)
* [Docker](https://docs.rapids.ai/install/#docker)
* [pip](https://docs.rapids.ai/install/#pip)
**Note: Windows use of RAPIDS depends on prior installation of** [WSL2](https://learn.microsoft.com/en-us/windows/wsl/install)
.
* From Windows
* [Conda](https://docs.rapids.ai/install#wsl2-conda)
* [Docker](https://docs.rapids.ai/install#wsl2-docker)
* [pip](https://docs.rapids.ai/install#wsl2-pip)
> Cugraph API Example
>
> import cugraph
> import cudf
>
> \# Create an instance of the popular Zachary Karate Club graph
> from cugraph.datasets import karate
> G \= karate.get\_graph()
>
> \# Call cugraph.degree\_centrality
> vertex\_bc \= cugraph.degree\_centrality(G)
>
> There are several resources containing cuGraph examples, the cuGraph [notebook repository](https://github.com/rapidsai/cugraph/blob/HEAD/notebooks/README.md)
> has many examples of loading graph data and running algorithms in Jupyter notebooks. The cuGraph [test code](https://github.com/rapidsai/cugraph/tree/main/python/cugraph/cugraph/tests)
> contains script examples of setting up and calling cuGraph algorithms.
>
> A simple example of [testing the degree centrality algorithm](https://github.com/rapidsai/cugraph/blob/HEAD/python/cugraph/cugraph/tests/centrality/test_degree_centrality.py)
> is a good place to start. There are also [multi-GPU examples](https://github.com/rapidsai/cugraph/blob/HEAD/python/cugraph/cugraph/tests/centrality/test_degree_centrality_mg.py)
> with larger data sets as well.
* * *
Table of Contents[#](#table-of-contents "Permalink to this heading")
---------------------------------------------------------------------
* [cuGraph Introduction](basics/)
* [Vision](basics/#vision)
* [Terminology](basics/#terminology)
* [nx-cugraph](nx_cugraph/)
* [How it Works](nx_cugraph/how-it-works/)
* [Installing nx-cugraph](nx_cugraph/installation/)
* [Supported Algorithms](nx_cugraph/supported-algorithms/)
* [Benchmarks](nx_cugraph/benchmarks/)
* [Installation](installation/)
* [Getting cuGraph Packages](installation/getting_cugraph/)
* [Building from Source](installation/source_build/)
* [Tutorials](tutorials/)
* [How To Guides](tutorials/how_to_guides/)
* [cuGraph Blogs and Presentations](tutorials/cugraph_blogs/)
* [Commmunity Resources](tutorials/community_resources/)
* [cuGraph Notebooks](tutorials/cugraph_notebooks/)
* [Graph Support](graph_support/)
* [Algorithms](graph_support/graph_algorithms/)
* [Compatibility](graph_support/compatibility/)
* [Graph Neural Network Support](graph_support/gnn_support/)
* [Data Stores](graph_support/datastores/)
* [CuGraph Service](graph_support/cugraph_service/)
* [WholeGraph](wholegraph/)
* [Basics](wholegraph/basics/)
* [Installation](wholegraph/installation/)
* [References](references/)
* [References](references/cugraph_ref/)
* [Data Sets](references/datasets/)
* [License](references/licenses/)
* [API Reference](api_docs/)
* [Core Graph API Documentation](api_docs/#core-graph-api-documentation)
* [Graph Neural Networks API Documentation](api_docs/#graph-neural-networks-api-documentation)
* [Additional Graph Packages API Documentation](api_docs/#additional-graph-packages-api-documentation)
Indices and tables[#](#indices-and-tables "Permalink to this heading")
-----------------------------------------------------------------------
* [Index](genindex/)
* [Search Page](search/)
On this page
[Show Source](_sources/index.rst.txt)
---
# WholeGraph — cugraph-docs 25.04.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cugraph
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
nightly (25.04)
[nightly (25.04)](/api/cugraph/nightly)
[stable (25.02)](/api/cugraph/stable)
[legacy (24.12)](/api/cugraph/legacy)
* [GitHub](https://github.com/rapidsai/cugraph "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
WholeGraph[#](#wholegraph "Link to this heading")
==================================================
RAPIDS WholeGraph has following package:
* pylibwholegraph: shared memory-based GPU-accelerated GNN training
Contents:
* [Basics](basics/)
* [WholeGraph Introduction](basics/wholegraph_intro/)
* [WholeMemory](basics/wholememory_intro/)
* [WholeMemory Implementation Details](basics/wholememory_implementation_details/)
* [Installation](installation/)
* [Getting the WholeGraph Packages](installation/getting_wholegraph/)
* [Build Container for WholeGraph](installation/container/)
* [Building from Source](installation/source_build/)
### This Page
* [Show Source](../_sources/wholegraph/index.rst.txt)
---
# cuDF User Guide — cudf 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cudf
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cudf/nightly/)
[stable (25.02)](/api/cudf/stable/)
[legacy (24.12)](/api/cudf/legacy/)
* [GitHub](https://github.com/rapidsai/cudf "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
cuDF User Guide[#](#cudf-user-guide "Link to this heading")
============================================================
* [API reference](api_docs/)
* [Series](api_docs/series/)
* [DataFrame](api_docs/dataframe/)
* [Index objects](api_docs/index_objects/)
* [GroupBy](api_docs/groupby/)
* [General Functions](api_docs/general_functions/)
* [General Utilities](api_docs/general_utilities/)
* [Window](api_docs/window/)
* [Input/output](api_docs/io/)
* [TokenizeVocabulary](api_docs/tokenize_vocabulary/)
* [String handling](api_docs/string_handling/)
* [List handling](api_docs/list_handling/)
* [Struct handling](api_docs/struct_handling/)
* [Options and settings](api_docs/options/)
* [Extension Dtypes](api_docs/extension_dtypes/)
* [Performance Tracking](api_docs/performance_tracking/)
* [10 Minutes to cuDF and Dask cuDF](10min/)
* [What are these Libraries?](10min/#what-are-these-libraries)
* [When to use cuDF and Dask cuDF](10min/#when-to-use-cudf-and-dask-cudf)
* [Object Creation](10min/#object-creation)
* [Viewing Data](10min/#viewing-data)
* [Selecting a Column](10min/#selecting-a-column)
* [Selecting Rows by Label](10min/#selecting-rows-by-label)
* [Selecting Rows by Position](10min/#selecting-rows-by-position)
* [Boolean Indexing](10min/#boolean-indexing)
* [MultiIndex](10min/#multiindex)
* [Missing Data](10min/#missing-data)
* [Stats](10min/#stats)
* [Applymap](10min/#applymap)
* [Histogramming](10min/#histogramming)
* [String Methods](10min/#string-methods)
* [Concat](10min/#concat)
* [Join](10min/#join)
* [Grouping](10min/#grouping)
* [Transpose](10min/#transpose)
* [Time Series](10min/#time-series)
* [Categoricals](10min/#categoricals)
* [Converting to Pandas](10min/#converting-to-pandas)
* [Converting to Numpy](10min/#converting-to-numpy)
* [Converting to Arrow](10min/#converting-to-arrow)
* [Reading/Writing CSV Files](10min/#reading-writing-csv-files)
* [Reading/Writing Parquet Files](10min/#reading-writing-parquet-files)
* [Reading/Writing ORC Files](10min/#reading-writing-orc-files)
* [Dask Performance Tips](10min/#dask-performance-tips)
* [Comparison of cuDF and Pandas](pandas-comparison/)
* [Supported operations](pandas-comparison/#supported-operations)
* [Data types](pandas-comparison/#data-types)
* [Null (or “missing”) values](pandas-comparison/#null-or-missing-values)
* [Iteration](pandas-comparison/#iteration)
* [Result ordering](pandas-comparison/#result-ordering)
* [Floating-point computation](pandas-comparison/#floating-point-computation)
* [Column names](pandas-comparison/#column-names)
* [Writing a DataFrame to Parquet with non-string column names](pandas-comparison/#writing-a-dataframe-to-parquet-with-non-string-column-names)
* [No true `"object"` data type](pandas-comparison/#no-true-object-data-type)
* [`.apply()` function limitations](pandas-comparison/#apply-function-limitations)
* [Supported Data Types](data-types/)
* [NumPy data types](data-types/#numpy-data-types)
* [A note on `object`](data-types/#a-note-on-object)
* [Decimal data types](data-types/#decimal-data-types)
* [Nested data types (`List` and `Struct`)](data-types/#nested-data-types-list-and-struct)
* [Input / Output](io/)
* [Input / Output](io/io/)
* [Working with JSON data](io/read-json/)
* [Working with missing data](missing-data/)
* [How to Detect missing values](missing-data/#how-to-detect-missing-values)
* [Float dtypes and missing data](missing-data/#float-dtypes-and-missing-data)
* [Datetimes](missing-data/#datetimes)
* [Calculations with missing data](missing-data/#calculations-with-missing-data)
* [Sum/product of Null/nans](missing-data/#sum-product-of-null-nans)
* [NA values in GroupBy](missing-data/#na-values-in-groupby)
* [Inserting missing data](missing-data/#inserting-missing-data)
* [Filling missing values: fillna](missing-data/#filling-missing-values-fillna)
* [Filling with cudf Object](missing-data/#filling-with-cudf-object)
* [Dropping axis labels with missing data: dropna](missing-data/#dropping-axis-labels-with-missing-data-dropna)
* [Replacing generic values](missing-data/#replacing-generic-values)
* [String/regular expression replacement](missing-data/#string-regular-expression-replacement)
* [Numeric replacement](missing-data/#numeric-replacement)
* [GroupBy](groupby/)
* [Summary of supported operations](groupby/#summary-of-supported-operations)
* [Grouping](groupby/#grouping)
* [Aggregation](groupby/#aggregation)
* [GroupBy apply](groupby/#groupby-apply)
* [Transform](groupby/#transform)
* [Rolling window calculations](groupby/#rolling-window-calculations)
* [Overview of User Defined Functions with cuDF](guide-to-udfs/)
* [Series UDFs](guide-to-udfs/#series-udfs)
* [DataFrame UDFs](guide-to-udfs/#dataframe-udfs)
* [Rolling Window UDFs](guide-to-udfs/#rolling-window-udfs)
* [GroupBy DataFrame UDFs](guide-to-udfs/#groupby-dataframe-udfs)
* [Numba Kernels on CuPy Arrays](guide-to-udfs/#numba-kernels-on-cupy-arrays)
* [Caveats](guide-to-udfs/#caveats)
* [Summary](guide-to-udfs/#summary)
* [Interoperability between cuDF and CuPy](cupy-interop/)
* [Converting a cuDF DataFrame to a CuPy Array](cupy-interop/#converting-a-cudf-dataframe-to-a-cupy-array)
* [Converting a cuDF Series to a CuPy Array](cupy-interop/#converting-a-cudf-series-to-a-cupy-array)
* [Converting a CuPy Array to a cuDF DataFrame](cupy-interop/#converting-a-cupy-array-to-a-cudf-dataframe)
* [Converting a CuPy Array to a cuDF Series](cupy-interop/#converting-a-cupy-array-to-a-cudf-series)
* [Interweaving CuDF and CuPy for Smooth PyData Workflows](cupy-interop/#interweaving-cudf-and-cupy-for-smooth-pydata-workflows)
* [Converting a cuDF DataFrame to a CuPy Sparse Matrix](cupy-interop/#converting-a-cudf-dataframe-to-a-cupy-sparse-matrix)
* [Options](options/)
* [Performance comparisons](performance-comparisons/)
* [Performance comparison](performance-comparisons/performance-comparisons/)
* [System Configuration](performance-comparisons/performance-comparisons/#system-configuration)
* [Pandas Compatibility Notes](PandasCompat/)
* [Copy-on-write](copy-on-write/)
* [Enabling copy-on-write](copy-on-write/#enabling-copy-on-write)
* [Disabling copy-on-write](copy-on-write/#disabling-copy-on-write)
* [Making copies](copy-on-write/#making-copies)
* [Notes](copy-on-write/#notes)
* [Memory Profiling](memory-profiling/)
* [Enabling Memory Profiling](memory-profiling/#enabling-memory-profiling)
* [Breaking changes for pandas 2 in cuDF 24.04+](pandas-2.0-breaking-changes/)
* [Removed `DataFrame.append` & `Series.append`, use `cudf.concat` instead.](pandas-2.0-breaking-changes/#removed-dataframe-append-series-append-use-cudf-concat-instead)
* [Removed various numeric `Index` sub-classes, use `cudf.Index`](pandas-2.0-breaking-changes/#removed-various-numeric-index-sub-classes-use-cudf-index)
* [Change in bitwise operation results](pandas-2.0-breaking-changes/#change-in-bitwise-operation-results)
* [ufuncs will perform re-indexing](pandas-2.0-breaking-changes/#ufuncs-will-perform-re-indexing)
* [`DataFrame` vs `Series` comparisons need to have matching index](pandas-2.0-breaking-changes/#dataframe-vs-series-comparisons-need-to-have-matching-index)
* [Series.rank](pandas-2.0-breaking-changes/#series-rank)
* [Value counts sets the results name to `count`/`proportion`](pandas-2.0-breaking-changes/#value-counts-sets-the-results-name-to-count-proportion)
* [`DataFrame.describe` will include datetime data by default](pandas-2.0-breaking-changes/#dataframe-describe-will-include-datetime-data-by-default)
* [Converting a datetime string with `Z` to timezone-naive dtype is not allowed.](pandas-2.0-breaking-changes/#converting-a-datetime-string-with-z-to-timezone-naive-dtype-is-not-allowed)
* [`Datetime` & `Timedelta` reduction operations will preserve their time resolutions.](pandas-2.0-breaking-changes/#datetime-timedelta-reduction-operations-will-preserve-their-time-resolutions)
* [`get_dummies` default return type is changed from `int8` to `bool`](pandas-2.0-breaking-changes/#get-dummies-default-return-type-is-changed-from-int8-to-bool)
* [`reset_index` will name columns as `None` when `name=None`](pandas-2.0-breaking-changes/#reset-index-will-name-columns-as-none-when-name-none)
* [Fixed an issue where duration components were being incorrectly calculated](pandas-2.0-breaking-changes/#fixed-an-issue-where-duration-components-were-being-incorrectly-calculated)
* [`fillna` on `datetime`/`timedelta` with a lower-resolution scalar will now type-cast the series](pandas-2.0-breaking-changes/#fillna-on-datetime-timedelta-with-a-lower-resolution-scalar-will-now-type-cast-the-series)
* [`Groupby.nth` & `Groupby.dtypes` will have the grouped column in result](pandas-2.0-breaking-changes/#groupby-nth-groupby-dtypes-will-have-the-grouped-column-in-result)
### This Page
* [Show Source](../_sources/user_guide/index.md.txt)
---
# Welcome to cuML’s documentation! — cuml 24.12.00 documentation
[Skip to main content](#main-content)
Back to top
Ctrl+K
[Home](/api)
cuml
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
legacy (24.12)
[nightly (25.04)](/api/cuml/nightly)
[stable (25.02)](/api/cuml/stable)
[legacy (24.12)](/api/cuml/legacy)
* [GitHub](https://github.com/rapidsai/cuml "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
Welcome to cuML’s documentation
==================================================================================================
cuML is a suite of fast, GPU-accelerated machine learning algorithms designed for data science and analytical tasks. Our API mirrors Sklearn’s, and we provide practitioners with the easy fit-predict-transform paradigm without ever having to program on a GPU.
As data gets larger, algorithms running on a CPU becomes slow and cumbersome. RAPIDS provides users a streamlined approach where data is initially loaded in the GPU, and compute tasks can be performed on it directly.
cuML is fully open source, and the RAPIDS team welcomes new and seasoned contributors, users and hobbyists! Thank you for your wonderful support!
An installation requirement for cuML is that your system must be Linux-like. Support for Windows is possible in the near future.
Contents:
* [Introduction](cuml_intro/)
* [1\. Where possible, match the scikit-learn API](cuml_intro/#where-possible-match-the-scikit-learn-api)
* [2\. Accept flexible input types, return predictable output types](cuml_intro/#accept-flexible-input-types-return-predictable-output-types)
* [3\. Be fast!](cuml_intro/#be-fast)
* [Learn more](cuml_intro/#learn-more)
* [API Reference](api/)
* [Module Configuration](api/#module-configuration)
* [Preprocessing, Metrics, and Utilities](api/#preprocessing-metrics-and-utilities)
* [Regression and Classification](api/#regression-and-classification)
* [Clustering](api/#clustering)
* [Dimensionality Reduction and Manifold Learning](api/#dimensionality-reduction-and-manifold-learning)
* [Neighbors](api/#neighbors)
* [Time Series](api/#time-series)
* [Model Explainability](api/#model-explainability)
* [Multi-Node, Multi-GPU Algorithms](api/#multi-node-multi-gpu-algorithms)
* [Experimental](api/#experimental)
* [User Guide](user_guide/)
* [Training and Evaluating Machine Learning Models](estimator_intro/)
* [Pickling Models for Persistence](pickling_cuml_models/)
* [cuML on GPU and CPU](execution_device_interoperability/)
* [Blogs and other references](cuml_blogs/)
* [Integrations, applications, and general concepts](cuml_blogs/#integrations-applications-and-general-concepts)
* [Tree and forest models](cuml_blogs/#tree-and-forest-models)
* [Other popular models](cuml_blogs/#other-popular-models)
* [Academic Papers](cuml_blogs/#academic-papers)
Indices and tables[#](#indices-and-tables "Permalink to this heading")
=======================================================================
* [Index](genindex/)
* [Module Index](py-modindex/)
* [Search Page](search/)
On this page
[Show Source](_sources/index.rst.txt)
---
# Welcome to Dask cuDF’s documentation! — dask-cudf 25.04.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
dask-cudf
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
nightly (25.04)
[nightly (25.04)](/api/dask-cudf/nightly)
[stable (25.02)](/api/dask-cudf/stable)
[legacy (24.12)](/api/dask-cudf/legacy)
* [GitHub](https://github.com/rapidsai/cudf "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
Welcome to Dask cuDF’s documentation
=======================================================================================================
**Dask cuDF** (pronounced “DASK KOO-dee-eff”) is an extension library for the [Dask](https://dask.org)
parallel computing framework. When installed, Dask cuDF is automatically registered as the `"cudf"` dataframe backend for [Dask DataFrame](https://docs.dask.org/en/stable/dataframe.html)
.
Note
Neither Dask cuDF nor Dask DataFrame provide support for multi-GPU or multi-node execution on their own. You must also deploy a [dask.distributed](https://distributed.dask.org/en/stable/)
cluster to leverage multiple GPUs. We strongly recommend using [Dask-CUDA](https://docs.rapids.ai/api/dask-cuda/stable/ "(in dask-cuda v25.02)")
to simplify the setup of the cluster, taking advantage of all features of the GPU and networking hardware.
If you are familiar with Dask and [pandas](pandas.pydata.org)
or [cuDF](https://docs.rapids.ai/api/cudf/stable/)
, then Dask cuDF should feel familiar to you. If not, we recommend starting with [10 minutes to Dask](https://docs.dask.org/en/stable/10-minutes-to-dask.html)
followed by [10 minutes to cuDF and Dask cuDF](https://docs.rapids.ai/api/cudf/stable/user_guide/10min.html)
.
After reviewing the sections below, please see the [Best Practices](best_practices/#best-practices)
page for further guidance on using Dask cuDF effectively.
Using Dask cuDF[#](#using-dask-cudf "Link to this heading")
------------------------------------------------------------
### The Dask DataFrame API (Recommended)[#](#the-dask-dataframe-api-recommended "Link to this heading")
Simply use the [Dask configuration](https://docs.dask.org/en/stable/how-to/selecting-the-collection-backend.html)
system to set the `"dataframe.backend"` option to `"cudf"`. From Python, this can be achieved like so:
import dask
dask.config.set({"dataframe.backend": "cudf"})
Alternatively, you can set `DASK_DATAFRAME__BACKEND=cudf` in the environment before running your code.
Once this is done, the public Dask DataFrame API will leverage `cudf` automatically when a new DataFrame collection is created from an on-disk format using any of the following `dask.dataframe` functions:
* [`dask.dataframe.read_parquet()`](https://docs.dask.org/en/stable/generated/dask.dataframe.read_parquet.html#dask.dataframe.read_parquet "(in Dask)")
* [`dask.dataframe.read_json()`](https://docs.dask.org/en/stable/generated/dask.dataframe.read_json.html#dask.dataframe.read_json "(in Dask)")
* [`dask.dataframe.read_csv()`](https://docs.dask.org/en/stable/generated/dask.dataframe.read_csv.html#dask.dataframe.read_csv "(in Dask)")
* [`dask.dataframe.read_orc()`](https://docs.dask.org/en/stable/generated/dask.dataframe.read_orc.html#dask.dataframe.read_orc "(in Dask)")
* [`dask.dataframe.read_hdf()`](https://docs.dask.org/en/stable/generated/dask.dataframe.read_hdf.html#dask.dataframe.read_hdf "(in Dask)")
* [`dask.dataframe.DataFrame.from_dict()`](https://docs.dask.org/en/stable/generated/dask.dataframe.DataFrame.from_dict.html#dask.dataframe.DataFrame.from_dict "(in Dask)")
For example:
import dask.dataframe as dd
\# By default, we obtain a pandas-backed dataframe
df \= dd.read\_parquet("data.parquet", ...)
import dask
dask.config.set({"dataframe.backend": "cudf"})
\# This now gives us a cuDF-backed dataframe
df \= dd.read\_parquet("data.parquet", ...)
When other functions are used to create a new collection (e.g. [`dask.dataframe.from_map()`](https://docs.dask.org/en/stable/generated/dask.dataframe.from_map.html#dask.dataframe.from_map "(in Dask)")
, [`dask.dataframe.from_pandas()`](https://docs.dask.org/en/stable/generated/dask.dataframe.from_pandas.html#dask.dataframe.from_pandas "(in Dask)")
, [`dask.dataframe.from_delayed()`](https://docs.dask.org/en/stable/generated/dask.dataframe.from_delayed.html#dask.dataframe.from_delayed "(in Dask)")
, and [`dask.dataframe.from_array()`](https://docs.dask.org/en/stable/generated/dask.dataframe.from_array.html#dask.dataframe.from_array "(in Dask)")
), the backend of the new collection will depend on the inputs to those functions. For example:
import pandas as pd
import cudf
\# This gives us a pandas-backed dataframe
dd.from\_pandas(pd.DataFrame({"a": range(10)}))
\# This gives us a cuDF-backed dataframe
dd.from\_pandas(cudf.DataFrame({"a": range(10)}))
An existing collection can always be moved to a specific backend using the [`dask.dataframe.DataFrame.to_backend()`](https://docs.dask.org/en/stable/generated/dask.dataframe.DataFrame.to_backend.html#dask.dataframe.DataFrame.to_backend "(in Dask)")
API:
\# This ensures that we have a cuDF-backed dataframe
df \= df.to\_backend("cudf")
\# This ensures that we have a pandas-backed dataframe
df \= df.to\_backend("pandas")
### The explicit Dask cuDF API[#](#the-explicit-dask-cudf-api "Link to this heading")
In addition to providing the `"cudf"` backend for Dask DataFrame, Dask cuDF also provides an explicit `dask_cudf` API:
import dask\_cudf
\# This always gives us a cuDF-backed dataframe
df \= dask\_cudf.read\_parquet("data.parquet", ...)
This API is used implicitly by the Dask DataFrame API when the `"cudf"` backend is enabled. Therefore, using it directly will not provide any performance benefit over the CPU/GPU-portable `dask.dataframe` API. Also, using some parts of the explicit API are incompatible with automatic query planning (see the next section).
### Query Planning[#](#query-planning "Link to this heading")
Dask cuDF now provides automatic query planning by default (RAPIDS 24.06+). As long as the `"dataframe.query-planning"` configuration is set to `True` (the default) when `dask.dataframe` is first imported, [Dask Expressions](https://github.com/dask/dask-expr)
will be used under the hood.
For example, the following code will automatically benefit from predicate pushdown when the result is computed:
df \= dd.read\_parquet("/my/parquet/dataset/")
result \= df.sort\_values('B')\['A'\]
Unoptimized expression graph (`df.pprint()`):
Projection: columns\='A'
SortValues: by\=\['B'\] shuffle\_method\='tasks' options\={}
ReadParquetFSSpec: path\='/my/parquet/dataset/' ...
Simplified expression graph (`df.simplify().pprint()`):
Projection: columns\='A'
SortValues: by\=\['B'\] shuffle\_method\='tasks' options\={}
ReadParquetFSSpec: path\='/my/parquet/dataset/' columns\=\['A', 'B'\] ...
Note
Dask will automatically simplify the expression graph (within [`dask.optimize()`](https://docs.dask.org/en/stable/api.html#dask.optimize "(in Dask)")
) when the result is converted to a task graph (via [`dask.compute()`](https://docs.dask.org/en/stable/api.html#dask.compute "(in Dask)")
or [`dask.persist()`](https://docs.dask.org/en/stable/api.html#dask.persist "(in Dask)")
). You do not need to optimize or simplify the graph yourself.
### Using Multiple GPUs and Multiple Nodes[#](#using-multiple-gpus-and-multiple-nodes "Link to this heading")
Whenever possible, Dask cuDF (i.e. Dask DataFrame) will automatically try to partition your data into small-enough tasks to fit comfortably in the memory of a single GPU. This means the necessary compute tasks needed to compute a query can often be streamed to a single GPU process for out-of-core computing. This also means that the compute tasks can be executed in parallel over a multi-GPU cluster.
In order to execute your Dask workflow on multiple GPUs, you will typically need to use [Dask-CUDA](https://docs.rapids.ai/api/dask-cuda/stable/ "(in dask-cuda v25.02)")
to deploy distributed Dask cluster, and [Distributed](https://distributed.dask.org/en/stable/client.html)
to define a client object. For example:
from dask\_cuda import LocalCUDACluster
from distributed import Client
if \_\_name\_\_ \== "\_\_main\_\_":
client \= Client(
LocalCUDACluster(
CUDA\_VISIBLE\_DEVICES\="0,1", \# Use two workers (on devices 0 and 1)
rmm\_pool\_size\=0.9, \# Use 90% of GPU memory as a pool for faster allocations
enable\_cudf\_spill\=True, \# Improve device memory stability
local\_directory\="/fast/scratch/", \# Use fast local storage for spilling
)
)
df \= dd.read\_parquet("/my/parquet/dataset/")
agg \= df.groupby('B').sum()
agg.compute() \# This will use the cluster defined above
Note
This example uses [`dask.compute()`](https://docs.dask.org/en/stable/api.html#dask.compute "(in Dask)")
to materialize a concrete `cudf.DataFrame` object in local memory. Never call [`dask.compute()`](https://docs.dask.org/en/stable/api.html#dask.compute "(in Dask)")
on a large collection that cannot fit comfortably in the memory of a single GPU! See Dask’s [documentation on managing computation](https://distributed.dask.org/en/stable/manage-computation.html)
for more details.
Please see the [Dask-CUDA](https://docs.rapids.ai/api/dask-cuda/stable/ "(in dask-cuda v25.02)")
documentation for more information about deploying GPU-aware clusters (including [best practices](https://docs.rapids.ai/api/dask-cuda/stable/examples/best-practices/)
).
API Reference[#](#api-reference "Link to this heading")
--------------------------------------------------------
Generally speaking, Dask cuDF tries to offer exactly the same API as Dask DataFrame. There are, however, some minor differences mostly because cuDF does not [perfectly mirror](https://docs.rapids.ai/api/cudf/stable/user_guide/PandasCompat/ "(in cudf v25.02)")
the pandas API, or because cuDF provides additional configuration flags (these mostly occur in data reading and writing interfaces).
As a result, straightforward workflows can be migrated without too much trouble, but more complex ones that utilise more features may need a bit of tweaking. The API documentation describes details of the differences and all functionality that Dask cuDF supports.
* [Dask cuDF Best Practices](best_practices/)
* [Deployment and Configuration](best_practices/#deployment-and-configuration)
* [Reading Data](best_practices/#reading-data)
* [Sorting, Joining, and Grouping](best_practices/#sorting-joining-and-grouping)
* [User-defined functions](best_practices/#user-defined-functions)
* [API reference](api/)
* [Creating and storing DataFrames](api/#creating-and-storing-dataframes)
Indices and tables[#](#indices-and-tables "Link to this heading")
==================================================================
* [Index](genindex/)
* [Module Index](py-modindex/)
* [Search Page](search/)
On this page
### This Page
* [Show Source](_sources/index.rst.txt)
---
# Welcome to Dask cuDF’s documentation! — dask-cudf 24.12.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
dask-cudf
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
legacy (24.12)
[nightly (25.04)](/api/dask-cudf/nightly)
[stable (25.02)](/api/dask-cudf/stable)
[legacy (24.12)](/api/dask-cudf/legacy)
* [GitHub](https://github.com/rapidsai/cudf "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
Welcome to Dask cuDF’s documentation
============================================================================================================
**Dask cuDF** (pronounced “DASK KOO-dee-eff”) is an extension library for the [Dask](https://dask.org)
parallel computing framework. When installed, Dask cuDF is automatically registered as the `"cudf"` dataframe backend for [Dask DataFrame](https://docs.dask.org/en/stable/dataframe.html)
.
Note
Neither Dask cuDF nor Dask DataFrame provide support for multi-GPU or multi-node execution on their own. You must also deploy a [dask.distributed](https://distributed.dask.org/en/stable/)
cluster to leverage multiple GPUs. We strongly recommend using [Dask-CUDA](https://docs.rapids.ai/api/dask-cuda/stable/ "(in dask-cuda v24.10)")
to simplify the setup of the cluster, taking advantage of all features of the GPU and networking hardware.
If you are familiar with Dask and [pandas](pandas.pydata.org)
or [cuDF](https://docs.rapids.ai/api/cudf/stable/)
, then Dask cuDF should feel familiar to you. If not, we recommend starting with [10 minutes to Dask](https://docs.dask.org/en/stable/10-minutes-to-dask.html)
followed by [10 minutes to cuDF and Dask cuDF](https://docs.rapids.ai/api/cudf/stable/user_guide/10min.html)
.
After reviewing the sections below, please see the [Best Practices](best_practices/#best-practices)
page for further guidance on using Dask cuDF effectively.
Using Dask cuDF[#](#using-dask-cudf "Permalink to this heading")
-----------------------------------------------------------------
### The Dask DataFrame API (Recommended)[#](#the-dask-dataframe-api-recommended "Permalink to this heading")
Simply use the [Dask configuration](https://docs.dask.org/en/stable/how-to/selecting-the-collection-backend.html)
system to set the `"dataframe.backend"` option to `"cudf"`. From Python, this can be achieved like so:
import dask
dask.config.set({"dataframe.backend": "cudf"})
Alternatively, you can set `DASK_DATAFRAME__BACKEND=cudf` in the environment before running your code.
Once this is done, the public Dask DataFrame API will leverage `cudf` automatically when a new DataFrame collection is created from an on-disk format using any of the following `dask.dataframe` functions:
* `read_parquet()`
* `read_json()`
* `read_csv()`
* `read_orc()`
* `read_hdf()`
* `from_dict()`
For example:
import dask.dataframe as dd
\# By default, we obtain a pandas-backed dataframe
df \= dd.read\_parquet("data.parquet", ...)
import dask
dask.config.set({"dataframe.backend": "cudf"})
\# This now gives us a cuDF-backed dataframe
df \= dd.read\_parquet("data.parquet", ...)
When other functions are used to create a new collection (e.g. `from_map()`, `from_pandas()`, `from_delayed()`, and `from_array()`), the backend of the new collection will depend on the inputs to those functions. For example:
import pandas as pd
import cudf
\# This gives us a pandas-backed dataframe
dd.from\_pandas(pd.DataFrame({"a": range(10)}))
\# This gives us a cuDF-backed dataframe
dd.from\_pandas(cudf.DataFrame({"a": range(10)}))
An existing collection can always be moved to a specific backend using the `dask.dataframe.DataFrame.to_backend()` API:
\# This ensures that we have a cuDF-backed dataframe
df \= df.to\_backend("cudf")
\# This ensures that we have a pandas-backed dataframe
df \= df.to\_backend("pandas")
### The explicit Dask cuDF API[#](#the-explicit-dask-cudf-api "Permalink to this heading")
In addition to providing the `"cudf"` backend for Dask DataFrame, Dask cuDF also provides an explicit `dask_cudf` API:
import dask\_cudf
\# This always gives us a cuDF-backed dataframe
df \= dask\_cudf.read\_parquet("data.parquet", ...)
This API is used implicitly by the Dask DataFrame API when the `"cudf"` backend is enabled. Therefore, using it directly will not provide any performance benefit over the CPU/GPU-portable `dask.dataframe` API. Also, using some parts of the explicit API are incompatible with automatic query planning (see the next section).
### Query Planning[#](#query-planning "Permalink to this heading")
Dask cuDF now provides automatic query planning by default (RAPIDS 24.06+). As long as the `"dataframe.query-planning"` configuration is set to `True` (the default) when `dask.dataframe` is first imported, [Dask Expressions](https://github.com/dask/dask-expr)
will be used under the hood.
For example, the following code will automatically benefit from predicate pushdown when the result is computed:
df \= dd.read\_parquet("/my/parquet/dataset/")
result \= df.sort\_values('B')\['A'\]
Unoptimized expression graph (`df.pprint()`):
Projection: columns\='A'
SortValues: by\=\['B'\] shuffle\_method\='tasks' options\={}
ReadParquetFSSpec: path\='/my/parquet/dataset/' ...
Simplified expression graph (`df.simplify().pprint()`):
Projection: columns\='A'
SortValues: by\=\['B'\] shuffle\_method\='tasks' options\={}
ReadParquetFSSpec: path\='/my/parquet/dataset/' columns\=\['A', 'B'\] ...
Note
Dask will automatically simplify the expression graph (within `optimize()`) when the result is converted to a task graph (via `compute()` or `persist()`). You do not need to call `simplify()` yourself.
### Using Multiple GPUs and Multiple Nodes[#](#using-multiple-gpus-and-multiple-nodes "Permalink to this heading")
Whenever possible, Dask cuDF (i.e. Dask DataFrame) will automatically try to partition your data into small-enough tasks to fit comfortably in the memory of a single GPU. This means the necessary compute tasks needed to compute a query can often be streamed to a single GPU process for out-of-core computing. This also means that the compute tasks can be executed in parallel over a multi-GPU cluster.
In order to execute your Dask workflow on multiple GPUs, you will typically need to use [Dask-CUDA](https://docs.rapids.ai/api/dask-cuda/stable/ "(in dask-cuda v24.10)")
to deploy distributed Dask cluster, and [Distributed](https://distributed.dask.org/en/stable/client.html)
to define a client object. For example:
from dask\_cuda import LocalCUDACluster
from distributed import Client
if \_\_name\_\_ \== "\_\_main\_\_":
client \= Client(
LocalCUDACluster(
CUDA\_VISIBLE\_DEVICES\="0,1", \# Use two workers (on devices 0 and 1)
rmm\_pool\_size\=0.9, \# Use 90% of GPU memory as a pool for faster allocations
enable\_cudf\_spill\=True, \# Improve device memory stability
local\_directory\="/fast/scratch/", \# Use fast local storage for spilling
)
)
df \= dd.read\_parquet("/my/parquet/dataset/")
agg \= df.groupby('B').sum()
agg.compute() \# This will use the cluster defined above
Note
This example uses `compute()` to materialize a concrete `cudf.DataFrame` object in local memory. Never call `compute()` on a large collection that cannot fit comfortably in the memory of a single GPU! See Dask’s [documentation on managing computation](https://distributed.dask.org/en/stable/manage-computation.html)
for more details.
Please see the [Dask-CUDA](https://docs.rapids.ai/api/dask-cuda/stable/ "(in dask-cuda v24.10)")
documentation for more information about deploying GPU-aware clusters (including [best practices](https://docs.rapids.ai/api/dask-cuda/stable/examples/best-practices/)
).
API Reference[#](#api-reference "Permalink to this heading")
-------------------------------------------------------------
Generally speaking, Dask cuDF tries to offer exactly the same API as Dask DataFrame. There are, however, some minor differences mostly because cuDF does not [perfectly mirror](https://docs.rapids.ai/api/cudf/stable/user_guide/PandasCompat/ "(in cudf v24.10)")
the pandas API, or because cuDF provides additional configuration flags (these mostly occur in data reading and writing interfaces).
As a result, straightforward workflows can be migrated without too much trouble, but more complex ones that utilise more features may need a bit of tweaking. The API documentation describes details of the differences and all functionality that Dask cuDF supports.
* [API reference](api/)
* [Creating and storing DataFrames](api/#creating-and-storing-dataframes)
* [Grouping](api/#grouping)
* [DataFrames and Series](api/#dataframes-and-series)
Indices and tables[#](#indices-and-tables "Permalink to this heading")
=======================================================================
* [Index](genindex/)
* [Module Index](py-modindex/)
* [Search Page](search/)
On this page
[Show Source](_sources/index.rst.txt)
---
# Index — cugraph-docs 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cugraph
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cugraph/nightly)
[stable (25.02)](/api/cugraph/stable)
[legacy (24.12)](/api/cugraph/legacy)
* [GitHub](https://github.com/rapidsai/cugraph "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
Index
=====
[**\_**](#_)
| [**A**](#A)
| [**B**](#B)
| [**C**](#C)
| [**D**](#D)
| [**E**](#E)
| [**F**](#F)
| [**G**](#G)
| [**H**](#H)
| [**I**](#I)
| [**J**](#J)
| [**K**](#K)
| [**L**](#L)
| [**M**](#M)
| [**N**](#N)
| [**O**](#O)
| [**P**](#P)
| [**R**](#R)
| [**S**](#S)
| [**T**](#T)
| [**U**](#U)
| [**V**](#V)
| [**W**](#W)
\_
--
* [\_\_init\_\_() (cugraph.experimental.PropertyGraph method)](../api_docs/api/cugraph/cugraph.experimental.PropertyGraph/#cugraph.experimental.PropertyGraph.__init__)
* [(cugraph.experimental.PropertySelection method)](../api_docs/api/cugraph/cugraph.experimental.PropertySelection/#cugraph.experimental.PropertySelection.__init__)
* [(cugraph.Graph method)](../api_docs/api/cugraph/cugraph.Graph/#cugraph.Graph.__init__)
* [(cugraph.MultiGraph method)](../api_docs/api/cugraph/cugraph.MultiGraph/#cugraph.MultiGraph.__init__)
* [(cugraph.structure.NumberMap method)](../api_docs/api/cugraph/cugraph.structure.NumberMap/#cugraph.structure.NumberMap.__init__)
* [(cugraph\_dgl.cugraph\_storage.CuGraphStorage method)](../api_docs/api/cugraph-dgl/cugraph_dgl.cugraph_storage.CuGraphStorage/#cugraph_dgl.cugraph_storage.CuGraphStorage.__init__)
* [(cugraph\_pyg.data.dask\_graph\_store.DaskGraphStore method)](../api_docs/api/cugraph-pyg/cugraph_pyg.data.dask_graph_store.DaskGraphStore/#cugraph_pyg.data.dask_graph_store.DaskGraphStore.__init__)
* [(cugraph\_pyg.data.feature\_store.TensorDictFeatureStore method)](../api_docs/api/cugraph-pyg/cugraph_pyg.data.feature_store.TensorDictFeatureStore/#cugraph_pyg.data.feature_store.TensorDictFeatureStore.__init__)
* [(cugraph\_pyg.data.feature\_store.WholeFeatureStore method)](../api_docs/api/cugraph-pyg/cugraph_pyg.data.feature_store.WholeFeatureStore/#cugraph_pyg.data.feature_store.WholeFeatureStore.__init__)
* [(cugraph\_pyg.data.graph\_store.GraphStore method)](../api_docs/api/cugraph-pyg/cugraph_pyg.data.graph_store.GraphStore/#cugraph_pyg.data.graph_store.GraphStore.__init__)
* [(cugraph\_pyg.loader.dask\_node\_loader.BulkSampleLoader method)](../api_docs/api/cugraph-pyg/cugraph_pyg.loader.dask_node_loader.BulkSampleLoader/#cugraph_pyg.loader.dask_node_loader.BulkSampleLoader.__init__)
* [(cugraph\_pyg.loader.dask\_node\_loader.DaskNeighborLoader method)](../api_docs/api/cugraph-pyg/cugraph_pyg.loader.dask_node_loader.DaskNeighborLoader/#cugraph_pyg.loader.dask_node_loader.DaskNeighborLoader.__init__)
* [(cugraph\_pyg.loader.neighbor\_loader.NeighborLoader method)](../api_docs/api/cugraph-pyg/cugraph_pyg.loader.neighbor_loader.NeighborLoader/#cugraph_pyg.loader.neighbor_loader.NeighborLoader.__init__)
* [(cugraph\_pyg.loader.node\_loader.NodeLoader method)](../api_docs/api/cugraph-pyg/cugraph_pyg.loader.node_loader.NodeLoader/#cugraph_pyg.loader.node_loader.NodeLoader.__init__)
* [(cugraph\_pyg.sampler.sampler.BaseSampler method)](../api_docs/api/cugraph-pyg/cugraph_pyg.sampler.sampler.BaseSampler/#cugraph_pyg.sampler.sampler.BaseSampler.__init__)
* [(cugraph\_pyg.sampler.sampler.HomogeneousSampleReader method)](../api_docs/api/cugraph-pyg/cugraph_pyg.sampler.sampler.HomogeneousSampleReader/#cugraph_pyg.sampler.sampler.HomogeneousSampleReader.__init__)
* [(cugraph\_pyg.sampler.sampler.SampleIterator method)](../api_docs/api/cugraph-pyg/cugraph_pyg.sampler.sampler.SampleIterator/#cugraph_pyg.sampler.sampler.SampleIterator.__init__)
* [(cugraph\_pyg.sampler.sampler.SampleReader method)](../api_docs/api/cugraph-pyg/cugraph_pyg.sampler.sampler.SampleReader/#cugraph_pyg.sampler.sampler.SampleReader.__init__)
* [(pylibwholegraph.torch.comm.WholeMemoryCommunicator method)](../api_docs/api/wg/pylibwholegraph.torch.comm.WholeMemoryCommunicator/#pylibwholegraph.torch.comm.WholeMemoryCommunicator.__init__)
* [(pylibwholegraph.torch.embedding.WholeMemoryCachePolicy method)](../api_docs/api/wg/pylibwholegraph.torch.embedding.WholeMemoryCachePolicy/#pylibwholegraph.torch.embedding.WholeMemoryCachePolicy.__init__)
* [(pylibwholegraph.torch.embedding.WholeMemoryEmbedding method)](../api_docs/api/wg/pylibwholegraph.torch.embedding.WholeMemoryEmbedding/#pylibwholegraph.torch.embedding.WholeMemoryEmbedding.__init__)
* [(pylibwholegraph.torch.embedding.WholeMemoryEmbeddingModule method)](../api_docs/api/wg/pylibwholegraph.torch.embedding.WholeMemoryEmbeddingModule/#pylibwholegraph.torch.embedding.WholeMemoryEmbeddingModule.__init__)
* [(pylibwholegraph.torch.embedding.WholeMemoryOptimizer method)](../api_docs/api/wg/pylibwholegraph.torch.embedding.WholeMemoryOptimizer/#pylibwholegraph.torch.embedding.WholeMemoryOptimizer.__init__)
* [(pylibwholegraph.torch.graph\_structure.GraphStructure method)](../api_docs/api/wg/pylibwholegraph.torch.graph_structure.GraphStructure/#pylibwholegraph.torch.graph_structure.GraphStructure.__init__)
* [(pylibwholegraph.torch.tensor.WholeMemoryTensor method)](../api_docs/api/wg/pylibwholegraph.torch.tensor.WholeMemoryTensor/#pylibwholegraph.torch.tensor.WholeMemoryTensor.__init__)
A
-
| | |
| --- | --- |
| * [add\_edge\_data() (cugraph.experimental.PropertyGraph method)](../api_docs/api/cugraph/cugraph.experimental.PropertyGraph.add_edge_data/#cugraph.experimental.PropertyGraph.add_edge_data)
* [add\_internal\_vertex\_id() (cugraph.Graph method)](../api_docs/api/cugraph/cugraph.Graph.add_internal_vertex_id/#cugraph.Graph.add_internal_vertex_id)
* [(cugraph.structure.NumberMap method)](../api_docs/api/cugraph/cugraph.structure.NumberMap.add_internal_vertex_id/#cugraph.structure.NumberMap.add_internal_vertex_id)
* [add\_nodes\_from() (cugraph.Graph method)](../api_docs/api/cugraph/cugraph.Graph.add_nodes_from/#cugraph.Graph.add_nodes_from)
* [add\_vertex\_data() (cugraph.experimental.PropertyGraph method)](../api_docs/api/cugraph/cugraph.experimental.PropertyGraph.add_vertex_data/#cugraph.experimental.PropertyGraph.add_vertex_data)
* [analyzeClustering\_edge\_cut (C++ function)](../api_docs/cugraph_cpp/algorithms/community_cpp/#_CPPv4I000E26analyzeClustering_edge_cutvRKN6legacy12GraphCSRViewI2VT2ET2WTEEiPK2VTP2WT) | * [analyzeClustering\_edge\_cut() (in module cugraph)](../api_docs/api/cugraph/cugraph.analyzeClustering_edge_cut/#cugraph.analyzeClustering_edge_cut)
* [analyzeClustering\_modularity (C++ function)](../api_docs/cugraph_cpp/algorithms/community_cpp/#_CPPv4I000E28analyzeClustering_modularityvRKN6legacy12GraphCSRViewI2VT2ET2WTEEiPK2VTP2WT)
* [analyzeClustering\_modularity() (in module cugraph)](../api_docs/api/cugraph/cugraph.analyzeClustering_modularity/#cugraph.analyzeClustering_modularity)
* [analyzeClustering\_ratio\_cut (C++ function)](../api_docs/cugraph_cpp/algorithms/community_cpp/#_CPPv4I000E27analyzeClustering_ratio_cutvRKN6legacy12GraphCSRViewI2VT2ET2WTEEiPK2VTP2WT)
* [analyzeClustering\_ratio\_cut() (in module cugraph)](../api_docs/api/cugraph/cugraph.analyzeClustering_ratio_cut/#cugraph.analyzeClustering_ratio_cut)
* [annotate\_dataframe() (cugraph.experimental.PropertyGraph method)](../api_docs/api/cugraph/cugraph.experimental.PropertyGraph.annotate_dataframe/#cugraph.experimental.PropertyGraph.annotate_dataframe)
* [approximate\_weighted\_matching (C++ function)](../api_docs/cugraph_cpp/algorithms/utility_cpp/#_CPPv4I000_bE29approximate_weighted_matchingNSt5tupleIN3rmm14device_uvectorI8vertex_tEE8weight_tEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuE20edge_property_view_tI6edge_tPK8weight_tE) |
B
-
| | |
| --- | --- |
| * [BaseSampler (class in cugraph\_pyg.sampler.sampler)](../api_docs/api/cugraph-pyg/cugraph_pyg.sampler.sampler.BaseSampler/#cugraph_pyg.sampler.sampler.BaseSampler)
* [batched\_ego\_graphs() (in module cugraph)](../api_docs/api/cugraph/cugraph.batched_ego_graphs/#cugraph.batched_ego_graphs)
* [betweenness\_centrality (C++ function)](../api_docs/cugraph_cpp/algorithms/centrality_cpp/#_CPPv4I0000E22betweenness_centralityvRKN4raft8handle_tERKN6legacy12GraphCSRViewI8vertex_t6edge_t8weight_tEEP8result_tbbPK8weight_t8vertex_tPK8vertex_t)
, [\[1\]](../api_docs/cugraph_cpp/algorithms/centrality_cpp/#_CPPv4I000_bE22betweenness_centralityN3rmm14device_uvectorI8weight_tEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEENSt8optionalIN4raft11device_spanIK8vertex_tEEEEKbKbKb)
* [betweenness\_centrality() (in module cugraph.centrality)](../api_docs/api/cugraph/cugraph.centrality.betweenness_centrality/#cugraph.centrality.betweenness_centrality)
* [bfs (C++ function)](../api_docs/cugraph_cpp/algorithms/traversal_cpp/#_CPPv4I00_bE3bfsvRKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuEP8vertex_tP8vertex_tPK8vertex_t6size_tb8vertex_tb)
* [bfs() (in module cugraph)](../api_docs/api/cugraph/cugraph.bfs/#cugraph.bfs)
* [(in module cugraph.dask.traversal.bfs)](../api_docs/api/cugraph/cugraph.dask.traversal.bfs.bfs/#cugraph.dask.traversal.bfs.bfs)
* [(in module pylibcugraph)](../api_docs/api/plc/pylibcugraph.bfs/#pylibcugraph.bfs) | * [bfs\_edges() (in module cugraph)](../api_docs/api/cugraph/cugraph.bfs_edges/#cugraph.bfs_edges)
* [biased\_neighbor\_sample (C++ function)](../api_docs/cugraph_cpp/graph_sampling_cpp/#_CPPv4I000000_b_bE22biased_neighbor_sampleNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI6edge_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEENSt8optionalIN3rmm14device_uvectorI7int32_tEEEENSt8optionalIN3rmm14device_uvectorI7label_tEEEENSt8optionalIN3rmm14device_uvectorI6size_tEEEEEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEENSt8optionalI20edge_property_view_tI6edge_tPK6edge_tEEENSt8optionalI20edge_property_view_tI6edge_tPK11edge_type_tEEE20edge_property_view_tI6edge_tPK6bias_tEN4raft11device_spanIK8vertex_tEENSt8optionalIN4raft11device_spanIK7label_tEEEENSt8optionalINSt5tupleIN4raft11device_spanIK7label_tEEN4raft11device_spanIK7int32_tEEEEEEN4raft9host_spanIK7int32_tEERN4raft6random8RngStateEbb24prior_sources_behavior_tbb)
* [biased\_random\_walks (C++ function)](../api_docs/cugraph_cpp/algorithms/sampling_cpp/#_CPPv4I000_bE19biased_random_walksNSt5tupleIN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEEEERKN4raft8handle_tERN4raft6random8RngStateERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuE20edge_property_view_tI6edge_tPK8weight_tEN4raft11device_spanIK8vertex_tEE6size_t)
* [build\_edge\_id\_and\_type\_to\_src\_dst\_lookup\_map (C++ function)](../api_docs/cugraph_cpp/graph_sampling_cpp/#_CPPv4I000_bE44build_edge_id_and_type_to_src_dst_lookup_map18lookup_container_tI6edge_t11edge_type_t8vertex_tERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuE20edge_property_view_tI6edge_tPK6edge_tE20edge_property_view_tI6edge_tPK11edge_type_tE)
* [BulkSampleLoader (class in cugraph\_pyg.loader.dask\_node\_loader)](../api_docs/api/cugraph-pyg/cugraph_pyg.loader.dask_node_loader.BulkSampleLoader/#cugraph_pyg.loader.dask_node_loader.BulkSampleLoader) |
C
-
| | |
| --- | --- |
| * [clear() (cugraph.Graph method)](../api_docs/api/cugraph/cugraph.Graph.clear/#cugraph.Graph.clear)
* [coarsen\_graph (C++ function)](../api_docs/cugraph_cpp/graph_functions_cpp/#_CPPv4I000_b_bE13coarsen_graphNSt5tupleI7graph_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE8weight_tEEENSt8optionalIN3rmm14device_uvectorI8vertex_tEEEEEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEEPK8vertex_tbb)
* [combine\_edgelists (C++ function)](../api_docs/cugraph_cpp/graph_generators_cpp/#_CPPv4I00E17combine_edgelistsNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEEEERKN4raft8handle_tERRNSt6vectorIN3rmm14device_uvectorI8vertex_tEEEERRNSt6vectorIN3rmm14device_uvectorI8vertex_tEEEERRNSt8optionalINSt6vectorIN3rmm14device_uvectorI8weight_tEEEEEEb)
* [compute\_in\_weight\_sums (C++ function)](../api_docs/cugraph_cpp/graph_functions_cpp/#_CPPv4I000_b_bE22compute_in_weight_sumsN3rmm14device_uvectorI8weight_tEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE20edge_property_view_tI6edge_tPK8weight_tE)
* [compute\_max\_in\_weight\_sum (C++ function)](../api_docs/cugraph_cpp/graph_functions_cpp/#_CPPv4I000_b_bE25compute_max_in_weight_sum8weight_tRKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE20edge_property_view_tI6edge_tPK8weight_tE)
* [compute\_max\_out\_weight\_sum (C++ function)](../api_docs/cugraph_cpp/graph_functions_cpp/#_CPPv4I000_b_bE26compute_max_out_weight_sum8weight_tRKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE20edge_property_view_tI6edge_tPK8weight_tE)
* [compute\_maximum\_vertex\_id (C++ function)](../api_docs/cugraph_cpp/graph_utility_wrappers_cpp/#_CPPv4I0E25compute_maximum_vertex_id8vertex_tRKN3rmm16cuda_stream_viewEPK8vertex_tPK8vertex_t6size_t)
, [\[1\]](../api_docs/cugraph_cpp/graph_utility_wrappers_cpp/#_CPPv4I0E25compute_maximum_vertex_id8vertex_tRKN3rmm16cuda_stream_viewERKN3rmm14device_uvectorI8vertex_tEERKN3rmm14device_uvectorI8vertex_tEE)
* [compute\_out\_weight\_sums (C++ function)](../api_docs/cugraph_cpp/graph_functions_cpp/#_CPPv4I000_b_bE23compute_out_weight_sumsN3rmm14device_uvectorI8weight_tEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE20edge_property_view_tI6edge_tPK8weight_tE)
* [compute\_total\_edge\_weight (C++ function)](../api_docs/cugraph_cpp/graph_functions_cpp/#_CPPv4I000_b_bE25compute_total_edge_weight8weight_tRKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE20edge_property_view_tI6edge_tPK8weight_tE)
* [compute\_vals() (cugraph.structure.NumberMap static method)](../api_docs/api/cugraph/cugraph.structure.NumberMap.compute_vals/#cugraph.structure.NumberMap.compute_vals)
* [compute\_vals\_types() (cugraph.structure.NumberMap static method)](../api_docs/api/cugraph/cugraph.structure.NumberMap.compute_vals_types/#cugraph.structure.NumberMap.compute_vals_types)
* [connected\_components (C++ function)](../api_docs/cugraph_cpp/algorithms/components_cpp/#_CPPv4I000E20connected_componentsvRKN6legacy12GraphCSRViewI2VT2ET2WTEE12cugraph_cc_tP2VT)
* [connected\_components() (in module cugraph)](../api_docs/api/cugraph/cugraph.connected_components/#cugraph.connected_components)
* [core\_number() (in module cugraph)](../api_docs/api/cugraph/cugraph.core_number/#cugraph.core_number)
* [cosine\_similarity\_all\_pairs\_coefficients (C++ function)](../api_docs/cugraph_cpp/algorithms/similarity_cpp/#_CPPv4I000_bE40cosine_similarity_all_pairs_coefficientsNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8weight_tEEEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEENSt8optionalIN4raft11device_spanIK8vertex_tEEEENSt8optionalI6size_tEEb)
* [cosine\_similarity\_coefficients (C++ function)](../api_docs/cugraph_cpp/algorithms/similarity_cpp/#_CPPv4I000_bE30cosine_similarity_coefficientsN3rmm14device_uvectorI8weight_tEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEENSt5tupleIN4raft11device_spanIK8vertex_tEEN4raft11device_spanIK8vertex_tEEEEb)
* [count\_values (C++ function)](../api_docs/cugraph_cpp/graph_utility_wrappers_cpp/#_CPPv4I0E12count_values6size_tRKN4raft8handle_tEN4raft11device_spanIK6data_tEE6data_t)
* [create\_builtin\_cache\_policy() (in module pylibwholegraph.torch.embedding)](../api_docs/api/wg/pylibwholegraph.torch.embedding.create_builtin_cache_policy/#pylibwholegraph.torch.embedding.create_builtin_cache_policy)
* [create\_embedding() (in module pylibwholegraph.torch.embedding)](../api_docs/api/wg/pylibwholegraph.torch.embedding.create_embedding/#pylibwholegraph.torch.embedding.create_embedding)
* [create\_embedding\_from\_filelist() (in module pylibwholegraph.torch.embedding)](../api_docs/api/wg/pylibwholegraph.torch.embedding.create_embedding_from_filelist/#pylibwholegraph.torch.embedding.create_embedding_from_filelist)
* [create\_graph\_from\_edgelist (C++ function)](../api_docs/cugraph_cpp/graph_functions_cpp/#_CPPv4I00000_b_bE26create_graph_from_edgelistNSt5tupleI7graph_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE8weight_tEEENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE6edge_tEEENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE11edge_type_tEEENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE11edge_time_tEEENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE11edge_time_tEEENSt8optionalIN3rmm14device_uvectorI8vertex_tEEEEEERKN4raft8handle_tERRNSt8optionalIN3rmm14device_uvectorI8vertex_tEEEERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEERRNSt8optionalIN3rmm14device_uvectorI8weight_tEEEERRNSt8optionalIN3rmm14device_uvectorI6edge_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_time_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_time_tEEEE18graph_properties_tbb)
, [\[1\]](../api_docs/cugraph_cpp/graph_functions_cpp/#_CPPv4I00000_b_bE26create_graph_from_edgelistNSt5tupleI7graph_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE8weight_tEEENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE6edge_tEEENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE11edge_type_tEEENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE11edge_time_tEEENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE11edge_time_tEEENSt8optionalIN3rmm14device_uvectorI8vertex_tEEEEEERKN4raft8handle_tERRNSt8optionalIN3rmm14device_uvectorI8vertex_tEEEERRNSt6vectorIN3rmm14device_uvectorI8vertex_tEEEERRNSt6vectorIN3rmm14device_uvectorI8vertex_tEEEERRNSt8optionalINSt6vectorIN3rmm14device_uvectorI8weight_tEEEEEERRNSt8optionalINSt6vectorIN3rmm14device_uvectorI6edge_tEEEEEERRNSt8optionalINSt6vectorIN3rmm14device_uvectorI11edge_type_tEEEEEERRNSt8optionalINSt6vectorIN3rmm14device_uvectorI11edge_time_tEEEEEERRNSt8optionalINSt6vectorIN3rmm14device_uvectorI11edge_time_tEEEEEE18graph_properties_tbb)
, [\[2\]](../api_docs/cugraph_cpp/graph_functions_cpp/#_CPPv4I0000_b_bE26create_graph_from_edgelistNSt5tupleI7graph_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE8weight_tEEENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE6edge_tEEENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE11edge_type_tEEENSt8optionalIN3rmm14device_uvectorI8vertex_tEEEEEERKN4raft8handle_tERRNSt8optionalIN3rmm14device_uvectorI8vertex_tEEEERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEERRNSt8optionalIN3rmm14device_uvectorI8weight_tEEEERRNSt8optionalIN3rmm14device_uvectorI6edge_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEE18graph_properties_tbb)
, [\[3\]](../api_docs/cugraph_cpp/graph_functions_cpp/#_CPPv4I0000_b_bE26create_graph_from_edgelistNSt5tupleI7graph_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE8weight_tEEENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE6edge_tEEENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE11edge_type_tEEENSt8optionalIN3rmm14device_uvectorI8vertex_tEEEEEERKN4raft8handle_tERRNSt8optionalIN3rmm14device_uvectorI8vertex_tEEEERRNSt6vectorIN3rmm14device_uvectorI8vertex_tEEEERRNSt6vectorIN3rmm14device_uvectorI8vertex_tEEEERRNSt8optionalINSt6vectorIN3rmm14device_uvectorI8weight_tEEEEEERRNSt8optionalINSt6vectorIN3rmm14device_uvectorI6edge_tEEEEEERRNSt8optionalINSt6vectorIN3rmm14device_uvectorI11edge_type_tEEEEEE18graph_properties_tbb)
* [create\_group\_communicator() (in module pylibwholegraph.torch.comm)](../api_docs/api/wg/pylibwholegraph.torch.comm.create_group_communicator/#pylibwholegraph.torch.comm.create_group_communicator)
* [create\_wholememory\_cache\_policy() (in module pylibwholegraph.torch.embedding)](../api_docs/api/wg/pylibwholegraph.torch.embedding.create_wholememory_cache_policy/#pylibwholegraph.torch.embedding.create_wholememory_cache_policy)
* [create\_wholememory\_optimizer() (in module pylibwholegraph.torch.embedding)](../api_docs/api/wg/pylibwholegraph.torch.embedding.create_wholememory_optimizer/#pylibwholegraph.torch.embedding.create_wholememory_optimizer)
* [create\_wholememory\_tensor() (in module pylibwholegraph.torch.tensor)](../api_docs/api/wg/pylibwholegraph.torch.tensor.create_wholememory_tensor/#pylibwholegraph.torch.tensor.create_wholememory_tensor)
* [create\_wholememory\_tensor\_from\_filelist() (in module pylibwholegraph.torch.tensor)](../api_docs/api/wg/pylibwholegraph.torch.tensor.create_wholememory_tensor_from_filelist/#pylibwholegraph.torch.tensor.create_wholememory_tensor_from_filelist)
* [csr\_add\_self\_loop (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv417csr_add_self_loop20wholememory_tensor_t20wholememory_tensor_t20wholememory_tensor_t20wholememory_tensor_tPv)
* [cugraph (C++ type)](../api_docs/cugraph_cpp/full_api/#_CPPv47cugraph)
* cugraph.dask.centrality.betweenness\_centrality
* [module](../api_docs/api/cugraph/cugraph.dask.centrality.betweenness_centrality/#module-cugraph.dask.centrality.betweenness_centrality)
* [cugraph::allocate\_dataframe\_buffer (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_PNSt11enable_if_tINSt13is_arithmeticI1TE5valueEEEEN7cugraph25allocate_dataframe_bufferEDa6size_tN3rmm16cuda_stream_viewE)
* [cugraph::c\_api (C++ type)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_apiE)
* [cugraph::c\_api::abstract\_functor (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api16abstract_functorE)
* [cugraph::c\_api::bfs\_functor (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api11bfs_functorE)
* [cugraph::c\_api::create\_constant\_edge\_property (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph5c_api29create_constant_edge_propertyE15edge_property_tI13GraphViewType1TERKN4raft8handle_tERK13GraphViewType1T)
* [cugraph::c\_api::cugraph\_centrality\_result\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api27cugraph_centrality_result_tE)
* [cugraph::c\_api::cugraph\_clustering\_result\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api27cugraph_clustering_result_tE)
* [cugraph::c\_api::cugraph\_coo\_list\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api18cugraph_coo_list_tE)
* [cugraph::c\_api::cugraph\_coo\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api13cugraph_coo_tE)
* [cugraph::c\_api::cugraph\_core\_result\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api21cugraph_core_result_tE)
* [cugraph::c\_api::cugraph\_degrees\_result\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api24cugraph_degrees_result_tE)
* [cugraph::c\_api::cugraph\_edge\_centrality\_result\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api32cugraph_edge_centrality_result_tE)
* [cugraph::c\_api::cugraph\_edge\_property\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api23cugraph_edge_property_tE)
* [cugraph::c\_api::cugraph\_edge\_property\_view\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api28cugraph_edge_property_view_tE)
* [cugraph::c\_api::cugraph\_edgelist\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api18cugraph_edgelist_tE)
* [cugraph::c\_api::cugraph\_error\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api15cugraph_error_tE)
* [cugraph::c\_api::cugraph\_extract\_paths\_result\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api30cugraph_extract_paths_result_tE)
* [cugraph::c\_api::cugraph\_graph\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api15cugraph_graph_tE)
* [cugraph::c\_api::cugraph\_hierarchical\_clustering\_result\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api40cugraph_hierarchical_clustering_result_tE)
* [cugraph::c\_api::cugraph\_hits\_result\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api21cugraph_hits_result_tE)
* [cugraph::c\_api::cugraph\_induced\_subgraph\_result\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api33cugraph_induced_subgraph_result_tE)
* [cugraph::c\_api::cugraph\_k\_core\_result\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api23cugraph_k_core_result_tE)
* [cugraph::c\_api::cugraph\_labeling\_result\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api25cugraph_labeling_result_tE)
* [cugraph::c\_api::cugraph\_lookup\_container\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api26cugraph_lookup_container_tE)
* [cugraph::c\_api::cugraph\_lookup\_result\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api23cugraph_lookup_result_tE)
* [cugraph::c\_api::cugraph\_paths\_result\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api22cugraph_paths_result_tE)
* [cugraph::c\_api::cugraph\_random\_walk\_result\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api28cugraph_random_walk_result_tE)
* [cugraph::c\_api::cugraph\_resource\_handle\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api25cugraph_resource_handle_tE)
* [cugraph::c\_api::cugraph\_rng\_state\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api19cugraph_rng_state_tE)
* [cugraph::c\_api::cugraph\_sample\_result\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api23cugraph_sample_result_tE)
* [cugraph::c\_api::cugraph\_sampling\_options\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api26cugraph_sampling_options_tE)
* [cugraph::c\_api::cugraph\_similarity\_result\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api27cugraph_similarity_result_tE)
* [cugraph::c\_api::cugraph\_triangle\_count\_result\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api31cugraph_triangle_count_result_tE)
* [cugraph::c\_api::cugraph\_type\_erased\_device\_array\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api34cugraph_type_erased_device_array_tE)
* [cugraph::c\_api::cugraph\_type\_erased\_device\_array\_view\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api39cugraph_type_erased_device_array_view_tE)
* [cugraph::c\_api::cugraph\_type\_erased\_host\_array\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api32cugraph_type_erased_host_array_tE)
* [cugraph::c\_api::cugraph\_type\_erased\_host\_array\_view\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api37cugraph_type_erased_host_array_view_tE)
* [cugraph::c\_api::cugraph\_vertex\_pairs\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api22cugraph_vertex_pairs_tE)
* [cugraph::c\_api::cugraph\_vertex\_property\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api25cugraph_vertex_property_tE)
* [cugraph::c\_api::cugraph\_vertex\_property\_view\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api30cugraph_vertex_property_view_tE)
* [cugraph::c\_api::data\_type\_sz (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api12data_type_szE)
* [cugraph::c\_api::detail (C++ type)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api6detailE)
* [cugraph::c\_api::detail::reorder\_extracted\_egonets (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph5c_api6detail25reorder_extracted_egonetsENSt5tupleIN3rmm14device_uvectorI6size_tEEN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEEEERKN4raft8handle_tERRN3rmm14device_uvectorI6size_tEERRN3rmm14device_uvectorI6size_tEERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEERRNSt8optionalIN3rmm14device_uvectorI8weight_tEEEE)
* [cugraph::c\_api::detail::shuffle\_vertex\_ids\_and\_offsets (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph5c_api6detail30shuffle_vertex_ids_and_offsetsENSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI6size_tEEEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEEN4raft11device_spanIK6size_tEE)
* [cugraph::c\_api::detail::sort\_by\_key (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph5c_api6detail11sort_by_keyEvRKN4raft8handle_tEN4raft11device_spanI5key_tEEN4raft11device_spanI7value_tEE)
* [cugraph::c\_api::edge\_dispatcher (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph5c_api15edge_dispatcherEDc22cugraph_data_type_id_t22cugraph_data_type_id_t22cugraph_data_type_id_tbbR9functor_t)
* [cugraph::c\_api::edge\_type\_type\_dispatcher (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000EN7cugraph5c_api25edge_type_type_dispatcherEDc22cugraph_data_type_id_tbbR9functor_t)
* [cugraph::c\_api::expand\_sparse\_offsets (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph5c_api21expand_sparse_offsetsEN3rmm14device_uvectorI8vertex_tEEN4raft11device_spanIK6edge_tEE8vertex_tRKN3rmm16cuda_stream_viewE)
* [cugraph::c\_api::extract\_paths\_functor (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api21extract_paths_functorE)
* [cugraph::c\_api::multi\_gpu\_dispatcher (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000_b0EN7cugraph5c_api20multi_gpu_dispatcherEDcbR9functor_t)
* [cugraph::c\_api::node2vec\_functor (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api16node2vec_functorE)
* [cugraph::c\_api::run\_algorithm (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph5c_api13run_algorithmE20cugraph_error_code_tPK15cugraph_graph_tR9functor_tP8result_tPP15cugraph_error_t)
* [cugraph::c\_api::sampling\_flags\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api16sampling_flags_tE)
* [cugraph::c\_api::sssp\_functor (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5c_api12sssp_functorE)
* [cugraph::c\_api::transpose\_dispatcher (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00000EN7cugraph5c_api20transpose_dispatcherEDcbbR9functor_t)
* [cugraph::c\_api::transpose\_storage (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000_b_bEN7cugraph5c_api17transpose_storageE20cugraph_error_code_tRKN4raft8handle_tEP15cugraph_graph_tP15cugraph_error_t)
* [cugraph::c\_api::vertex\_dispatcher (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph5c_api17vertex_dispatcherEDc22cugraph_data_type_id_t22cugraph_data_type_id_t22cugraph_data_type_id_t22cugraph_data_type_id_tbbR9functor_t)
* [cugraph::c\_api::weight\_dispatcher (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph5c_api17weight_dispatcherEDc22cugraph_data_type_id_t22cugraph_data_type_id_tbbR9functor_t)
* [cugraph::cast\_edge\_op\_bool\_to\_integer (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000000EN7cugraph28cast_edge_op_bool_to_integerE)
* [cugraph::centrality\_algorithm\_metadata\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph31centrality_algorithm_metadata_tE)
* [cugraph::collect\_values\_for\_int\_vertices (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph31collect_values_for_int_verticesE23dataframe_buffer_type_tIN6thrust15iterator_traitsI13ValueIteratorE10value_typeEERKN4raft5comms7comms_tE14VertexIterator14VertexIterator13ValueIteratorRKNSt6vectorIN6thrust15iterator_traitsI14VertexIteratorE10value_typeEEEN6thrust15iterator_traitsI14VertexIteratorE10value_typeEN3rmm16cuda_stream_viewE)
* [cugraph::collect\_values\_for\_keys (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph23collect_values_for_keysE23dataframe_buffer_type_tIN15KVStoreViewType10value_typeEERKN4raft5comms7comms_tE15KVStoreViewType11KeyIterator11KeyIterator15KeyToCommRankOpN3rmm16cuda_stream_viewE)
* [cugraph::collect\_values\_for\_sorted\_unique\_int\_vertices (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph45collect_values_for_sorted_unique_int_verticesE23dataframe_buffer_type_tIN6thrust15iterator_traitsI13ValueIteratorE10value_typeEERKN4raft5comms7comms_tEN4raft11device_spanIK8vertex_tEE13ValueIteratorRKNSt6vectorI8vertex_tEE8vertex_tN3rmm16cuda_stream_viewE)
* [cugraph::collect\_values\_for\_unique\_keys (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph30collect_values_for_unique_keysENSt5tupleIN3rmm14device_uvectorIN15KVStoreViewType8key_typeEEE23dataframe_buffer_type_tIN15KVStoreViewType10value_typeEEEERKN4raft5comms7comms_tE15KVStoreViewTypeRRN3rmm14device_uvectorIN15KVStoreViewType8key_typeEEE15KeyToCommRankOpN3rmm16cuda_stream_viewE)
* [cugraph::compute\_key\_lower\_bound (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph23compute_key_lower_boundE11KeyIterator11KeyIterator11KeyIterator8vertex_tN3rmm16cuda_stream_viewE)
* [cugraph::compute\_key\_segment\_offsets (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph27compute_key_segment_offsetsENSt6vectorI6size_tEE11KeyIterator11KeyIteratorN4raft9host_spanIK8vertex_tEE8vertex_tN3rmm16cuda_stream_viewE)
* [cugraph::compute\_num\_out\_nbrs\_from\_frontier (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph34compute_num_out_nbrs_from_frontierE6size_tRKN4raft8handle_tERK13GraphViewTypeRK13KeyBucketType)
* [cugraph::compute\_thrust\_tuple\_element\_sizes (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph34compute_thrust_tuple_element_sizesE)
* [cugraph::compute\_vertex\_list\_bitmap\_info (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph31compute_vertex_list_bitmap_infoEN3rmm14device_uvectorI8uint32_tEE14VertexIterator14VertexIteratorN6thrust15iterator_traitsI14VertexIteratorE10value_typeEN6thrust15iterator_traitsI14VertexIteratorE10value_typeEN3rmm16cuda_stream_viewE)
* [cugraph::convert\_paths\_to\_coo (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph20convert_paths_to_cooENSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI7index_tEEEERKN4raft8handle_tE7index_t7index_tRRN3rmm13device_bufferERRN3rmm13device_bufferE)
* [cugraph::coo\_to\_csr\_inplace (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph18coo_to_csr_inplaceEvRN6legacy12GraphCOOViewI2VT2ET2WTEERN6legacy12GraphCSRViewI2VT2ET2WTEE)
* [cugraph::core\_number (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_bEN7cugraph11core_numberEvRKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuEP6edge_t20k_core_degree_type_t6size_t6size_tb)
* [cugraph::count\_if\_e (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00000EN7cugraph10count_if_eEN13GraphViewType9edge_typeERKN4raft8handle_tERK13GraphViewType24EdgeSrcValueInputWrapper24EdgeDstValueInputWrapper21EdgeValueInputWrapper6EdgeOpb)
* [cugraph::count\_if\_v (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph10count_if_vEN13GraphViewType11vertex_typeERKN4raft8handle_tERK13GraphViewType24VertexValueInputIterator8VertexOpb)
* [cugraph::cugraph\_cc\_t (C++ enum)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph12cugraph_cc_tE)
* [cugraph::cugraph\_cc\_t::CUGRAPH\_STRONG (C++ enumerator)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph12cugraph_cc_t14CUGRAPH_STRONGE)
* [cugraph::cugraph\_cc\_t::NUM\_CONNECTIVITY\_TYPES (C++ enumerator)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph12cugraph_cc_t22NUM_CONNECTIVITY_TYPESE)
* [cugraph::dataframe\_buffer\_const\_iterator\_type (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph36dataframe_buffer_const_iterator_typeE)
* [cugraph::dataframe\_buffer\_const\_iterator\_type> (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4IDpEN7cugraph36dataframe_buffer_const_iterator_typeIN6thrust5tupleIDp2TsEEEE)
* [cugraph::dataframe\_buffer\_const\_iterator\_type\_t (C++ type)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph38dataframe_buffer_const_iterator_type_tE)
* [cugraph::dataframe\_buffer\_iterator\_type (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph30dataframe_buffer_iterator_typeE)
* [cugraph::dataframe\_buffer\_iterator\_type> (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4IDpEN7cugraph30dataframe_buffer_iterator_typeIN6thrust5tupleIDp2TsEEEE)
* [cugraph::dataframe\_buffer\_iterator\_type\_t (C++ type)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph32dataframe_buffer_iterator_type_tE)
* [cugraph::dataframe\_buffer\_type (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph21dataframe_buffer_typeE)
* [cugraph::dataframe\_buffer\_type\_t (C++ type)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph23dataframe_buffer_type_tE)
* [cugraph::Dendrogram (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph10DendrogramE)
* [cugraph::dense (C++ type)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph5denseE)
* [cugraph::dense::hungarian (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph5dense9hungarianE8weight_tRKN4raft8handle_tEPK8weight_t7index_t7index_tP7index_t)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph5dense9hungarianE8weight_tRKN4raft8handle_tEPK8weight_t7index_t7index_tP7index_t8weight_t)
* [cugraph::detail (C++ type)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detailE)
* [cugraph::detail::\_\_syncthreads (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail13__syncthreadsEv)
* [cugraph::detail::\_\_threadfence\_block (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail19__threadfence_blockEv)
* [cugraph::detail::accumulate\_edge\_results (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000_bEN7cugraph6detail23accumulate_edge_resultsEvRKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEE20edge_property_view_tI6edge_tP8weight_tERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI6edge_tEEb)
* [cugraph::detail::accumulate\_vertex\_property\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail28accumulate_vertex_property_tE)
* [cugraph::detail::accumulate\_vertex\_results (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000_bEN7cugraph6detail25accumulate_vertex_resultsEvRKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEEN4raft11device_spanI8weight_tEERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI6edge_tEEbb)
* [cugraph::detail::aggregate\_offset\_vectors (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail24aggregate_offset_vectorsENSt6vectorI8vertex_tEERKN4raft8handle_tERKNSt6vectorI8vertex_tEE)
* [cugraph::detail::all\_pairs\_similarity (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000_b0EN7cugraph6detail20all_pairs_similarityENSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8weight_tEEEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEENSt8optionalIN4raft11device_spanIK8vertex_tEEEENSt8optionalI6size_tEE9functor_t13coefficient_tb)
* [cugraph::detail::allocate\_dataframe\_buffer\_tuple\_impl (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_Dp6size_tEN7cugraph6detail36allocate_dataframe_buffer_tuple_implEDaNSt14index_sequenceIDp2IsEE6size_tN3rmm16cuda_stream_viewE)
* [cugraph::detail::allocate\_optional\_dataframe\_buffer (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail34allocate_optional_dataframe_bufferEDa6size_tN3rmm16cuda_stream_viewE)
* [cugraph::detail::append\_all (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail10append_allEN3rmm14device_uvectorI1TEERKN4raft8handle_tERRNSt6vectorIN3rmm14device_uvectorI1TEEEE)
* [cugraph::detail::approximate\_weighted\_matching (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000_bEN7cugraph6detail29approximate_weighted_matchingENSt5tupleIN3rmm14device_uvectorI8vertex_tEE8weight_tEERKN4raft8handle_tERKN7cugraph12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuEE20edge_property_view_tI6edge_tPK8weight_tE)
* [cugraph::detail::atomicMax (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail9atomicMaxE9maxdepthd13localmaxdepth)
* [cugraph::detail::barnes\_hut (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail10barnes_hutEvRKN4raft8handle_tERN6legacy12GraphCOOViewI8vertex_t6edge_t8weight_tEEPfKiPfPfbbbKfKfKfKfbKfbPN9internals24GraphBasedDimRedCallbackE)
* [cugraph::detail::betweenness\_centrality (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000_b0EN7cugraph6detail22betweenness_centralityEN3rmm14device_uvectorI8weight_tEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEE14VertexIterator14VertexIteratorKbKbKb)
* [cugraph::detail::bfs (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail3bfsEvRKN4raft8handle_tERK13GraphViewTypePN13GraphViewType11vertex_typeE19PredecessorIteratorPKN13GraphViewType11vertex_typeE6size_tbN13GraphViewType11vertex_typeEb)
* [cugraph::detail::biased\_random\_walk\_e\_bias\_op\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail30biased_random_walk_e_bias_op_tE)
* [cugraph::detail::biased\_sample\_edges\_op\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail24biased_sample_edges_op_tE)
* [cugraph::detail::biased\_sample\_with\_replacement (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000_bEN7cugraph6detail30biased_sample_with_replacementENSt5tupleIN3rmm14device_uvectorI6edge_tEENSt8optionalIN3rmm14device_uvectorI6size_tEEEENSt6vectorI6size_tEEEERKN4raft8handle_tEN4raft11device_spanIK6size_tEEN4raft9host_spanIK6size_tEEN4raft11device_spanIK6bias_tEEN4raft11device_spanIK6size_tEEN4raft9host_spanIK6size_tEERN4raft6random8RngStateEN4raft9host_spanIK6size_tEE)
* [cugraph::detail::biased\_selector (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail15biased_selectorE)
* [cugraph::detail::bottom (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail6bottomE)
* [cugraph::detail::brandes\_bfs (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000_bEN7cugraph6detail11brandes_bfsENSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI6edge_tEEEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEER17vertex_frontier_tI8vertex_tv9multi_gpuXL1EEEb)
* [cugraph::detail::build\_edge\_id\_and\_type\_to\_src\_dst\_lookup\_map (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000EN7cugraph6detail44build_edge_id_and_type_to_src_dst_lookup_mapE40EdgeTypeAndIdToSrcDstLookupContainerTypeRKN4raft8handle_tERK13GraphViewType18EdgeIdInputWrapper20EdgeTypeInputWrapper)
* [cugraph::detail::cache\_line\_size (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail15cache_line_sizeE)
* [cugraph::detail::call\_const\_true\_e\_op\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail22call_const_true_e_op_tE)
* [cugraph::detail::call\_e\_op\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000000EN7cugraph6detail11call_e_op_tE)
* [cugraph::detail::call\_e\_op\_with\_key\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000000EN7cugraph6detail20call_e_op_with_key_tE)
* [cugraph::detail::call\_intersection\_op\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000000EN7cugraph6detail22call_intersection_op_tE)
* [cugraph::detail::call\_key\_aggregated\_e\_op\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00000000EN7cugraph6detail26call_key_aggregated_e_op_tE)
* [cugraph::detail::ch (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail2chE)
* [cugraph::detail::check\_bit\_set\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail15check_bit_set_tE)
* [cugraph::detail::check\_clustering (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_bEN7cugraph6detail16check_clusteringEvRK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuEP8vertex_t)
* [cugraph::detail::check\_edge\_bias\_values (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000_bEN7cugraph6detail22check_edge_bias_valuesENSt5tupleI6size_t6size_tEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuE20edge_property_view_tI6edge_tPK6bias_tE)
* [cugraph::detail::check\_edge\_src\_and\_dst\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail24check_edge_src_and_dst_tE)
* [cugraph::detail::check\_in\_range\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail16check_in_range_tE)
* [cugraph::detail::check\_invalid\_bucket\_idx\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail26check_invalid_bucket_idx_tE)
* [cugraph::detail::check\_invalid\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail15check_invalid_tE)
* [cugraph::detail::check\_out\_of\_range\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail20check_out_of_range_tE)
* [cugraph::detail::cluster\_update\_op\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail19cluster_update_op_tE)
* [cugraph::detail::cm (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail2cmE)
* [cugraph::detail::coarsen\_graph (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000_b_bEN7cugraph6detail13coarsen_graphENSt11enable_if_tI9multi_gpuNSt5tupleI7graph_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE8weight_tEEENSt8optionalIN3rmm14device_uvectorI8vertex_tEEEEEEEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEEPK8vertex_tbb)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I000_b_bEN7cugraph6detail13coarsen_graphENSt11enable_if_tIXnt9multi_gpuENSt5tupleI7graph_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE8weight_tEEENSt8optionalIN3rmm14device_uvectorI8vertex_tEEEEEEEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEEPK8vertex_tbb)
* [cugraph::detail::coefficient\_t (C++ enum)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail13coefficient_tE)
* [cugraph::detail::coefficient\_t::COSINE (C++ enumerator)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail13coefficient_t6COSINEE)
* [cugraph::detail::coefficient\_t::JACCARD (C++ enumerator)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail13coefficient_t7JACCARDE)
* [cugraph::detail::coefficient\_t::OVERLAP (C++ enumerator)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail13coefficient_t7OVERLAPE)
* [cugraph::detail::coefficient\_t::SORENSEN (C++ enumerator)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail13coefficient_t8SORENSENE)
* [cugraph::detail::col\_indx\_extract\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000EN7cugraph6detail18col_indx_extract_tE)
* [cugraph::detail::compress\_hypersparse\_offsets (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail28compress_hypersparse_offsetsENSt5tupleIN3rmm14device_uvectorI6edge_tEEN3rmm14device_uvectorI8vertex_tEEEERRN3rmm14device_uvectorI6edge_tEE8vertex_t8vertex_t8vertex_tN3rmm16cuda_stream_viewE)
* [cugraph::detail::compute\_aggregate\_local\_frontier\_bias\_type\_pairs (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000000EN7cugraph6detail48compute_aggregate_local_frontier_bias_type_pairsENSt5tupleIN3rmm14device_uvectorIN19edge_op_result_typeIN6thrust15iterator_traitsI11KeyIteratorE10value_typeEN13GraphViewType11vertex_typeEN24EdgeSrcValueInputWrapper10value_typeEN24EdgeDstValueInputWrapper10value_typeEN21EdgeValueInputWrapper10value_typeE10BiasEdgeOpE4typeEEEN3rmm14device_uvectorIN20EdgeTypeInputWrapper10value_typeEEEN3rmm14device_uvectorIN13GraphViewType9edge_typeEEEN3rmm14device_uvectorI6size_tEEEERKN4raft8handle_tERK13GraphViewType11KeyIterator24EdgeSrcValueInputWrapper24EdgeDstValueInputWrapper21EdgeValueInputWrapper10BiasEdgeOp20EdgeTypeInputWrapperN4raft9host_spanIK6size_tEEb)
* [cugraph::detail::compute\_aggregate\_local\_frontier\_biases (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000000EN7cugraph6detail39compute_aggregate_local_frontier_biasesENSt5tupleIN3rmm14device_uvectorIN19edge_op_result_typeIN6thrust15iterator_traitsI11KeyIteratorE10value_typeEN13GraphViewType11vertex_typeEN24EdgeSrcValueInputWrapper10value_typeEN24EdgeDstValueInputWrapper10value_typeEN21EdgeValueInputWrapper10value_typeE10BiasEdgeOpE4typeEEEN3rmm14device_uvectorIN13GraphViewType9edge_typeEEEN3rmm14device_uvectorI6size_tEEEERKN4raft8handle_tERK13GraphViewType11KeyIterator24EdgeSrcValueInputWrapper24EdgeDstValueInputWrapper21EdgeValueInputWrapper10BiasEdgeOpN4raft9host_spanIK6size_tEEb)
* [cugraph::detail::compute\_aggregate\_local\_frontier\_edge\_types (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail43compute_aggregate_local_frontier_edge_typesENSt5tupleIN3rmm14device_uvectorIN20EdgeTypeInputWrapper10value_typeEEEN3rmm14device_uvectorI6size_tEEEERKN4raft8handle_tERK13GraphViewType11KeyIterator20EdgeTypeInputWrapperN4raft9host_spanIK6size_tEE)
* [cugraph::detail::compute\_aggregate\_local\_frontier\_local\_degrees (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail46compute_aggregate_local_frontier_local_degreesEN3rmm14device_uvectorIN13GraphViewType9edge_typeEEERKN4raft8handle_tERK13GraphViewType14VertexIteratorN4raft9host_spanIK6size_tEE)
* [cugraph::detail::compute\_aggregate\_local\_frontier\_per\_type\_local\_degrees (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail55compute_aggregate_local_frontier_per_type_local_degreesEN3rmm14device_uvectorI6edge_tEERKN4raft8handle_tEN4raft11device_spanIK6size_tEEN4raft9host_spanIK6size_tEEN4raft11device_spanIK11edge_type_tEEN4raft11device_spanIK6size_tEEN4raft9host_spanIK6size_tEE6size_t)
* [cugraph::detail::compute\_chunk\_id\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail18compute_chunk_id_tE)
* [cugraph::detail::compute\_cluster\_keys\_and\_values (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000_bEN7cugraph6detail31compute_cluster_keys_and_valuesENSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8weight_tEEEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEERKN3rmm14device_uvectorI8vertex_tEERK19edge_src_property_tI12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuE8vertex_tE)
* [cugraph::detail::compute\_edge\_partition\_id\_from\_ext\_edge\_endpoints\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail51compute_edge_partition_id_from_ext_edge_endpoints_tE)
* [cugraph::detail::compute\_edge\_partition\_id\_from\_int\_edge\_endpoints\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail51compute_edge_partition_id_from_int_edge_endpoints_tE)
* [cugraph::detail::compute\_frontier\_value\_sums\_and\_partitioned\_local\_value\_sum\_displacements (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail73compute_frontier_value_sums_and_partitioned_local_value_sum_displacementsENSt5tupleIN3rmm14device_uvectorI7value_tEEN3rmm14device_uvectorI7value_tEEEERKN4raft8handle_tEN4raft11device_spanIK7value_tEEN4raft9host_spanIK6size_tEE6size_t)
* [cugraph::detail::compute\_gpu\_id\_from\_ext\_edge\_endpoints\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail40compute_gpu_id_from_ext_edge_endpoints_tE)
* [cugraph::detail::compute\_gpu\_id\_from\_ext\_edge\_id\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail33compute_gpu_id_from_ext_edge_id_tE)
* [cugraph::detail::compute\_gpu\_id\_from\_ext\_vertex\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail32compute_gpu_id_from_ext_vertex_tE)
* [cugraph::detail::compute\_gpu\_id\_from\_int\_edge\_endpoints\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail40compute_gpu_id_from_int_edge_endpoints_tE)
* [cugraph::detail::compute\_gpu\_id\_from\_int\_vertex\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail32compute_gpu_id_from_int_vertex_tE)
* [cugraph::detail::compute\_group\_id\_count\_pair\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail29compute_group_id_count_pair_tE)
* [cugraph::detail::compute\_heterogeneous\_biased\_sampling\_index\_without\_replacement (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail63compute_heterogeneous_biased_sampling_index_without_replacementEvRKN4raft8handle_tENSt8optionalIN4raft11device_spanIK6size_tEEEEN4raft11device_spanIK11edge_type_tEEN4raft11device_spanIK6size_tEEN4raft11device_spanIK6bias_tEEN4raft11device_spanIK6size_tEEN4raft11device_spanI6edge_tEENSt8optionalIN4raft11device_spanI6bias_tEEEERN4raft6random8RngStateEN4raft11device_spanIK6size_tEEb)
* [cugraph::detail::compute\_heterogeneous\_uniform\_sampling\_index\_without\_replacement (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail64compute_heterogeneous_uniform_sampling_index_without_replacementEN3rmm14device_uvectorI6edge_tEERKN4raft8handle_tEN4raft11device_spanIK6edge_tEERN4raft6random8RngStateEN4raft11device_spanIK6size_tEE6size_t)
* [cugraph::detail::compute\_homogeneous\_biased\_sampling\_index\_without\_replacement (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail61compute_homogeneous_biased_sampling_index_without_replacementEvRKN4raft8handle_tENSt8optionalIN4raft11device_spanIK6size_tEEEEN4raft11device_spanIK6size_tEEN4raft11device_spanIK6bias_tEENSt8optionalIN4raft11device_spanIK6size_tEEEEN4raft11device_spanI6edge_tEENSt8optionalIN4raft11device_spanI6bias_tEEEERN4raft6random8RngStateE6size_tb)
* [cugraph::detail::compute\_homogeneous\_uniform\_sampling\_index\_without\_replacement (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail62compute_homogeneous_uniform_sampling_index_without_replacementEN3rmm14device_uvectorI6edge_tEERKN4raft8handle_tEN4raft11device_spanIK6edge_tEERN4raft6random8RngStateE6size_t)
* [cugraph::detail::compute\_local\_edge\_partition\_id\_from\_ext\_edge\_endpoints\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail57compute_local_edge_partition_id_from_ext_edge_endpoints_tE)
* [cugraph::detail::compute\_local\_edge\_partition\_id\_from\_int\_edge\_endpoints\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail57compute_local_edge_partition_id_from_int_edge_endpoints_tE)
* [cugraph::detail::compute\_local\_edge\_partition\_id\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail33compute_local_edge_partition_id_tE)
* [cugraph::detail::compute\_local\_edge\_partition\_major\_range\_vertex\_partition\_id\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail62compute_local_edge_partition_major_range_vertex_partition_id_tE)
* [cugraph::detail::compute\_local\_edge\_partition\_minor\_range\_vertex\_partition\_id\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail62compute_local_edge_partition_minor_range_vertex_partition_id_tE)
* [cugraph::detail::compute\_local\_nbr\_count\_per\_rank\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail34compute_local_nbr_count_per_rank_tE)
* [cugraph::detail::compute\_local\_nbr\_indices\_from\_per\_type\_local\_nbr\_indices (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail57compute_local_nbr_indices_from_per_type_local_nbr_indicesEN3rmm14device_uvectorI6edge_tEERKN4raft8handle_tEN4raft11device_spanIK6size_tEEN4raft9host_spanIK6size_tEEN4raft11device_spanIK6size_tEEN4raft9host_spanIK6size_tEENSt8optionalINSt5tupleIN4raft11device_spanIK11edge_type_tEEN4raft11device_spanIK6size_tEEEEEERRN3rmm14device_uvectorI6edge_tEEN4raft9host_spanIK6size_tEEN4raft11device_spanIK6size_tEE6size_t)
* [cugraph::detail::compute\_local\_value\_displacements\_and\_global\_value\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail52compute_local_value_displacements_and_global_value_tE)
* [cugraph::detail::compute\_max (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail11compute_maxE)
* [cugraph::detail::compute\_max\_distance (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_bEN7cugraph6detail20compute_max_distanceE)
* [cugraph::detail::compute\_modularity (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000_bEN7cugraph6detail18compute_modularityE8weight_tRKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEERK19edge_src_property_tI12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuE8vertex_tERK19edge_dst_property_tI12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuE8vertex_tERKN3rmm14device_uvectorI8vertex_tEERKN3rmm14device_uvectorI8weight_tEE8weight_t8weight_t)
* [cugraph::detail::compute\_offset\_aligned\_element\_chunks (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail37compute_offset_aligned_element_chunksENSt5tupleINSt6vectorI8vertex_tEENSt6vectorI8offset_tEEEERKN4raft8handle_tEN4raft11device_spanIK8offset_tEE8offset_t8vertex_t)
* [cugraph::detail::compute\_priorities (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail18compute_prioritiesEvRKN4raft5comms7comms_tE13ValueIteratorN4raft11device_spanI10priority_tEENSt8optionalINSt7variantIN4raft11device_spanIK8uint32_tEEN4raft11device_spanIK6size_tEEEEEE6size_tiiN6thrust15iterator_traitsI13ValueIteratorE10value_typeEbN3rmm16cuda_stream_viewE)
* [cugraph::detail::compute\_renumber\_map (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_bEN7cugraph6detail20compute_renumber_mapENSt5tupleIN3rmm14device_uvectorI8vertex_tEENSt6vectorI8vertex_tEENSt8optionalINSt6vectorI8vertex_tEEEE8vertex_tEERKN4raft8handle_tERRNSt8optionalIN3rmm14device_uvectorI8vertex_tEEEERKNSt6vectorIPK8vertex_tEERKNSt6vectorIPK8vertex_tEERKNSt6vectorI6edge_tEE)
* [cugraph::detail::compute\_selected\_ranks\_from\_priorities (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail38compute_selected_ranks_from_prioritiesENSt7variantIN3rmm14device_uvectorINSt13conditional_tINSt9is_same_vI10priority_t8uint32_tEEi10priority_tEEEENSt8optionalIN3rmm14device_uvectorI8uint32_tEEEEEERKN4raft5comms7comms_tEN4raft11device_spanIK10priority_tEENSt8optionalINSt7variantIN4raft11device_spanIK8uint32_tEEN4raft11device_spanIK6size_tEEEEEE6size_tiibN3rmm16cuda_stream_viewE)
* [cugraph::detail::compute\_sparse\_offsets (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail22compute_sparse_offsetsEN3rmm14device_uvectorI6edge_tEE14VertexIterator14VertexIteratorN6thrust15iterator_traitsI14VertexIteratorE10value_typeEN6thrust15iterator_traitsI14VertexIteratorE10value_typeEbN3rmm16cuda_stream_viewE)
* [cugraph::detail::compute\_thrust\_tuple\_element\_sizes\_impl (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_6size_t_6size_tEN7cugraph6detail39compute_thrust_tuple_element_sizes_implE)
* [cugraph::detail::compute\_thrust\_tuple\_element\_sizes\_impl (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_6size_tEN7cugraph6detail39compute_thrust_tuple_element_sizes_implI9TupleType1I1IEE)
* [cugraph::detail::compute\_tx\_rx\_counts\_offsets\_ranks (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail34compute_tx_rx_counts_offsets_ranksERKN4raft5comms7comms_tERKN3rmm14device_uvectorI6size_tEEbN3rmm16cuda_stream_viewE)
* [cugraph::detail::compute\_unique\_keys (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail19compute_unique_keysENSt5tupleI23dataframe_buffer_type_tIN6thrust15iterator_traitsI11KeyIteratorE10value_typeEEN3rmm14device_uvectorI6size_tEENSt6vectorI6size_tEEEERKN4raft8handle_tE11KeyIteratorN4raft9host_spanIK6size_tEE)
* [cugraph::detail::compute\_valid\_local\_nbr\_count\_inclusive\_sum\_high\_local\_degree\_threshold (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail71compute_valid_local_nbr_count_inclusive_sum_high_local_degree_thresholdE)
* [cugraph::detail::compute\_valid\_local\_nbr\_count\_inclusive\_sum\_local\_degree\_threshold (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail66compute_valid_local_nbr_count_inclusive_sum_local_degree_thresholdE)
* [cugraph::detail::compute\_valid\_local\_nbr\_count\_inclusive\_sum\_mid\_local\_degree\_threshold (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail70compute_valid_local_nbr_count_inclusive_sum_mid_local_degree_thresholdE)
* [cugraph::detail::compute\_valid\_local\_nbr\_count\_inclusive\_sums (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail44compute_valid_local_nbr_count_inclusive_sumsENSt6vectorINSt5tupleIN3rmm14device_uvectorI6size_tEEN3rmm14device_uvectorIN13GraphViewType9edge_typeEEEEEEERKN4raft8handle_tERK13GraphViewType14VertexIteratorN4raft9host_spanIK6size_tEE)
* [cugraph::detail::compute\_vertex\_partition\_id\_from\_ext\_vertex\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail45compute_vertex_partition_id_from_ext_vertex_tE)
* [cugraph::detail::compute\_vertex\_partition\_id\_from\_int\_vertex\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail45compute_vertex_partition_id_from_int_vertex_tE)
* [cugraph::detail::connected\_components\_impl (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000_iEN7cugraph6detail25connected_components_implENSt11enable_if_tINSt9is_signedI2VTE5valueEEERKN6legacy12GraphCSRViewI2VT2ET2WTEE12cugraph_cc_tP2VT12cudaStream_t)
* [cugraph::detail::const\_true\_e\_op\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00000_bEN7cugraph6detail17const_true_e_op_tE)
* [cugraph::detail::constant\_bias\_e\_op\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00000EN7cugraph6detail20constant_bias_e_op_tE)
* [cugraph::detail::convert\_per\_type\_value\_key\_pair\_to\_shuffle\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000EN7cugraph6detail44convert_per_type_value_key_pair_to_shuffle_tE)
* [cugraph::detail::convert\_starting\_vertex\_label\_offsets\_to\_labels (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail47convert_starting_vertex_label_offsets_to_labelsERKN4raft8handle_tEN4raft11device_spanIK6size_tEE)
* [cugraph::detail::convert\_to\_unmasked\_local\_nbr\_idx (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail33convert_to_unmasked_local_nbr_idxEN3rmm14device_uvectorIN13GraphViewType9edge_typeEEERKN4raft8handle_tERK13GraphViewType14VertexIteratorRRN3rmm14device_uvectorIN13GraphViewType9edge_typeEEENSt8optionalIN4raft11device_spanIK6size_tEEEEN4raft9host_spanIK6size_tEEN4raft9host_spanIK6size_tEE6size_t)
* [cugraph::detail::convert\_value\_key\_pair\_to\_shuffle\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail35convert_value_key_pair_to_shuffle_tE)
* [cugraph::detail::coo\_convertor\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail15coo_convertor_tE)
* [cugraph::detail::copy\_if\_mask\_set (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail16copy_if_mask_setE14OutputIteratorRKN4raft8handle_tE13InputIterator13InputIterator12MaskIterator14OutputIterator)
* [cugraph::detail::copy\_if\_nosync (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail14copy_if_nosyncEv13InputIterator13InputIterator12FlagIterator14OutputIteratorN4raft11device_spanI6size_tEEN3rmm16cuda_stream_viewE)
* [cugraph::detail::copy\_intersecting\_nbrs\_and\_update\_intersection\_size\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00000000_bEN7cugraph6detail53copy_intersecting_nbrs_and_update_intersection_size_tE)
* [cugraph::detail::cosine\_functor\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail16cosine_functor_tE)
* [cugraph::detail::count\_if\_call\_v\_op\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail20count_if_call_v_op_tE)
* [cugraph::detail::count\_invalid\_vertex\_pairs (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail26count_invalid_vertex_pairsE6size_tRKN4raft8handle_tERK13GraphViewType18VertexPairIterator18VertexPairIterator)
* [cugraph::detail::count\_nosync (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail12count_nosyncEv13InputIterator13InputIteratorN4raft11device_spanI6size_tEEN6thrust15iterator_traitsI13InputIteratorE10value_typeEN3rmm16cuda_stream_viewE)
* [cugraph::detail::count\_set\_bits (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail14count_set_bitsE6size_tRKN4raft8handle_tE12MaskIterator6size_t)
* [cugraph::detail::count\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail7count_tE)
* [cugraph::detail::count\_updown\_moves\_op\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail23count_updown_moves_op_tE)
* [cugraph::detail::count\_valids\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail14count_valids_tE)
* [cugraph::detail::create\_local\_samples (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000_b_bEN7cugraph6detail20create_local_samplesEN3rmm14device_uvectorI8vertex_tEERKN4raft8handle_tERN4raft6random8RngStateERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuERKNSt8optionalIN3rmm14device_uvectorI8weight_tEEEERKNSt8optionalIN3rmm14device_uvectorI8weight_tEEEE6size_t)
* [cugraph::detail::create\_offset (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail13create_offsetEN3rmm13device_bufferEP2VT2VT2ETN3rmm16cuda_stream_viewEN3rmm25device_async_resource_refE)
* [cugraph::detail::cuco\_storage\_type (C++ type)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail17cuco_storage_typeE)
* [cugraph::detail::dec (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail3decE)
* [cugraph::detail::decompress\_edge\_partition\_block\_size (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail36decompress_edge_partition_block_sizeE)
* [cugraph::detail::decompress\_edge\_partition\_to\_edgelist (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000_bEN7cugraph6detail37decompress_edge_partition_to_edgelistEvRKN4raft8handle_tE28edge_partition_device_view_tI8vertex_t6edge_t9multi_gpuENSt8optionalI42edge_partition_edge_property_device_view_tI6edge_tPK8weight_tEEENSt8optionalI42edge_partition_edge_property_device_view_tI6edge_tPK6edge_tEEENSt8optionalI42edge_partition_edge_property_device_view_tI6edge_tPK11edge_type_tEEENSt8optionalI42edge_partition_edge_property_device_view_tI6edge_tPK8uint32_tbEEEN4raft11device_spanI8vertex_tEEN4raft11device_spanI8vertex_tEENSt8optionalIN4raft11device_spanI8weight_tEEEENSt8optionalIN4raft11device_spanI6edge_tEEEENSt8optionalIN4raft11device_spanI11edge_type_tEEEERKNSt8optionalINSt6vectorI8vertex_tEEEE)
* [cugraph::detail::decompress\_edge\_partition\_to\_fill\_edgelist\_majors (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_bEN7cugraph6detail49decompress_edge_partition_to_fill_edgelist_majorsEvRKN4raft8handle_tE28edge_partition_device_view_tI8vertex_t6edge_t9multi_gpuENSt8optionalI42edge_partition_edge_property_device_view_tI6edge_tPK8uint32_tbEEEN4raft11device_spanI8vertex_tEERKNSt8optionalINSt6vectorI8vertex_tEEEE)
* [cugraph::detail::decrement\_position (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail18decrement_positionE)
* [cugraph::detail::default\_epsilon (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail15default_epsilonE8weight_tv)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4IEN7cugraph6detail15default_epsilonEdv)
, [\[2\]](../api_docs/cugraph_cpp/full_api/#_CPPv4IEN7cugraph6detail15default_epsilonEfv)
* [cugraph::detail::device\_allgather\_impl (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail21device_allgather_implENSt11enable_if_tIN6thrust6detail19is_discard_iteratorI14OutputIteratorE5valueEvEERKN4raft5comms7comms_tE13InputIterator14OutputIterator6size_tN3rmm16cuda_stream_viewE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail21device_allgather_implENSt11enable_if_tINSt13is_arithmeticINSt15iterator_traitsI14OutputIteratorE10value_typeEE5valueEvEERKN4raft5comms7comms_tE13InputIterator14OutputIterator6size_tN3rmm16cuda_stream_viewE)
* [cugraph::detail::device\_allgather\_tuple\_iterator\_element\_impl (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_6size_t_6size_tEN7cugraph6detail44device_allgather_tuple_iterator_element_implE)
* [cugraph::detail::device\_allgather\_tuple\_iterator\_element\_impl (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_6size_tEN7cugraph6detail44device_allgather_tuple_iterator_element_implI13InputIterator14OutputIterator1I1IEE)
* [cugraph::detail::device\_allgatherv\_impl (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail22device_allgatherv_implENSt11enable_if_tIN6thrust6detail19is_discard_iteratorI14OutputIteratorE5valueEvEERKN4raft5comms7comms_tE13InputIterator14OutputIteratorRKNSt6vectorI6size_tEERKNSt6vectorI6size_tEEN3rmm16cuda_stream_viewE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail22device_allgatherv_implENSt11enable_if_tINSt13is_arithmeticINSt15iterator_traitsI14OutputIteratorE10value_typeEE5valueEvEERKN4raft5comms7comms_tE13InputIterator14OutputIteratorRKNSt6vectorI6size_tEERKNSt6vectorI6size_tEEN3rmm16cuda_stream_viewE)
* [cugraph::detail::device\_allgatherv\_tuple\_iterator\_element\_impl (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_6size_t_6size_tEN7cugraph6detail45device_allgatherv_tuple_iterator_element_implE)
* [cugraph::detail::device\_allgatherv\_tuple\_iterator\_element\_impl (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_6size_tEN7cugraph6detail45device_allgatherv_tuple_iterator_element_implI13InputIterator14OutputIterator1I1IEE)
* [cugraph::detail::device\_allreduce\_impl (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail21device_allreduce_implENSt11enable_if_tIN6thrust6detail19is_discard_iteratorI14OutputIteratorE5valueEvEERKN4raft5comms7comms_tE13InputIterator14OutputIterator6size_tN4raft5comms4op_tEN3rmm16cuda_stream_viewE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail21device_allreduce_implENSt11enable_if_tINSt13is_arithmeticINSt15iterator_traitsI14OutputIteratorE10value_typeEE5valueEvEERKN4raft5comms7comms_tE13InputIterator14OutputIterator6size_tN4raft5comms4op_tEN3rmm16cuda_stream_viewE)
* [cugraph::detail::device\_allreduce\_tuple\_iterator\_element\_impl (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_6size_t_6size_tEN7cugraph6detail44device_allreduce_tuple_iterator_element_implE)
* [cugraph::detail::device\_allreduce\_tuple\_iterator\_element\_impl (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_6size_tEN7cugraph6detail44device_allreduce_tuple_iterator_element_implI13InputIterator14OutputIterator1I1IEE)
* [cugraph::detail::device\_bcast\_impl (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail17device_bcast_implENSt11enable_if_tIN6thrust6detail19is_discard_iteratorI14OutputIteratorE5valueEvEERKN4raft5comms7comms_tE13InputIterator14OutputIterator6size_tiN3rmm16cuda_stream_viewE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail17device_bcast_implENSt11enable_if_tINSt13is_arithmeticINSt15iterator_traitsI14OutputIteratorE10value_typeEE5valueEvEERKN4raft5comms7comms_tE13InputIterator14OutputIterator6size_tiN3rmm16cuda_stream_viewE)
* [cugraph::detail::device\_bcast\_tuple\_iterator\_element\_impl (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_6size_t_6size_tEN7cugraph6detail40device_bcast_tuple_iterator_element_implE)
* [cugraph::detail::device\_bcast\_tuple\_iterator\_element\_impl (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_6size_tEN7cugraph6detail40device_bcast_tuple_iterator_element_implI13InputIterator14OutputIterator1I1IEE)
* [cugraph::detail::device\_gatherv\_impl (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail19device_gatherv_implENSt11enable_if_tIN6thrust6detail19is_discard_iteratorI14OutputIteratorE5valueEvEERKN4raft5comms7comms_tE13InputIterator14OutputIterator6size_tRKNSt6vectorI6size_tEERKNSt6vectorI6size_tEEiN3rmm16cuda_stream_viewE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail19device_gatherv_implENSt11enable_if_tINSt13is_arithmeticINSt15iterator_traitsI14OutputIteratorE10value_typeEE5valueEvEERKN4raft5comms7comms_tE13InputIterator14OutputIterator6size_tRKNSt6vectorI6size_tEERKNSt6vectorI6size_tEEiN3rmm16cuda_stream_viewE)
* [cugraph::detail::device\_gatherv\_tuple\_iterator\_element\_impl (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_6size_t_6size_tEN7cugraph6detail42device_gatherv_tuple_iterator_element_implE)
* [cugraph::detail::device\_gatherv\_tuple\_iterator\_element\_impl (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_6size_tEN7cugraph6detail42device_gatherv_tuple_iterator_element_implI13InputIterator14OutputIterator1I1IEE)
* [cugraph::detail::device\_irecv\_impl (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail17device_irecv_implENSt11enable_if_tIN6thrust6detail19is_discard_iteratorI14OutputIteratorE5valueEvEERKN4raft5comms7comms_tE14OutputIterator6size_tiiPN4raft5comms9request_tE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail17device_irecv_implENSt11enable_if_tINSt13is_arithmeticINSt15iterator_traitsI14OutputIteratorE10value_typeEE5valueEvEERKN4raft5comms7comms_tE14OutputIterator6size_tiiPN4raft5comms9request_tE)
* [cugraph::detail::device\_irecv\_tuple\_iterator\_element\_impl (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_6size_t_6size_tEN7cugraph6detail40device_irecv_tuple_iterator_element_implE)
* [cugraph::detail::device\_irecv\_tuple\_iterator\_element\_impl (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_6size_tEN7cugraph6detail40device_irecv_tuple_iterator_element_implI13InputIterator14OutputIterator1I1IEE)
* [cugraph::detail::device\_isend\_impl (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail17device_isend_implENSt11enable_if_tINSt13is_arithmeticI15OutputValueTypeE5valueEvEERKN4raft5comms7comms_tE13InputIterator6size_tiiPN4raft5comms9request_tE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail17device_isend_implENSt11enable_if_tINSt9is_same_vI15OutputValueTypeN6thrust6detail10any_assignEEEvEERKN4raft5comms7comms_tE13InputIterator6size_tiiPN4raft5comms9request_tE)
* [cugraph::detail::device\_isend\_tuple\_iterator\_element\_impl (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_6size_t_6size_tEN7cugraph6detail40device_isend_tuple_iterator_element_implE)
* [cugraph::detail::device\_isend\_tuple\_iterator\_element\_impl (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_6size_tEN7cugraph6detail40device_isend_tuple_iterator_element_implI13InputIterator14OutputIterator1I1IEE)
* [cugraph::detail::device\_multicast\_sendrecv\_impl (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail30device_multicast_sendrecv_implENSt11enable_if_tIN6thrust6detail19is_discard_iteratorI14OutputIteratorE5valueEvEERKN4raft5comms7comms_tE13InputIteratorRKNSt6vectorI6size_tEERKNSt6vectorI6size_tEERKNSt6vectorIiEE14OutputIteratorRKNSt6vectorI6size_tEERKNSt6vectorI6size_tEERKNSt6vectorIiEEN3rmm16cuda_stream_viewE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail30device_multicast_sendrecv_implENSt11enable_if_tINSt13is_arithmeticINSt15iterator_traitsI14OutputIteratorE10value_typeEE5valueEvEERKN4raft5comms7comms_tE13InputIteratorRKNSt6vectorI6size_tEERKNSt6vectorI6size_tEERKNSt6vectorIiEE14OutputIteratorRKNSt6vectorI6size_tEERKNSt6vectorI6size_tEERKNSt6vectorIiEEN3rmm16cuda_stream_viewE)
* [cugraph::detail::device\_multicast\_sendrecv\_tuple\_iterator\_element\_impl (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_6size_t_6size_tEN7cugraph6detail53device_multicast_sendrecv_tuple_iterator_element_implE)
* [cugraph::detail::device\_multicast\_sendrecv\_tuple\_iterator\_element\_impl (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_6size_tEN7cugraph6detail53device_multicast_sendrecv_tuple_iterator_element_implI13InputIterator14OutputIterator1I1IEE)
* [cugraph::detail::device\_reduce\_impl (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail18device_reduce_implENSt11enable_if_tIN6thrust6detail19is_discard_iteratorI14OutputIteratorE5valueEvEERKN4raft5comms7comms_tE13InputIterator14OutputIterator6size_tN4raft5comms4op_tEiN3rmm16cuda_stream_viewE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail18device_reduce_implENSt11enable_if_tINSt13is_arithmeticINSt15iterator_traitsI14OutputIteratorE10value_typeEE5valueEvEERKN4raft5comms7comms_tE13InputIterator14OutputIterator6size_tN4raft5comms4op_tEiN3rmm16cuda_stream_viewE)
* [cugraph::detail::device\_reduce\_tuple\_iterator\_element\_impl (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_6size_t_6size_tEN7cugraph6detail41device_reduce_tuple_iterator_element_implE)
* [cugraph::detail::device\_reduce\_tuple\_iterator\_element\_impl (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_6size_tEN7cugraph6detail41device_reduce_tuple_iterator_element_implI13InputIterator14OutputIterator1I1IEE)
* [cugraph::detail::device\_sendrecv\_impl (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail20device_sendrecv_implENSt11enable_if_tIN6thrust6detail19is_discard_iteratorI14OutputIteratorE5valueEvEERKN4raft5comms7comms_tE13InputIterator6size_ti14OutputIterator6size_tiN3rmm16cuda_stream_viewE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail20device_sendrecv_implENSt11enable_if_tINSt13is_arithmeticINSt15iterator_traitsI14OutputIteratorE10value_typeEE5valueEvEERKN4raft5comms7comms_tE13InputIterator6size_ti14OutputIterator6size_tiN3rmm16cuda_stream_viewE)
* [cugraph::detail::device\_sendrecv\_tuple\_iterator\_element\_impl (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_6size_t_6size_tEN7cugraph6detail43device_sendrecv_tuple_iterator_element_implE)
* [cugraph::detail::device\_sendrecv\_tuple\_iterator\_element\_impl (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_6size_tEN7cugraph6detail43device_sendrecv_tuple_iterator_element_implI13InputIterator14OutputIterator1I1IEE)
* [cugraph::detail::diff (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail4diffE)
* [cugraph::detail::divider\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail9divider_tE)
* [cugraph::detail::ecg (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000_bEN7cugraph6detail3ecgENSt5tupleIN3rmm14device_uvectorI8vertex_tEE6size_t8weight_tEERKN4raft8handle_tERN4raft6random8RngStateERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEE8weight_t6size_t6size_t8weight_t8weight_t)
* [cugraph::detail::edge\_betweenness\_centrality (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000_b0EN7cugraph6detail27edge_betweenness_centralityE15edge_property_tI12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuE8weight_tERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEE14VertexIterator14VertexIteratorKbKb)
* [cugraph::detail::edge\_endpoint\_dummy\_property\_view\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail35edge_endpoint_dummy_property_view_tE)
* [cugraph::detail::edge\_major\_property\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail21edge_major_property_tE)
* [cugraph::detail::edge\_major\_property\_view\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail26edge_major_property_view_tE)
* [cugraph::detail::edge\_minor\_property\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail21edge_minor_property_tE)
* [cugraph::detail::edge\_minor\_property\_view\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail26edge_minor_property_view_tE)
* [cugraph::detail::edge\_op\_result\_type (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000000EN7cugraph6detail19edge_op_result_typeE)
* [cugraph::detail::edge\_op\_result\_type>> (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000000EN7cugraph6detail19edge_op_result_typeI5key_t8vertex_t11src_value_t11dst_value_t9e_value_t6EdgeOpNSt11enable_if_tINSt14is_invocable_vI6EdgeOp5key_t8vertex_t11src_value_t11dst_value_t9e_value_tEEEEEE)
* [cugraph::detail::edge\_partition\_device\_view\_base\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail33edge_partition_device_view_base_tE)
* [cugraph::detail::edge\_partition\_edge\_dummy\_property\_device\_view\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail48edge_partition_edge_dummy_property_device_view_tE)
* [cugraph::detail::edge\_partition\_edge\_property\_device\_view\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail42edge_partition_edge_property_device_view_tE)
* [cugraph::detail::edge\_partition\_endpoint\_dummy\_property\_device\_view\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail52edge_partition_endpoint_dummy_property_device_view_tE)
* [cugraph::detail::edge\_partition\_endpoint\_property\_device\_view\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail46edge_partition_endpoint_property_device_view_tE)
* [cugraph::detail::edge\_partition\_src\_dst\_property\_values\_kv\_pair\_fill\_ratio\_threshold (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail67edge_partition_src_dst_property_values_kv_pair_fill_ratio_thresholdE)
* [cugraph::detail::edge\_partition\_view\_base\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail26edge_partition_view_base_tE)
* [cugraph::detail::edge\_triangle\_count\_impl (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_b_bEN7cugraph6detail24edge_triangle_count_implE15edge_property_tI12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuE6edge_tERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuEb)
* [cugraph::detail::eigenvector\_centrality (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000_bEN7cugraph6detail22eigenvector_centralityEN3rmm14device_uvectorI8weight_tEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL1EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEENSt8optionalIN4raft11device_spanIK8weight_tEEEE8weight_t6size_tb)
* [cugraph::detail::exact\_fa2 (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail9exact_fa2EvRKN4raft8handle_tERN6legacy12GraphCOOViewI8vertex_t6edge_t8weight_tEEPfKiPfPfbbbKfKfKfbKfbPN9internals24GraphBasedDimRedCallbackE)
* [cugraph::detail::expand\_sparse\_offsets (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail21expand_sparse_offsetsEN3rmm14device_uvectorI5idx_tEEN4raft11device_spanIK8offset_tEE5idx_tN3rmm16cuda_stream_viewE)
* [cugraph::detail::expensive\_check\_edgelist (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_bEN7cugraph6detail24expensive_check_edgelistEvRKN4raft8handle_tERKNSt8optionalIN3rmm14device_uvectorI8vertex_tEEEERKNSt6vectorIPK8vertex_tEERKNSt6vectorIPK8vertex_tEERKNSt6vectorI6edge_tEERKNSt8optionalINSt6vectorINSt6vectorI6edge_tEEEEEE)
* [cugraph::detail::extract\_p\_r\_q\_r (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail15extract_p_r_q_rE)
* [cugraph::detail::extract\_q\_r (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail11extract_q_rE)
* [cugraph::detail::extract\_transform\_v\_frontier\_e (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I_b00000000EN7cugraph6detail30extract_transform_v_frontier_eENSt5tupleI32optional_dataframe_buffer_type_tI10OutputKeyTE32optional_dataframe_buffer_type_tI12OutputValueTEEERKN4raft8handle_tERK13GraphViewTypeRK13KeyBucketType24EdgeSrcValueInputWrapper24EdgeDstValueInputWrapper21EdgeValueInputWrapper6EdgeOpb)
* [cugraph::detail::extract\_transform\_v\_frontier\_e\_edge\_partition (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000000000EN7cugraph6detail45extract_transform_v_frontier_e_edge_partitionEvRKN4raft8handle_tE28edge_partition_device_view_tIN13GraphViewType11vertex_typeEN13GraphViewType9edge_typeEN13GraphViewType12is_multi_gpuEE16InputKeyIterator16InputKeyIterator33EdgePartitionSrcValueInputWrapper33EdgePartitionDstValueInputWrapper30EdgePartitionValueInputWrapperN4cudaSt8optionalI28EdgePartitionEdgeMaskWrapperEE25OptionalOutputKeyIterator27OptionalOutputValueIteratorN4raft11device_spanI6size_tEE6EdgeOpNSt8optionalIN4raft11device_spanIK6size_tEEEENSt8optionalI6size_tEENSt8optionalIN4raft9host_spanIK6size_tEEEERKNSt8optionalIN4raft9host_spanIK6size_tEEEE)
* [cugraph::detail::extract\_transform\_v\_frontier\_e\_kernel\_block\_size (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail48extract_transform_v_frontier_e_kernel_block_sizeE)
* [cugraph::detail::fill\_edge\_major\_property (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000EN7cugraph6detail24fill_edge_major_propertyEvRKN4raft8handle_tERK13GraphViewType14VertexIterator14VertexIterator30EdgeMajorPropertyOutputWrapper1T)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail24fill_edge_major_propertyEvRKN4raft8handle_tERK13GraphViewType30EdgeMajorPropertyOutputWrapper1T)
* [cugraph::detail::fill\_edge\_minor\_property (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000EN7cugraph6detail24fill_edge_minor_propertyEvRKN4raft8handle_tERK13GraphViewType14VertexIterator14VertexIterator30EdgeMinorPropertyOutputWrapper1T)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail24fill_edge_minor_propertyEvRKN4raft8handle_tERK13GraphViewType30EdgeMinorPropertyOutputWrapper1T)
* [cugraph::detail::fill\_edge\_property (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail18fill_edge_propertyEvRKN4raft8handle_tERK13GraphViewType25EdgePropertyOutputWrapper1T)
* [cugraph::detail::fill\_offset (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail11fill_offsetEvP2VTP2ET2VT2ETN3rmm16cuda_stream_viewE)
* [cugraph::detail::filter\_buffer\_elements (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail22filter_buffer_elementsENSt5tupleIN3rmm14device_uvectorI8vertex_tEE32optional_dataframe_buffer_type_tI9payload_tEEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEERR32optional_dataframe_buffer_type_tI9payload_tEN4raft11device_spanIK8vertex_tEE8vertex_ti)
* [cugraph::detail::find\_locally\_unused\_ext\_vertex\_id (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail33find_locally_unused_ext_vertex_idENSt8optionalI8vertex_tEERKN4raft8handle_tEN4raft11device_spanIK8vertex_tEEb)
* [cugraph::detail::find\_nth\_valid\_nbr\_idx\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail24find_nth_valid_nbr_idx_tE)
* [cugraph::detail::find\_unused\_id\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail16find_unused_id_tE)
* [cugraph::detail::flatten\_dendrogram (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_bEN7cugraph6detail18flatten_dendrogramEvRKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuERK10DendrogramI8vertex_tEP8vertex_t)
* [cugraph::detail::flatten\_label\_map (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail17flatten_label_mapEN3rmm14device_uvectorI7int32_tEERKN4raft8handle_tENSt5tupleIN4raft11device_spanIK7label_tEEN4raft11device_spanIK7int32_tEEEE)
* [cugraph::detail::flatten\_leiden\_dendrogram (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_bEN7cugraph6detail25flatten_leiden_dendrogramEvRKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuERK10DendrogramI8vertex_tEP8vertex_t)
* [cugraph::detail::gather\_one\_hop\_edgelist (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000000_bEN7cugraph6detail23gather_one_hop_edgelistENSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI6edge_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEENSt8optionalIN3rmm14device_uvectorI7label_tEEEEEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEENSt8optionalI20edge_property_view_tI6edge_tPK6edge_tEEENSt8optionalI20edge_property_view_tI6edge_tPK11edge_type_tEEERKN7cugraph17vertex_frontier_tI8vertex_t5tag_t9multi_gpuXL0EEEEb)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00000_bEN7cugraph6detail23gather_one_hop_edgelistENSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI6edge_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEENSt8optionalIN3rmm14device_uvectorI7label_tEEEEEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEENSt8optionalI20edge_property_view_tI6edge_tPK6edge_tEEENSt8optionalI20edge_property_view_tI6edge_tPK11edge_type_tEEEN4raft11device_spanIK8vertex_tEENSt8optionalIN4raft11device_spanIK7label_tEEEEb)
* [cugraph::detail::gatherv\_indices\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000EN7cugraph6detail17gatherv_indices_tE)
* [cugraph::detail::get\_dataframe\_buffer\_begin\_tuple\_impl (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_DpNSt6size_tEEN7cugraph6detail37get_dataframe_buffer_begin_tuple_implEDaNSt14index_sequenceIDp2IsEER9TupleType)
* [cugraph::detail::get\_dataframe\_buffer\_cbegin\_tuple\_impl (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_Dp6size_tEN7cugraph6detail38get_dataframe_buffer_cbegin_tuple_implEDaNSt14index_sequenceIDp2IsEER9TupleType)
* [cugraph::detail::get\_dataframe\_buffer\_cend\_tuple\_impl (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_DpNSt6size_tEEN7cugraph6detail36get_dataframe_buffer_cend_tuple_implEDaNSt14index_sequenceIDp2IsEER9TupleType)
* [cugraph::detail::get\_dataframe\_buffer\_end\_tuple\_impl (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_DpNSt6size_tEEN7cugraph6detail35get_dataframe_buffer_end_tuple_implEDaNSt14index_sequenceIDp2IsEER9TupleType)
* [cugraph::detail::get\_optional\_dataframe\_buffer\_begin (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail35get_optional_dataframe_buffer_beginEDaR32optional_dataframe_buffer_type_tI1TE)
* [cugraph::detail::get\_optional\_dataframe\_buffer\_cbegin (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail36get_optional_dataframe_buffer_cbeginEDaRK32optional_dataframe_buffer_type_tI1TE)
* [cugraph::detail::get\_optional\_dataframe\_buffer\_cend (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail34get_optional_dataframe_buffer_cendEDaRK32optional_dataframe_buffer_type_tI1TE)
* [cugraph::detail::get\_optional\_dataframe\_buffer\_end (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail33get_optional_dataframe_buffer_endEDaR32optional_dataframe_buffer_type_tI1TE)
* [cugraph::detail::get\_traversed\_cost\_impl (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail23get_traversed_cost_implEvRKN4raft8handle_tEPK8vertex_tPK8vertex_tPK8weight_tP8weight_t8vertex_t8vertex_t)
* [cugraph::detail::getMultiProcessorCount (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail22getMultiProcessorCountEv)
* [cugraph::detail::graph\_base\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail12graph_base_tE)
* [cugraph::detail::graph\_contraction (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000_bEN7cugraph6detail17graph_contractionENSt5tupleI7graph_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuE8weight_tEEEEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEEN4raft11device_spanI8vertex_tEE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I000_bEN7cugraph6detail17graph_contractionENSt5tupleIN7cugraph7graph_tI8vertex_t6edge_tXL0EE9multi_gpuEENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuE8weight_tEEEEERKN4raft8handle_tERKN7cugraph12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuEENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEEN4raft11device_spanI8vertex_tEE)
* [cugraph::detail::group\_multi\_edges (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail17group_multi_edgesENSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEE23dataframe_buffer_type_tI12edge_value_tEEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEERR23dataframe_buffer_type_tI12edge_value_tE6size_tb)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail17group_multi_edgesENSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEE6size_t)
* [cugraph::detail::has\_packed\_bool\_element (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_DpNSt6size_tEEN7cugraph6detail23has_packed_bool_elementENSt11enable_if_tIXaaN7cugraph29is_thrust_tuple_of_arithmeticIN6thrust15iterator_traitsI13ValueIteratorE10value_typeEE5valueEN7cugraph29is_thrust_tuple_of_arithmeticI7value_tE5valueEEbEENSt14index_sequenceIDp2IsEE)
* [cugraph::detail::hash\_src\_dst\_pair (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail17hash_src_dst_pairE)
* [cugraph::detail::heterogeneous\_biased\_sample\_and\_compute\_local\_nbr\_indices (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000000EN7cugraph6detail57heterogeneous_biased_sample_and_compute_local_nbr_indicesENSt5tupleIN3rmm14device_uvectorIN13GraphViewType9edge_typeEEENSt8optionalIN3rmm14device_uvectorI6size_tEEEENSt6vectorI6size_tEEEERKN4raft8handle_tERK13GraphViewType11KeyIterator24EdgeSrcValueInputWrapper24EdgeDstValueInputWrapper21EdgeValueInputWrapper10BiasEdgeOp20EdgeTypeInputWrapperN4raft9host_spanIK6size_tEERN4raft6random8RngStateEN4raft9host_spanIK6size_tEEbb)
* [cugraph::detail::heterogeneous\_biased\_sample\_without\_replacement (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000_bEN7cugraph6detail47heterogeneous_biased_sample_without_replacementENSt5tupleIN3rmm14device_uvectorI6edge_tEENSt8optionalIN3rmm14device_uvectorI6size_tEEEENSt6vectorI6size_tEEEERKN4raft8handle_tEN4raft11device_spanIK6size_tEEN4raft9host_spanIK6size_tEEN4raft11device_spanIK6bias_tEEN4raft11device_spanIK6size_tEEN4raft9host_spanIK6size_tEERN4raft6random8RngStateEN4raft9host_spanIK6size_tEE)
* [cugraph::detail::heterogeneous\_uniform\_sample\_and\_compute\_local\_nbr\_indices (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail58heterogeneous_uniform_sample_and_compute_local_nbr_indicesENSt5tupleIN3rmm14device_uvectorIN13GraphViewType9edge_typeEEENSt8optionalIN3rmm14device_uvectorI6size_tEEEENSt6vectorI6size_tEEEERKN4raft8handle_tERK13GraphViewType11KeyIterator20EdgeTypeInputWrapperN4raft9host_spanIK6size_tEERN4raft6random8RngStateEN4raft9host_spanIK6size_tEEb)
* [cugraph::detail::hits (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail4hitsENSt5tupleI8result_t6size_tEERKN4raft8handle_tERK13GraphViewTypePC8result_tPC8result_t8result_t6size_tbbb)
* [cugraph::detail::homogeneous\_biased\_sample\_and\_compute\_local\_nbr\_indices (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000000EN7cugraph6detail55homogeneous_biased_sample_and_compute_local_nbr_indicesENSt5tupleIN3rmm14device_uvectorIN13GraphViewType9edge_typeEEENSt8optionalIN3rmm14device_uvectorI6size_tEEEENSt6vectorI6size_tEEEERKN4raft8handle_tERK13GraphViewType11KeyIterator24EdgeSrcValueInputWrapper24EdgeDstValueInputWrapper21EdgeValueInputWrapper10BiasEdgeOpN4raft9host_spanIK6size_tEERN4raft6random8RngStateE6size_tbb)
* [cugraph::detail::homogeneous\_biased\_sample\_without\_replacement (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_bEN7cugraph6detail45homogeneous_biased_sample_without_replacementENSt5tupleIN3rmm14device_uvectorI6edge_tEENSt8optionalIN3rmm14device_uvectorI6size_tEEEENSt6vectorI6size_tEEEERKN4raft8handle_tEN4raft11device_spanIK6size_tEEN4raft9host_spanIK6size_tEEN4raft11device_spanIK6bias_tEEN4raft11device_spanIK6size_tEEN4raft9host_spanIK6size_tEERN4raft6random8RngStateE6size_t)
* [cugraph::detail::homogeneous\_uniform\_sample\_and\_compute\_local\_nbr\_indices (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail56homogeneous_uniform_sample_and_compute_local_nbr_indicesENSt5tupleIN3rmm14device_uvectorIN13GraphViewType9edge_typeEEENSt8optionalIN3rmm14device_uvectorI6size_tEEEENSt6vectorI6size_tEEEERKN4raft8handle_tERK13GraphViewType11KeyIteratorN4raft9host_spanIK6size_tEERN4raft6random8RngStateE6size_tb)
* [cugraph::detail::host\_allreduce\_tuple\_scalar\_element\_impl (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_6size_t_6size_tEN7cugraph6detail40host_allreduce_tuple_scalar_element_implE)
* [cugraph::detail::host\_allreduce\_tuple\_scalar\_element\_impl (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_6size_tEN7cugraph6detail40host_allreduce_tuple_scalar_element_implI9TupleType1I1IEE)
* [cugraph::detail::host\_reduce\_tuple\_scalar\_element\_impl (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_6size_t_6size_tEN7cugraph6detail37host_reduce_tuple_scalar_element_implE)
* [cugraph::detail::host\_reduce\_tuple\_scalar\_element\_impl (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_6size_tEN7cugraph6detail37host_reduce_tuple_scalar_element_implI9TupleType1I1IEE)
* [cugraph::detail::hungarian (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail9hungarianE8weight_tRKN4raft8handle_tE7index_t7index_tPK8weight_tP7index_t8weight_t)
* [cugraph::detail::hungarian\_sparse (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail16hungarian_sparseE8weight_tRKN4raft8handle_tERKN6legacy12GraphCOOViewI8vertex_t6edge_t8weight_tEE8vertex_tPK8vertex_tP8vertex_t8weight_t)
* [cugraph::detail::hypersparse\_threshold\_ratio (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail27hypersparse_threshold_ratioE)
* [cugraph::detail::i (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail1iE)
* [cugraph::detail::inc (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail3incE)
* [cugraph::detail::indirection\_compare\_less\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail26indirection_compare_less_tE)
* [cugraph::detail::indirection\_if\_idx\_valid\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail26indirection_if_idx_valid_tE)
* [cugraph::detail::indirection\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail13indirection_tE)
* [cugraph::detail::induced\_subgraph\_unweighted\_edge\_op (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail35induced_subgraph_unweighted_edge_opE)
* [cugraph::detail::induced\_subgraph\_weighted\_edge\_op (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail33induced_subgraph_weighted_edge_opE)
* [cugraph::detail::init\_pred\_op (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000000EN7cugraph6detail12init_pred_opE10__device__RK28edge_partition_device_view_tIN13GraphViewType11vertex_typeEN13GraphViewType9edge_typeEN13GraphViewType12is_multi_gpuEERK33EdgePartitionSrcValueInputWrapperRK33EdgePartitionDstValueInputWrapperRK34EdgePartitionEdgeValueInputWrapperRK6PredOp5key_tN13GraphViewType11vertex_typeEPKN13GraphViewType11vertex_typeEN13GraphViewType9edge_typeE)
* [cugraph::detail::init\_stream\_pool\_indices (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail24init_stream_pool_indicesE6size_t6size_t6size_t6size_t6size_t)
* [cugraph::detail::intersection\_op\_result\_type (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00000EN7cugraph6detail27intersection_op_result_typeE)
* [cugraph::detail::intersection\_op\_result\_type>>> (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000EN7cugraph6detail27intersection_op_result_typeI8vertex_t11src_value_t11dst_value_t14IntersectionOpNSt11enable_if_tINSt14is_invocable_vI14IntersectionOp8vertex_t8vertex_t11src_value_t11dst_value_tN4raft11device_spanIK8vertex_tEEEEEEEE)
* [cugraph::detail::invalidate\_if\_not\_first\_in\_run\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail32invalidate_if_not_first_in_run_tE)
* [cugraph::detail::is\_equal\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail10is_equal_tE)
* [cugraph::detail::is\_first\_in\_run\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail17is_first_in_run_tE)
* [cugraph::detail::is\_invalid\_input\_vertex\_pair\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail30is_invalid_input_vertex_pair_tE)
* [cugraph::detail::is\_not\_equal\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail14is_not_equal_tE)
* [cugraph::detail::is\_thrust\_tuple\_of\_arithemetic\_impl (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_6size_t_6size_tEN7cugraph6detail35is_thrust_tuple_of_arithemetic_implE)
* [cugraph::detail::is\_thrust\_tuple\_of\_arithemetic\_impl (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_6size_tEN7cugraph6detail35is_thrust_tuple_of_arithemetic_implI9TupleType1I1IEE)
* [cugraph::detail::is\_valid\_vertex\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail17is_valid_vertex_tE)
* [cugraph::detail::iter\_to\_raw\_ptr (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail15iter_to_raw_ptrEDaN6thrust6detail15normal_iteratorIN6thrust10device_ptrI1TEEEE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail15iter_to_raw_ptrEP1TN6thrust10device_ptrI1TEE)
, [\[2\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail15iter_to_raw_ptrEP1TP1T)
* [cugraph::detail::iterator\_value\_type\_or\_default\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail32iterator_value_type_or_default_tE)
* [cugraph::detail::iterator\_value\_type\_or\_default\_t>> (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail32iterator_value_type_or_default_tI8Iterator9default_tNSt11enable_if_tIXntNSt9is_same_vI8IteratorPvEEEEEEE)
* [cugraph::detail::iterator\_value\_type\_or\_default\_t>> (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail32iterator_value_type_or_default_tI8Iterator9default_tNSt11enable_if_tINSt9is_same_vI8IteratorPvEEEEEE)
* [cugraph::detail::j (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail1jE)
* [cugraph::detail::jaccard\_functor\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail17jaccard_functor_tE)
* [cugraph::detail::k (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail1kE)
* [cugraph::detail::k\_hop\_nbrs (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail10k_hop_nbrsENSt5tupleIN3rmm14device_uvectorI6size_tEEN3rmm14device_uvectorIN13GraphViewType11vertex_typeEEEEERKN4raft8handle_tERK13GraphViewTypeN4raft11device_spanIKN13GraphViewType11vertex_typeEEE6size_tb)
* [cugraph::detail::katz\_centrality (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail15katz_centralityEvRKN4raft8handle_tERK13GraphViewTypeNSt8optionalI20edge_property_view_tIN13GraphViewType9edge_typeEPK8weight_tEEEPK8result_tP8result_t8result_t8result_t8result_t6size_tbbb)
* [cugraph::detail::keep\_flagged\_elements (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail21keep_flagged_elementsEN3rmm14device_uvectorI1TEERKN4raft8handle_tERRN3rmm14device_uvectorI1TEEN4raft11device_spanIK8uint32_tEE6size_t)
* [cugraph::detail::key\_aggregated\_edge\_op\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail24key_aggregated_edge_op_tE)
* [cugraph::detail::key\_binary\_search\_contains\_op\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail31key_binary_search_contains_op_tE)
* [cugraph::detail::key\_binary\_search\_store\_device\_view\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail37key_binary_search_store_device_view_tE)
* [cugraph::detail::key\_binary\_search\_store\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail25key_binary_search_store_tE)
* [cugraph::detail::key\_binary\_search\_store\_view\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail30key_binary_search_store_view_tE)
* [cugraph::detail::key\_cuco\_store\_contains\_device\_view\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail37key_cuco_store_contains_device_view_tE)
* [cugraph::detail::key\_cuco\_store\_insert\_device\_view\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail35key_cuco_store_insert_device_view_tE)
* [cugraph::detail::key\_cuco\_store\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail16key_cuco_store_tE)
* [cugraph::detail::key\_cuco\_store\_view\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail21key_cuco_store_view_tE)
* [cugraph::detail::key\_group\_id\_less\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail19key_group_id_less_tE)
* [cugraph::detail::kv\_binary\_search\_contains\_op\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail30kv_binary_search_contains_op_tE)
* [cugraph::detail::kv\_binary\_search\_find\_op\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail26kv_binary_search_find_op_tE)
* [cugraph::detail::kv\_binary\_search\_store\_device\_view\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail36kv_binary_search_store_device_view_tE)
* [cugraph::detail::kv\_binary\_search\_store\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail24kv_binary_search_store_tE)
* [cugraph::detail::kv\_binary\_search\_store\_view\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail29kv_binary_search_store_view_tE)
* [cugraph::detail::kv\_cuco\_insert\_and\_assign\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail27kv_cuco_insert_and_assign_tE)
* [cugraph::detail::kv\_cuco\_insert\_and\_increment\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail30kv_cuco_insert_and_increment_tE)
* [cugraph::detail::kv\_cuco\_insert\_if\_and\_increment\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000EN7cugraph6detail33kv_cuco_insert_if_and_increment_tE)
* [cugraph::detail::kv\_cuco\_store\_find\_device\_view\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail32kv_cuco_store_find_device_view_tE)
* [cugraph::detail::kv\_cuco\_store\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail15kv_cuco_store_tE)
* [cugraph::detail::kv\_cuco\_store\_view\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail20kv_cuco_store_view_tE)
* [cugraph::detail::kv\_pair\_group\_id\_greater\_equal\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail32kv_pair_group_id_greater_equal_tE)
* [cugraph::detail::kv\_pair\_group\_id\_less\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail23kv_pair_group_id_less_tE)
* [cugraph::detail::leiden (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000_b_bEN7cugraph6detail6leidenENSt4pairINSt10unique_ptrI10DendrogramI8vertex_tEEE8weight_tEERKN4raft8handle_tERN4raft6random8RngStateERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEE6size_t8weight_t8weight_t)
* [cugraph::detail::leiden\_key\_aggregated\_edge\_op\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail31leiden_key_aggregated_edge_op_tE)
* [cugraph::detail::local\_degree\_op\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000_b_bEN7cugraph6detail17local_degree_op_tE)
* [cugraph::detail::local\_degree\_with\_mask\_op\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000_b_b0EN7cugraph6detail27local_degree_with_mask_op_tE)
* [cugraph::detail::localmaxdepth (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail13localmaxdepthE)
* [cugraph::detail::locked (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail6lockedE)
* [cugraph::detail::lookup\_endpoints\_from\_edge\_ids\_and\_single\_type (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000_bEN7cugraph6detail46lookup_endpoints_from_edge_ids_and_single_typeENSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEERKN4raft8handle_tERK40EdgeTypeAndIdToSrcDstLookupContainerTypeN4raft11device_spanIK9edge_id_tEE11edge_type_t)
* [cugraph::detail::lookup\_endpoints\_from\_edge\_ids\_and\_types (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000_bEN7cugraph6detail40lookup_endpoints_from_edge_ids_and_typesENSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEERKN4raft8handle_tERK40EdgeTypeAndIdToSrcDstLookupContainerTypeN4raft11device_spanIK9edge_id_tEEN4raft11device_spanIK11edge_type_tEE)
* [cugraph::detail::louvain (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000_bEN7cugraph6detail7louvainENSt4pairINSt10unique_ptrI10DendrogramI8vertex_tEEE8weight_tEERKN4raft8handle_tENSt8optionalINSt17reference_wrapperIN4raft6random8RngStateEEEEERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEE6size_t8weight_t8weight_t)
* [cugraph::detail::low\_degree\_threshold (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail20low_degree_thresholdE)
* [cugraph::detail::major\_to\_group\_idx\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail20major_to_group_idx_tE)
* [cugraph::detail::map\_index\_to\_path\_offset (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_bEN7cugraph6detail24map_index_to_path_offsetE)
* [cugraph::detail::mark\_entries (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail12mark_entriesENSt5tupleI6size_tN3rmm14device_uvectorI8uint32_tEEEERKN4raft8handle_tE6size_t12comparison_t)
* [cugraph::detail::MAX\_SIZE (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail8MAX_SIZEE)
* [cugraph::detail::max\_thrust\_tuple\_element\_sizes (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_DpNSt6size_tEEN7cugraph6detail30max_thrust_tuple_element_sizesE6size_tNSt14index_sequenceIDp2IsEE)
* [cugraph::detail::maximal\_independent\_moves (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_bEN7cugraph6detail25maximal_independent_movesEN3rmm14device_uvectorI8vertex_tEERKN4raft8handle_tERKN7cugraph12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuEERN4raft6random8RngStateE)
* [cugraph::detail::maximal\_independent\_set (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_bEN7cugraph6detail23maximal_independent_setEN3rmm14device_uvectorI8vertex_tEERKN4raft8handle_tERKN7cugraph12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuEERN4raft6random8RngStateE)
* [cugraph::detail::mem\_frugal\_groupby (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail18mem_frugal_groupbyEv11KeyIterator11KeyIterator13ValueIterator14KeyToGroupIdOpi6size_tN3rmm16cuda_stream_viewE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail18mem_frugal_groupbyEv13ValueIterator13ValueIterator16ValueToGroupIdOpi6size_tN3rmm16cuda_stream_viewE)
* [cugraph::detail::mem\_frugal\_partition (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail20mem_frugal_partitionENSt5tupleI11KeyIterator13ValueIteratorEE11KeyIterator11KeyIterator13ValueIterator14KeyToGroupIdOpiN3rmm16cuda_stream_viewE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail20mem_frugal_partitionE13ValueIterator13ValueIterator13ValueIterator16ValueToGroupIdOpiN3rmm16cuda_stream_viewE)
* [cugraph::detail::merge\_lower\_triangular (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail22merge_lower_triangularENSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI10property_tEEEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI10property_tEERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI10property_tEE6size_tb)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail22merge_lower_triangularENSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEE6size_tb)
* [cugraph::detail::mid\_degree\_threshold (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail20mid_degree_thresholdE)
* [cugraph::detail::min\_thrust\_tuple\_element\_sizes (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_DpNSt6size_tEEN7cugraph6detail30min_thrust_tuple_element_sizesE6size_tNSt14index_sequenceIDp2IsEE)
* [cugraph::detail::minor\_to\_key\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail14minor_to_key_tE)
* [cugraph::detail::mst\_impl (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail8mst_implENSt10unique_ptrIN6legacy8GraphCOOI8vertex_t6edge_t8weight_tEEEERKN4raft8handle_tERKN6legacy12GraphCSRViewI8vertex_t6edge_t8weight_tEEN3rmm25device_async_resource_refE)
* [cugraph::detail::multi\_partition (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail15multi_partitionEv11KeyIterator11KeyIterator13ValueIterator14KeyToGroupIdOpiiN3rmm16cuda_stream_viewE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail15multi_partitionEv13ValueIterator13ValueIterator16ValueToGroupIdOpiiN3rmm16cuda_stream_viewE)
* [cugraph::detail::multiplier\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail12multiplier_tE)
* [cugraph::detail::multiply\_and\_add\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail18multiply_and_add_tE)
* [cugraph::detail::n (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail1nE)
* [cugraph::detail::nbr\_intersection (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail16nbr_intersectionENSt13conditional_tIXntNSt9is_same_vIN22EdgeValueInputIterator10value_typeEN4cudaSt9nullopt_tEEEENSt5tupleIN3rmm14device_uvectorI6size_tEEN3rmm14device_uvectorIN13GraphViewType11vertex_typeEEEN3rmm14device_uvectorIN22EdgeValueInputIterator10value_typeEEEN3rmm14device_uvectorIN22EdgeValueInputIterator10value_typeEEEEENSt5tupleIN3rmm14device_uvectorI6size_tEEN3rmm14device_uvectorIN13GraphViewType11vertex_typeEEEEEEERKN4raft8handle_tERK13GraphViewType22EdgeValueInputIterator18VertexPairIterator18VertexPairIteratorNSt5arrayIbXL2EEEEb)
* [cugraph::detail::neighbor\_sample\_impl (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000000_b_bEN7cugraph6detail20neighbor_sample_implENSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI6edge_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEENSt8optionalIN3rmm14device_uvectorI7int32_tEEEENSt8optionalIN3rmm14device_uvectorI7label_tEEEENSt8optionalIN3rmm14device_uvectorI6size_tEEEEEERKN4raft8handle_tERN4raft6random8RngStateERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEENSt8optionalI20edge_property_view_tI6edge_tPK6edge_tEEENSt8optionalI20edge_property_view_tI6edge_tPK11edge_type_tEEENSt8optionalI20edge_property_view_tI6edge_tPK6bias_tEEEN4raft11device_spanIK8vertex_tEENSt8optionalIN4raft11device_spanIK7label_tEEEENSt8optionalIN4raft11device_spanIK7int32_tEEEEN4raft9host_spanIK7int32_tEE11edge_type_tbb24prior_sources_behavior_tbb)
* [cugraph::detail::node2vec\_random\_walk\_e\_bias\_op\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail32node2vec_random_walk_e_bias_op_tE)
* [cugraph::detail::node2vec\_sample\_edges\_op\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail26node2vec_sample_edges_op_tE)
* [cugraph::detail::node2vec\_selector (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail17node2vec_selectorE)
* [cugraph::detail::normalize (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail9normalizeEvRKN4raft8handle_tERK13GraphViewTypeP8result_t8result_t8ReduceOp)
* [cugraph::detail::normalize\_biases (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000_b_bEN7cugraph6detail16normalize_biasesENSt5tupleINSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEEEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuEN4raft11device_spanIK8weight_tEE)
* [cugraph::detail::num\_sparse\_segments\_per\_vertex\_partition (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail40num_sparse_segments_per_vertex_partitionE)
* [cugraph::detail::optional\_dataframe\_buffer\_iterator\_value\_type\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail47optional_dataframe_buffer_iterator_value_type_tE)
* [cugraph::detail::optional\_dataframe\_buffer\_iterator\_value\_type\_t>> (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail47optional_dataframe_buffer_iterator_value_type_tI8IteratorNSt11enable_if_tIXntNSt9is_same_vI8IteratorPvEEEEEEE)
* [cugraph::detail::optional\_dataframe\_buffer\_iterator\_value\_type\_t>> (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail47optional_dataframe_buffer_iterator_value_type_tI8IteratorNSt11enable_if_tINSt9is_same_vI8IteratorPvEEEEEE)
* [cugraph::detail::optional\_dataframe\_buffer\_type (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail30optional_dataframe_buffer_typeE)
* [cugraph::detail::optional\_dataframe\_buffer\_type\_t (C++ type)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail32optional_dataframe_buffer_type_tE)
* [cugraph::detail::original (C++ type)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail8originalE)
* [cugraph::detail::original::biased\_selector\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000EN7cugraph6detail8original17biased_selector_tE)
* [cugraph::detail::original::biased\_selector\_t::sampler\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail8original17biased_selector_t9sampler_tE)
* [cugraph::detail::original::clock\_seeding\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail8original15clock_seeding_tE)
* [cugraph::detail::original::device\_const\_vector\_view (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail8original24device_const_vector_viewE)
* [cugraph::detail::original::device\_v\_it (C++ type)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail8original11device_v_itE)
* [cugraph::detail::original::device\_vec\_t (C++ type)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail8original12device_vec_tE)
* [cugraph::detail::original::fixed\_seeding\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail8original15fixed_seeding_tE)
* [cugraph::detail::original::horizontal\_traversal\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail8original22horizontal_traversal_tE)
* [cugraph::detail::original::node2vec\_selector\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000EN7cugraph6detail8original19node2vec_selector_tE)
* [cugraph::detail::original::node2vec\_selector\_t::sampler\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail8original19node2vec_selector_t9sampler_tE)
* [cugraph::detail::original::raw\_const\_ptr (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail8original13raw_const_ptrEPK7value_tR24device_const_vector_viewI7value_tE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail8original13raw_const_ptrEPK7value_tRK12device_vec_tI7value_tE)
* [cugraph::detail::original::raw\_ptr (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail8original7raw_ptrEP7value_tR12device_vec_tI7value_tE)
* [cugraph::detail::original::uniform\_selector\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000EN7cugraph6detail8original18uniform_selector_tE)
* [cugraph::detail::original::uniform\_selector\_t::sampler\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail8original18uniform_selector_t9sampler_tE)
* [cugraph::detail::original::vertical\_traversal\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail8original20vertical_traversal_tE)
* [cugraph::detail::overlap\_functor\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail17overlap_functor_tE)
* [cugraph::detail::pack\_bool\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail11pack_bool_tE)
* [cugraph::detail::pack\_bools (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail10pack_boolsEvRKN4raft8handle_tE17BoolInputIterator17BoolInputIterator24PackedBoolOutputIterator)
* [cugraph::detail::pack\_unaligned\_bools (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail20pack_unaligned_boolsEvRKN4raft8handle_tE17BoolInputIterator17BoolInputIterator24PackedBoolOutputIterator6size_t)
* [cugraph::detail::pagerank (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail8pagerankE31centrality_algorithm_metadata_tRKN4raft8handle_tERK13GraphViewTypeNSt8optionalI20edge_property_view_tIN13GraphViewType9edge_typeEPK8weight_tEEENSt8optionalIN4raft11device_spanIK8weight_tEEEENSt8optionalINSt5tupleIN4raft11device_spanIKN13GraphViewType11vertex_typeEEEN4raft11device_spanIK8result_tEEEEEEN4raft11device_spanI8result_tEE8result_t8result_t6size_tb)
* [cugraph::detail::pair\_to\_binary\_partition\_id\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail29pair_to_binary_partition_id_tE)
* [cugraph::detail::partition\_v\_frontier (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail20partition_v_frontierENSt5tupleIN3rmm14device_uvectorI6size_tEENSt6vectorI6size_tEEEERKN4raft8handle_tE13ValueIterator13ValueIteratorRKNSt6vectorIN6thrust15iterator_traitsI13ValueIteratorE10value_typeEEE)
* [cugraph::detail::partition\_v\_frontier\_per\_value\_idx (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail34partition_v_frontier_per_value_idxENSt5tupleIN3rmm14device_uvectorI6size_tEEN3rmm14device_uvectorI11value_idx_tEENSt6vectorI6size_tEEEERKN4raft8handle_tE13ValueIterator13ValueIteratorN4raft9host_spanIKN6thrust15iterator_traitsI13ValueIteratorE10value_typeEEE6size_t)
* [cugraph::detail::patch (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail5patchE)
* [cugraph::detail::per\_v\_random\_select\_transform\_e (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I_b000000000000EN7cugraph6detail31per_v_random_select_transform_eENSt5tupleINSt8optionalIN3rmm14device_uvectorI6size_tEEEE23dataframe_buffer_type_tI1TEEERKN4raft8handle_tERK13GraphViewTypeRK13KeyBucketType28BiasEdgeSrcValueInputWrapper28BiasEdgeDstValueInputWrapper25BiasEdgeValueInputWrapper10BiasEdgeOp24EdgeSrcValueInputWrapper24EdgeDstValueInputWrapper21EdgeValueInputWrapper6EdgeOp20EdgeTypeInputWrapperRN4raft6random8RngStateEN4raft9host_spanIK6size_tEEbNSt8optionalI1TEEb)
* [cugraph::detail::per\_v\_transform\_reduce\_e (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I_b0000000000EN7cugraph6detail24per_v_transform_reduce_eEvRKN4raft8handle_tERK13GraphViewType19OptionalKeyIterator19OptionalKeyIterator24EdgeSrcValueInputWrapper24EdgeDstValueInputWrapper21EdgeValueInputWrapper6EdgeOp1T8ReduceOp6PredOp25VertexValueOutputIterator)
* [cugraph::detail::per\_v\_transform\_reduce\_e\_edge\_partition (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I_b00000000000EN7cugraph6detail39per_v_transform_reduce_e_edge_partitionEvRKN4raft8handle_tE28edge_partition_device_view_tIN13GraphViewType11vertex_typeEN13GraphViewType9edge_typeEN13GraphViewType12is_multi_gpuEE19OptionalKeyIterator19OptionalKeyIterator33EdgePartitionSrcValueInputWrapper33EdgePartitionDstValueInputWrapper30EdgePartitionValueInputWrapperN4cudaSt8optionalI28EdgePartitionEdgeMaskWrapperEE34ResultValueOutputIteratorOrWrapper6EdgeOp1T1T8ReduceOp6PredOpNSt8optionalIN4raft9host_spanIK6size_tEEEERKNSt8optionalIN4raft9host_spanIK6size_tEEEE)
* [cugraph::detail::per\_v\_transform\_reduce\_e\_kernel\_block\_size (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail42per_v_transform_reduce_e_kernel_block_sizeE)
* [cugraph::detail::per\_v\_transform\_reduce\_e\_kernel\_high\_degree\_reduce\_any\_block\_size (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail65per_v_transform_reduce_e_kernel_high_degree_reduce_any_block_sizeE)
* [cugraph::detail::pick\_min\_degree\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000_bEN7cugraph6detail17pick_min_degree_tE)
* [cugraph::detail::prepare\_next\_frontier (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_bEN7cugraph6detail21prepare_next_frontierENSt5tupleIN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI7label_tEEEENSt8optionalINSt5tupleIN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI7label_tEEEEEEEEEERKN4raft8handle_tEN4raft11device_spanIK8vertex_tEENSt8optionalIN4raft11device_spanIK7label_tEEEEN4raft11device_spanIK8vertex_tEENSt8optionalIN4raft11device_spanIK7label_tEEEERRNSt8optionalINSt5tupleIN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI7label_tEEEEEEEE23vertex_partition_view_tI8vertex_t9multi_gpuERKNSt6vectorI8vertex_tEE24prior_sources_behavior_tbb)
* [cugraph::detail::px (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail2pxE)
* [cugraph::detail::py (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail2pyE)
* [cugraph::detail::r (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail1rE)
* [cugraph::detail::radius (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail6radiusE)
* [cugraph::detail::random\_walk\_impl (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000_b0EN7cugraph6detail16random_walk_implENSt5tupleIN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEEEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEEN4raft11device_spanIK8vertex_tEE6size_t17random_selector_t)
* [cugraph::detail::random\_walker\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00000EN7cugraph6detail15random_walker_tE)
* [cugraph::detail::random\_walks\_impl (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00000000EN7cugraph6detail17random_walks_implENSt5tupleIN8original12device_vec_tI8vertex_tEEN8original12device_vec_tI8weight_tEEN8original12device_vec_tI7index_tEEN15random_engine_t9seed_typeEEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EEXL0EEENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEERN8original24device_const_vector_viewI8vertex_t7index_tEE7index_tRK10selector_tb16seeding_policy_t)
* [cugraph::detail::rebase\_offset\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail15rebase_offset_tE)
* [cugraph::detail::reduce\_op\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail11reduce_op_tE)
* [cugraph::detail::reduce\_to\_unique\_kv\_pairs (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000EN7cugraph6detail25reduce_to_unique_kv_pairsENSt5tupleIN3rmm14device_uvectorI8vertex_tEE10BufferTypeEERRN3rmm14device_uvectorI8vertex_tEERR10BufferType8ReduceOp12cudaStream_t)
* [cugraph::detail::reduce\_with\_init\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail18reduce_with_init_tE)
* [cugraph::detail::refine\_clustering (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail17refine_clusteringENSt5tupleIN3rmm14device_uvectorIN12graph_view_t11vertex_typeEEENSt4pairIN3rmm14device_uvectorIN12graph_view_t11vertex_typeEEEN3rmm14device_uvectorIN12graph_view_t11vertex_typeEEEEEEERKN4raft8handle_tERN4raft6random8RngStateERK12graph_view_tNSt8optionalI20edge_property_view_tIN12graph_view_t9edge_typeEPK8weight_tEEE8weight_t8weight_t8weight_tRKN3rmm14device_uvectorI8weight_tEERRN3rmm14device_uvectorIN12graph_view_t11vertex_typeEEERRN3rmm14device_uvectorI8weight_tEERRN3rmm14device_uvectorIN12graph_view_t11vertex_typeEEERK19edge_src_property_tI12graph_view_t8weight_tERK19edge_src_property_tI12graph_view_tN12graph_view_t11vertex_typeEERK19edge_dst_property_tI12graph_view_tN12graph_view_t11vertex_typeEE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail17refine_clusteringENSt5tupleIN3rmm14device_uvectorIN13GraphViewType11vertex_typeEEENSt4pairIN3rmm14device_uvectorIN13GraphViewType11vertex_typeEEEN3rmm14device_uvectorIN13GraphViewType11vertex_typeEEEEEEERKN4raft8handle_tERN4raft6random8RngStateERK13GraphViewTypeNSt8optionalI20edge_property_view_tIN13GraphViewType9edge_typeEPK8weight_tEEE8weight_t8weight_t8weight_tRKN3rmm14device_uvectorI8weight_tEERRN3rmm14device_uvectorIN13GraphViewType11vertex_typeEEERRN3rmm14device_uvectorI8weight_tEERRN3rmm14device_uvectorIN13GraphViewType11vertex_typeEEERK19edge_src_property_tI13GraphViewType8weight_tERK19edge_src_property_tI13GraphViewTypeN13GraphViewType11vertex_typeEERK19edge_dst_property_tI13GraphViewTypeN13GraphViewType11vertex_typeEE)
* [cugraph::detail::relabel\_cluster\_ids (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_bEN7cugraph6detail19relabel_cluster_idsEvRKN4raft8handle_tERN3rmm14device_uvectorI8vertex_tEEP8vertex_t6size_t)
* [cugraph::detail::remap\_local\_nbr\_indices (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail23remap_local_nbr_indicesEN3rmm14device_uvectorI6edge_tEERKN4raft8handle_tEN4raft11device_spanIK6size_tEEN4raft9host_spanIK6size_tEEN4raft11device_spanIK6edge_tEEN4raft11device_spanIK6size_tEEN4raft9host_spanIK6size_tEERRN3rmm14device_uvectorI6edge_tEENSt8optionalIN4raft11device_spanIK6size_tEEEEN4raft9host_spanIK6size_tEE6size_t)
* [cugraph::detail::remove\_duplicates (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_bEN7cugraph6detail17remove_duplicatesE8vertex_tRKN4raft8handle_tERN3rmm14device_uvectorI8vertex_tEE)
* [cugraph::detail::remove\_visited\_vertices\_from\_frontier (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail37remove_visited_vertices_from_frontierENSt5tupleIN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI7label_tEEEEEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEERRNSt8optionalIN3rmm14device_uvectorI7label_tEEEEN4raft11device_spanIK8vertex_tEENSt8optionalIN4raft11device_spanIK7label_tEEEE)
* [cugraph::detail::reorder\_group\_count\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail21reorder_group_count_tE)
* [cugraph::detail::reserve\_optional\_dataframe\_buffer (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail33reserve_optional_dataframe_bufferEvR32optional_dataframe_buffer_type_tI1TE6size_tN3rmm16cuda_stream_viewE)
* [cugraph::detail::resize\_optional\_dataframe\_buffer (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail32resize_optional_dataframe_bufferEvR32optional_dataframe_buffer_type_tI1TE6size_tN3rmm16cuda_stream_viewE)
* [cugraph::detail::restart (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail7restartE)
* [cugraph::detail::return\_edge\_weight\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail20return_edge_weight_tE)
* [cugraph::detail::return\_edges\_with\_properties\_e\_op (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail33return_edges_with_properties_e_opE)
* [cugraph::detail::return\_one\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail12return_one_tE)
* [cugraph::detail::return\_value\_compute\_offset\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I_bEN7cugraph6detail29return_value_compute_offset_tE)
* [cugraph::detail::rootx (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail5rootxE)
* [cugraph::detail::rooty (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail5rootyE)
* [cugraph::detail::rrandom\_gen\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00000EN7cugraph6detail13rrandom_gen_tE)
* [cugraph::detail::sample\_and\_compute\_local\_nbr\_indices\_block\_size (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail47sample_and_compute_local_nbr_indices_block_sizeE)
* [cugraph::detail::sample\_edge\_biases\_op\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail23sample_edge_biases_op_tE)
* [cugraph::detail::sample\_edges (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000000_bEN7cugraph6detail12sample_edgesENSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI6edge_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEENSt8optionalIN3rmm14device_uvectorI7label_tEEEEEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEENSt8optionalI20edge_property_view_tI6edge_tPK6edge_tEEENSt8optionalI20edge_property_view_tI6edge_tPK11edge_type_tEEENSt8optionalI20edge_property_view_tI6edge_tPK6bias_tEEERN4raft6random8RngStateEN4raft11device_spanIK8vertex_tEENSt8optionalIN4raft11device_spanIK7label_tEEEE6size_tb)
* [cugraph::detail::sample\_edges\_op\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail17sample_edges_op_tE)
* [cugraph::detail::sample\_nbr\_index\_with\_replacement (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail33sample_nbr_index_with_replacementEvRKN4raft8handle_tEN4raft11device_spanIK6edge_tEENSt8optionalINSt5tupleIN4raft11device_spanIK6size_tEEN4raft11device_spanIK11edge_type_tEEEEEEN4raft11device_spanI6edge_tEERN4raft6random8RngStateEN4raft11device_spanIK6size_tEE6size_t)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail33sample_nbr_index_with_replacementEvRKN4raft8handle_tEN4raft11device_spanIK6edge_tEENSt8optionalIN4raft11device_spanIK6size_tEEEEN4raft11device_spanI6edge_tEERN4raft6random8RngStateE6size_t)
* [cugraph::detail::sample\_nbr\_index\_without\_replacement (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail36sample_nbr_index_without_replacementEvRKN4raft8handle_tEN4raft11device_spanIK6edge_tEENSt8optionalINSt5tupleIN4raft11device_spanIK6size_tEEN4raft11device_spanIK11edge_type_tEEEEEEN4raft11device_spanI6edge_tEERN4raft6random8RngStateEN4raft11device_spanIK6size_tEE6size_tb)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail36sample_nbr_index_without_replacementEvRKN4raft8handle_tEN4raft11device_spanIK6edge_tEENSt8optionalIN4raft11device_spanIK6size_tEEEEN4raft11device_spanI6edge_tEERN4raft6random8RngStateE6size_tb)
* [cugraph::detail::sbase (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail5sbaseE)
* [cugraph::detail::SBASE\_EQ\_THREAD (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail15SBASE_EQ_THREADE)
* [cugraph::detail::search\_and\_increment\_degree\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail29search_and_increment_degree_tE)
* [cugraph::detail::segmented\_fill\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail16segmented_fill_tE)
* [cugraph::detail::sg\_lookup\_predecessor (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail21sg_lookup_predecessorE)
* [cugraph::detail::shift\_left\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail12shift_left_tE)
* [cugraph::detail::shift\_right\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail13shift_right_tE)
* [cugraph::detail::shrink\_extraction\_list (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail22shrink_extraction_listENSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI6size_tEEEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI6size_tEE)
* [cugraph::detail::shrink\_to\_fit\_optional\_dataframe\_buffer (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail39shrink_to_fit_optional_dataframe_bufferEvR32optional_dataframe_buffer_type_tI1TEN3rmm16cuda_stream_viewE)
* [cugraph::detail::shuffle\_and\_compute\_local\_nbr\_values (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail36shuffle_and_compute_local_nbr_valuesENSt5tupleIN3rmm14device_uvectorI7value_tEEN3rmm14device_uvectorI6size_tEENSt6vectorI6size_tEEEERKN4raft8handle_tERRN3rmm14device_uvectorI7value_tEEN4raft11device_spanIK7value_tEE6size_t7value_t)
* [cugraph::detail::shuffle\_and\_compute\_per\_type\_local\_nbr\_values (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail45shuffle_and_compute_per_type_local_nbr_valuesENSt5tupleIN3rmm14device_uvectorI7value_tEEN3rmm14device_uvectorI11edge_type_tEEN3rmm14device_uvectorI6size_tEENSt6vectorI6size_tEEEERKN4raft8handle_tERRN3rmm14device_uvectorI7value_tEEN4raft11device_spanIK7value_tEEN4raft11device_spanIK6size_tEE6size_t7value_t)
* [cugraph::detail::shuffle\_and\_organize\_output (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00000EN7cugraph6detail27shuffle_and_organize_outputENSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI6edge_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEENSt8optionalIN3rmm14device_uvectorI7int32_tEEEENSt8optionalIN3rmm14device_uvectorI7label_tEEEENSt8optionalIN3rmm14device_uvectorI6size_tEEEEEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEERRNSt8optionalIN3rmm14device_uvectorI8weight_tEEEERRNSt8optionalIN3rmm14device_uvectorI6edge_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEERRNSt8optionalIN3rmm14device_uvectorI7int32_tEEEERRNSt8optionalIN3rmm14device_uvectorI7label_tEEEENSt8optionalIN4raft11device_spanIK7int32_tEEEE) | * [cugraph::detail::shuffle\_index\_compute\_offset\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail30shuffle_index_compute_offset_tE)
* [cugraph::detail::shuffle\_sampling\_results (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00000EN7cugraph6detail24shuffle_sampling_resultsENSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI6edge_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEENSt8optionalIN3rmm14device_uvectorI7int32_tEEEENSt8optionalIN3rmm14device_uvectorI7label_tEEEEEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEERRNSt8optionalIN3rmm14device_uvectorI8weight_tEEEERRNSt8optionalIN3rmm14device_uvectorI6edge_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEERRNSt8optionalIN3rmm14device_uvectorI7int32_tEEEERRNSt8optionalIN3rmm14device_uvectorI7label_tEEEEN4raft11device_spanIK7int32_tEE)
* [cugraph::detail::shuffle\_to\_output\_comm\_rank\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail29shuffle_to_output_comm_rank_tE)
* [cugraph::detail::similarity (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000_b0EN7cugraph6detail10similarityEN3rmm14device_uvectorI8weight_tEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEENSt5tupleIN4raft11device_spanIK8vertex_tEEN4raft11device_spanIK8vertex_tEEEE9functor_t13coefficient_tb)
* [cugraph::detail::size\_optional\_dataframe\_buffer (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail30size_optional_dataframe_bufferE6size_tR32optional_dataframe_buffer_type_tI1TE)
* [cugraph::detail::skip (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail4skipE)
* [cugraph::detail::sorensen\_functor\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail18sorensen_functor_tE)
* [cugraph::detail::sort (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail4sortE2VTRN6legacy12GraphCOOViewI2VT2ET2WTEEN3rmm16cuda_stream_viewE)
* [cugraph::detail::sort\_adjacency\_list (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail19sort_adjacency_listEvRKN4raft8handle_tEN4raft11device_spanIK6edge_tEE14VertexIterator14VertexIterator17EdgeValueIterator)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail19sort_adjacency_listEvRKN4raft8handle_tEN4raft11device_spanIK6edge_tEE14VertexIterator14VertexIterator)
* [cugraph::detail::sort\_and\_compress\_edgelist (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000_bEN7cugraph6detail26sort_and_compress_edgelistENSt5tupleIN3rmm14device_uvectorI6edge_tEEN3rmm14device_uvectorI8vertex_tEEDTcl25allocate_dataframe_bufferI12edge_value_tEcl6size_tL0EEclN3rmm16cuda_stream_viewEEEENSt8optionalIN3rmm14device_uvectorI8vertex_tEEEEEERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEERRDTcl25allocate_dataframe_bufferI12edge_value_tEL0EclN3rmm16cuda_stream_viewEEEE8vertex_tNSt8optionalI8vertex_tEE8vertex_t8vertex_t8vertex_t6size_tN3rmm16cuda_stream_viewE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_bEN7cugraph6detail26sort_and_compress_edgelistENSt5tupleIN3rmm14device_uvectorI6edge_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8vertex_tEEEEEERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEE8vertex_tNSt8optionalI8vertex_tEE8vertex_t8vertex_t8vertex_t6size_tN3rmm16cuda_stream_viewE)
* [cugraph::detail::sort\_and\_reduce\_buffer\_elements (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000EN7cugraph6detail31sort_and_reduce_buffer_elementsENSt5tupleI23dataframe_buffer_type_tI5key_tE32optional_dataframe_buffer_type_tI9payload_tEEERKN4raft8handle_tERR23dataframe_buffer_type_tI11input_key_tERR32optional_dataframe_buffer_type_tI9payload_tE8ReduceOpNSt13conditional_tINSt13is_integral_vI5key_tEENSt5tupleI5key_t5key_tEENSt4byteEEENSt8optionalI11input_key_tEE)
* [cugraph::detail::sort\_and\_reduce\_by\_vertices (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail27sort_and_reduce_by_verticesENSt5tupleIN3rmm14device_uvectorI8vertex_tEE11ValueBufferEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEERR11ValueBuffer)
* [cugraph::detail::sort\_sampled\_tuples (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00000EN7cugraph6detail19sort_sampled_tuplesEvRKN4raft8handle_tERN3rmm14device_uvectorI8vertex_tEERN3rmm14device_uvectorI8vertex_tEERNSt8optionalIN3rmm14device_uvectorI8weight_tEEEERNSt8optionalIN3rmm14device_uvectorI6edge_tEEEERNSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEERNSt8optionalIN3rmm14device_uvectorI7int32_tEEEERN3rmm14device_uvectorI7label_tEE)
* [cugraph::detail::sssp (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail4ssspEvRKN4raft8handle_tERK13GraphViewType20edge_property_view_tIN13GraphViewType9edge_typeEPK8weight_tEP8weight_t19PredecessorIteratorN13GraphViewType11vertex_typeE8weight_tb)
* [cugraph::detail::start (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail5startE)
* [cugraph::detail::std\_tuple\_to\_thrust\_tuple (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_DpNSt6size_tEEN7cugraph6detail25std_tuple_to_thrust_tupleEDa9TupleTypeNSt14index_sequenceIDp2IsEE)
* [cugraph::detail::strided\_accumulate\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail20strided_accumulate_tE)
* [cugraph::detail::strided\_sum\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail13strided_sum_tE)
* [cugraph::detail::sum\_nosync (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail10sum_nosyncEv13InputIterator13InputIteratorN4raft11device_spanIN6thrust15iterator_traitsI13InputIteratorE10value_typeEEEN3rmm16cuda_stream_viewE)
* [cugraph::detail::sum\_thrust\_tuple\_element\_sizes (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_DpNSt6size_tEEN7cugraph6detail30sum_thrust_tuple_element_sizesE6size_tNSt14index_sequenceIDp2IsEE)
* [cugraph::detail::swap\_partitions (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail15swap_partitionsEv11KeyIterator11KeyIterator13ValueIterator6size_tN3rmm16cuda_stream_viewE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail15swap_partitionsEv13ValueIterator13ValueIterator6size_tN3rmm16cuda_stream_viewE)
* [cugraph::detail::symmetrize\_edgelist (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00000_bEN7cugraph6detail19symmetrize_edgelistENSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI6edge_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_time_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_time_tEEEEEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEERRNSt8optionalIN3rmm14device_uvectorI8weight_tEEEERRNSt8optionalIN3rmm14device_uvectorI6edge_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_time_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_time_tEEEEb)
* [cugraph::detail::thrust\_tuple\_of\_arithmetic\_numeric\_limits\_lowest (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_DpNSt6size_tEEN7cugraph6detail48thrust_tuple_of_arithmetic_numeric_limits_lowestE9TupleTypeNSt14index_sequenceIDp2IsEE)
* [cugraph::detail::thrust\_tuple\_of\_arithmetic\_numeric\_limits\_max (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_DpNSt6size_tEEN7cugraph6detail45thrust_tuple_of_arithmetic_numeric_limits_maxE9TupleTypeNSt14index_sequenceIDp2IsEE)
* [cugraph::detail::thrust\_tuple\_to\_std\_tuple (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_DpNSt6size_tEEN7cugraph6detail25thrust_tuple_to_std_tupleEDa9TupleTypeNSt14index_sequenceIDp2IsEE)
* [cugraph::detail::to\_std\_optional (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail15to_std_optionalENSt8optionalI1TEEN4cudaSt8optionalI1TEE)
* [cugraph::detail::to\_thrust\_optional (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail18to_thrust_optionalEN4cudaSt8optionalI1TEENSt8optionalI1TEE)
* [cugraph::detail::transform\_and\_atomic\_reduce\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_b00000EN7cugraph6detail29transform_and_atomic_reduce_tE)
* [cugraph::detail::transform\_e\_kernel\_block\_size (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail29transform_e_kernel_block_sizeE)
* [cugraph::detail::transform\_local\_nbr\_indices\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00000000EN7cugraph6detail29transform_local_nbr_indices_tE)
* [cugraph::detail::transform\_reduce\_call\_v\_op\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000EN7cugraph6detail28transform_reduce_call_v_op_tE)
* [cugraph::detail::transform\_reduce\_e\_by\_src\_dst\_key (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I_b00000000EN7cugraph6detail33transform_reduce_e_by_src_dst_keyENSt5tupleIN3rmm14device_uvectorIN13GraphViewType11vertex_typeEEEDTcl25allocate_dataframe_bufferI1TEL0Ecl12cudaStream_tLDnEEEEEERKN4raft8handle_tERK13GraphViewType24EdgeSrcValueInputWrapper24EdgeDstValueInputWrapper21EdgeValueInputWrapper25EdgeSrcDstKeyInputWrapper6EdgeOp1T8ReduceOp)
* [cugraph::detail::transform\_reduce\_e\_by\_src\_dst\_key\_kernel\_block\_size (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail51transform_reduce_e_by_src_dst_key_kernel_block_sizeE)
* [cugraph::detail::transform\_reduce\_e\_kernel\_block\_size (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail36transform_reduce_e_kernel_block_sizeE)
* [cugraph::detail::transform\_reduce\_v\_frontier\_call\_e\_op\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000000EN7cugraph6detail39transform_reduce_v_frontier_call_e_op_tE)
* [cugraph::detail::transform\_reduce\_v\_frontier\_outgoing\_e\_by\_dst (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000000EN7cugraph6detail45transform_reduce_v_frontier_outgoing_e_by_dstENSt13conditional_tIXntNSt9is_same_vIN8ReduceOp10value_typeEvEEENSt5tupleIDTcl25allocate_dataframe_bufferIN13KeyBucketType8key_typeEEL0EclN3rmm16cuda_stream_viewEEEEDTclN6detail34allocate_optional_dataframe_bufferIN8ReduceOp10value_typeEEEL0EclN3rmm16cuda_stream_viewEEEEEEDTcl25allocate_dataframe_bufferIN13KeyBucketType8key_typeEEL0EclN3rmm16cuda_stream_viewEEEEEERKN4raft8handle_tERK13GraphViewTypeRK13KeyBucketType24EdgeSrcValueInputWrapper24EdgeDstValueInputWrapper21EdgeValueInputWrapper6EdgeOp8ReduceOpb)
* [cugraph::detail::transform\_v\_frontier\_e (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000000EN7cugraph6detail22transform_v_frontier_eEDaRKN4raft8handle_tERK13GraphViewType11KeyIterator24EdgeSrcValueInputWrapper24EdgeDstValueInputWrapper21EdgeValueInputWrapper6EdgeOpRKNSt6vectorI6size_tEERKNSt6vectorI6size_tEE)
* [cugraph::detail::transform\_v\_frontier\_e\_kernel\_block\_size (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail40transform_v_frontier_e_kernel_block_sizeE)
* [cugraph::detail::tuple\_to\_minor\_comm\_rank\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail26tuple_to_minor_comm_rank_tE)
* [cugraph::detail::typecast\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail10typecast_tE)
* [cugraph::detail::uniform\_selector (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail16uniform_selectorE)
* [cugraph::detail::unrenumber\_local\_int\_edges (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail26unrenumber_local_int_edgesEvRKN4raft8handle_tERKNSt6vectorIP8vertex_tEERKNSt6vectorIP8vertex_tEERKNSt6vectorI6size_tEEPK8vertex_tRKNSt6vectorI8vertex_tEERKNSt8optionalINSt6vectorINSt6vectorI6size_tEEEEEEb)
* [cugraph::detail::update\_clustering\_by\_delta\_modularity (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000_bEN7cugraph6detail37update_clustering_by_delta_modularityEN3rmm14device_uvectorI8vertex_tEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEE8weight_t8weight_tRKN3rmm14device_uvectorI8weight_tEERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8weight_tEERRN3rmm14device_uvectorI8vertex_tEERK19edge_src_property_tI12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuE8weight_tERK19edge_src_property_tI12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuE8vertex_tERK19edge_dst_property_tI12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuE8vertex_tEb)
* [cugraph::detail::update\_e\_value\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I_b0000000EN7cugraph6detail16update_e_value_tE)
* [cugraph::detail::update\_edge\_major\_property (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000EN7cugraph6detail26update_edge_major_propertyEvRKN4raft8handle_tERK13GraphViewType14VertexIterator14VertexIterator27VertexPropertyInputIterator30EdgeMajorPropertyOutputWrapper)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail26update_edge_major_propertyEvRKN4raft8handle_tERK13GraphViewType27VertexPropertyInputIterator30EdgeMajorPropertyOutputWrapper)
* [cugraph::detail::update\_edge\_minor\_property (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000EN7cugraph6detail26update_edge_minor_propertyEvRKN4raft8handle_tERK13GraphViewType14VertexIterator14VertexIterator27VertexPropertyInputIterator30EdgeMinorPropertyOutputWrapper)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail26update_edge_minor_propertyEvRKN4raft8handle_tERK13GraphViewType27VertexPropertyInputIterator30EdgeMinorPropertyOutputWrapper)
* [cugraph::detail::update\_edges\_p\_r\_q\_r\_num\_triangles (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6detail34update_edges_p_r_q_r_num_trianglesE)
* [cugraph::detail::update\_keep\_flag\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail18update_keep_flag_tE)
* [cugraph::detail::update\_paths (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail12update_pathsE)
* [cugraph::detail::update\_rx\_major\_local\_degree\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_bEN7cugraph6detail30update_rx_major_local_degree_tE)
* [cugraph::detail::update\_rx\_major\_local\_nbrs\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000_bEN7cugraph6detail28update_rx_major_local_nbrs_tE)
* [cugraph::detail::update\_tuple\_from\_vector\_of\_tuple\_scalar\_elements\_impl (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_6size_t_6size_tEN7cugraph6detail54update_tuple_from_vector_of_tuple_scalar_elements_implE)
* [cugraph::detail::update\_tuple\_from\_vector\_of\_tuple\_scalar\_elements\_impl (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_6size_tEN7cugraph6detail54update_tuple_from_vector_of_tuple_scalar_elements_implI9TupleType1I1IEE)
* [cugraph::detail::update\_v\_frontier\_call\_v\_op\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000000EN7cugraph6detail29update_v_frontier_call_v_op_tE)
* [cugraph::detail::update\_v\_frontier\_call\_v\_op\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00000EN7cugraph6detail29update_v_frontier_call_v_op_tI8vertex_t24VertexValueInputIterator25VertexValueOutputIterator8VertexOp5key_tvEE)
* [cugraph::detail::update\_v\_frontier\_from\_outgoing\_e\_kernel\_block\_size (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail51update_v_frontier_from_outgoing_e_kernel_block_sizeE)
* [cugraph::detail::update\_vector\_of\_tuple\_scalar\_elements\_from\_tuple\_impl (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_6size_t_6size_tEN7cugraph6detail54update_vector_of_tuple_scalar_elements_from_tuple_implE)
* [cugraph::detail::update\_vector\_of\_tuple\_scalar\_elements\_from\_tuple\_impl (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_6size_tEN7cugraph6detail54update_vector_of_tuple_scalar_elements_from_tuple_implI9TupleType1I1IEE)
* [cugraph::detail::value\_group\_id\_greater\_equal\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail30value_group_id_greater_equal_tE)
* [cugraph::detail::value\_group\_id\_less\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6detail21value_group_id_less_tE)
* [cugraph::detail::vertex\_coloring (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_bEN7cugraph6detail15vertex_coloringEN3rmm14device_uvectorI8vertex_tEERKN4raft8handle_tERKN7cugraph12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuEERN4raft6random8RngStateE)
* [cugraph::detail::vertex\_local\_offset\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_bEN7cugraph6detail21vertex_local_offset_tE)
* [cugraph::detail::vertex\_partition\_device\_view\_base\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail35vertex_partition_device_view_base_tE)
* [cugraph::detail::vertex\_partition\_view\_base\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6detail28vertex_partition_view_base_tE)
* [cugraph::detail::x (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail1xE)
* [cugraph::detail::y (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6detail1yE)
* [cugraph::device\_allgather (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph16device_allgatherENSt11enable_if_tINSt13is_arithmeticINSt15iterator_traitsI13InputIteratorE10value_typeEE5valueEvEERKN4raft5comms7comms_tE13InputIterator14OutputIterator6size_tN3rmm16cuda_stream_viewE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph16device_allgatherENSt11enable_if_tIXaaN29is_thrust_tuple_of_arithmeticINSt15iterator_traitsI13InputIteratorE10value_typeEE5valueEN15is_thrust_tupleINSt15iterator_traitsI14OutputIteratorE10value_typeEE5valueEEvEERKN4raft5comms7comms_tE13InputIterator14OutputIterator6size_tN3rmm16cuda_stream_viewE)
* [cugraph::device\_allgatherv (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph17device_allgathervENSt11enable_if_tINSt13is_arithmeticINSt15iterator_traitsI13InputIteratorE10value_typeEE5valueEvEERKN4raft5comms7comms_tE13InputIterator14OutputIteratorRKNSt6vectorI6size_tEERKNSt6vectorI6size_tEEN3rmm16cuda_stream_viewE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph17device_allgathervENSt11enable_if_tIXaaN29is_thrust_tuple_of_arithmeticINSt15iterator_traitsI13InputIteratorE10value_typeEE5valueEN15is_thrust_tupleINSt15iterator_traitsI14OutputIteratorE10value_typeEE5valueEEvEERKN4raft5comms7comms_tE13InputIterator14OutputIteratorRKNSt6vectorI6size_tEERKNSt6vectorI6size_tEEN3rmm16cuda_stream_viewE)
, [\[2\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph17device_allgathervEN3rmm14device_uvectorI1TEERKN4raft8handle_tERKN4raft5comms7comms_tEN4raft11device_spanIK1TEE)
* [cugraph::device\_allreduce (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph16device_allreduceENSt11enable_if_tINSt13is_arithmeticINSt15iterator_traitsI13InputIteratorE10value_typeEE5valueEvEERKN4raft5comms7comms_tE13InputIterator14OutputIterator6size_tN4raft5comms4op_tEN3rmm16cuda_stream_viewE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph16device_allreduceENSt11enable_if_tIXaaN29is_thrust_tuple_of_arithmeticINSt15iterator_traitsI13InputIteratorE10value_typeEE5valueEN15is_thrust_tupleINSt15iterator_traitsI14OutputIteratorE10value_typeEE5valueEEvEERKN4raft5comms7comms_tE13InputIterator14OutputIterator6size_tN4raft5comms4op_tEN3rmm16cuda_stream_viewE)
* [cugraph::device\_bcast (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph12device_bcastENSt11enable_if_tINSt13is_arithmeticINSt15iterator_traitsI13InputIteratorE10value_typeEE5valueEvEERKN4raft5comms7comms_tE13InputIterator14OutputIterator6size_tiN3rmm16cuda_stream_viewE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph12device_bcastENSt11enable_if_tIXaaN29is_thrust_tuple_of_arithmeticINSt15iterator_traitsI13InputIteratorE10value_typeEE5valueEN15is_thrust_tupleINSt15iterator_traitsI14OutputIteratorE10value_typeEE5valueEEvEERKN4raft5comms7comms_tE13InputIterator14OutputIterator6size_tiN3rmm16cuda_stream_viewE)
* [cugraph::device\_bcast\_vertex\_list (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph24device_bcast_vertex_listEvRKN4raft5comms7comms_tENSt7variantIN4raft11device_spanIK8uint32_tEE19InputVertexIteratorEE20OutputVertexIteratorN6thrust15iterator_traitsI19InputVertexIteratorE10value_typeEN6thrust15iterator_traitsI19InputVertexIteratorE10value_typeE6size_tiN3rmm16cuda_stream_viewE)
* [cugraph::device\_gatherv (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph14device_gathervENSt11enable_if_tINSt13is_arithmeticINSt15iterator_traitsI13InputIteratorE10value_typeEE5valueEvEERKN4raft5comms7comms_tE13InputIterator14OutputIterator6size_tRKNSt6vectorI6size_tEERKNSt6vectorI6size_tEEiN3rmm16cuda_stream_viewE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph14device_gathervENSt11enable_if_tIXaaN29is_thrust_tuple_of_arithmeticINSt15iterator_traitsI13InputIteratorE10value_typeEE5valueEN15is_thrust_tupleINSt15iterator_traitsI14OutputIteratorE10value_typeEE5valueEEvEERKN4raft5comms7comms_tE13InputIterator14OutputIterator6size_tRKNSt6vectorI6size_tEERKNSt6vectorI6size_tEEiN3rmm16cuda_stream_viewE)
* [cugraph::device\_group\_end (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph16device_group_endERKN4raft5comms7comms_tE)
* [cugraph::device\_group\_start (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph18device_group_startERKN4raft5comms7comms_tE)
* [cugraph::device\_irecv (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph12device_irecvENSt11enable_if_tINSt13is_arithmeticINSt15iterator_traitsI13InputIteratorE10value_typeEE5valueEvEERKN4raft5comms7comms_tE14OutputIterator6size_tiiPN4raft5comms9request_tE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph12device_irecvENSt11enable_if_tIXaaN29is_thrust_tuple_of_arithmeticINSt15iterator_traitsI13InputIteratorE10value_typeEE5valueEN15is_thrust_tupleINSt15iterator_traitsI14OutputIteratorE10value_typeEE5valueEEvEERKN4raft5comms7comms_tE14OutputIterator6size_tiiPN4raft5comms9request_tE)
* [cugraph::device\_isend (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph12device_isendENSt11enable_if_tINSt13is_arithmeticINSt15iterator_traitsI13InputIteratorE10value_typeEE5valueEvEERKN4raft5comms7comms_tE13InputIterator6size_tiiPN4raft5comms9request_tE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph12device_isendENSt11enable_if_tIXaaN29is_thrust_tuple_of_arithmeticINSt15iterator_traitsI13InputIteratorE10value_typeEE5valueEN15is_thrust_tupleINSt15iterator_traitsI14OutputIteratorE10value_typeEE5valueEEvEERKN4raft5comms7comms_tE13InputIterator6size_tiiPN4raft5comms9request_tE)
* [cugraph::device\_multicast\_sendrecv (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph25device_multicast_sendrecvENSt11enable_if_tINSt13is_arithmeticINSt15iterator_traitsI13InputIteratorE10value_typeEE5valueEvEERKN4raft5comms7comms_tE13InputIteratorRKNSt6vectorI6size_tEERKNSt6vectorI6size_tEERKNSt6vectorIiEE14OutputIteratorRKNSt6vectorI6size_tEERKNSt6vectorI6size_tEERKNSt6vectorIiEEN3rmm16cuda_stream_viewE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph25device_multicast_sendrecvENSt11enable_if_tIXaaN29is_thrust_tuple_of_arithmeticINSt15iterator_traitsI13InputIteratorE10value_typeEE5valueEN15is_thrust_tupleINSt15iterator_traitsI14OutputIteratorE10value_typeEE5valueEEvEERKN4raft5comms7comms_tE13InputIteratorRKNSt6vectorI6size_tEERKNSt6vectorI6size_tEERKNSt6vectorIiEE14OutputIteratorRKNSt6vectorI6size_tEERKNSt6vectorI6size_tEERKNSt6vectorIiEEN3rmm16cuda_stream_viewE)
* [cugraph::device\_reduce (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph13device_reduceENSt11enable_if_tINSt13is_arithmeticINSt15iterator_traitsI13InputIteratorE10value_typeEE5valueEvEERKN4raft5comms7comms_tE13InputIterator14OutputIterator6size_tN4raft5comms4op_tEiN3rmm16cuda_stream_viewE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph13device_reduceENSt11enable_if_tIXaaN29is_thrust_tuple_of_arithmeticINSt15iterator_traitsI13InputIteratorE10value_typeEE5valueEN15is_thrust_tupleINSt15iterator_traitsI14OutputIteratorE10value_typeEE5valueEEvEERKN4raft5comms7comms_tE13InputIterator14OutputIterator6size_tN4raft5comms4op_tEiN3rmm16cuda_stream_viewE)
* [cugraph::device\_sendrecv (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph15device_sendrecvENSt11enable_if_tINSt13is_arithmeticINSt15iterator_traitsI13InputIteratorE10value_typeEE5valueEvEERKN4raft5comms7comms_tE13InputIterator6size_ti14OutputIterator6size_tiN3rmm16cuda_stream_viewE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph15device_sendrecvENSt11enable_if_tIXaaN29is_thrust_tuple_of_arithmeticINSt15iterator_traitsI13InputIteratorE10value_typeEE5valueEN15is_thrust_tupleINSt15iterator_traitsI14OutputIteratorE10value_typeEE5valueEEvEERKN4raft5comms7comms_tE13InputIterator6size_ti14OutputIterator6size_tiN3rmm16cuda_stream_viewE)
* [cugraph::edge\_bucket\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_b_b_bEN7cugraph13edge_bucket_tE)
* [cugraph::edge\_bucket\_t::insert (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000_PNSt11enable_if_tIXntNSt9is_same_vI8tag_typevEEEEEEN7cugraph13edge_bucket_t6insertEv14VertexIterator14VertexIterator14VertexIterator11TagIterator)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_PNSt11enable_if_tINSt9is_same_vI8tag_typevEEEEEN7cugraph13edge_bucket_t6insertEv14VertexIterator14VertexIterator14VertexIterator)
, [\[2\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_PNSt11enable_if_tINSt9is_same_vI8tag_typevEEEEEN7cugraph13edge_bucket_t6insertEv8vertex_t8vertex_t)
, [\[3\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_PNSt11enable_if_tIXntNSt9is_same_vI8tag_typevEEEEEEN7cugraph13edge_bucket_t6insertEv8vertex_t8vertex_t8tag_type)
* [cugraph::edge\_dst\_dummy\_property\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph25edge_dst_dummy_property_tE)
* [cugraph::edge\_dst\_property\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph19edge_dst_property_tE)
* [cugraph::edge\_dummy\_property\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph21edge_dummy_property_tE)
* [cugraph::edge\_dummy\_property\_view\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph26edge_dummy_property_view_tE)
* [cugraph::edge\_partition\_device\_view\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_b0EN7cugraph28edge_partition_device_view_tE)
* [cugraph::edge\_partition\_device\_view\_t> (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_bEN7cugraph28edge_partition_device_view_tI8vertex_t6edge_t9multi_gpuNSt11enable_if_tIXnt9multi_gpuEEEEE)
* [cugraph::edge\_partition\_device\_view\_t> (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_bEN7cugraph28edge_partition_device_view_tI8vertex_t6edge_t9multi_gpuNSt11enable_if_tI9multi_gpuEEEE)
* [cugraph::edge\_partition\_view\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_b0EN7cugraph21edge_partition_view_tE)
* [cugraph::edge\_partition\_view\_t> (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_bEN7cugraph21edge_partition_view_tI8vertex_t6edge_t9multi_gpuNSt11enable_if_tIXnt9multi_gpuEEEEE)
* [cugraph::edge\_partition\_view\_t> (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_bEN7cugraph21edge_partition_view_tI8vertex_t6edge_t9multi_gpuNSt11enable_if_tI9multi_gpuEEEE)
* [cugraph::edge\_property\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph15edge_property_tE)
* [cugraph::edge\_property\_view\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph20edge_property_view_tE)
* [cugraph::edge\_src\_dummy\_property\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph25edge_src_dummy_property_tE)
* [cugraph::edge\_src\_property\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph19edge_src_property_tE)
* [cugraph::ext\_raft (C++ type)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph8ext_raftE)
* [cugraph::ext\_raft::balancedCutClustering (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph8ext_raft21balancedCutClusteringEvRKN6legacy12GraphCSRViewI2VT2ET2WTEE2VT2VT2WTi2WTiP2VT)
* [cugraph::ext\_raft::detail (C++ type)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph8ext_raft6detailE)
* [cugraph::ext\_raft::detail::analyzeBalancedCut\_impl (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph8ext_raft6detail23analyzeBalancedCut_implEvRKN6legacy12GraphCSRViewI8vertex_t6edge_t8weight_tEE8vertex_tPK8vertex_tP8weight_tP8weight_t)
* [cugraph::ext\_raft::detail::analyzeModularityClustering\_impl (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph8ext_raft6detail32analyzeModularityClustering_implEvRKN6legacy12GraphCSRViewI8vertex_t6edge_t8weight_tEEiPK8vertex_tP8weight_t)
* [cugraph::ext\_raft::detail::balancedCutClustering\_impl (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph8ext_raft6detail26balancedCutClustering_implEvRKN6legacy12GraphCSRViewI8vertex_t6edge_t8weight_tEE8vertex_t8vertex_t8weight_ti8weight_tiP8vertex_tP8weight_tP8weight_t)
* [cugraph::ext\_raft::detail::spectralModularityMaximization\_impl (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph8ext_raft6detail35spectralModularityMaximization_implEvRKN6legacy12GraphCSRViewI8vertex_t6edge_t8weight_tEE8vertex_t8vertex_t8weight_ti8weight_tiP8vertex_tP8weight_tP8weight_t)
* [cugraph::extract\_transform\_e (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00000EN7cugraph19extract_transform_eEDTcl25allocate_dataframe_bufferIN6detail19edge_op_result_typeIN13GraphViewType11vertex_typeEN13GraphViewType11vertex_typeEN24EdgeSrcValueInputWrapper10value_typeEN24EdgeDstValueInputWrapper10value_typeEN21EdgeValueInputWrapper10value_typeE6EdgeOpE4type10value_typeEEcl6size_tL0EEclN3rmm16cuda_stream_viewEEEERKN4raft8handle_tERK13GraphViewType24EdgeSrcValueInputWrapper24EdgeDstValueInputWrapper21EdgeValueInputWrapper6EdgeOpb)
* [cugraph::extract\_transform\_v\_frontier\_outgoing\_e (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000000EN7cugraph39extract_transform_v_frontier_outgoing_eEDTcl25allocate_dataframe_bufferIN6detail19edge_op_result_typeIN13KeyBucketType8key_typeEN13GraphViewType11vertex_typeEN24EdgeSrcValueInputWrapper10value_typeEN24EdgeDstValueInputWrapper10value_typeEN21EdgeValueInputWrapper10value_typeE6EdgeOpE4type10value_typeEEcl6size_tL0EEclN3rmm16cuda_stream_viewEEEERKN4raft8handle_tERK13GraphViewTypeRK13KeyBucketType24EdgeSrcValueInputWrapper24EdgeDstValueInputWrapper21EdgeValueInputWrapper6EdgeOpb)
* [cugraph::extract\_triangles\_endpoints (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph27extract_triangles_endpointsE)
* [cugraph::extract\_weak\_edges (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph18extract_weak_edgesE)
* [cugraph::fill\_edge\_dst\_property (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000EN7cugraph22fill_edge_dst_propertyEvRKN4raft8handle_tERK13GraphViewType14VertexIterator14VertexIterator25EdgeDstValueOutputWrapper1Tb)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph22fill_edge_dst_propertyEvRKN4raft8handle_tERK13GraphViewType25EdgeDstValueOutputWrapper1Tb)
* [cugraph::fill\_edge\_property (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph18fill_edge_propertyEvRKN4raft8handle_tERK13GraphViewType22EdgeValueOutputWrapper1Tb)
* [cugraph::fill\_edge\_src\_property (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000EN7cugraph22fill_edge_src_propertyEvRKN4raft8handle_tERK13GraphViewType14VertexIterator14VertexIterator25EdgeSrcValueOutputWrapper1Tb)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph22fill_edge_src_propertyEvRKN4raft8handle_tERK13GraphViewType25EdgeSrcValueOutputWrapper1Tb)
* [cugraph::flatten\_dendrogram (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_bEN7cugraph18flatten_dendrogramEvRKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuERK10DendrogramI8vertex_tEP8vertex_t)
* [cugraph::flatten\_leiden\_dendrogram (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_bEN7cugraph25flatten_leiden_dendrogramEvRKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuERK10DendrogramI8vertex_tEP8vertex_t)
* [cugraph::generator\_distribution\_t (C++ enum)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph24generator_distribution_tE)
* [cugraph::generator\_distribution\_t::POWER\_LAW (C++ enumerator)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph24generator_distribution_t9POWER_LAWE)
* [cugraph::generator\_distribution\_t::UNIFORM (C++ enumerator)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph24generator_distribution_t7UNIFORME)
* [cugraph::get\_dataframe\_buffer\_begin (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_PNSt11enable_if_tIN20is_arithmetic_vectorINSt11remove_cv_tI10BufferTypeEEN3rmm14device_uvectorEE5valueEEEEN7cugraph26get_dataframe_buffer_beginEDaR10BufferType)
* [cugraph::get\_dataframe\_buffer\_cbegin (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_PNSt11enable_if_tIN20is_arithmetic_vectorINSt11remove_cv_tI10BufferTypeEEN3rmm14device_uvectorEE5valueEEEEN7cugraph27get_dataframe_buffer_cbeginEDaR10BufferType)
* [cugraph::get\_dataframe\_buffer\_cend (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_PNSt11enable_if_tIN20is_arithmetic_vectorINSt11remove_cv_tI10BufferTypeEEN3rmm14device_uvectorEE5valueEEEEN7cugraph25get_dataframe_buffer_cendEDaR10BufferType)
* [cugraph::get\_dataframe\_buffer\_end (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_PNSt11enable_if_tIN20is_arithmetic_vectorINSt11remove_cv_tI10BufferTypeEEN3rmm14device_uvectorEE5valueEEEEN7cugraph24get_dataframe_buffer_endEDaR10BufferType)
* [cugraph::get\_first\_of\_pack (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0DpEN7cugraph17get_first_of_packEDcRR1TDpRR2Ts)
* [cugraph::get\_traversed\_cost (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph18get_traversed_costEvRKN4raft8handle_tEPK8vertex_tPK8vertex_tPK8weight_tP8weight_t8vertex_t8vertex_t)
* [cugraph::graph\_meta\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_b0EN7cugraph12graph_meta_tE)
* [cugraph::graph\_meta\_t> (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_bEN7cugraph12graph_meta_tI8vertex_t6edge_t9multi_gpuNSt11enable_if_tIXnt9multi_gpuEEEEE)
* [cugraph::graph\_meta\_t> (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_bEN7cugraph12graph_meta_tI8vertex_t6edge_t9multi_gpuNSt11enable_if_tI9multi_gpuEEEE)
* [cugraph::graph\_properties\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph18graph_properties_tE)
* [cugraph::graph\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_b_b0EN7cugraph7graph_tE)
* [cugraph::graph\_t> (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_b_bEN7cugraph7graph_tI8vertex_t6edge_t16store_transposed9multi_gpuNSt11enable_if_tIXnt9multi_gpuEEEEE)
* [cugraph::graph\_t> (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_b_bEN7cugraph7graph_tI8vertex_t6edge_t16store_transposed9multi_gpuNSt11enable_if_tI9multi_gpuEEEE)
* [cugraph::graph\_view\_meta\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_b_b0EN7cugraph17graph_view_meta_tE)
* [cugraph::graph\_view\_meta\_t> (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_b_bEN7cugraph17graph_view_meta_tI8vertex_t6edge_t16store_transposed9multi_gpuNSt11enable_if_tIXnt9multi_gpuEEEEE)
* [cugraph::graph\_view\_meta\_t> (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_b_bEN7cugraph17graph_view_meta_tI8vertex_t6edge_t16store_transposed9multi_gpuNSt11enable_if_tI9multi_gpuEEEE)
* [cugraph::graph\_view\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_b_b0EN7cugraph12graph_view_tE)
* [cugraph::graph\_view\_t> (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_b_bEN7cugraph12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuNSt11enable_if_tIXnt9multi_gpuEEEEE)
* [cugraph::graph\_view\_t> (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_b_bEN7cugraph12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuNSt11enable_if_tI9multi_gpuEEEE)
* [cugraph::groupby\_and\_count (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph17groupby_and_countEN3rmm14device_uvectorI6size_tEE14VertexIterator14VertexIterator13ValueIterator14KeyToGroupIdOpi6size_tN3rmm16cuda_stream_viewE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph17groupby_and_countEN3rmm14device_uvectorI6size_tEE13ValueIterator13ValueIterator16ValueToGroupIdOpi6size_tN3rmm16cuda_stream_viewE)
* [cugraph::groupby\_gpu\_id\_and\_shuffle\_kv\_pairs (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph35groupby_gpu_id_and_shuffle_kv_pairsEDaRKN4raft5comms7comms_tE14VertexIterator14VertexIterator13ValueIterator12KeyToGPUIdOpN3rmm16cuda_stream_viewE)
* [cugraph::groupby\_gpu\_id\_and\_shuffle\_values (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph33groupby_gpu_id_and_shuffle_valuesEDaRKN4raft5comms7comms_tE13ValueIterator13ValueIterator14ValueToGPUIdOpN3rmm16cuda_stream_viewE)
* [cugraph::has\_packed\_bool\_element (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph23has_packed_bool_elementEbv)
* [cugraph::host\_scalar\_allgather (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph21host_scalar_allgatherENSt11enable_if_tIN7cugraph29is_thrust_tuple_of_arithmeticI1TE5valueENSt6vectorI1TEEEERKN4raft5comms7comms_tE1T12cudaStream_t)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph21host_scalar_allgatherENSt11enable_if_tINSt13is_arithmeticI1TE5valueENSt6vectorI1TEEEERKN4raft5comms7comms_tE1T12cudaStream_t)
* [cugraph::host\_scalar\_allreduce (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph21host_scalar_allreduceENSt11enable_if_tIN7cugraph29is_thrust_tuple_of_arithmeticI1TE5valueE1TEERKN4raft5comms7comms_tE1TN4raft5comms4op_tE12cudaStream_t)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph21host_scalar_allreduceENSt11enable_if_tINSt13is_arithmeticI1TE5valueE1TEERKN4raft5comms7comms_tE1TN4raft5comms4op_tE12cudaStream_t)
* [cugraph::host\_scalar\_bcast (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph17host_scalar_bcastENSt11enable_if_tIN7cugraph29is_thrust_tuple_of_arithmeticI1TE5valueE1TEERKN4raft5comms7comms_tE1Ti12cudaStream_t)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph17host_scalar_bcastENSt11enable_if_tINSt13is_arithmeticI1TE5valueE1TEERKN4raft5comms7comms_tE1Ti12cudaStream_t)
* [cugraph::host\_scalar\_gather (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph18host_scalar_gatherENSt11enable_if_tIN7cugraph29is_thrust_tuple_of_arithmeticI1TE5valueENSt6vectorI1TEEEERKN4raft5comms7comms_tE1Ti12cudaStream_t)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph18host_scalar_gatherENSt11enable_if_tINSt13is_arithmeticI1TE5valueENSt6vectorI1TEEEERKN4raft5comms7comms_tE1Ti12cudaStream_t)
* [cugraph::host\_scalar\_reduce (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph18host_scalar_reduceENSt11enable_if_tIN7cugraph29is_thrust_tuple_of_arithmeticI1TE5valueE1TEERKN4raft5comms7comms_tE1TN4raft5comms4op_tEi12cudaStream_t)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph18host_scalar_reduceENSt11enable_if_tINSt13is_arithmeticI1TE5valueE1TEERKN4raft5comms7comms_tE1TN4raft5comms4op_tEi12cudaStream_t)
* [cugraph::host\_scalar\_scatter (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph19host_scalar_scatterENSt11enable_if_tIN7cugraph29is_thrust_tuple_of_arithmeticI1TE5valueE1TEERKN4raft5comms7comms_tERKNSt6vectorI1TEEi12cudaStream_t)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph19host_scalar_scatterENSt11enable_if_tINSt13is_arithmeticI1TE5valueE1TEERKN4raft5comms7comms_tERKNSt6vectorI1TEEi12cudaStream_t)
* [cugraph::internals (C++ type)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph9internalsE)
* [cugraph::internals::Callback (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph9internals8CallbackE)
* [cugraph::internals::GraphBasedDimRedCallback (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph9internals24GraphBasedDimRedCallbackE)
* [cugraph::invalid\_component\_id (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph20invalid_component_idE)
* [cugraph::invalid\_component\_id\_v (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph22invalid_component_id_vE)
* [cugraph::invalid\_edge\_id (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph15invalid_edge_idE)
* [cugraph::invalid\_edge\_id\_v (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph17invalid_edge_id_vE)
* [cugraph::invalid\_idx (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph11invalid_idxE)
* [cugraph::invalid\_idx::value && std::is\_signed::value>> (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph11invalid_idxI1TNSt11enable_if_tIXaaNSt11is_integralI1TE5valueENSt9is_signedI1TE5valueEEEEEE)
* [cugraph::invalid\_idx::value && std::is\_unsigned::value>> (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph11invalid_idxI1TNSt11enable_if_tIXaaNSt11is_integralI1TE5valueENSt11is_unsignedI1TE5valueEEEEEE)
* [cugraph::invalid\_vertex\_id (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph17invalid_vertex_idE)
* [cugraph::invalid\_vertex\_id\_v (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph19invalid_vertex_id_vE)
* [cugraph::is\_arithmetic\_or\_thrust\_tuple\_of\_arithmetic (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph43is_arithmetic_or_thrust_tuple_of_arithmeticE)
* [cugraph::is\_arithmetic\_or\_thrust\_tuple\_of\_arithmetic> (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4IDpEN7cugraph43is_arithmetic_or_thrust_tuple_of_arithmeticIN6thrust5tupleIDp2TsEEEE)
* [cugraph::is\_arithmetic\_vector (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0I0E0EN7cugraph20is_arithmetic_vectorE)
* [cugraph::is\_arithmetic\_vector, Vector> (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4II0E00EN7cugraph20is_arithmetic_vectorI6VectorI1TE6VectorEE)
* [cugraph::is\_candidate (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph12is_candidateE)
* [cugraph::is\_candidate\_legacy (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph19is_candidate_legacyE)
* [cugraph::is\_k\_or\_greater\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph17is_k_or_greater_tE)
* [cugraph::is\_one\_of (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00DpEN7cugraph9is_one_ofE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I0DpEN7cugraph9is_one_ofE)
, [\[2\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph9is_one_ofE)
* [cugraph::is\_packed\_bool (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph14is_packed_boolEbv)
* [cugraph::is\_std\_tuple (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph12is_std_tupleE)
* [cugraph::is\_std\_tuple> (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4IDpEN7cugraph12is_std_tupleINSt5tupleIDp2TsEEEE)
* [cugraph::is\_std\_tuple\_of\_arithmetic\_vectors (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph34is_std_tuple_of_arithmetic_vectorsE)
* [cugraph::is\_std\_tuple\_of\_arithmetic\_vectors...>> (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4IDpEN7cugraph34is_std_tuple_of_arithmetic_vectorsINSt5tupleIDpN3rmm14device_uvectorI2TsEEEEEE)
* [cugraph::is\_thrust\_tuple (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph15is_thrust_tupleE)
* [cugraph::is\_thrust\_tuple> (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4IDpEN7cugraph15is_thrust_tupleIN6thrust5tupleIDp2TsEEEE)
* [cugraph::is\_thrust\_tuple\_of\_arithmetic (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph29is_thrust_tuple_of_arithmeticE)
* [cugraph::is\_thrust\_tuple\_of\_arithmetic> (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4IDpEN7cugraph29is_thrust_tuple_of_arithmeticIN6thrust5tupleIDp2TsEEEE)
* [cugraph::is\_thrust\_tuple\_of\_integral (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph27is_thrust_tuple_of_integralE)
* [cugraph::is\_thrust\_tuple\_of\_integral> (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4IDpEN7cugraph27is_thrust_tuple_of_integralIN6thrust5tupleIDp2TsEEEE)
* [cugraph::is\_vertex\_edge\_combo (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph20is_vertex_edge_comboE)
* [cugraph::is\_vertex\_edge\_combo\_legacy (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph27is_vertex_edge_combo_legacyE)
* [cugraph::k\_core (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000_bEN7cugraph6k_coreENSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEEEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEE6size_tNSt8optionalI20k_core_degree_type_tEENSt8optionalIN4raft11device_spanIK6edge_tEEEEb)
* [cugraph::k\_core\_degree\_type\_t (C++ enum)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph20k_core_degree_type_tE)
* [cugraph::k\_core\_degree\_type\_t::IN (C++ enumerator)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph20k_core_degree_type_t2INE)
* [cugraph::k\_core\_degree\_type\_t::INOUT (C++ enumerator)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph20k_core_degree_type_t5INOUTE)
* [cugraph::k\_core\_degree\_type\_t::OUT (C++ enumerator)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph20k_core_degree_type_t3OUTE)
* [cugraph::k\_hop\_nbrs (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_bEN7cugraph10k_hop_nbrsENSt5tupleIN3rmm14device_uvectorI6size_tEEN3rmm14device_uvectorI8vertex_tEEEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuEN4raft11device_spanIK8vertex_tEE6size_tb)
* [cugraph::key\_bucket\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_b_bEN7cugraph12key_bucket_tE)
* [cugraph::key\_bucket\_t::insert (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_PNSt11enable_if_tINSt9is_same_vI8tag_typevEEEEEN7cugraph12key_bucket_t6insertEv14VertexIterator14VertexIterator)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_PNSt11enable_if_tIXntNSt9is_same_vI8tag_typevEEEEEEN7cugraph12key_bucket_t6insertEv11KeyIterator11KeyIterator)
, [\[2\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_PNSt11enable_if_tINSt9is_same_vI8tag_typevEEEEEN7cugraph12key_bucket_t6insertEv8vertex_t)
, [\[3\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_PNSt11enable_if_tIXntNSt9is_same_vI8tag_typevEEEEEEN7cugraph12key_bucket_t6insertEvN6thrust5tupleI8vertex_t8tag_typeEE)
* [cugraph::key\_store\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_bEN7cugraph11key_store_tE)
* [cugraph::kv\_store\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_bEN7cugraph10kv_store_tE)
* [cugraph::legacy (C++ type)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6legacyE)
* [cugraph::legacy::DegreeDirection (C++ enum)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6legacy15DegreeDirectionE)
* [cugraph::legacy::DegreeDirection::DEGREE\_DIRECTION\_COUNT (C++ enumerator)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6legacy15DegreeDirection22DEGREE_DIRECTION_COUNTE)
* [cugraph::legacy::DegreeDirection::IN (C++ enumerator)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6legacy15DegreeDirection2INE)
* [cugraph::legacy::DegreeDirection::IN\_PLUS\_OUT (C++ enumerator)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6legacy15DegreeDirection11IN_PLUS_OUTE)
* [cugraph::legacy::DegreeDirection::OUT (C++ enumerator)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6legacy15DegreeDirection3OUTE)
* [cugraph::legacy::GraphCompressedSparseBase (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6legacy25GraphCompressedSparseBaseE)
, [\[1\]](../api_docs/cugraph_cpp/graph_legacy_cpp/#_CPPv4I000EN7cugraph6legacy25GraphCompressedSparseBaseE)
* [cugraph::legacy::GraphCompressedSparseBaseView (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6legacy29GraphCompressedSparseBaseViewE)
, [\[1\]](../api_docs/cugraph_cpp/graph_legacy_cpp/#_CPPv4I000EN7cugraph6legacy29GraphCompressedSparseBaseViewE)
* [cugraph::legacy::GraphCompressedSparseBaseView::indices (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6legacy29GraphCompressedSparseBaseView7indicesE)
, [\[1\]](../api_docs/cugraph_cpp/graph_legacy_cpp/#_CPPv4N7cugraph6legacy29GraphCompressedSparseBaseView7indicesE)
* [cugraph::legacy::GraphCompressedSparseBaseView::offsets (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6legacy29GraphCompressedSparseBaseView7offsetsE)
, [\[1\]](../api_docs/cugraph_cpp/graph_legacy_cpp/#_CPPv4N7cugraph6legacy29GraphCompressedSparseBaseView7offsetsE)
* [cugraph::legacy::GraphCOO (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6legacy8GraphCOOE)
, [\[1\]](../api_docs/cugraph_cpp/graph_legacy_cpp/#_CPPv4I000EN7cugraph6legacy8GraphCOOE)
* [cugraph::legacy::GraphCOOContents (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6legacy16GraphCOOContentsE)
, [\[1\]](../api_docs/cugraph_cpp/graph_legacy_cpp/#_CPPv4I000EN7cugraph6legacy16GraphCOOContentsE)
* [cugraph::legacy::GraphCOOView (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6legacy12GraphCOOViewE)
, [\[1\]](../api_docs/cugraph_cpp/graph_legacy_cpp/#_CPPv4I000EN7cugraph6legacy12GraphCOOViewE)
* [cugraph::legacy::GraphCOOView::dst\_indices (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6legacy12GraphCOOView11dst_indicesE)
, [\[1\]](../api_docs/cugraph_cpp/graph_legacy_cpp/#_CPPv4N7cugraph6legacy12GraphCOOView11dst_indicesE)
* [cugraph::legacy::GraphCOOView::GraphCOOView (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6legacy12GraphCOOView12GraphCOOViewEv)
, [\[1\]](../api_docs/cugraph_cpp/graph_legacy_cpp/#_CPPv4N7cugraph6legacy12GraphCOOView12GraphCOOViewEv)
* [cugraph::legacy::GraphCOOView::src\_indices (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6legacy12GraphCOOView11src_indicesE)
, [\[1\]](../api_docs/cugraph_cpp/graph_legacy_cpp/#_CPPv4N7cugraph6legacy12GraphCOOView11src_indicesE)
* [cugraph::legacy::GraphCSR (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6legacy8GraphCSRE)
, [\[1\]](../api_docs/cugraph_cpp/graph_legacy_cpp/#_CPPv4I000EN7cugraph6legacy8GraphCSRE)
* [cugraph::legacy::GraphCSRView (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6legacy12GraphCSRViewE)
, [\[1\]](../api_docs/cugraph_cpp/graph_legacy_cpp/#_CPPv4I000EN7cugraph6legacy12GraphCSRViewE)
* [cugraph::legacy::GraphCSRView::GraphCSRView (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6legacy12GraphCSRView12GraphCSRViewEv)
, [\[1\]](../api_docs/cugraph_cpp/graph_legacy_cpp/#_CPPv4N7cugraph6legacy12GraphCSRView12GraphCSRViewEv)
* [cugraph::legacy::GraphProperties (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6legacy15GraphPropertiesE)
* [cugraph::legacy::GraphSparseContents (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6legacy19GraphSparseContentsE)
* [cugraph::legacy::GraphViewBase (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph6legacy13GraphViewBaseE)
, [\[1\]](../api_docs/cugraph_cpp/graph_legacy_cpp/#_CPPv4I000EN7cugraph6legacy13GraphViewBaseE)
* [cugraph::legacy::GraphViewBase::edge\_data (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6legacy13GraphViewBase9edge_dataE)
, [\[1\]](../api_docs/cugraph_cpp/graph_legacy_cpp/#_CPPv4N7cugraph6legacy13GraphViewBase9edge_dataE)
* [cugraph::legacy::invalid\_edge\_id (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6legacy15invalid_edge_idE)
* [cugraph::legacy::invalid\_idx (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph6legacy11invalid_idxE)
* [cugraph::legacy::invalid\_idx::value && std::is\_signed::value>> (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6legacy11invalid_idxI1TNSt11enable_if_tIXaaNSt11is_integralI1TE5valueENSt9is_signedI1TE5valueEEEEEE)
* [cugraph::legacy::invalid\_idx::value && std::is\_unsigned::value>> (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6legacy11invalid_idxI1TNSt11enable_if_tIXaaNSt11is_integralI1TE5valueENSt11is_unsignedI1TE5valueEEEEEE)
* [cugraph::legacy::invalid\_vertex\_id (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph6legacy17invalid_vertex_idE)
* [cugraph::legacy::PropType (C++ enum)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6legacy8PropTypeE)
* [cugraph::legacy::PropType::PROP\_FALSE (C++ enumerator)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6legacy8PropType10PROP_FALSEE)
* [cugraph::legacy::PropType::PROP\_TRUE (C++ enumerator)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6legacy8PropType9PROP_TRUEE)
* [cugraph::legacy::PropType::PROP\_UNDEF (C++ enumerator)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph6legacy8PropType10PROP_UNDEFE)
* [cugraph::logic\_error (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph11logic_errorE)
* [cugraph::lookup\_container\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000EN7cugraph18lookup_container_tE)
* [cugraph::lookup\_container\_t::lookup\_container\_impl (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000EN7cugraph18lookup_container_t21lookup_container_implE)
* [cugraph::lookup\_endpoints\_from\_edge\_ids\_and\_single\_type (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000_bEN7cugraph46lookup_endpoints_from_edge_ids_and_single_typeENSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEERKN4raft8handle_tERK18lookup_container_tI9edge_id_t11edge_type_t8vertex_tEN4raft11device_spanIK9edge_id_tEE11edge_type_t)
* [cugraph::lookup\_endpoints\_from\_edge\_ids\_and\_types (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000_bEN7cugraph40lookup_endpoints_from_edge_ids_and_typesENSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEERKN4raft8handle_tERK18lookup_container_tI9edge_id_t11edge_type_t8vertex_tEN4raft11device_spanIK9edge_id_tEEN4raft11device_spanIK11edge_type_tEE)
* [cugraph::max\_identity\_element (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph20max_identity_elementENSt11enable_if_tIN29is_thrust_tuple_of_arithmeticI1TE5valueE1TEEv)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph20max_identity_elementENSt11enable_if_tINSt13is_arithmeticI1TE5valueE1TEEv)
* [cugraph::max\_thrust\_tuple\_element\_sizes (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph30max_thrust_tuple_element_sizesE6size_tv)
* [cugraph::min\_identity\_element (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph20min_identity_elementENSt11enable_if_tIN29is_thrust_tuple_of_arithmeticI1TE5valueE1TEEv)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph20min_identity_elementENSt11enable_if_tINSt13is_arithmeticI1TE5valueE1TEEv)
* [cugraph::min\_thrust\_tuple\_element\_sizes (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph30min_thrust_tuple_element_sizesE6size_tv)
* [cugraph::mtmg (C++ type)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph4mtmgE)
* [cugraph::mtmg::create\_graph\_from\_edgelist (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00000_b_bEN7cugraph4mtmg26create_graph_from_edgelistEvRK8handle_tRN7cugraph4mtmg10edgelist_tI8vertex_t8weight_t9edge_id_t11edge_type_tEE18graph_properties_tbRN7cugraph4mtmg7graph_tI8vertex_t6edge_t16store_transposed9multi_gpuEERNSt8optionalIN7cugraph4mtmg15edge_property_tIN7cugraph4mtmg12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuEE8weight_tEEEERNSt8optionalIN7cugraph4mtmg15edge_property_tIN7cugraph4mtmg12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuEE9edge_id_tEEEERNSt8optionalIN7cugraph4mtmg15edge_property_tIN7cugraph4mtmg12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuEE11edge_type_tEEEERNSt8optionalIN7cugraph4mtmg14renumber_map_tI8vertex_tEEEEb)
* [cugraph::mtmg::detail (C++ type)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph4mtmg6detailE)
* [cugraph::mtmg::detail::device\_shared\_device\_span\_t (C++ type)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph4mtmg6detail27device_shared_device_span_tE)
* [cugraph::mtmg::detail::device\_shared\_device\_span\_tuple\_t (C++ type)](../api_docs/cugraph_cpp/full_api/#_CPPv4IDpEN7cugraph4mtmg6detail33device_shared_device_span_tuple_tE)
* [cugraph::mtmg::detail::device\_shared\_device\_vector\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph4mtmg6detail29device_shared_device_vector_tE)
* [cugraph::mtmg::detail::device\_shared\_device\_vector\_t::view (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph4mtmg6detail29device_shared_device_vector_t4viewEv)
* [cugraph::mtmg::detail::device\_shared\_device\_vector\_tuple\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4IDpEN7cugraph4mtmg6detail35device_shared_device_vector_tuple_tE)
* [cugraph::mtmg::detail::device\_shared\_device\_vector\_tuple\_t::view (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph4mtmg6detail35device_shared_device_vector_tuple_t4viewEv)
* [cugraph::mtmg::detail::device\_shared\_wrapper\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph4mtmg6detail23device_shared_wrapper_tE)
* [cugraph::mtmg::detail::device\_shared\_wrapper\_t::get (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph4mtmg6detail23device_shared_wrapper_t3getERKN7cugraph4mtmg8handle_tE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4NK7cugraph4mtmg6detail23device_shared_wrapper_t3getERKN7cugraph4mtmg8handle_tE)
* [cugraph::mtmg::detail::device\_shared\_wrapper\_t::set (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph4mtmg6detail23device_shared_wrapper_t3setERKN7cugraph4mtmg8handle_tERR9wrapped_t)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph4mtmg6detail23device_shared_wrapper_t3setEiRR9wrapped_t)
* [cugraph::mtmg::detail::per\_device\_edgelist\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000EN7cugraph4mtmg6detail21per_device_edgelist_tE)
* [cugraph::mtmg::detail::per\_device\_edgelist\_t::append (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph4mtmg6detail21per_device_edgelist_t6appendEN4raft9host_spanIK8vertex_tEEN4raft9host_spanIK8vertex_tEENSt8optionalIN4raft9host_spanIK8weight_tEEEENSt8optionalIN4raft9host_spanIK6edge_tEEEENSt8optionalIN4raft9host_spanIK11edge_type_tEEEEN3rmm16cuda_stream_viewE)
* [cugraph::mtmg::detail::per\_device\_edgelist\_t::consolidate\_and\_shuffle (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph4mtmg6detail21per_device_edgelist_t23consolidate_and_shuffleERKN7cugraph4mtmg8handle_tEb)
* [cugraph::mtmg::detail::per\_device\_edgelist\_t::finalize\_buffer (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph4mtmg6detail21per_device_edgelist_t15finalize_bufferEN3rmm16cuda_stream_viewE)
* [cugraph::mtmg::detail::per\_device\_edgelist\_t::per\_device\_edgelist\_t (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph4mtmg6detail21per_device_edgelist_t21per_device_edgelist_tE6size_tbbbN3rmm16cuda_stream_viewE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph4mtmg6detail21per_device_edgelist_t21per_device_edgelist_tERR21per_device_edgelist_t)
* [cugraph::mtmg::edge\_property\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph4mtmg15edge_property_tE)
* [cugraph::mtmg::edge\_property\_t::view (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph4mtmg15edge_property_t4viewEv)
* [cugraph::mtmg::edge\_property\_view\_t (C++ type)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph4mtmg20edge_property_view_tE)
* [cugraph::mtmg::edgelist\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000EN7cugraph4mtmg10edgelist_tE)
* [cugraph::mtmg::edgelist\_t::consolidate\_and\_shuffle (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph4mtmg10edgelist_t23consolidate_and_shuffleERKN7cugraph4mtmg8handle_tEb)
* [cugraph::mtmg::edgelist\_t::finalize\_buffer (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph4mtmg10edgelist_t15finalize_bufferERK8handle_t)
* [cugraph::mtmg::edgelist\_t::set (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph4mtmg10edgelist_t3setERK8handle_t6size_tbbb)
* [cugraph::mtmg::graph\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_b_bEN7cugraph4mtmg7graph_tE)
* [cugraph::mtmg::graph\_t::view (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph4mtmg7graph_t4viewEv)
* [cugraph::mtmg::graph\_view\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_b_bEN7cugraph4mtmg12graph_view_tE)
* [cugraph::mtmg::graph\_view\_t::get\_vertex\_partition\_range\_lasts (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4NK7cugraph4mtmg12graph_view_t32get_vertex_partition_range_lastsERKN7cugraph4mtmg8handle_tE)
* [cugraph::mtmg::graph\_view\_t::get\_vertex\_partition\_view (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4NK7cugraph4mtmg12graph_view_t25get_vertex_partition_viewERKN7cugraph4mtmg8handle_tE)
* [cugraph::mtmg::handle\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph4mtmg8handle_tE)
* [cugraph::mtmg::handle\_t::get\_rank (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4NK7cugraph4mtmg8handle_t8get_rankEv)
* [cugraph::mtmg::handle\_t::get\_size (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4NK7cugraph4mtmg8handle_t8get_sizeEv)
* [cugraph::mtmg::handle\_t::get\_stream (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4NK7cugraph4mtmg8handle_t10get_streamEv)
* [cugraph::mtmg::handle\_t::get\_thread\_rank (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4NK7cugraph4mtmg8handle_t15get_thread_rankEv)
* [cugraph::mtmg::handle\_t::get\_thrust\_policy (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4NK7cugraph4mtmg8handle_t17get_thrust_policyEN3rmm16cuda_stream_viewE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4NK7cugraph4mtmg8handle_t17get_thrust_policyEv)
* [cugraph::mtmg::handle\_t::handle\_t (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph4mtmg8handle_t8handle_tERKN4raft8handle_tEiN3rmm14cuda_device_idE)
* [cugraph::mtmg::handle\_t::raft\_handle (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4NK7cugraph4mtmg8handle_t11raft_handleEv)
* [cugraph::mtmg::handle\_t::sync\_stream (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4NK7cugraph4mtmg8handle_t11sync_streamEN3rmm16cuda_stream_viewE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4NK7cugraph4mtmg8handle_t11sync_streamEv)
* [cugraph::mtmg::handle\_t::sync\_stream\_pool (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4NK7cugraph4mtmg8handle_t16sync_stream_poolEv)
* [cugraph::mtmg::instance\_manager\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph4mtmg18instance_manager_tE)
* [cugraph::mtmg::instance\_manager\_t::get\_handle (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph4mtmg18instance_manager_t10get_handleEii)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph4mtmg18instance_manager_t10get_handleEv)
* [cugraph::mtmg::instance\_manager\_t::get\_local\_gpu\_count (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph4mtmg18instance_manager_t19get_local_gpu_countEv)
* [cugraph::mtmg::instance\_manager\_t::instance\_manager\_t (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph4mtmg18instance_manager_t18instance_manager_tERRNSt6vectorINSt10unique_ptrIN4raft8handle_tEEEEERRNSt6vectorINSt10unique_ptrI10ncclComm_tEEEERRNSt6vectorIN3rmm14cuda_device_idEEE)
* [cugraph::mtmg::instance\_manager\_t::reset\_threads (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph4mtmg18instance_manager_t13reset_threadsEv)
* [cugraph::mtmg::per\_thread\_edgelist\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000EN7cugraph4mtmg21per_thread_edgelist_tE)
* [cugraph::mtmg::per\_thread\_edgelist\_t::append (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph4mtmg21per_thread_edgelist_t6appendE8vertex_t8vertex_tNSt8optionalI8weight_tEENSt8optionalI6edge_tEENSt8optionalI11edge_type_tEEN3rmm16cuda_stream_viewE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph4mtmg21per_thread_edgelist_t6appendEN4raft9host_spanIK8vertex_tEEN4raft9host_spanIK8vertex_tEENSt8optionalIN4raft9host_spanIK8weight_tEEEENSt8optionalIN4raft9host_spanIK6edge_tEEEENSt8optionalIN4raft9host_spanIK11edge_type_tEEEEN3rmm16cuda_stream_viewE)
* [cugraph::mtmg::per\_thread\_edgelist\_t::flush (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph4mtmg21per_thread_edgelist_t5flushEN3rmm16cuda_stream_viewEb)
* [cugraph::mtmg::per\_thread\_edgelist\_t::per\_thread\_edgelist\_t (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph4mtmg21per_thread_edgelist_t21per_thread_edgelist_tERN6detail21per_device_edgelist_tI8vertex_t8weight_t6edge_t11edge_type_tEE6size_t)
* [cugraph::mtmg::renumber\_map\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph4mtmg14renumber_map_tE)
* [cugraph::mtmg::renumber\_map\_t::view (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph4mtmg14renumber_map_t4viewEv)
* [cugraph::mtmg::renumber\_map\_view\_t (C++ type)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph4mtmg19renumber_map_view_tE)
* [cugraph::mtmg::resource\_manager\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph4mtmg18resource_manager_tE)
* [cugraph::mtmg::resource\_manager\_t::create\_instance\_manager (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4NK7cugraph4mtmg18resource_manager_t23create_instance_managerENSt6vectorIiEE12ncclUniqueId6size_t)
* [cugraph::mtmg::resource\_manager\_t::register\_local\_gpu (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph4mtmg18resource_manager_t18register_local_gpuEiN3rmm14cuda_device_idE)
* [cugraph::mtmg::resource\_manager\_t::register\_remote\_gpu (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph4mtmg18resource_manager_t19register_remote_gpuEi)
* [cugraph::mtmg::resource\_manager\_t::registered\_ranks (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4NK7cugraph4mtmg18resource_manager_t16registered_ranksEv)
* [cugraph::mtmg::resource\_manager\_t::resource\_manager\_t (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph4mtmg18resource_manager_t18resource_manager_tEv)
* [cugraph::mtmg::vertex\_pair\_result\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph4mtmg20vertex_pair_result_tE)
* [cugraph::mtmg::vertex\_pair\_result\_t::view (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph4mtmg20vertex_pair_result_t4viewEv)
* [cugraph::mtmg::vertex\_pair\_result\_view\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph4mtmg25vertex_pair_result_view_tE)
* [cugraph::mtmg::vertex\_pair\_result\_view\_t::gather (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I_bEN7cugraph4mtmg25vertex_pair_result_view_t6gatherENSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8result_tEEEERK8handle_tN4raft11device_spanIK8vertex_tEERKNSt6vectorI8vertex_tEEN7cugraph23vertex_partition_view_tI8vertex_t9multi_gpuEERNSt8optionalIN7cugraph4mtmg19renumber_map_view_tI8vertex_tEEEE)
* [cugraph::mtmg::vertex\_result\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph4mtmg15vertex_result_tE)
* [cugraph::mtmg::vertex\_result\_t::view (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph4mtmg15vertex_result_t4viewEv)
* [cugraph::mtmg::vertex\_result\_view\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph4mtmg20vertex_result_view_tE)
* [cugraph::mtmg::vertex\_result\_view\_t::gather (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_bEN7cugraph4mtmg20vertex_result_view_t6gatherEN3rmm14device_uvectorI8result_tEERK8handle_tN4raft11device_spanIK8vertex_tEERKNSt6vectorI8vertex_tEEN7cugraph23vertex_partition_view_tI8vertex_t9multi_gpuEERNSt8optionalIN7cugraph4mtmg19renumber_map_view_tI8vertex_tEEEE8result_t)
* [cugraph::packed\_bool\_empty\_mask (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph22packed_bool_empty_maskEv)
* [cugraph::packed\_bool\_full\_mask (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph21packed_bool_full_maskEv)
* [cugraph::packed\_bool\_mask (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph16packed_bool_maskE8uint32_t1T)
* [cugraph::packed\_bool\_offset (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph18packed_bool_offsetE1T1T)
* [cugraph::packed\_bool\_partial\_mask (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph24packed_bool_partial_maskE8uint32_t1T)
* [cugraph::packed\_bool\_size (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph16packed_bool_sizeE6size_t)
* [cugraph::packed\_bools\_per\_word (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph21packed_bools_per_wordEv)
* [cugraph::partition\_at\_level (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_bEN7cugraph18partition_at_levelEvRKN4raft8handle_tERK10DendrogramI8vertex_tEPK8vertex_tP8vertex_t6size_t)
* [cugraph::partition\_manager (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph17partition_managerE)
* [cugraph::partition\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph11partition_tE)
* [cugraph::per\_v\_pair\_dst\_nbr\_intersection (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph31per_v_pair_dst_nbr_intersectionENSt5tupleIN3rmm14device_uvectorI6size_tEEN3rmm14device_uvectorIN13GraphViewType11vertex_typeEEEEERKN4raft8handle_tERK13GraphViewType18VertexPairIterator18VertexPairIteratorb)
* [cugraph::per\_v\_pair\_transform\_dst\_nbr\_intersection (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000000EN7cugraph41per_v_pair_transform_dst_nbr_intersectionEvRKN4raft8handle_tERK13GraphViewType22EdgeValueInputIterator18VertexPairIterator18VertexPairIterator24VertexValueInputIterator14IntersectionOp29VertexPairValueOutputIteratorb)
* [cugraph::per\_v\_random\_select\_transform\_outgoing\_e (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000000000000EN7cugraph40per_v_random_select_transform_outgoing_eENSt5tupleINSt8optionalIN3rmm14device_uvectorI6size_tEEEE23dataframe_buffer_type_tI1TEEERKN4raft8handle_tERK13GraphViewTypeRK13KeyBucketType28BiasEdgeSrcValueInputWrapper28BiasEdgeDstValueInputWrapper25BiasEdgeValueInputWrapper10BiasEdgeOp24EdgeSrcValueInputWrapper24EdgeDstValueInputWrapper21EdgeValueInputWrapper6EdgeOp20EdgeTypeInputWrapperRN4raft6random8RngStateEN4raft9host_spanIK6size_tEEbNSt8optionalI1TEEb)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00000000000EN7cugraph40per_v_random_select_transform_outgoing_eENSt5tupleINSt8optionalIN3rmm14device_uvectorI6size_tEEEE23dataframe_buffer_type_tI1TEEERKN4raft8handle_tERK13GraphViewTypeRK13KeyBucketType28BiasEdgeSrcValueInputWrapper28BiasEdgeDstValueInputWrapper25BiasEdgeValueInputWrapper10BiasEdgeOp24EdgeSrcValueInputWrapper24EdgeDstValueInputWrapper21EdgeValueInputWrapper6EdgeOpRN4raft6random8RngStateE6size_tbNSt8optionalI1TEEb)
, [\[2\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00000000EN7cugraph40per_v_random_select_transform_outgoing_eENSt5tupleINSt8optionalIN3rmm14device_uvectorI6size_tEEEE23dataframe_buffer_type_tI1TEEERKN4raft8handle_tERK13GraphViewTypeRK13KeyBucketType24EdgeSrcValueInputWrapper24EdgeDstValueInputWrapper21EdgeValueInputWrapper6EdgeOp20EdgeTypeInputWrapperRN4raft6random8RngStateEN4raft9host_spanIK6size_tEEbNSt8optionalI1TEEb)
, [\[3\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000000EN7cugraph40per_v_random_select_transform_outgoing_eENSt5tupleINSt8optionalIN3rmm14device_uvectorI6size_tEEEE23dataframe_buffer_type_tI1TEEERKN4raft8handle_tERK13GraphViewTypeRK13KeyBucketType24EdgeSrcValueInputWrapper24EdgeDstValueInputWrapper21EdgeValueInputWrapper6EdgeOpRN4raft6random8RngStateE6size_tbNSt8optionalI1TEEb)
* [cugraph::per\_v\_transform\_reduce\_dst\_key\_aggregated\_outgoing\_e (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000000000EN7cugraph52per_v_transform_reduce_dst_key_aggregated_outgoing_eEvRKN4raft8handle_tERK13GraphViewType24EdgeSrcValueInputWrapper21EdgeValueInputWrapper22EdgeDstKeyInputWrapper15KVStoreViewType19KeyAggregatedEdgeOp1T8ReduceOp25VertexValueOutputIteratorb)
* [cugraph::per\_v\_transform\_reduce\_if\_incoming\_e (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000000000EN7cugraph36per_v_transform_reduce_if_incoming_eEvRKN4raft8handle_tERK13GraphViewTypeRK13KeyBucketType24EdgeSrcValueInputWrapper24EdgeDstValueInputWrapper21EdgeValueInputWrapper6EdgeOp1T8ReduceOp6PredOp25VertexValueOutputIteratorb)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I000000000EN7cugraph36per_v_transform_reduce_if_incoming_eEvRKN4raft8handle_tERK13GraphViewType24EdgeSrcValueInputWrapper24EdgeDstValueInputWrapper21EdgeValueInputWrapper6EdgeOp1T8ReduceOp6PredOp25VertexValueOutputIteratorb)
* [cugraph::per\_v\_transform\_reduce\_if\_outgoing\_e (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000000000EN7cugraph36per_v_transform_reduce_if_outgoing_eEvRKN4raft8handle_tERK13GraphViewTypeRK13KeyBucketType24EdgeSrcValueInputWrapper24EdgeDstValueInputWrapper21EdgeValueInputWrapper6EdgeOp1T8ReduceOp6PredOp25VertexValueOutputIteratorb)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I000000000EN7cugraph36per_v_transform_reduce_if_outgoing_eEvRKN4raft8handle_tERK13GraphViewType24EdgeSrcValueInputWrapper24EdgeDstValueInputWrapper21EdgeValueInputWrapper6EdgeOp1T8ReduceOp6PredOp25VertexValueOutputIteratorb)
* [cugraph::per\_v\_transform\_reduce\_incoming\_e (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000000000EN7cugraph33per_v_transform_reduce_incoming_eEvRKN4raft8handle_tERK13GraphViewTypeRK13KeyBucketType24EdgeSrcValueInputWrapper24EdgeDstValueInputWrapper21EdgeValueInputWrapper6EdgeOp1T8ReduceOp25VertexValueOutputIteratorb)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00000000EN7cugraph33per_v_transform_reduce_incoming_eEvRKN4raft8handle_tERK13GraphViewType24EdgeSrcValueInputWrapper24EdgeDstValueInputWrapper21EdgeValueInputWrapper6EdgeOp1T8ReduceOp25VertexValueOutputIteratorb)
* [cugraph::per\_v\_transform\_reduce\_outgoing\_e (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000000000EN7cugraph33per_v_transform_reduce_outgoing_eEvRKN4raft8handle_tERK13GraphViewTypeRK13KeyBucketType24EdgeSrcValueInputWrapper24EdgeDstValueInputWrapper21EdgeValueInputWrapper6EdgeOp1T8ReduceOp25VertexValueOutputIteratorb)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00000000EN7cugraph33per_v_transform_reduce_outgoing_eEvRKN4raft8handle_tERK13GraphViewType24EdgeSrcValueInputWrapper24EdgeDstValueInputWrapper21EdgeValueInputWrapper6EdgeOp1T8ReduceOp25VertexValueOutputIteratorb)
* [cugraph::property\_op (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0I0E0EN7cugraph11property_opE)
* [cugraph::property\_op, Op> (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4IDpI0E0EN7cugraph11property_opIN6thrust5tupleIDp4ArgsEE2OpEE)
* [cugraph::query\_rw\_sizes\_offsets (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph22query_rw_sizes_offsetsENSt5tupleIN3rmm14device_uvectorI7index_tEEN3rmm14device_uvectorI7index_tEEN3rmm14device_uvectorI7index_tEEEERKN4raft8handle_tE7index_tPK7index_t)
* [cugraph::reduce\_op (C++ type)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph9reduce_opE)
* [cugraph::reduce\_op::any (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph9reduce_op3anyE)
* [cugraph::reduce\_op::detail (C++ type)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph9reduce_op6detailE)
* [cugraph::reduce\_op::elementwise\_maximum (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph9reduce_op19elementwise_maximumE)
* [cugraph::reduce\_op::elementwise\_minimum (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph9reduce_op19elementwise_minimumE)
* [cugraph::reduce\_op::has\_compatible\_raft\_comms\_op (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph9reduce_op28has_compatible_raft_comms_opE)
* [cugraph::reduce\_op::has\_compatible\_raft\_comms\_op> (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph9reduce_op28has_compatible_raft_comms_opI8ReduceOpNSt11remove_cv_tIDTN8ReduceOp24compatible_raft_comms_opEEEEEE)
* [cugraph::reduce\_op::has\_compatible\_raft\_comms\_op\_v (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph9reduce_op30has_compatible_raft_comms_op_vE)
* [cugraph::reduce\_op::has\_identity\_element (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph9reduce_op20has_identity_elementE)
* [cugraph::reduce\_op::has\_identity\_element> (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph9reduce_op20has_identity_elementI8ReduceOpNSt11remove_cv_tIDTN8ReduceOp16identity_elementEEEEEE)
* [cugraph::reduce\_op::has\_identity\_element\_v (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph9reduce_op22has_identity_element_vE)
* [cugraph::reduce\_op::maximum (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph9reduce_op7maximumE)
* [cugraph::reduce\_op::maximum::value>> (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph9reduce_op7maximumI1TNSt11enable_if_tIN7cugraph29is_thrust_tuple_of_arithmeticI1TE5valueEEEEE)
* [cugraph::reduce\_op::maximum>> (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph9reduce_op7maximumI1TNSt11enable_if_tINSt15is_arithmetic_vI1TEEEEEE)
* [cugraph::reduce\_op::minimum (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph9reduce_op7minimumE)
* [cugraph::reduce\_op::minimum::value>> (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph9reduce_op7minimumI1TNSt11enable_if_tIN7cugraph29is_thrust_tuple_of_arithmeticI1TE5valueEEEEE)
* [cugraph::reduce\_op::minimum>> (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph9reduce_op7minimumI1TNSt11enable_if_tINSt15is_arithmetic_vI1TEEEEEE)
* [cugraph::reduce\_op::null (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph9reduce_op4nullE)
* [cugraph::reduce\_op::plus (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph9reduce_op4plusE)
* [cugraph::reduce\_v (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000EN7cugraph8reduce_vE1TRKN4raft8handle_tERK13GraphViewType24VertexValueInputIterator1T8ReduceOpb)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph8reduce_vE1TRKN4raft8handle_tERK13GraphViewType24VertexValueInputIterator1Tb)
, [\[2\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00EN7cugraph8reduce_vEDaRKN4raft8handle_tERK13GraphViewType24VertexValueInputIteratorb)
* [cugraph::renumber\_meta\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_b0EN7cugraph15renumber_meta_tE)
* [cugraph::renumber\_meta\_t> (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_bEN7cugraph15renumber_meta_tI8vertex_t6edge_t9multi_gpuNSt11enable_if_tIXnt9multi_gpuEEEEE)
* [cugraph::renumber\_meta\_t> (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_bEN7cugraph15renumber_meta_tI8vertex_t6edge_t9multi_gpuNSt11enable_if_tI9multi_gpuEEEE)
* [cugraph::reserve\_dataframe\_buffer (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph24reserve_dataframe_bufferEvR10BufferType6size_tN3rmm16cuda_stream_viewE)
* [cugraph::resize\_dataframe\_buffer (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph23resize_dataframe_bufferEvR10BufferType6size_tN3rmm16cuda_stream_viewE)
* [cugraph::retrieve\_vertex\_list\_from\_bitmap (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph32retrieve_vertex_list_from_bitmapEvN4raft11device_spanIK8uint32_tEE20OutputVertexIteratorN4raft11device_spanI6size_tEEN6thrust15iterator_traitsI20OutputVertexIteratorE10value_typeEN6thrust15iterator_traitsI20OutputVertexIteratorE10value_typeEN3rmm16cuda_stream_viewE)
* [cugraph::sampling\_flags\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph16sampling_flags_tE)
* [cugraph::sampling\_flags\_t::dedupe\_sources (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph16sampling_flags_t14dedupe_sourcesE)
* [cugraph::sampling\_flags\_t::prior\_sources\_behavior (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph16sampling_flags_t22prior_sources_behaviorE)
* [cugraph::sampling\_flags\_t::return\_hops (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph16sampling_flags_t11return_hopsE)
* [cugraph::sampling\_flags\_t::with\_replacement (C++ member)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph16sampling_flags_t16with_replacementE)
* [cugraph::sampling\_params\_t (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph17sampling_params_tE)
* [cugraph::sampling\_strategy\_t (C++ enum)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph19sampling_strategy_tE)
* [cugraph::sampling\_strategy\_t::BIASED (C++ enumerator)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph19sampling_strategy_t6BIASEDE)
* [cugraph::sampling\_strategy\_t::NODE2VEC (C++ enumerator)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph19sampling_strategy_t8NODE2VECE)
* [cugraph::sampling\_strategy\_t::UNIFORM (C++ enumerator)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph19sampling_strategy_t7UNIFORME)
* [cugraph::shrink\_to\_fit\_dataframe\_buffer (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph30shrink_to_fit_dataframe_bufferEvR10BufferTypeN3rmm16cuda_stream_viewE)
* [cugraph::shuffle\_and\_unique\_segment\_sorted\_values (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph40shuffle_and_unique_segment_sorted_valuesEDaRKN4raft5comms7comms_tE15TxValueIteratorRKNSt6vectorI6size_tEEN3rmm16cuda_stream_viewE)
* [cugraph::shuffle\_external\_edges (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00000EN7cugraph22shuffle_external_edgesENSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI6edge_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_time_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_time_tEEEENSt6vectorI6size_tEEEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEERRNSt8optionalIN3rmm14device_uvectorI8weight_tEEEERRNSt8optionalIN3rmm14device_uvectorI6edge_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_time_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_time_tEEEE)
* [cugraph::shuffle\_values (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph14shuffle_valuesEDaRKN4raft5comms7comms_tE15TxValueIteratorRKNSt6vectorI6size_tEE6size_tNSt8optionalIN6thrust15iterator_traitsI15TxValueIteratorE10value_typeEEEN3rmm16cuda_stream_viewE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph14shuffle_valuesEDaRKN4raft5comms7comms_tE15TxValueIteratorRKNSt6vectorI6size_tEEN3rmm16cuda_stream_viewE)
* [cugraph::size\_dataframe\_buffer (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph21size_dataframe_bufferE6size_tR10BufferType)
* [cugraph::std\_tuple\_to\_thrust\_tuple (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph25std_tuple_to_thrust_tupleEDa9TupleType)
* [cugraph::subgraph (C++ type)](../api_docs/cugraph_cpp/full_api/#_CPPv4N7cugraph8subgraphE)
* [cugraph::sum\_thrust\_tuple\_element\_sizes (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph30sum_thrust_tuple_element_sizesE6size_tv)
* [cugraph::symmetrize\_edgelist (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_b_bEN7cugraph19symmetrize_edgelistENSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEEEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEERRNSt8optionalIN3rmm14device_uvectorI8weight_tEEEEb)
* [cugraph::thrust\_tuple\_cat (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4IDpEN7cugraph16thrust_tuple_catEDaDp10TupleTypes)
* [cugraph::thrust\_tuple\_get (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_6size_tEN7cugraph16thrust_tuple_getE)
* [cugraph::thrust\_tuple\_get\_or\_identity (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_6size_t_PNSt11enable_if_tINSt15is_arithmetic_vI1TEEEEEN7cugraph28thrust_tuple_get_or_identityEDa1T)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_6size_t_PNSt11enable_if_tINSt15is_arithmetic_vIN6thrust15iterator_traitsI8IteratorE10value_typeEEEEEEN7cugraph28thrust_tuple_get_or_identityEDa8Iterator)
* [cugraph::thrust\_tuple\_of\_arithmetic\_numeric\_limits\_lowest (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph48thrust_tuple_of_arithmetic_numeric_limits_lowestE9TupleTypev)
* [cugraph::thrust\_tuple\_of\_arithmetic\_numeric\_limits\_max (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph45thrust_tuple_of_arithmetic_numeric_limits_maxE9TupleTypev)
* [cugraph::thrust\_tuple\_size\_or\_one (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph24thrust_tuple_size_or_oneE)
* [cugraph::thrust\_tuple\_size\_or\_one> (C++ struct)](../api_docs/cugraph_cpp/full_api/#_CPPv4IDpEN7cugraph24thrust_tuple_size_or_oneIN6thrust5tupleIDp2TsEEEE)
* [cugraph::thrust\_tuple\_to\_std\_tuple (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph25thrust_tuple_to_std_tupleEDa9TupleType)
* [cugraph::to\_thrust\_iterator\_tuple (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_PNSt11enable_if_tINSt15is_arithmetic_vINSt15iterator_traitsI8IteratorE10value_typeEEEEEEN7cugraph24to_thrust_iterator_tupleEDa8Iterator)
* [cugraph::to\_thrust\_tuple (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph15to_thrust_tupleEDa1T)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4IDpEN7cugraph15to_thrust_tupleEDaN6thrust5tupleIDp2TsEE)
* [cugraph::transform\_e (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000000EN7cugraph11transform_eEvRKN4raft8handle_tERK13GraphViewTypeRK14EdgeBucketType24EdgeSrcValueInputWrapper24EdgeDstValueInputWrapper21EdgeValueInputWrapper6EdgeOp22EdgeValueOutputWrapperb)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I000000EN7cugraph11transform_eEvRKN4raft8handle_tERK13GraphViewType24EdgeSrcValueInputWrapper24EdgeDstValueInputWrapper21EdgeValueInputWrapper6EdgeOp22EdgeValueOutputWrapperb)
* [cugraph::transform\_reduce\_dst\_nbr\_intersection\_of\_e\_endpoints\_by\_v (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000000EN7cugraph57transform_reduce_dst_nbr_intersection_of_e_endpoints_by_vEvRKN4raft8handle_tERK13GraphViewType24EdgeSrcValueInputWrapper24EdgeDstValueInputWrapper14IntersectionOp1T25VertexValueOutputIteratorb)
* [cugraph::transform\_reduce\_e (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I000000EN7cugraph18transform_reduce_eE1TRKN4raft8handle_tERK13GraphViewType24EdgeSrcValueInputWrapper24EdgeDstValueInputWrapper21EdgeValueInputWrapper6EdgeOp1Tb)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I00000EN7cugraph18transform_reduce_eEDaRKN4raft8handle_tERK13GraphViewType24EdgeSrcValueInputWrapper24EdgeDstValueInputWrapper21EdgeValueInputWrapper6EdgeOpb)
* [cugraph::transform\_reduce\_e\_by\_dst\_key (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00000000EN7cugraph29transform_reduce_e_by_dst_keyEDaRKN4raft8handle_tERK13GraphViewType24EdgeSrcValueInputWrapper24EdgeDstValueInputWrapper21EdgeValueInputWrapper22EdgeDstKeyInputWrapper6EdgeOp1T8ReduceOpb)
* [cugraph::transform\_reduce\_e\_by\_src\_key (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00000000EN7cugraph29transform_reduce_e_by_src_keyEDaRKN4raft8handle_tERK13GraphViewType24EdgeSrcValueInputWrapper24EdgeDstValueInputWrapper21EdgeValueInputWrapper22EdgeSrcKeyInputWrapper6EdgeOp1T8ReduceOpb)
* [cugraph::transform\_reduce\_v (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00000EN7cugraph18transform_reduce_vE1TRKN4raft8handle_tERK13GraphViewType24VertexValueInputIterator8VertexOp1T8ReduceOpb)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000EN7cugraph18transform_reduce_vE1TRKN4raft8handle_tERK13GraphViewType24VertexValueInputIterator8VertexOp1Tb)
, [\[2\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph18transform_reduce_vEDaRKN4raft8handle_tERK13GraphViewType24VertexValueInputIterator8VertexOpb)
* [cugraph::transform\_reduce\_v\_frontier\_outgoing\_e\_by\_dst (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000000EN7cugraph45transform_reduce_v_frontier_outgoing_e_by_dstENSt13conditional_tIXntNSt9is_same_vIN8ReduceOp10value_typeEvEEENSt5tupleIDTcl25allocate_dataframe_bufferIN13KeyBucketType8key_typeEEL0EclN3rmm16cuda_stream_viewEEEEDTclN6detail34allocate_optional_dataframe_bufferIN8ReduceOp10value_typeEEEL0EclN3rmm16cuda_stream_viewEEEEEEDTcl25allocate_dataframe_bufferIN13KeyBucketType8key_typeEEL0EclN3rmm16cuda_stream_viewEEEEEERKN4raft8handle_tERK13GraphViewTypeRK13KeyBucketType24EdgeSrcValueInputWrapper24EdgeDstValueInputWrapper21EdgeValueInputWrapper6EdgeOp8ReduceOpb)
* [cugraph::try\_allocate\_dataframe\_buffer (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0EN7cugraph29try_allocate_dataframe_bufferENSt8optionalI23dataframe_buffer_type_tI1TEEE6size_tN3rmm16cuda_stream_viewE)
* [cugraph::update\_edge\_dst\_property (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000EN7cugraph24update_edge_dst_propertyEvRKN4raft8handle_tERK13GraphViewType14VertexIterator14VertexIterator27VertexPropertyInputIterator25EdgeDstValueOutputWrapperb)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph24update_edge_dst_propertyEvRKN4raft8handle_tERK13GraphViewType27VertexPropertyInputIterator25EdgeDstValueOutputWrapperb)
* [cugraph::update\_edge\_src\_property (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000EN7cugraph24update_edge_src_propertyEvRKN4raft8handle_tERK13GraphViewType14VertexIterator14VertexIterator27VertexPropertyInputIterator25EdgeSrcValueOutputWrapperb)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I000EN7cugraph24update_edge_src_propertyEvRKN4raft8handle_tERK13GraphViewType27VertexPropertyInputIterator25EdgeSrcValueOutputWrapperb)
* [cugraph::update\_v\_frontier (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0000000EN7cugraph17update_v_frontierEvRKN4raft8handle_tERK13GraphViewTypeRR9KeyBufferRR13PayloadBufferR18VertexFrontierTypeRKNSt6vectorI6size_tEE24VertexValueInputIterator25VertexValueOutputIterator8VertexOpb)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I000000EN7cugraph17update_v_frontierEvRKN4raft8handle_tERK13GraphViewTypeRR9KeyBufferR18VertexFrontierTypeRKNSt6vectorI6size_tEE24VertexValueInputIterator25VertexValueOutputIterator8VertexOpb)
* [cugraph::vertex\_frontier\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I00_b_bEN7cugraph17vertex_frontier_tE)
* [cugraph::vertex\_partition\_device\_view\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_b0EN7cugraph30vertex_partition_device_view_tE)
* [cugraph::vertex\_partition\_device\_view\_t> (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_bEN7cugraph30vertex_partition_device_view_tI8vertex_t9multi_gpuNSt11enable_if_tIXnt9multi_gpuEEEEE)
* [cugraph::vertex\_partition\_device\_view\_t> (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_bEN7cugraph30vertex_partition_device_view_tI8vertex_t9multi_gpuNSt11enable_if_tI9multi_gpuEEEE)
* [cugraph::vertex\_partition\_view\_t (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_b0EN7cugraph23vertex_partition_view_tE)
* [cugraph::vertex\_partition\_view\_t> (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_bEN7cugraph23vertex_partition_view_tI8vertex_t9multi_gpuNSt11enable_if_tIXnt9multi_gpuEEEEE)
* [cugraph::vertex\_partition\_view\_t> (C++ class)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0_bEN7cugraph23vertex_partition_view_tI8vertex_t9multi_gpuNSt11enable_if_tI9multi_gpuEEEE)
* [cugraph::view\_concat (C++ function)](../api_docs/cugraph_cpp/full_api/#_CPPv4I0DpDpEN7cugraph11view_concatEDaDpRK20edge_property_view_tI6edge_t5Iters5TypesE)
, [\[1\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I0DpDpEN7cugraph11view_concatEDaDpRKN6detail26edge_major_property_view_tI8vertex_t5Iters5TypesEE)
, [\[2\]](../api_docs/cugraph_cpp/full_api/#_CPPv4I0DpDpEN7cugraph11view_concatEDaDpRKN6detail26edge_minor_property_view_tI8vertex_t5Iters5TypesEE)
* [cugraph\_analyze\_clustering\_edge\_cut (C++ function)](../api_docs/cugraph_c/community/#_CPPv435cugraph_analyze_clustering_edge_cutPK25cugraph_resource_handle_tP15cugraph_graph_t6size_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_tPdPP15cugraph_error_t)
* [cugraph\_analyze\_clustering\_modularity (C++ function)](../api_docs/cugraph_c/community/#_CPPv437cugraph_analyze_clustering_modularityPK25cugraph_resource_handle_tP15cugraph_graph_t6size_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_tPdPP15cugraph_error_t)
* [cugraph\_analyze\_clustering\_ratio\_cut (C++ function)](../api_docs/cugraph_c/community/#_CPPv436cugraph_analyze_clustering_ratio_cutPK25cugraph_resource_handle_tP15cugraph_graph_t6size_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_tPdPP15cugraph_error_t)
* [cugraph\_balanced\_cut\_clustering (C++ function)](../api_docs/cugraph_c/community/#_CPPv431cugraph_balanced_cut_clusteringPK25cugraph_resource_handle_tP15cugraph_graph_t6size_t6size_tdidi6bool_tPP27cugraph_clustering_result_tPP15cugraph_error_t)
* [cugraph\_betweenness\_centrality (C++ function)](../api_docs/cugraph_c/centrality/#_CPPv430cugraph_betweenness_centralityPK25cugraph_resource_handle_tP15cugraph_graph_tPK39cugraph_type_erased_device_array_view_t6bool_t6bool_t6bool_tPP27cugraph_centrality_result_tPP15cugraph_error_t)
* [cugraph\_bfs (C++ function)](../api_docs/cugraph_c/traversal/#_CPPv411cugraph_bfsPK25cugraph_resource_handle_tP15cugraph_graph_tP39cugraph_type_erased_device_array_view_t6bool_t6size_t6bool_t6bool_tPP22cugraph_paths_result_tPP15cugraph_error_t)
* [cugraph\_biased\_random\_walks (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv427cugraph_biased_random_walksPK25cugraph_resource_handle_tP19cugraph_rng_state_tP15cugraph_graph_tPK39cugraph_type_erased_device_array_view_t6size_tPP28cugraph_random_walk_result_tPP15cugraph_error_t)
* [cugraph\_centrality\_result\_converged (C++ function)](../api_docs/cugraph_c/centrality/#_CPPv435cugraph_centrality_result_convergedP27cugraph_centrality_result_t)
* [cugraph\_centrality\_result\_free (C++ function)](../api_docs/cugraph_c/centrality/#_CPPv430cugraph_centrality_result_freeP27cugraph_centrality_result_t)
* [cugraph\_centrality\_result\_get\_num\_iterations (C++ function)](../api_docs/cugraph_c/centrality/#_CPPv444cugraph_centrality_result_get_num_iterationsP27cugraph_centrality_result_t)
* [cugraph\_centrality\_result\_get\_values (C++ function)](../api_docs/cugraph_c/centrality/#_CPPv436cugraph_centrality_result_get_valuesP27cugraph_centrality_result_t)
* [cugraph\_centrality\_result\_get\_vertices (C++ function)](../api_docs/cugraph_c/centrality/#_CPPv438cugraph_centrality_result_get_verticesP27cugraph_centrality_result_t)
* [cugraph\_core\_number (C++ function)](../api_docs/cugraph_c/core/#_CPPv419cugraph_core_numberPK25cugraph_resource_handle_tP15cugraph_graph_t28cugraph_k_core_degree_type_t6bool_tPP21cugraph_core_result_tPP15cugraph_error_t)
* [cugraph\_core\_result\_create (C++ function)](../api_docs/cugraph_c/core/#_CPPv426cugraph_core_result_createPK25cugraph_resource_handle_tP39cugraph_type_erased_device_array_view_tP39cugraph_type_erased_device_array_view_tPP21cugraph_core_result_tPP15cugraph_error_t)
* [cugraph\_core\_result\_free (C++ function)](../api_docs/cugraph_c/core/#_CPPv424cugraph_core_result_freeP21cugraph_core_result_t)
* [cugraph\_core\_result\_get\_core\_numbers (C++ function)](../api_docs/cugraph_c/core/#_CPPv436cugraph_core_result_get_core_numbersP21cugraph_core_result_t)
* [cugraph\_core\_result\_get\_vertices (C++ function)](../api_docs/cugraph_c/core/#_CPPv432cugraph_core_result_get_verticesP21cugraph_core_result_t)
* [cugraph\_ecg (C++ function)](../api_docs/cugraph_c/community/#_CPPv411cugraph_ecgPK25cugraph_resource_handle_tP19cugraph_rng_state_tP15cugraph_graph_td6size_t6size_tdd6bool_tPP40cugraph_hierarchical_clustering_result_tPP15cugraph_error_t)
* [cugraph\_edge\_betweenness\_centrality (C++ function)](../api_docs/cugraph_c/centrality/#_CPPv435cugraph_edge_betweenness_centralityPK25cugraph_resource_handle_tP15cugraph_graph_tPK39cugraph_type_erased_device_array_view_t6bool_t6bool_tPP32cugraph_edge_centrality_result_tPP15cugraph_error_t)
* [cugraph\_edge\_centrality\_result\_free (C++ function)](../api_docs/cugraph_c/centrality/#_CPPv435cugraph_edge_centrality_result_freeP32cugraph_edge_centrality_result_t)
* [cugraph\_edge\_centrality\_result\_get\_dst\_vertices (C++ function)](../api_docs/cugraph_c/centrality/#_CPPv447cugraph_edge_centrality_result_get_dst_verticesP32cugraph_edge_centrality_result_t)
* [cugraph\_edge\_centrality\_result\_get\_edge\_ids (C++ function)](../api_docs/cugraph_c/centrality/#_CPPv443cugraph_edge_centrality_result_get_edge_idsP32cugraph_edge_centrality_result_t)
* [cugraph\_edge\_centrality\_result\_get\_src\_vertices (C++ function)](../api_docs/cugraph_c/centrality/#_CPPv447cugraph_edge_centrality_result_get_src_verticesP32cugraph_edge_centrality_result_t)
* [cugraph\_edge\_centrality\_result\_get\_values (C++ function)](../api_docs/cugraph_c/centrality/#_CPPv441cugraph_edge_centrality_result_get_valuesP32cugraph_edge_centrality_result_t)
* [cugraph\_eigenvector\_centrality (C++ function)](../api_docs/cugraph_c/centrality/#_CPPv430cugraph_eigenvector_centralityPK25cugraph_resource_handle_tP15cugraph_graph_td6size_t6bool_tPP27cugraph_centrality_result_tPP15cugraph_error_t)
* [cugraph\_extract\_ego (C++ function)](../api_docs/cugraph_c/community/#_CPPv419cugraph_extract_egoPK25cugraph_resource_handle_tP15cugraph_graph_tPK39cugraph_type_erased_device_array_view_t6size_t6bool_tPP33cugraph_induced_subgraph_result_tPP15cugraph_error_t)
* [cugraph\_extract\_paths (C++ function)](../api_docs/cugraph_c/traversal/#_CPPv421cugraph_extract_pathsPK25cugraph_resource_handle_tP15cugraph_graph_tPK39cugraph_type_erased_device_array_view_tPK22cugraph_paths_result_tPK39cugraph_type_erased_device_array_view_tPP30cugraph_extract_paths_result_tPP15cugraph_error_t)
* [cugraph\_extract\_paths\_result\_free (C++ function)](../api_docs/cugraph_c/traversal/#_CPPv433cugraph_extract_paths_result_freeP30cugraph_extract_paths_result_t)
* [cugraph\_extract\_paths\_result\_get\_max\_path\_length (C++ function)](../api_docs/cugraph_c/traversal/#_CPPv448cugraph_extract_paths_result_get_max_path_lengthP30cugraph_extract_paths_result_t)
* [cugraph\_extract\_paths\_result\_get\_paths (C++ function)](../api_docs/cugraph_c/traversal/#_CPPv438cugraph_extract_paths_result_get_pathsP30cugraph_extract_paths_result_t)
* [cugraph\_hierarchical\_clustering\_result\_free (C++ function)](../api_docs/cugraph_c/community/#_CPPv443cugraph_hierarchical_clustering_result_freeP40cugraph_hierarchical_clustering_result_t)
* [cugraph\_hierarchical\_clustering\_result\_get\_clusters (C++ function)](../api_docs/cugraph_c/community/#_CPPv451cugraph_hierarchical_clustering_result_get_clustersP40cugraph_hierarchical_clustering_result_t)
* [cugraph\_hierarchical\_clustering\_result\_get\_modularity (C++ function)](../api_docs/cugraph_c/community/#_CPPv453cugraph_hierarchical_clustering_result_get_modularityP40cugraph_hierarchical_clustering_result_t)
* [cugraph\_hierarchical\_clustering\_result\_get\_vertices (C++ function)](../api_docs/cugraph_c/community/#_CPPv451cugraph_hierarchical_clustering_result_get_verticesP40cugraph_hierarchical_clustering_result_t)
* [cugraph\_hits (C++ function)](../api_docs/cugraph_c/centrality/#_CPPv412cugraph_hitsPK25cugraph_resource_handle_tP15cugraph_graph_td6size_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_t6bool_t6bool_tPP21cugraph_hits_result_tPP15cugraph_error_t)
* [cugraph\_hits\_result\_free (C++ function)](../api_docs/cugraph_c/centrality/#_CPPv424cugraph_hits_result_freeP21cugraph_hits_result_t)
* [cugraph\_hits\_result\_get\_authorities (C++ function)](../api_docs/cugraph_c/centrality/#_CPPv435cugraph_hits_result_get_authoritiesP21cugraph_hits_result_t)
* [cugraph\_hits\_result\_get\_hub\_score\_differences (C++ function)](../api_docs/cugraph_c/centrality/#_CPPv445cugraph_hits_result_get_hub_score_differencesP21cugraph_hits_result_t)
* [cugraph\_hits\_result\_get\_hubs (C++ function)](../api_docs/cugraph_c/centrality/#_CPPv428cugraph_hits_result_get_hubsP21cugraph_hits_result_t)
* [cugraph\_hits\_result\_get\_number\_of\_iterations (C++ function)](../api_docs/cugraph_c/centrality/#_CPPv444cugraph_hits_result_get_number_of_iterationsP21cugraph_hits_result_t)
* [cugraph\_hits\_result\_get\_vertices (C++ function)](../api_docs/cugraph_c/centrality/#_CPPv432cugraph_hits_result_get_verticesP21cugraph_hits_result_t)
* [cugraph\_jaccard\_coefficients (C++ function)](../api_docs/cugraph_c/similarity/#_CPPv428cugraph_jaccard_coefficientsPK25cugraph_resource_handle_tP15cugraph_graph_tPK22cugraph_vertex_pairs_t6bool_t6bool_tPP27cugraph_similarity_result_tPP15cugraph_error_t)
* [cugraph\_k\_core (C++ function)](../api_docs/cugraph_c/core/#_CPPv414cugraph_k_corePK25cugraph_resource_handle_tP15cugraph_graph_t6size_t28cugraph_k_core_degree_type_tPK21cugraph_core_result_t6bool_tPP23cugraph_k_core_result_tPP15cugraph_error_t)
* [cugraph\_k\_core\_degree\_type\_t (C++ enum)](../api_docs/cugraph_c/core/#_CPPv428cugraph_k_core_degree_type_t)
* [cugraph\_k\_core\_degree\_type\_t::K\_CORE\_DEGREE\_TYPE\_IN (C++ enumerator)](../api_docs/cugraph_c/core/#_CPPv4N28cugraph_k_core_degree_type_t21K_CORE_DEGREE_TYPE_INE)
* [cugraph\_k\_core\_degree\_type\_t::K\_CORE\_DEGREE\_TYPE\_INOUT (C++ enumerator)](../api_docs/cugraph_c/core/#_CPPv4N28cugraph_k_core_degree_type_t24K_CORE_DEGREE_TYPE_INOUTE)
* [cugraph\_k\_core\_degree\_type\_t::K\_CORE\_DEGREE\_TYPE\_OUT (C++ enumerator)](../api_docs/cugraph_c/core/#_CPPv4N28cugraph_k_core_degree_type_t22K_CORE_DEGREE_TYPE_OUTE)
* [cugraph\_k\_core\_result\_free (C++ function)](../api_docs/cugraph_c/core/#_CPPv426cugraph_k_core_result_freeP23cugraph_k_core_result_t)
* [cugraph\_k\_core\_result\_get\_dst\_vertices (C++ function)](../api_docs/cugraph_c/core/#_CPPv438cugraph_k_core_result_get_dst_verticesP23cugraph_k_core_result_t)
* [cugraph\_k\_core\_result\_get\_src\_vertices (C++ function)](../api_docs/cugraph_c/core/#_CPPv438cugraph_k_core_result_get_src_verticesP23cugraph_k_core_result_t)
* [cugraph\_k\_core\_result\_get\_weights (C++ function)](../api_docs/cugraph_c/core/#_CPPv433cugraph_k_core_result_get_weightsP23cugraph_k_core_result_t)
* [cugraph\_katz\_centrality (C++ function)](../api_docs/cugraph_c/centrality/#_CPPv423cugraph_katz_centralityPK25cugraph_resource_handle_tP15cugraph_graph_tPK39cugraph_type_erased_device_array_view_tddd6size_t6bool_tPP27cugraph_centrality_result_tPP15cugraph_error_t)
* [cugraph\_labeling\_result\_free (C++ function)](../api_docs/cugraph_c/labeling/#_CPPv428cugraph_labeling_result_freeP25cugraph_labeling_result_t)
* [cugraph\_labeling\_result\_get\_labels (C++ function)](../api_docs/cugraph_c/labeling/#_CPPv434cugraph_labeling_result_get_labelsP25cugraph_labeling_result_t)
* [cugraph\_labeling\_result\_get\_vertices (C++ function)](../api_docs/cugraph_c/labeling/#_CPPv436cugraph_labeling_result_get_verticesP25cugraph_labeling_result_t)
* [cugraph\_leiden (C++ function)](../api_docs/cugraph_c/community/#_CPPv414cugraph_leidenPK25cugraph_resource_handle_tP19cugraph_rng_state_tP15cugraph_graph_t6size_tdd6bool_tPP40cugraph_hierarchical_clustering_result_tPP15cugraph_error_t)
* [cugraph\_lookup\_container\_free (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv429cugraph_lookup_container_freeP26cugraph_lookup_container_t)
* [cugraph\_lookup\_result\_free (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv426cugraph_lookup_result_freeP23cugraph_lookup_result_t)
* [cugraph\_lookup\_result\_get\_dsts (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv430cugraph_lookup_result_get_dstsPK23cugraph_lookup_result_t)
* [cugraph\_lookup\_result\_get\_srcs (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv430cugraph_lookup_result_get_srcsPK23cugraph_lookup_result_t)
* [cugraph\_louvain (C++ function)](../api_docs/cugraph_c/community/#_CPPv415cugraph_louvainPK25cugraph_resource_handle_tP15cugraph_graph_t6size_tdd6bool_tPP40cugraph_hierarchical_clustering_result_tPP15cugraph_error_t)
* [cugraph\_negative\_sampling (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv425cugraph_negative_samplingPK25cugraph_resource_handle_tP19cugraph_rng_state_tP15cugraph_graph_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_t6size_t6bool_t6bool_t6bool_t6bool_tPP13cugraph_coo_tPP15cugraph_error_t)
* [cugraph\_node2vec (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv416cugraph_node2vecPK25cugraph_resource_handle_tP15cugraph_graph_tPK39cugraph_type_erased_device_array_view_t6size_t6bool_tddPP28cugraph_random_walk_result_tPP15cugraph_error_t)
* [cugraph\_node2vec\_random\_walks (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv429cugraph_node2vec_random_walksPK25cugraph_resource_handle_tP19cugraph_rng_state_tP15cugraph_graph_tPK39cugraph_type_erased_device_array_view_t6size_tddPP28cugraph_random_walk_result_tPP15cugraph_error_t)
* [cugraph\_overlap\_coefficients (C++ function)](../api_docs/cugraph_c/similarity/#_CPPv428cugraph_overlap_coefficientsPK25cugraph_resource_handle_tP15cugraph_graph_tPK22cugraph_vertex_pairs_t6bool_t6bool_tPP27cugraph_similarity_result_tPP15cugraph_error_t)
* [cugraph\_pagerank (C++ function)](../api_docs/cugraph_c/centrality/#_CPPv416cugraph_pagerankPK25cugraph_resource_handle_tP15cugraph_graph_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_tdd6size_t6bool_tPP27cugraph_centrality_result_tPP15cugraph_error_t)
* [cugraph\_pagerank\_allow\_nonconvergence (C++ function)](../api_docs/cugraph_c/centrality/#_CPPv437cugraph_pagerank_allow_nonconvergencePK25cugraph_resource_handle_tP15cugraph_graph_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_tdd6size_t6bool_tPP27cugraph_centrality_result_tPP15cugraph_error_t)
* [cugraph\_paths\_result\_free (C++ function)](../api_docs/cugraph_c/traversal/#_CPPv425cugraph_paths_result_freeP22cugraph_paths_result_t)
* [cugraph\_paths\_result\_get\_distances (C++ function)](../api_docs/cugraph_c/traversal/#_CPPv434cugraph_paths_result_get_distancesP22cugraph_paths_result_t)
* [cugraph\_paths\_result\_get\_predecessors (C++ function)](../api_docs/cugraph_c/traversal/#_CPPv437cugraph_paths_result_get_predecessorsP22cugraph_paths_result_t)
* [cugraph\_paths\_result\_get\_vertices (C++ function)](../api_docs/cugraph_c/traversal/#_CPPv433cugraph_paths_result_get_verticesP22cugraph_paths_result_t)
* [cugraph\_personalized\_pagerank (C++ function)](../api_docs/cugraph_c/centrality/#_CPPv429cugraph_personalized_pagerankPK25cugraph_resource_handle_tP15cugraph_graph_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_tdd6size_t6bool_tPP27cugraph_centrality_result_tPP15cugraph_error_t)
* [cugraph\_personalized\_pagerank\_allow\_nonconvergence (C++ function)](../api_docs/cugraph_c/centrality/#_CPPv450cugraph_personalized_pagerank_allow_nonconvergencePK25cugraph_resource_handle_tP15cugraph_graph_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_tdd6size_t6bool_tPP27cugraph_centrality_result_tPP15cugraph_error_t)
* [cugraph\_random\_walk\_result\_free (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv431cugraph_random_walk_result_freeP28cugraph_random_walk_result_t)
* [cugraph\_random\_walk\_result\_get\_max\_path\_length (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv446cugraph_random_walk_result_get_max_path_lengthP28cugraph_random_walk_result_t)
* [cugraph\_random\_walk\_result\_get\_path\_sizes (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv441cugraph_random_walk_result_get_path_sizesP28cugraph_random_walk_result_t)
* [cugraph\_random\_walk\_result\_get\_paths (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv436cugraph_random_walk_result_get_pathsP28cugraph_random_walk_result_t)
* [cugraph\_random\_walk\_result\_get\_weights (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv438cugraph_random_walk_result_get_weightsP28cugraph_random_walk_result_t)
* [cugraph\_sample\_result\_free (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv426cugraph_sample_result_freeP23cugraph_sample_result_t)
* [cugraph\_sample\_result\_get\_edge\_id (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv433cugraph_sample_result_get_edge_idPK23cugraph_sample_result_t)
* [cugraph\_sample\_result\_get\_edge\_renumber\_map (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv443cugraph_sample_result_get_edge_renumber_mapPK23cugraph_sample_result_t)
* [cugraph\_sample\_result\_get\_edge\_renumber\_map\_offsets (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv451cugraph_sample_result_get_edge_renumber_map_offsetsPK23cugraph_sample_result_t)
* [cugraph\_sample\_result\_get\_edge\_type (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv435cugraph_sample_result_get_edge_typePK23cugraph_sample_result_t)
* [cugraph\_sample\_result\_get\_edge\_weight (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv437cugraph_sample_result_get_edge_weightPK23cugraph_sample_result_t)
* [cugraph\_sample\_result\_get\_hop (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv429cugraph_sample_result_get_hopPK23cugraph_sample_result_t)
* [cugraph\_sample\_result\_get\_index (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv431cugraph_sample_result_get_indexPK23cugraph_sample_result_t)
* [cugraph\_sample\_result\_get\_label\_hop\_offsets (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv443cugraph_sample_result_get_label_hop_offsetsPK23cugraph_sample_result_t)
* [cugraph\_sample\_result\_get\_label\_type\_hop\_offsets (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv448cugraph_sample_result_get_label_type_hop_offsetsPK23cugraph_sample_result_t)
* [cugraph\_sample\_result\_get\_major\_offsets (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv439cugraph_sample_result_get_major_offsetsPK23cugraph_sample_result_t)
* [cugraph\_sample\_result\_get\_majors (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv432cugraph_sample_result_get_majorsPK23cugraph_sample_result_t)
* [cugraph\_sample\_result\_get\_minors (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv432cugraph_sample_result_get_minorsPK23cugraph_sample_result_t)
* [cugraph\_sample\_result\_get\_renumber\_map (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv438cugraph_sample_result_get_renumber_mapPK23cugraph_sample_result_t)
* [cugraph\_sample\_result\_get\_renumber\_map\_offsets (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv446cugraph_sample_result_get_renumber_map_offsetsPK23cugraph_sample_result_t)
* [cugraph\_sample\_result\_get\_start\_labels (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv438cugraph_sample_result_get_start_labelsPK23cugraph_sample_result_t)
* [cugraph\_sampling\_options\_create (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv431cugraph_sampling_options_createPP26cugraph_sampling_options_tPP15cugraph_error_t)
* [cugraph\_sampling\_options\_free (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv429cugraph_sampling_options_freeP26cugraph_sampling_options_t)
* [cugraph\_sampling\_set\_compress\_per\_hop (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv437cugraph_sampling_set_compress_per_hopP26cugraph_sampling_options_t6bool_t)
* [cugraph\_sampling\_set\_compression\_type (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv437cugraph_sampling_set_compression_typeP26cugraph_sampling_options_t26cugraph_compression_type_t)
* [cugraph\_sampling\_set\_dedupe\_sources (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv435cugraph_sampling_set_dedupe_sourcesP26cugraph_sampling_options_t6bool_t)
* [cugraph\_sampling\_set\_prior\_sources\_behavior (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv443cugraph_sampling_set_prior_sources_behaviorP26cugraph_sampling_options_t32cugraph_prior_sources_behavior_t)
* [cugraph\_sampling\_set\_renumber\_results (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv437cugraph_sampling_set_renumber_resultsP26cugraph_sampling_options_t6bool_t)
* [cugraph\_sampling\_set\_retain\_seeds (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv433cugraph_sampling_set_retain_seedsP26cugraph_sampling_options_t6bool_t)
* [cugraph\_sampling\_set\_return\_hops (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv432cugraph_sampling_set_return_hopsP26cugraph_sampling_options_t6bool_t)
* [cugraph\_sampling\_set\_with\_replacement (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv437cugraph_sampling_set_with_replacementP26cugraph_sampling_options_t6bool_t)
* [cugraph\_select\_random\_vertices (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv430cugraph_select_random_verticesPK25cugraph_resource_handle_tPK15cugraph_graph_tP19cugraph_rng_state_t6size_tPP34cugraph_type_erased_device_array_tPP15cugraph_error_t)
* [cugraph\_similarity\_result\_free (C++ function)](../api_docs/cugraph_c/similarity/#_CPPv430cugraph_similarity_result_freeP27cugraph_similarity_result_t)
* [cugraph\_similarity\_result\_get\_similarity (C++ function)](../api_docs/cugraph_c/similarity/#_CPPv440cugraph_similarity_result_get_similarityP27cugraph_similarity_result_t)
* [cugraph\_similarity\_result\_get\_vertex\_pairs (C++ function)](../api_docs/cugraph_c/similarity/#_CPPv442cugraph_similarity_result_get_vertex_pairsP27cugraph_similarity_result_t)
* [cugraph\_sorensen\_coefficients (C++ function)](../api_docs/cugraph_c/similarity/#_CPPv429cugraph_sorensen_coefficientsPK25cugraph_resource_handle_tP15cugraph_graph_tPK22cugraph_vertex_pairs_t6bool_t6bool_tPP27cugraph_similarity_result_tPP15cugraph_error_t)
* [cugraph\_spectral\_modularity\_maximization (C++ function)](../api_docs/cugraph_c/community/#_CPPv440cugraph_spectral_modularity_maximizationPK25cugraph_resource_handle_tP15cugraph_graph_t6size_t6size_tdidi6bool_tPP27cugraph_clustering_result_tPP15cugraph_error_t)
* [cugraph\_sssp (C++ function)](../api_docs/cugraph_c/traversal/#_CPPv412cugraph_ssspPK25cugraph_resource_handle_tP15cugraph_graph_t6size_td6bool_t6bool_tPP22cugraph_paths_result_tPP15cugraph_error_t)
* [cugraph\_storage\_from\_heterograph() (in module cugraph\_dgl.convert)](../api_docs/api/cugraph-dgl/cugraph_dgl.convert.cugraph_storage_from_heterograph/#cugraph_dgl.convert.cugraph_storage_from_heterograph)
* [cugraph\_strongly\_connected\_components (C++ function)](../api_docs/cugraph_c/labeling/#_CPPv437cugraph_strongly_connected_componentsPK25cugraph_resource_handle_tP15cugraph_graph_t6bool_tPP25cugraph_labeling_result_tPP15cugraph_error_t)
* [cugraph\_test\_sample\_result\_create (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv433cugraph_test_sample_result_createPK25cugraph_resource_handle_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_tPP23cugraph_sample_result_tPP15cugraph_error_t)
* [cugraph\_test\_uniform\_neighborhood\_sample\_result\_create (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv454cugraph_test_uniform_neighborhood_sample_result_createPK25cugraph_resource_handle_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_tPP23cugraph_sample_result_tPP15cugraph_error_t)
* [cugraph\_triangle\_count (C++ function)](../api_docs/cugraph_c/community/#_CPPv422cugraph_triangle_countPK25cugraph_resource_handle_tP15cugraph_graph_tPK39cugraph_type_erased_device_array_view_t6bool_tPP31cugraph_triangle_count_result_tPP15cugraph_error_t)
* [cugraph\_triangle\_count\_result\_free (C++ function)](../api_docs/cugraph_c/community/#_CPPv434cugraph_triangle_count_result_freeP31cugraph_triangle_count_result_t)
* [cugraph\_triangle\_count\_result\_get\_counts (C++ function)](../api_docs/cugraph_c/community/#_CPPv440cugraph_triangle_count_result_get_countsP31cugraph_triangle_count_result_t)
* [cugraph\_triangle\_count\_result\_get\_vertices (C++ function)](../api_docs/cugraph_c/community/#_CPPv442cugraph_triangle_count_result_get_verticesP31cugraph_triangle_count_result_t)
* [cugraph\_uniform\_neighbor\_sample (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv431cugraph_uniform_neighbor_samplePK25cugraph_resource_handle_tP15cugraph_graph_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_tPK39cugraph_type_erased_device_array_view_tPK37cugraph_type_erased_host_array_view_tP19cugraph_rng_state_tPK26cugraph_sampling_options_t6bool_tPP23cugraph_sample_result_tPP15cugraph_error_t)
* [cugraph\_uniform\_random\_walks (C++ function)](../api_docs/cugraph_c/sampling/#_CPPv428cugraph_uniform_random_walksPK25cugraph_resource_handle_tP19cugraph_rng_state_tP15cugraph_graph_tPK39cugraph_type_erased_device_array_view_t6size_tPP28cugraph_random_walk_result_tPP15cugraph_error_t)
* [cugraph\_weakly\_connected\_components (C++ function)](../api_docs/cugraph_c/labeling/#_CPPv435cugraph_weakly_connected_componentsPK25cugraph_resource_handle_tP15cugraph_graph_t6bool_tPP25cugraph_labeling_result_tPP15cugraph_error_t)
* [CuGraphStorage (class in cugraph\_dgl.cugraph\_storage)](../api_docs/api/cugraph-dgl/cugraph_dgl.cugraph_storage.CuGraphStorage/#cugraph_dgl.cugraph_storage.CuGraphStorage) |
D
-
| | |
| --- | --- |
| * [DaskGraphStore (class in cugraph\_pyg.data.dask\_graph\_store)](../api_docs/api/cugraph-pyg/cugraph_pyg.data.dask_graph_store.DaskGraphStore/#cugraph_pyg.data.dask_graph_store.DaskGraphStore)
* [DaskNeighborLoader (class in cugraph\_pyg.loader.dask\_node\_loader)](../api_docs/api/cugraph-pyg/cugraph_pyg.loader.dask_node_loader.DaskNeighborLoader/#cugraph_pyg.loader.dask_node_loader.DaskNeighborLoader)
* [decompress\_to\_edgelist (C++ function)](../api_docs/cugraph_cpp/graph_functions_cpp/#_CPPv4I0000_b_bE22decompress_to_edgelistNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI6edge_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEEEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEENSt8optionalI20edge_property_view_tI6edge_tPK6edge_tEEENSt8optionalI20edge_property_view_tI6edge_tPK11edge_type_tEEENSt8optionalIN4raft11device_spanIK8vertex_tEEEEb)
* [degree (C++ function)](../api_docs/cugraph_cpp/graph_legacy_cpp/#_CPPv4NK6degreeEP6edge_t15DegreeDirection)
, [\[1\]](../api_docs/cugraph_cpp/graph_legacy_cpp/#_CPPv4NK6degreeEP6edge_t15DegreeDirection)
* [degree() (cugraph.structure.graph\_implementation.simpleGraphImpl method)](../api_docs/api/cugraph/cugraph.structure.graph_implementation.simpleGraphImpl.degree/#cugraph.structure.graph_implementation.simpleGraphImpl.degree)
* [degree\_centrality() (in module cugraph.centrality)](../api_docs/api/cugraph/cugraph.centrality.degree_centrality/#cugraph.centrality.degree_centrality)
* [degrees() (cugraph.structure.graph\_implementation.simpleGraphImpl method)](../api_docs/api/cugraph/cugraph.structure.graph_implementation.simpleGraphImpl.degrees/#cugraph.structure.graph_implementation.simpleGraphImpl.degrees)
* [delete\_adj\_list() (cugraph.structure.graph\_implementation.simpleGraphImpl method)](../api_docs/api/cugraph/cugraph.structure.graph_implementation.simpleGraphImpl.delete_adj_list/#cugraph.structure.graph_implementation.simpleGraphImpl.delete_adj_list) | * [delete\_edge\_list() (cugraph.structure.graph\_implementation.simpleGraphImpl method)](../api_docs/api/cugraph/cugraph.structure.graph_implementation.simpleGraphImpl.delete_edge_list/#cugraph.structure.graph_implementation.simpleGraphImpl.delete_edge_list)
* [dense\_hungarian() (in module cugraph)](../api_docs/api/cugraph/cugraph.dense_hungarian/#cugraph.dense_hungarian)
* [destroy() (in module cugraph.dask.comms.comms)](../api_docs/api/cugraph/cugraph.dask.comms.comms.destroy/#cugraph.dask.comms.comms.destroy)
* [destroy\_communicator() (in module pylibwholegraph.torch.comm)](../api_docs/api/wg/pylibwholegraph.torch.comm.destroy_communicator/#pylibwholegraph.torch.comm.destroy_communicator)
* [destroy\_embedding() (in module pylibwholegraph.torch.embedding)](../api_docs/api/wg/pylibwholegraph.torch.embedding.destroy_embedding/#pylibwholegraph.torch.embedding.destroy_embedding)
* [destroy\_wholememory\_cache\_policy() (in module pylibwholegraph.torch.embedding)](../api_docs/api/wg/pylibwholegraph.torch.embedding.destroy_wholememory_cache_policy/#pylibwholegraph.torch.embedding.destroy_wholememory_cache_policy)
* [destroy\_wholememory\_optimizer() (in module pylibwholegraph.torch.embedding)](../api_docs/api/wg/pylibwholegraph.torch.embedding.destroy_wholememory_optimizer/#pylibwholegraph.torch.embedding.destroy_wholememory_optimizer)
* [destroy\_wholememory\_tensor() (in module pylibwholegraph.torch.tensor)](../api_docs/api/wg/pylibwholegraph.torch.tensor.destroy_wholememory_tensor/#pylibwholegraph.torch.tensor.destroy_wholememory_tensor)
* [device\_allgatherv (C++ function)](../api_docs/cugraph_cpp/collect_comm_wrapper_cpp/#_CPPv4I0E17device_allgathervN3rmm14device_uvectorI1TEERKN4raft8handle_tERKN4raft5comms7comms_tEN4raft11device_spanIK1TEE) |
E
-
| | |
| --- | --- |
| * [ecg (C++ function)](../api_docs/cugraph_cpp/algorithms/community_cpp/#_CPPv4I000_bE3ecgNSt5tupleIN3rmm14device_uvectorI8vertex_tEE6size_t8weight_tEERKN4raft8handle_tERN4raft6random8RngStateERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEE8weight_t6size_t6size_t8weight_t8weight_t)
* [ecg() (in module cugraph)](../api_docs/api/cugraph/cugraph.ecg/#cugraph.ecg)
* [edge\_betweenness\_centrality (C++ function)](../api_docs/cugraph_cpp/algorithms/centrality_cpp/#_CPPv4I0000E27edge_betweenness_centralityvRKN4raft8handle_tERKN6legacy12GraphCSRViewI8vertex_t6edge_t8weight_tEEP8result_tbPK8weight_t8vertex_tPK8vertex_t)
, [\[1\]](../api_docs/cugraph_cpp/algorithms/centrality_cpp/#_CPPv4I000_bE27edge_betweenness_centrality15edge_property_tI12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuE8weight_tERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEENSt8optionalIN4raft11device_spanIK8vertex_tEEEEbb)
* [edge\_betweenness\_centrality() (in module cugraph.centrality)](../api_docs/api/cugraph/cugraph.centrality.edge_betweenness_centrality/#cugraph.centrality.edge_betweenness_centrality)
* [edge\_props\_to\_graph() (cugraph.experimental.PropertyGraph method)](../api_docs/api/cugraph/cugraph.experimental.PropertyGraph.edge_props_to_graph/#cugraph.experimental.PropertyGraph.edge_props_to_graph)
* [edge\_triangle\_count (C++ function)](../api_docs/cugraph_cpp/algorithms/community_cpp/#_CPPv4I00_bE19edge_triangle_count15edge_property_tI12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuE6edge_tERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuEb)
* [edges() (cugraph.structure.graph\_implementation.simpleGraphImpl method)](../api_docs/api/cugraph/cugraph.structure.graph_implementation.simpleGraphImpl.edges/#cugraph.structure.graph_implementation.simpleGraphImpl.edges)
* [ego\_graph() (in module cugraph)](../api_docs/api/cugraph/cugraph.ego_graph/#cugraph.ego_graph)
* [eigenvector\_centrality (C++ function)](../api_docs/cugraph_cpp/algorithms/centrality_cpp/#_CPPv4I000_bE22eigenvector_centralityN3rmm14device_uvectorI8weight_tEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL1EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEENSt8optionalIN4raft11device_spanIK8weight_tEEEE8weight_t6size_tb) | * [eigenvector\_centrality() (in module cugraph.centrality)](../api_docs/api/cugraph/cugraph.centrality.eigenvector_centrality/#cugraph.centrality.eigenvector_centrality)
* [(in module cugraph.dask.centrality.eigenvector\_centrality)](../api_docs/api/cugraph/cugraph.dask.centrality.eigenvector_centrality.eigenvector_centrality/#cugraph.dask.centrality.eigenvector_centrality.eigenvector_centrality)
* [(in module pylibcugraph)](../api_docs/api/plc/pylibcugraph.eigenvector_centrality/#pylibcugraph.eigenvector_centrality)
* [enable\_batch() (cugraph.structure.graph\_implementation.simpleGraphImpl method)](../api_docs/api/cugraph/cugraph.structure.graph_implementation.simpleGraphImpl.enable_batch/#cugraph.structure.graph_implementation.simpleGraphImpl.enable_batch)
* [extract\_bfs\_paths (C++ function)](../api_docs/cugraph_cpp/algorithms/traversal_cpp/#_CPPv4I00_bE17extract_bfs_pathsNSt5tupleIN3rmm14device_uvectorI8vertex_tEE8vertex_tEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuEPK8vertex_tPK8vertex_tPK8vertex_t6size_t)
* [extract\_ego (C++ function)](../api_docs/cugraph_cpp/algorithms/community_cpp/#_CPPv4I000_bE11extract_egoNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEEN3rmm14device_uvectorI6size_tEEEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEEN4raft11device_spanIK8vertex_tEE8vertex_tb)
, [\[1\]](../api_docs/cugraph_cpp/algorithms/community_cpp/#_CPPv4I000_bE11extract_egoNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEEN3rmm14device_uvectorI6size_tEEEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEEP8vertex_t8vertex_t8vertex_t)
* [extract\_induced\_subgraphs (C++ function)](../api_docs/cugraph_cpp/graph_functions_cpp/#_CPPv4I000_b_bE25extract_induced_subgraphsNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEEN3rmm14device_uvectorI6size_tEEEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEEN4raft11device_spanIK6size_tEEN4raft11device_spanIK8vertex_tEEb)
* [extract\_subgraph() (cugraph.experimental.PropertyGraph method)](../api_docs/api/cugraph/cugraph.experimental.PropertyGraph.extract_subgraph/#cugraph.experimental.PropertyGraph.extract_subgraph)
* [extract\_subgraph\_vertex (C++ function)](../api_docs/cugraph_cpp/algorithms/utility_cpp/#_CPPv4I000E23extract_subgraph_vertexNSt10unique_ptrIN6legacy8GraphCOOI2VT2ET2WTEEEERKN6legacy12GraphCOOViewI2VT2ET2WTEEPK2VT2VT) |
F
-
| | |
| --- | --- |
| * [filter\_degree\_0\_vertices (C++ function)](../api_docs/cugraph_cpp/graph_utility_wrappers_cpp/#_CPPv4I00E24filter_degree_0_verticesNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI6edge_tEEEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI6edge_tEE)
* [filter\_unreachable() (in module cugraph)](../api_docs/api/cugraph/cugraph.filter_unreachable/#cugraph.filter_unreachable)
* [finalize() (in module pylibwholegraph.torch.initialize)](../api_docs/api/wg/pylibwholegraph.torch.initialize.finalize/#pylibwholegraph.torch.initialize.finalize)
* [flatten\_dendrogram (C++ function)](../api_docs/cugraph_cpp/algorithms/community_cpp/#_CPPv4I0E18flatten_dendrogramvRKN4raft8handle_tERK12graph_view_tRK10DendrogramIN12graph_view_t11vertex_typeEEPN12graph_view_t11vertex_typeE)
* [force\_atlas2 (C++ function)](../api_docs/cugraph_cpp/algorithms/layout_cpp/#_CPPv4I000E12force_atlas2vRKN4raft8handle_tERN6legacy12GraphCOOViewI8vertex_t6edge_t8weight_tEEPfKiPfPfbbbKfKfbKfKfbKfbPN9internals24GraphBasedDimRedCallbackE)
* [force\_atlas2() (in module cugraph)](../api_docs/api/cugraph/cugraph.force_atlas2/#cugraph.force_atlas2)
* [fork\_get\_device\_count (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv421fork_get_device_countv)
* [from\_adjlist() (in module cugraph)](../api_docs/api/cugraph/cugraph.from_adjlist/#cugraph.from_adjlist)
* [from\_cudf\_adjlist() (cugraph.Graph method)](../api_docs/api/cugraph/cugraph.Graph.from_cudf_adjlist/#cugraph.Graph.from_cudf_adjlist)
* [from\_cudf\_edgelist() (cugraph.Graph method)](../api_docs/api/cugraph/cugraph.Graph.from_cudf_edgelist/#cugraph.Graph.from_cudf_edgelist)
* [(in module cugraph)](../api_docs/api/cugraph/cugraph.from_cudf_edgelist/#cugraph.from_cudf_edgelist) | * [from\_dask\_cudf\_edgelist() (cugraph.Graph method)](../api_docs/api/cugraph/cugraph.Graph.from_dask_cudf_edgelist/#cugraph.Graph.from_dask_cudf_edgelist)
* [from\_edgelist() (in module cugraph)](../api_docs/api/cugraph/cugraph.from_edgelist/#cugraph.from_edgelist)
* [from\_internal\_vertex\_id() (cugraph.structure.NumberMap method)](../api_docs/api/cugraph/cugraph.structure.NumberMap.from_internal_vertex_id/#cugraph.structure.NumberMap.from_internal_vertex_id)
* [from\_numpy\_array() (cugraph.Graph method)](../api_docs/api/cugraph/cugraph.Graph.from_numpy_array/#cugraph.Graph.from_numpy_array)
* [(in module cugraph)](../api_docs/api/cugraph/cugraph.from_numpy_array/#cugraph.from_numpy_array)
* [from\_numpy\_matrix() (cugraph.Graph method)](../api_docs/api/cugraph/cugraph.Graph.from_numpy_matrix/#cugraph.Graph.from_numpy_matrix)
* [(in module cugraph)](../api_docs/api/cugraph/cugraph.from_numpy_matrix/#cugraph.from_numpy_matrix)
* [from\_pandas\_adjacency() (cugraph.Graph method)](../api_docs/api/cugraph/cugraph.Graph.from_pandas_adjacency/#cugraph.Graph.from_pandas_adjacency)
* [(in module cugraph)](../api_docs/api/cugraph/cugraph.from_pandas_adjacency/#cugraph.from_pandas_adjacency)
* [from\_pandas\_edgelist() (cugraph.Graph method)](../api_docs/api/cugraph/cugraph.Graph.from_pandas_edgelist/#cugraph.Graph.from_pandas_edgelist)
* [(in module cugraph)](../api_docs/api/cugraph/cugraph.from_pandas_edgelist/#cugraph.from_pandas_edgelist) |
G
-
| | |
| --- | --- |
| * [generate\_2d\_mesh\_graph\_edgelist (C++ function)](../api_docs/cugraph_cpp/graph_generators_cpp/#_CPPv4I0E31generate_2d_mesh_graph_edgelistNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEERKN4raft8handle_tERKNSt6vectorINSt5tupleI8vertex_t8vertex_t8vertex_tEEEE)
* [generate\_3d\_mesh\_graph\_edgelist (C++ function)](../api_docs/cugraph_cpp/graph_generators_cpp/#_CPPv4I0E31generate_3d_mesh_graph_edgelistNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEERKN4raft8handle_tERKNSt6vectorINSt5tupleI8vertex_t8vertex_t8vertex_t8vertex_tEEEE)
* [generate\_bipartite\_rmat\_edgelist (C++ function)](../api_docs/cugraph_cpp/graph_generators_cpp/#_CPPv4I0E32generate_bipartite_rmat_edgelistNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEERKN4raft8handle_tERN4raft6random8RngStateE6size_t6size_t6size_tddd)
* [generate\_complete\_graph\_edgelist (C++ function)](../api_docs/cugraph_cpp/graph_generators_cpp/#_CPPv4I0E32generate_complete_graph_edgelistNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEERKN4raft8handle_tERKNSt6vectorINSt5tupleI8vertex_t8vertex_tEEEE)
* [generate\_erdos\_renyi\_graph\_edgelist\_gnm (C++ function)](../api_docs/cugraph_cpp/graph_generators_cpp/#_CPPv4I0E39generate_erdos_renyi_graph_edgelist_gnmNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEERKN4raft8handle_tE8vertex_t6size_t8vertex_t8uint64_t)
* [generate\_erdos\_renyi\_graph\_edgelist\_gnp (C++ function)](../api_docs/cugraph_cpp/graph_generators_cpp/#_CPPv4I0E39generate_erdos_renyi_graph_edgelist_gnpNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEERKN4raft8handle_tE8vertex_tf8vertex_t8uint64_t)
* [generate\_path\_graph\_edgelist (C++ function)](../api_docs/cugraph_cpp/graph_generators_cpp/#_CPPv4I0E28generate_path_graph_edgelistNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEERKN4raft8handle_tERKNSt6vectorINSt5tupleI8vertex_t8vertex_tEEEE)
* [generate\_rmat\_edgelist (C++ function)](../api_docs/cugraph_cpp/graph_generators_cpp/#_CPPv4I0E22generate_rmat_edgelistNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEERKN4raft8handle_tE6size_t6size_tddd8uint64_tbb)
, [\[1\]](../api_docs/cugraph_cpp/graph_generators_cpp/#_CPPv4I0E22generate_rmat_edgelistNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEERKN4raft8handle_tERN4raft6random8RngStateE6size_t6size_tdddbb)
* [generate\_rmat\_edgelists (C++ function)](../api_docs/cugraph_cpp/graph_generators_cpp/#_CPPv4I0E23generate_rmat_edgelistsNSt6vectorINSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEEEERKN4raft8handle_tE6size_t6size_t6size_t6size_t24generator_distribution_t24generator_distribution_t8uint64_tbb)
, [\[1\]](../api_docs/cugraph_cpp/graph_generators_cpp/#_CPPv4I0E23generate_rmat_edgelistsNSt6vectorINSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEEEERKN4raft8handle_tERN4raft6random8RngStateE6size_t6size_t6size_t6size_t24generator_distribution_t24generator_distribution_tbb)
* [generate\_unused\_column\_name() (cugraph.structure.NumberMap static method)](../api_docs/api/cugraph/cugraph.structure.NumberMap.generate_unused_column_name/#cugraph.structure.NumberMap.generate_unused_column_name)
* [get\_2D\_partition() (in module cugraph.dask.comms.comms)](../api_docs/api/cugraph/cugraph.dask.comms.comms.get_2D_partition/#cugraph.dask.comms.comms.get_2D_partition)
* [get\_chunksize() (in module cugraph.dask.common.read\_utils)](../api_docs/api/cugraph/cugraph.dask.common.read_utils.get_chunksize/#cugraph.dask.common.read_utils.get_chunksize)
* [get\_comms() (in module cugraph.dask.comms.comms)](../api_docs/api/cugraph/cugraph.dask.comms.comms.get_comms/#cugraph.dask.comms.comms.get_comms)
* [get\_default\_handle() (in module cugraph.dask.comms.comms)](../api_docs/api/cugraph/cugraph.dask.comms.comms.get_default_handle/#cugraph.dask.comms.comms.get_default_handle)
* [get\_edge\_data() (cugraph.experimental.PropertyGraph method)](../api_docs/api/cugraph/cugraph.experimental.PropertyGraph.get_edge_data/#cugraph.experimental.PropertyGraph.get_edge_data)
* [get\_global\_communicator() (in module pylibwholegraph.torch.comm)](../api_docs/api/wg/pylibwholegraph.torch.comm.get_global_communicator/#pylibwholegraph.torch.comm.get_global_communicator)
* [get\_handle() (in module cugraph.dask.comms.comms)](../api_docs/api/cugraph/cugraph.dask.comms.comms.get_handle/#cugraph.dask.comms.comms.get_handle)
* [get\_local\_device\_communicator() (in module pylibwholegraph.torch.comm)](../api_docs/api/wg/pylibwholegraph.torch.comm.get_local_device_communicator/#pylibwholegraph.torch.comm.get_local_device_communicator)
* [get\_local\_node\_communicator() (in module pylibwholegraph.torch.comm)](../api_docs/api/wg/pylibwholegraph.torch.comm.get_local_node_communicator/#pylibwholegraph.torch.comm.get_local_node_communicator)
* [get\_num\_edges() (cugraph.experimental.PropertyGraph method)](../api_docs/api/cugraph/cugraph.experimental.PropertyGraph.get_num_edges/#cugraph.experimental.PropertyGraph.get_num_edges) | * [get\_num\_vertices() (cugraph.experimental.PropertyGraph method)](../api_docs/api/cugraph/cugraph.experimental.PropertyGraph.get_num_vertices/#cugraph.experimental.PropertyGraph.get_num_vertices)
* [get\_session\_id() (in module cugraph.dask.comms.comms)](../api_docs/api/cugraph/cugraph.dask.comms.comms.get_session_id/#cugraph.dask.comms.comms.get_session_id)
* [get\_source\_indices (C++ function)](../api_docs/cugraph_cpp/graph_legacy_cpp/#_CPPv4NK18get_source_indicesEP8vertex_t)
* [get\_two\_hop\_neighbors (C++ function)](../api_docs/cugraph_cpp/graph_functions_cpp/#_CPPv4I00_b_bE21get_two_hop_neighborsNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalIN4raft11device_spanIK8vertex_tEEEE)
* [get\_two\_hop\_neighbors() (cugraph.structure.graph\_implementation.simpleGraphImpl method)](../api_docs/api/cugraph/cugraph.structure.graph_implementation.simpleGraphImpl.get_two_hop_neighbors/#cugraph.structure.graph_implementation.simpleGraphImpl.get_two_hop_neighbors)
* [get\_vertex\_data() (cugraph.experimental.PropertyGraph method)](../api_docs/api/cugraph/cugraph.experimental.PropertyGraph.get_vertex_data/#cugraph.experimental.PropertyGraph.get_vertex_data)
* [get\_vertex\_identifiers (C++ function)](../api_docs/cugraph_cpp/graph_legacy_cpp/#_CPPv4NK22get_vertex_identifiersEP8vertex_t)
* [get\_vertices() (cugraph.experimental.PropertyGraph method)](../api_docs/api/cugraph/cugraph.experimental.PropertyGraph.get_vertices/#cugraph.experimental.PropertyGraph.get_vertices)
* [get\_worker\_id() (in module cugraph.dask.comms.comms)](../api_docs/api/cugraph/cugraph.dask.comms.comms.get_worker_id/#cugraph.dask.comms.comms.get_worker_id)
* [get\_workers() (in module cugraph.dask.comms.comms)](../api_docs/api/cugraph/cugraph.dask.comms.comms.get_workers/#cugraph.dask.comms.comms.get_workers)
* [Graph (class in cugraph)](../api_docs/api/cugraph/cugraph.Graph/#cugraph.Graph)
* [graph\_append\_unique (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv419graph_append_unique20wholememory_tensor_t20wholememory_tensor_tPv20wholememory_tensor_tP22wholememory_env_func_tPv)
* [GraphCompressedSparseBase (C++ function)](../api_docs/cugraph_cpp/graph_legacy_cpp/#_CPPv425GraphCompressedSparseBase8vertex_t6edge_tb12cudaStream_tN3rmm25device_async_resource_refE)
* [GraphCompressedSparseBaseView (C++ function)](../api_docs/cugraph_cpp/graph_legacy_cpp/#_CPPv429GraphCompressedSparseBaseViewP6edge_tP8vertex_tP8weight_t8vertex_t6edge_t)
* [GraphCOO (C++ function)](../api_docs/cugraph_cpp/graph_legacy_cpp/#_CPPv48GraphCOO8vertex_t6edge_tb12cudaStream_tN3rmm25device_async_resource_refE)
* [GraphCOOView (C++ function)](../api_docs/cugraph_cpp/graph_legacy_cpp/#_CPPv412GraphCOOViewP8vertex_tP8vertex_tP8weight_t8vertex_t6edge_t)
* [GraphCSR (C++ function)](../api_docs/cugraph_cpp/graph_legacy_cpp/#_CPPv48GraphCSR8vertex_t6edge_tb12cudaStream_tN3rmm25device_async_resource_refE)
, [\[1\]](../api_docs/cugraph_cpp/graph_legacy_cpp/#_CPPv48GraphCSRv)
* [GraphCSRView (C++ function)](../api_docs/cugraph_cpp/graph_legacy_cpp/#_CPPv412GraphCSRViewP6edge_tP8vertex_tP8weight_t8vertex_t6edge_t)
* [GraphStore (class in cugraph\_pyg.data.graph\_store)](../api_docs/api/cugraph-pyg/cugraph_pyg.data.graph_store.GraphStore/#cugraph_pyg.data.graph_store.GraphStore)
* [GraphStructure (class in pylibwholegraph.torch.graph\_structure)](../api_docs/api/wg/pylibwholegraph.torch.graph_structure.GraphStructure/#pylibwholegraph.torch.graph_structure.GraphStructure) |
H
-
| | |
| --- | --- |
| * [has\_duplicate\_edges() (cugraph.experimental.PropertyGraph class method)](../api_docs/api/cugraph/cugraph.experimental.PropertyGraph.has_duplicate_edges/#cugraph.experimental.PropertyGraph.has_duplicate_edges)
* [has\_edge() (cugraph.structure.graph\_implementation.simpleGraphImpl method)](../api_docs/api/cugraph/cugraph.structure.graph_implementation.simpleGraphImpl.has_edge/#cugraph.structure.graph_implementation.simpleGraphImpl.has_edge)
* [has\_isolated\_vertices() (cugraph.Graph method)](../api_docs/api/cugraph/cugraph.Graph.has_isolated_vertices/#cugraph.Graph.has_isolated_vertices)
* [has\_node() (cugraph.structure.graph\_implementation.simpleGraphImpl method)](../api_docs/api/cugraph/cugraph.structure.graph_implementation.simpleGraphImpl.has_node/#cugraph.structure.graph_implementation.simpleGraphImpl.has_node)
* [has\_self\_loop() (cugraph.structure.graph\_implementation.simpleGraphImpl method)](../api_docs/api/cugraph/cugraph.structure.graph_implementation.simpleGraphImpl.has_self_loop/#cugraph.structure.graph_implementation.simpleGraphImpl.has_self_loop)
* [heterogeneous\_biased\_neighbor\_sample (C++ function)](../api_docs/cugraph_cpp/graph_sampling_cpp/#_CPPv4I00000_b_bE36heterogeneous_biased_neighbor_sampleNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI6edge_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEENSt8optionalIN3rmm14device_uvectorI7int32_tEEEENSt8optionalIN3rmm14device_uvectorI6size_tEEEEEERKN4raft8handle_tERN4raft6random8RngStateERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEENSt8optionalI20edge_property_view_tI6edge_tPK6edge_tEEENSt8optionalI20edge_property_view_tI6edge_tPK11edge_type_tEEE20edge_property_view_tI6edge_tPK6bias_tEN4raft11device_spanIK8vertex_tEENSt8optionalIN4raft11device_spanIK7int32_tEEEENSt8optionalIN4raft11device_spanIK7int32_tEEEEN4raft9host_spanIK7int32_tEE11edge_type_t16sampling_flags_tb)
* [heterogeneous\_renumber\_and\_sort\_sampled\_edgelist (C++ function)](../api_docs/cugraph_cpp/graph_sampling_cpp/#_CPPv4I0000E48heterogeneous_renumber_and_sort_sampled_edgelistNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI9edge_id_tEEEENSt8optionalIN3rmm14device_uvectorI6size_tEEEEN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI6size_tEENSt8optionalIN3rmm14device_uvectorI9edge_id_tEEEENSt8optionalIN3rmm14device_uvectorI6size_tEEEEEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEERRNSt8optionalIN3rmm14device_uvectorI8weight_tEEEERRNSt8optionalIN3rmm14device_uvectorI9edge_id_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEERRNSt8optionalIN3rmm14device_uvectorI7int32_tEEEENSt8optionalIN4raft11device_spanIK8vertex_tEEEENSt8optionalIN4raft11device_spanIK6size_tEEEENSt8optionalIN4raft11device_spanIK6size_tEEEEN4raft11device_spanIK8vertex_tEE6size_t6size_t6size_t6size_tbb)
* [heterogeneous\_uniform\_neighbor\_sample (C++ function)](../api_docs/cugraph_cpp/graph_sampling_cpp/#_CPPv4I0000_b_bE37heterogeneous_uniform_neighbor_sampleNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI6edge_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEENSt8optionalIN3rmm14device_uvectorI7int32_tEEEENSt8optionalIN3rmm14device_uvectorI6size_tEEEEEERKN4raft8handle_tERN4raft6random8RngStateERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEENSt8optionalI20edge_property_view_tI6edge_tPK6edge_tEEENSt8optionalI20edge_property_view_tI6edge_tPK11edge_type_tEEEN4raft11device_spanIK8vertex_tEENSt8optionalIN4raft11device_spanIK7int32_tEEEENSt8optionalIN4raft11device_spanIK7int32_tEEEEN4raft9host_spanIK7int32_tEE11edge_type_t16sampling_flags_tb)
* [hits (C++ function)](../api_docs/cugraph_cpp/algorithms/link_analysis_cpp/#_CPPv4I000_bE4hitsNSt5tupleI8result_t6size_tEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL1EE9multi_gpuEP8result_tP8result_t8result_t6size_tbbb) | * [hits() (in module cugraph)](../api_docs/api/cugraph/cugraph.hits/#cugraph.hits)
* [(in module cugraph.dask.link\_analysis.hits)](../api_docs/api/cugraph/cugraph.dask.link_analysis.hits.hits/#cugraph.dask.link_analysis.hits.hits)
* [(in module pylibcugraph)](../api_docs/api/plc/pylibcugraph.hits/#pylibcugraph.hits)
* [homogeneous\_biased\_neighbor\_sample (C++ function)](../api_docs/cugraph_cpp/graph_sampling_cpp/#_CPPv4I00000_b_bE34homogeneous_biased_neighbor_sampleNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI6edge_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEENSt8optionalIN3rmm14device_uvectorI7int32_tEEEENSt8optionalIN3rmm14device_uvectorI6size_tEEEEEERKN4raft8handle_tERN4raft6random8RngStateERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEENSt8optionalI20edge_property_view_tI6edge_tPK6edge_tEEENSt8optionalI20edge_property_view_tI6edge_tPK11edge_type_tEEE20edge_property_view_tI6edge_tPK6bias_tEN4raft11device_spanIK8vertex_tEENSt8optionalIN4raft11device_spanIK7int32_tEEEENSt8optionalIN4raft11device_spanIK7int32_tEEEEN4raft9host_spanIK7int32_tEE16sampling_flags_tb)
* [homogeneous\_uniform\_neighbor\_sample (C++ function)](../api_docs/cugraph_cpp/graph_sampling_cpp/#_CPPv4I0000_b_bE35homogeneous_uniform_neighbor_sampleNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI6edge_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEENSt8optionalIN3rmm14device_uvectorI7int32_tEEEENSt8optionalIN3rmm14device_uvectorI6size_tEEEEEERKN4raft8handle_tERN4raft6random8RngStateERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEENSt8optionalI20edge_property_view_tI6edge_tPK6edge_tEEENSt8optionalI20edge_property_view_tI6edge_tPK11edge_type_tEEEN4raft11device_spanIK8vertex_tEENSt8optionalIN4raft11device_spanIK7int32_tEEEENSt8optionalIN4raft11device_spanIK7int32_tEEEEN4raft9host_spanIK7int32_tEE16sampling_flags_tb)
* [HomogeneousSampleReader (class in cugraph\_pyg.sampler.sampler)](../api_docs/api/cugraph-pyg/cugraph_pyg.sampler.sampler.HomogeneousSampleReader/#cugraph_pyg.sampler.sampler.HomogeneousSampleReader)
* [hungarian (C++ function)](../api_docs/cugraph_cpp/algorithms/linear_cpp/#_CPPv4I000E9hungarian8weight_tRKN4raft8handle_tERKN6legacy12GraphCOOViewI8vertex_t6edge_t8weight_tEE8vertex_tPK8vertex_tP8vertex_t)
, [\[1\]](../api_docs/cugraph_cpp/algorithms/linear_cpp/#_CPPv4I000E9hungarian8weight_tRKN4raft8handle_tERKN6legacy12GraphCOOViewI8vertex_t6edge_t8weight_tEE8vertex_tPK8vertex_tP8vertex_t8weight_t)
, [\[2\]](../api_docs/cugraph_cpp/algorithms/linear_cpp/#_CPPv4I00E9hungarian8weight_tRKN4raft8handle_tEPK8weight_t8vertex_t8vertex_tP8vertex_t)
, [\[3\]](../api_docs/cugraph_cpp/algorithms/linear_cpp/#_CPPv4I00E9hungarian8weight_tRKN4raft8handle_tEPK8weight_t8vertex_t8vertex_tP8vertex_t8weight_t)
* [hungarian() (in module cugraph)](../api_docs/api/cugraph/cugraph.hungarian/#cugraph.hungarian)
* [hypergraph() (in module cugraph)](../api_docs/api/cugraph/cugraph.hypergraph/#cugraph.hypergraph) |
I
-
| | |
| --- | --- |
| * [in\_degree() (cugraph.structure.graph\_implementation.simpleGraphImpl method)](../api_docs/api/cugraph/cugraph.structure.graph_implementation.simpleGraphImpl.in_degree/#cugraph.structure.graph_implementation.simpleGraphImpl.in_degree)
* [init\_torch\_env() (in module pylibwholegraph.torch.initialize)](../api_docs/api/wg/pylibwholegraph.torch.initialize.init_torch_env/#pylibwholegraph.torch.initialize.init_torch_env)
* [init\_torch\_env\_and\_create\_wm\_comm() (in module pylibwholegraph.torch.initialize)](../api_docs/api/wg/pylibwholegraph.torch.initialize.init_torch_env_and_create_wm_comm/#pylibwholegraph.torch.initialize.init_torch_env_and_create_wm_comm)
* [initialize() (in module cugraph.dask.comms.comms)](../api_docs/api/cugraph/cugraph.dask.comms.comms.initialize/#cugraph.dask.comms.comms.initialize)
* [is\_bipartite() (cugraph.Graph method)](../api_docs/api/cugraph/cugraph.Graph.is_bipartite/#cugraph.Graph.is_bipartite)
* [is\_directed() (cugraph.Graph method)](../api_docs/api/cugraph/cugraph.Graph.is_directed/#cugraph.Graph.is_directed)
* [is\_equal (C++ function)](../api_docs/cugraph_cpp/graph_utility_wrappers_cpp/#_CPPv4I0E8is_equalbRKN4raft8handle_tEN4raft11device_spanI6data_tEEN4raft11device_spanI6data_tEE) | * [is\_initialized() (in module cugraph.dask.comms.comms)](../api_docs/api/cugraph/cugraph.dask.comms.comms.is_initialized/#cugraph.dask.comms.comms.is_initialized)
* [is\_multigraph() (cugraph.experimental.PropertyGraph class method)](../api_docs/api/cugraph/cugraph.experimental.PropertyGraph.is_multigraph/#cugraph.experimental.PropertyGraph.is_multigraph)
* [(cugraph.Graph method)](../api_docs/api/cugraph/cugraph.Graph.is_multigraph/#cugraph.Graph.is_multigraph)
* [is\_multipartite() (cugraph.Graph method)](../api_docs/api/cugraph/cugraph.Graph.is_multipartite/#cugraph.Graph.is_multipartite)
* [is\_renumbered() (cugraph.Graph method)](../api_docs/api/cugraph/cugraph.Graph.is_renumbered/#cugraph.Graph.is_renumbered)
* [is\_sorted (C++ function)](../api_docs/cugraph_cpp/graph_utility_wrappers_cpp/#_CPPv4I0E9is_sortedbRKN4raft8handle_tEN4raft11device_spanI6data_tEE)
* [is\_weighted() (cugraph.Graph method)](../api_docs/api/cugraph/cugraph.Graph.is_weighted/#cugraph.Graph.is_weighted) |
J
-
| | |
| --- | --- |
| * [jaccard (C++ function)](../api_docs/cugraph_cpp/algorithms/similarity_cpp/#_CPPv4I000E7jaccardvRKN6legacy12GraphCSRViewI2VT2ET2WTEEPK2WTP2WT)
* [jaccard() (in module cugraph)](../api_docs/api/cugraph/cugraph.jaccard/#cugraph.jaccard)
* [jaccard\_all\_pairs\_coefficients (C++ function)](../api_docs/cugraph_cpp/algorithms/similarity_cpp/#_CPPv4I000_bE30jaccard_all_pairs_coefficientsNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8weight_tEEEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEENSt8optionalIN4raft11device_spanIK8vertex_tEEEENSt8optionalI6size_tEEb) | * [jaccard\_coefficient() (in module cugraph)](../api_docs/api/cugraph/cugraph.jaccard_coefficient/#cugraph.jaccard_coefficient)
* [jaccard\_coefficients (C++ function)](../api_docs/cugraph_cpp/algorithms/similarity_cpp/#_CPPv4I000_bE20jaccard_coefficientsN3rmm14device_uvectorI8weight_tEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEENSt5tupleIN4raft11device_spanIK8vertex_tEEN4raft11device_spanIK8vertex_tEEEEb)
* [jaccard\_list (C++ function)](../api_docs/cugraph_cpp/algorithms/similarity_cpp/#_CPPv4I000E12jaccard_listvRKN6legacy12GraphCSRViewI2VT2ET2WTEEPK2WT2ETPK2VTPK2VTP2WT) |
K
-
| | |
| --- | --- |
| * [k\_core() (in module cugraph)](../api_docs/api/cugraph/cugraph.k_core/#cugraph.k_core)
* [k\_truss (C++ function)](../api_docs/cugraph_cpp/algorithms/community_cpp/#_CPPv4I000_bE7k_trussNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEEEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEE6edge_tb)
* [k\_truss() (in module cugraph)](../api_docs/api/cugraph/cugraph.k_truss/#cugraph.k_truss)
* [katz\_centrality (C++ function)](../api_docs/cugraph_cpp/algorithms/centrality_cpp/#_CPPv4I0000_bE15katz_centralityvRKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL1EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEEPK8result_tP8result_t8result_t8result_t8result_t6size_tbbb) | * [katz\_centrality() (in module cugraph.centrality)](../api_docs/api/cugraph/cugraph.centrality.katz_centrality/#cugraph.centrality.katz_centrality)
* [(in module cugraph.dask.centrality.katz\_centrality)](../api_docs/api/cugraph/cugraph.dask.centrality.katz_centrality.katz_centrality/#cugraph.dask.centrality.katz_centrality.katz_centrality)
* [(in module pylibcugraph)](../api_docs/api/plc/pylibcugraph.katz_centrality/#pylibcugraph.katz_centrality)
* [ktruss\_subgraph() (in module cugraph)](../api_docs/api/cugraph/cugraph.ktruss_subgraph/#cugraph.ktruss_subgraph) |
L
-
| | |
| --- | --- |
| * [leiden (C++ function)](../api_docs/cugraph_cpp/algorithms/community_cpp/#_CPPv4I000_bE6leidenNSt4pairI6size_t8weight_tEERKN4raft8handle_tERN4raft6random8RngStateERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEEP8vertex_t6size_t8weight_t8weight_t)
, [\[1\]](../api_docs/cugraph_cpp/algorithms/community_cpp/#_CPPv4I000_bE6leidenNSt4pairINSt10unique_ptrI10DendrogramI8vertex_tEEE8weight_tEERKN4raft8handle_tERN4raft6random8RngStateERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEE6size_t8weight_t8weight_t)
* [leiden() (in module cugraph)](../api_docs/api/cugraph/cugraph.leiden/#cugraph.leiden)
* [lookup\_endpoints\_from\_edge\_ids\_and\_single\_type (C++ function)](../api_docs/cugraph_cpp/graph_sampling_cpp/#_CPPv4I000_bE46lookup_endpoints_from_edge_ids_and_single_typeNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEERKN4raft8handle_tERK18lookup_container_tI6edge_t11edge_type_t8vertex_tEN4raft11device_spanIK6edge_tEE11edge_type_t)
* [lookup\_endpoints\_from\_edge\_ids\_and\_types (C++ function)](../api_docs/cugraph_cpp/graph_sampling_cpp/#_CPPv4I000_bE40lookup_endpoints_from_edge_ids_and_typesNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEERKN4raft8handle_tERK18lookup_container_tI6edge_t11edge_type_t8vertex_tEN4raft11device_spanIK6edge_tEEN4raft11device_spanIK11edge_type_tEE) | * [lookup\_internal\_vertex\_id() (cugraph.Graph method)](../api_docs/api/cugraph/cugraph.Graph.lookup_internal_vertex_id/#cugraph.Graph.lookup_internal_vertex_id)
* [louvain (C++ function)](../api_docs/cugraph_cpp/algorithms/community_cpp/#_CPPv4I000_bE7louvainNSt4pairI6size_t8weight_tEERKN4raft8handle_tENSt8optionalINSt17reference_wrapperIN4raft6random8RngStateEEEEERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEEP8vertex_t6size_t8weight_t8weight_t)
, [\[1\]](../api_docs/cugraph_cpp/algorithms/community_cpp/#_CPPv4I000_bE7louvainNSt4pairINSt10unique_ptrI10DendrogramI8vertex_tEEE8weight_tEERKN4raft8handle_tENSt8optionalINSt17reference_wrapperIN4raft6random8RngStateEEEEERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEE6size_t8weight_t8weight_t)
* [louvain() (in module cugraph)](../api_docs/api/cugraph/cugraph.louvain/#cugraph.louvain)
* [(in module cugraph.dask.community.louvain)](../api_docs/api/cugraph/cugraph.dask.community.louvain.louvain/#cugraph.dask.community.louvain.louvain) |
M
-
| | |
| --- | --- |
| * [maximal\_independent\_set (C++ function)](../api_docs/cugraph_cpp/algorithms/tree_cpp/#_CPPv4I00_bE23maximal_independent_setN3rmm14device_uvectorI8vertex_tEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuERN4raft6random8RngStateE)
* [maximum\_spanning\_tree() (in module cugraph.tree.minimum\_spanning\_tree)](../api_docs/api/cugraph/cugraph.tree.minimum_spanning_tree.maximum_spanning_tree/#cugraph.tree.minimum_spanning_tree.maximum_spanning_tree)
* [minimum\_spanning\_tree (C++ function)](../api_docs/cugraph_cpp/algorithms/tree_cpp/#_CPPv4I000E21minimum_spanning_treeNSt10unique_ptrIN6legacy8GraphCOOI8vertex_t6edge_t8weight_tEEEERKN4raft8handle_tERKN6legacy12GraphCSRViewI8vertex_t6edge_t8weight_tEEN3rmm25device_async_resource_refE) | * [minimum\_spanning\_tree() (in module cugraph.tree.minimum\_spanning\_tree)](../api_docs/api/cugraph/cugraph.tree.minimum_spanning_tree.minimum_spanning_tree/#cugraph.tree.minimum_spanning_tree.minimum_spanning_tree)
* module
* [cugraph.dask.centrality.betweenness\_centrality](../api_docs/api/cugraph/cugraph.dask.centrality.betweenness_centrality/#module-cugraph.dask.centrality.betweenness_centrality)
* [MultiGraph (class in cugraph)](../api_docs/api/cugraph/cugraph.MultiGraph/#cugraph.MultiGraph) |
N
-
| | |
| --- | --- |
| * [negative\_sampling (C++ function)](../api_docs/cugraph_cpp/graph_sampling_cpp/#_CPPv4I000_b_bE17negative_samplingNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEERKN4raft8handle_tERN4raft6random8RngStateERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalIN4raft11device_spanIK8weight_tEEEENSt8optionalIN4raft11device_spanIK8weight_tEEEE6size_tbbbb)
* [NeighborLoader (class in cugraph\_pyg.loader.neighbor\_loader)](../api_docs/api/cugraph-pyg/cugraph_pyg.loader.neighbor_loader.NeighborLoader/#cugraph_pyg.loader.neighbor_loader.NeighborLoader)
* [neighbors() (cugraph.structure.graph\_implementation.simpleGraphImpl method)](../api_docs/api/cugraph/cugraph.structure.graph_implementation.simpleGraphImpl.neighbors/#cugraph.structure.graph_implementation.simpleGraphImpl.neighbors)
* [node2vec() (in module cugraph)](../api_docs/api/cugraph/cugraph.node2vec/#cugraph.node2vec)
* [(in module pylibcugraph)](../api_docs/api/plc/pylibcugraph.node2vec/#pylibcugraph.node2vec)
* [node2vec\_random\_walks (C++ function)](../api_docs/cugraph_cpp/algorithms/sampling_cpp/#_CPPv4I000_bE21node2vec_random_walksNSt5tupleIN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEEEERKN4raft8handle_tERN4raft6random8RngStateERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEEN4raft11device_spanIK8vertex_tEE6size_t8weight_t8weight_t) | * [NodeLoader (class in cugraph\_pyg.loader.node\_loader)](../api_docs/api/cugraph-pyg/cugraph_pyg.loader.node_loader.NodeLoader/#cugraph_pyg.loader.node_loader.NodeLoader)
* [nodes() (cugraph.structure.graph\_implementation.simpleGraphImpl method)](../api_docs/api/cugraph/cugraph.structure.graph_implementation.simpleGraphImpl.nodes/#cugraph.structure.graph_implementation.simpleGraphImpl.nodes)
* [number\_of\_edges() (cugraph.structure.graph\_implementation.simpleGraphImpl method)](../api_docs/api/cugraph/cugraph.structure.graph_implementation.simpleGraphImpl.number_of_edges/#cugraph.structure.graph_implementation.simpleGraphImpl.number_of_edges)
* [number\_of\_nodes() (cugraph.structure.graph\_implementation.simpleGraphImpl method)](../api_docs/api/cugraph/cugraph.structure.graph_implementation.simpleGraphImpl.number_of_nodes/#cugraph.structure.graph_implementation.simpleGraphImpl.number_of_nodes)
* [number\_of\_vertices() (cugraph.structure.graph\_implementation.simpleGraphImpl method)](../api_docs/api/cugraph/cugraph.structure.graph_implementation.simpleGraphImpl.number_of_vertices/#cugraph.structure.graph_implementation.simpleGraphImpl.number_of_vertices)
* [NumberMap (class in cugraph.structure)](../api_docs/api/cugraph/cugraph.structure.NumberMap/#cugraph.structure.NumberMap) |
O
-
| | |
| --- | --- |
| * [od\_shortest\_distances (C++ function)](../api_docs/cugraph_cpp/algorithms/traversal_cpp/#_CPPv4I000_bE21od_shortest_distancesN3rmm14device_uvectorI8weight_tEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuE20edge_property_view_tI6edge_tPK8weight_tEN4raft11device_spanIK8vertex_tEEN4raft11device_spanIK8vertex_tEE8weight_tb)
* [out\_degree() (cugraph.structure.graph\_implementation.simpleGraphImpl method)](../api_docs/api/cugraph/cugraph.structure.graph_implementation.simpleGraphImpl.out_degree/#cugraph.structure.graph_implementation.simpleGraphImpl.out_degree)
* [overlap (C++ function)](../api_docs/cugraph_cpp/algorithms/similarity_cpp/#_CPPv4I000E7overlapvRKN6legacy12GraphCSRViewI2VT2ET2WTEEPK2WTP2WT)
* [overlap() (in module cugraph)](../api_docs/api/cugraph/cugraph.overlap/#cugraph.overlap) | * [overlap\_all\_pairs\_coefficients (C++ function)](../api_docs/cugraph_cpp/algorithms/similarity_cpp/#_CPPv4I000_bE30overlap_all_pairs_coefficientsNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8weight_tEEEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEENSt8optionalIN4raft11device_spanIK8vertex_tEEEENSt8optionalI6size_tEEb)
* [overlap\_coefficient() (in module cugraph)](../api_docs/api/cugraph/cugraph.overlap_coefficient/#cugraph.overlap_coefficient)
* [overlap\_coefficients (C++ function)](../api_docs/cugraph_cpp/algorithms/similarity_cpp/#_CPPv4I000_bE20overlap_coefficientsN3rmm14device_uvectorI8weight_tEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEENSt5tupleIN4raft11device_spanIK8vertex_tEEN4raft11device_spanIK8vertex_tEEEEb)
* [overlap\_list (C++ function)](../api_docs/cugraph_cpp/algorithms/similarity_cpp/#_CPPv4I000E12overlap_listvRKN6legacy12GraphCSRViewI2VT2ET2WTEEPK2WT2ETPK2VTPK2VTP2WT) |
P
-
| | |
| --- | --- |
| * [pagerank (C++ function)](../api_docs/cugraph_cpp/algorithms/link_analysis_cpp/#_CPPv4I0000_bE8pagerankNSt5tupleIN3rmm14device_uvectorI8result_tEE31centrality_algorithm_metadata_tEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL1EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEENSt8optionalIN4raft11device_spanIK8weight_tEEEENSt8optionalINSt5tupleIN4raft11device_spanIK8vertex_tEEN4raft11device_spanIK8result_tEEEEEENSt8optionalIN4raft11device_spanIK8result_tEEEE8result_t8result_t6size_tb)
, [\[1\]](../api_docs/cugraph_cpp/algorithms/link_analysis_cpp/#_CPPv4I0000_bE8pagerankvRKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL1EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEENSt8optionalIPK8weight_tEENSt8optionalIPK8vertex_tEENSt8optionalIPK8result_tEENSt8optionalI8vertex_tEEP8result_t8result_t8result_t6size_tbb)
* [pagerank() (in module cugraph)](../api_docs/api/cugraph/cugraph.pagerank/#cugraph.pagerank)
* [(in module cugraph.dask.link\_analysis.pagerank)](../api_docs/api/cugraph/cugraph.dask.link_analysis.pagerank.pagerank/#cugraph.dask.link_analysis.pagerank.pagerank)
* [(in module pylibcugraph)](../api_docs/api/plc/pylibcugraph.pagerank/#pylibcugraph.pagerank)
* [prior\_sources\_behavior\_t (C++ enum)](../api_docs/cugraph_cpp/graph_sampling_cpp/#_CPPv424prior_sources_behavior_t) | * [prior\_sources\_behavior\_t::CARRY\_OVER (C++ enumerator)](../api_docs/cugraph_cpp/graph_sampling_cpp/#_CPPv4N24prior_sources_behavior_t10CARRY_OVERE)
* [prior\_sources\_behavior\_t::DEFAULT (C++ enumerator)](../api_docs/cugraph_cpp/graph_sampling_cpp/#_CPPv4N24prior_sources_behavior_t7DEFAULTE)
* [prior\_sources\_behavior\_t::EXCLUDE (C++ enumerator)](../api_docs/cugraph_cpp/graph_sampling_cpp/#_CPPv4N24prior_sources_behavior_t7EXCLUDEE)
* [PropertyGraph (class in cugraph.experimental)](../api_docs/api/cugraph/cugraph.experimental.PropertyGraph/#cugraph.experimental.PropertyGraph)
* [PropertySelection (class in cugraph.experimental)](../api_docs/api/cugraph/cugraph.experimental.PropertySelection/#cugraph.experimental.PropertySelection) |
R
-
| | |
| --- | --- |
| * [random\_walks (C++ function)](../api_docs/cugraph_cpp/algorithms/sampling_cpp/#_CPPv4I0000_bE12random_walksNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8weight_tEEN3rmm14device_uvectorI7index_tEEEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEEPK8vertex_t7index_t7index_tbNSt10unique_ptrI17sampling_params_tEE)
* [random\_walks() (in module cugraph)](../api_docs/api/cugraph/cugraph.random_walks/#cugraph.random_walks)
* [relabel (C++ function)](../api_docs/cugraph_cpp/graph_functions_cpp/#_CPPv4I0_bE7relabelvRKN4raft8handle_tENSt5tupleIPK8vertex_tPK8vertex_tEE8vertex_tP8vertex_t8vertex_tbb)
* [remove\_multi\_edges (C++ function)](../api_docs/cugraph_cpp/graph_functions_cpp/#_CPPv4I00000E18remove_multi_edgesNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI6edge_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_time_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_time_tEEEEEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEERRNSt8optionalIN3rmm14device_uvectorI8weight_tEEEERRNSt8optionalIN3rmm14device_uvectorI6edge_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_time_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_time_tEEEEb)
* [remove\_self\_loops (C++ function)](../api_docs/cugraph_cpp/graph_functions_cpp/#_CPPv4I00000E17remove_self_loopsNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI6edge_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_time_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_time_tEEEEEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEERRNSt8optionalIN3rmm14device_uvectorI8weight_tEEEERRNSt8optionalIN3rmm14device_uvectorI6edge_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_time_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_time_tEEEE)
* [renumber() (cugraph.structure.NumberMap static method)](../api_docs/api/cugraph/cugraph.structure.NumberMap.renumber/#cugraph.structure.NumberMap.renumber)
* [renumber\_and\_compress\_sampled\_edgelist (C++ function)](../api_docs/cugraph_cpp/graph_sampling_cpp/#_CPPv4I0000E38renumber_and_compress_sampled_edgelistNSt5tupleINSt8optionalIN3rmm14device_uvectorI8vertex_tEEEEN3rmm14device_uvectorI6size_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI9edge_id_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEENSt8optionalIN3rmm14device_uvectorI6size_tEEEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI6size_tEEEEEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEERRNSt8optionalIN3rmm14device_uvectorI8weight_tEEEERRNSt8optionalIN3rmm14device_uvectorI9edge_id_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEERRNSt8optionalIN3rmm14device_uvectorI7int32_tEEEENSt8optionalIN4raft11device_spanIK8vertex_tEEEENSt8optionalIN4raft11device_spanIK6size_tEEEENSt8optionalIN4raft11device_spanIK6size_tEEEE6size_t6size_tbbbb) | * [renumber\_and\_segment() (cugraph.structure.NumberMap static method)](../api_docs/api/cugraph/cugraph.structure.NumberMap.renumber_and_segment/#cugraph.structure.NumberMap.renumber_and_segment)
* [renumber\_and\_sort\_sampled\_edgelist (C++ function)](../api_docs/cugraph_cpp/graph_sampling_cpp/#_CPPv4I0000E34renumber_and_sort_sampled_edgelistNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI9edge_id_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEENSt8optionalIN3rmm14device_uvectorI6size_tEEEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI6size_tEEEEEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEERRNSt8optionalIN3rmm14device_uvectorI8weight_tEEEERRNSt8optionalIN3rmm14device_uvectorI9edge_id_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEERRNSt8optionalIN3rmm14device_uvectorI7int32_tEEEENSt8optionalIN4raft11device_spanIK8vertex_tEEEENSt8optionalIN4raft11device_spanIK6size_tEEEENSt8optionalIN4raft11device_spanIK6size_tEEEE6size_t6size_tbb)
* [renumber\_edgelist (C++ function)](../api_docs/cugraph_cpp/graph_functions_cpp/#_CPPv4I00_bE17renumber_edgelistNSt11enable_if_tI9multi_gpuNSt5tupleIN3rmm14device_uvectorI8vertex_tEE15renumber_meta_tI8vertex_t6edge_t9multi_gpuEEEEERKN4raft8handle_tERRNSt8optionalIN3rmm14device_uvectorI8vertex_tEEEERKNSt6vectorIP8vertex_tEERKNSt6vectorIP8vertex_tEERKNSt6vectorI6edge_tEERKNSt8optionalINSt6vectorINSt6vectorI6edge_tEEEEEEbb)
, [\[1\]](../api_docs/cugraph_cpp/graph_functions_cpp/#_CPPv4I00_bE17renumber_edgelistNSt11enable_if_tIXnt9multi_gpuENSt5tupleIN3rmm14device_uvectorI8vertex_tEE15renumber_meta_tI8vertex_t6edge_t9multi_gpuEEEEERKN4raft8handle_tERRNSt8optionalIN3rmm14device_uvectorI8vertex_tEEEEP8vertex_tP8vertex_t6edge_tbb)
* [renumber\_edges\_by\_type() (cugraph.experimental.PropertyGraph method)](../api_docs/api/cugraph/cugraph.experimental.PropertyGraph.renumber_edges_by_type/#cugraph.experimental.PropertyGraph.renumber_edges_by_type)
* [renumber\_ext\_vertices (C++ function)](../api_docs/cugraph_cpp/graph_functions_cpp/#_CPPv4I0_bE21renumber_ext_verticesvRKN4raft8handle_tEP8vertex_t6size_tPK8vertex_t8vertex_t8vertex_tb)
* [renumber\_local\_ext\_vertices (C++ function)](../api_docs/cugraph_cpp/graph_functions_cpp/#_CPPv4I0_bE27renumber_local_ext_verticesvRKN4raft8handle_tEP8vertex_t6size_tPK8vertex_t8vertex_t8vertex_tb)
* [renumber\_vertices\_by\_type() (cugraph.experimental.PropertyGraph method)](../api_docs/api/cugraph/cugraph.experimental.PropertyGraph.renumber_vertices_by_type/#cugraph.experimental.PropertyGraph.renumber_vertices_by_type)
* [rmat() (in module cugraph.generators)](../api_docs/api/cugraph/cugraph.generators.rmat/#cugraph.generators.rmat) |
S
-
| | |
| --- | --- |
| * [SampleIterator (class in cugraph\_pyg.sampler.sampler)](../api_docs/api/cugraph-pyg/cugraph_pyg.sampler.sampler.SampleIterator/#cugraph_pyg.sampler.sampler.SampleIterator)
* [SampleReader (class in cugraph\_pyg.sampler.sampler)](../api_docs/api/cugraph-pyg/cugraph_pyg.sampler.sampler.SampleReader/#cugraph_pyg.sampler.sampler.SampleReader)
* [scalar\_fill (C++ function)](../api_docs/cugraph_cpp/graph_utility_wrappers_cpp/#_CPPv4I0E11scalar_fillvRKN4raft8handle_tEP7value_t6size_t7value_t)
* [scramble\_vertex\_ids (C++ function)](../api_docs/cugraph_cpp/graph_generators_cpp/#_CPPv4I0E19scramble_vertex_idsN3rmm14device_uvectorI8vertex_tEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEE6size_t)
, [\[1\]](../api_docs/cugraph_cpp/graph_generators_cpp/#_CPPv4I0E19scramble_vertex_idsNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEE6size_t)
* [select\_edges() (cugraph.experimental.PropertyGraph method)](../api_docs/api/cugraph/cugraph.experimental.PropertyGraph.select_edges/#cugraph.experimental.PropertyGraph.select_edges)
* [select\_random\_vertices (C++ function)](../api_docs/cugraph_cpp/graph_functions_cpp/#_CPPv4I00_b_bE22select_random_verticesN3rmm14device_uvectorI8vertex_tEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalIN4raft11device_spanIK8vertex_tEEEERN4raft6random8RngStateE6size_tbbb)
* [select\_vertices() (cugraph.experimental.PropertyGraph method)](../api_docs/api/cugraph/cugraph.experimental.PropertyGraph.select_vertices/#cugraph.experimental.PropertyGraph.select_vertices)
* [sequence\_fill (C++ function)](../api_docs/cugraph_cpp/graph_utility_wrappers_cpp/#_CPPv4I0E13sequence_fillvRKN3rmm16cuda_stream_viewEP7value_t6size_t7value_t)
* [set\_renumbered\_col\_names() (cugraph.structure.NumberMap method)](../api_docs/api/cugraph/cugraph.structure.NumberMap.set_renumbered_col_names/#cugraph.structure.NumberMap.set_renumbered_col_names)
* [set\_world\_info() (in module pylibwholegraph.torch.comm)](../api_docs/api/wg/pylibwholegraph.torch.comm.set_world_info/#pylibwholegraph.torch.comm.set_world_info)
* [shortest\_path() (in module cugraph)](../api_docs/api/cugraph/cugraph.shortest_path/#cugraph.shortest_path)
* [shortest\_path\_length() (in module cugraph)](../api_docs/api/cugraph/cugraph.shortest_path_length/#cugraph.shortest_path_length)
* [shuffle\_external\_edges (C++ function)](../api_docs/cugraph_cpp/graph_functions_cpp/#_CPPv4I0000E22shuffle_external_edgesNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI6edge_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEENSt6vectorI6size_tEEEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEERRNSt8optionalIN3rmm14device_uvectorI8weight_tEEEERRNSt8optionalIN3rmm14device_uvectorI6edge_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEE)
* [shuffle\_external\_vertex\_value\_pairs (C++ function)](../api_docs/cugraph_cpp/graph_functions_cpp/#_CPPv4I00E35shuffle_external_vertex_value_pairsNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI7value_tEEEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI7value_tEE)
* [shuffle\_external\_vertices (C++ function)](../api_docs/cugraph_cpp/graph_functions_cpp/#_CPPv4I0E25shuffle_external_verticesN3rmm14device_uvectorI8vertex_tEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEE)
* [sorensen() (in module cugraph)](../api_docs/api/cugraph/cugraph.sorensen/#cugraph.sorensen)
* [sorensen\_all\_pairs\_coefficients (C++ function)](../api_docs/cugraph_cpp/algorithms/similarity_cpp/#_CPPv4I000_bE31sorensen_all_pairs_coefficientsNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8weight_tEEEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEENSt8optionalIN4raft11device_spanIK8vertex_tEEEENSt8optionalI6size_tEEb)
* [sorensen\_coefficient() (in module cugraph)](../api_docs/api/cugraph/cugraph.sorensen_coefficient/#cugraph.sorensen_coefficient)
* [sorensen\_coefficients (C++ function)](../api_docs/cugraph_cpp/algorithms/similarity_cpp/#_CPPv4I000_bE21sorensen_coefficientsN3rmm14device_uvectorI8weight_tEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEENSt5tupleIN4raft11device_spanIK8vertex_tEEN4raft11device_spanIK8vertex_tEEEEb) | * [sort\_ints (C++ function)](../api_docs/cugraph_cpp/graph_utility_wrappers_cpp/#_CPPv4I0E9sort_intsvRKN4raft8handle_tEN4raft11device_spanI7value_tEE)
* [sort\_sampled\_edgelist (C++ function)](../api_docs/cugraph_cpp/graph_sampling_cpp/#_CPPv4I0000E21sort_sampled_edgelistNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI9edge_id_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEENSt8optionalIN3rmm14device_uvectorI6size_tEEEEEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEERRNSt8optionalIN3rmm14device_uvectorI8weight_tEEEERRNSt8optionalIN3rmm14device_uvectorI9edge_id_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEERRNSt8optionalIN3rmm14device_uvectorI7int32_tEEEENSt8optionalIN4raft11device_spanIK6size_tEEEE6size_t6size_tbb)
* [spectralBalancedCutClustering() (in module cugraph)](../api_docs/api/cugraph/cugraph.spectralBalancedCutClustering/#cugraph.spectralBalancedCutClustering)
* [spectralModularityMaximization (C++ function)](../api_docs/cugraph_cpp/algorithms/community_cpp/#_CPPv4I000E30spectralModularityMaximizationvRKN6legacy12GraphCSRViewI2VT2ET2WTEE2VT2VT2WTi2WTiP2VT)
* [spectralModularityMaximizationClustering() (in module cugraph)](../api_docs/api/cugraph/cugraph.spectralModularityMaximizationClustering/#cugraph.spectralModularityMaximizationClustering)
* [sssp (C++ function)](../api_docs/cugraph_cpp/algorithms/traversal_cpp/#_CPPv4I000_bE4ssspvRKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuE20edge_property_view_tI6edge_tPK8weight_tEP8weight_tP8vertex_t8vertex_t8weight_tb)
* [sssp() (in module cugraph)](../api_docs/api/cugraph/cugraph.sssp/#cugraph.sssp)
* [(in module cugraph.dask.traversal.sssp)](../api_docs/api/cugraph/cugraph.dask.traversal.sssp.sssp/#cugraph.dask.traversal.sssp.sssp)
* [(in module pylibcugraph)](../api_docs/api/plc/pylibcugraph.sssp/#pylibcugraph.sssp)
* [stride\_fill (C++ function)](../api_docs/cugraph_cpp/graph_utility_wrappers_cpp/#_CPPv4I0E11stride_fillvRKN3rmm16cuda_stream_viewEP7value_t6size_t7value_t7value_t)
* [strongly\_connected\_components() (in module cugraph)](../api_docs/api/cugraph/cugraph.strongly_connected_components/#cugraph.strongly_connected_components)
* [(in module pylibcugraph)](../api_docs/api/plc/pylibcugraph.strongly_connected_components/#pylibcugraph.strongly_connected_components)
* [subgraph() (in module cugraph)](../api_docs/api/cugraph/cugraph.subgraph/#cugraph.subgraph)
* [symmetrize() (in module cugraph)](../api_docs/api/cugraph/cugraph.symmetrize/#cugraph.symmetrize)
* [symmetrize\_ddf() (in module cugraph)](../api_docs/api/cugraph/cugraph.symmetrize_ddf/#cugraph.symmetrize_ddf)
* [symmetrize\_df() (in module cugraph)](../api_docs/api/cugraph/cugraph.symmetrize_df/#cugraph.symmetrize_df)
* [symmetrize\_edgelist (C++ function)](../api_docs/cugraph_cpp/graph_functions_cpp/#_CPPv4I00000_bE19symmetrize_edgelistNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI6edge_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_time_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_time_tEEEEEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEERRNSt8optionalIN3rmm14device_uvectorI8weight_tEEEERRNSt8optionalIN3rmm14device_uvectorI6edge_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_time_tEEEERRNSt8optionalIN3rmm14device_uvectorI11edge_time_tEEEEb)
* [symmetrize\_edgelist\_from\_triangular (C++ function)](../api_docs/cugraph_cpp/graph_generators_cpp/#_CPPv4I00E35symmetrize_edgelist_from_triangularNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEEEERKN4raft8handle_tERRN3rmm14device_uvectorI8vertex_tEERRN3rmm14device_uvectorI8vertex_tEERRNSt8optionalIN3rmm14device_uvectorI8weight_tEEEEb)
* [symmetrize\_graph (C++ function)](../api_docs/cugraph_cpp/graph_functions_cpp/#_CPPv4I000_b_bE16symmetrize_graphNSt5tupleI7graph_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE8weight_tEEENSt8optionalIN3rmm14device_uvectorI8vertex_tEEEEEERKN4raft8handle_tERR7graph_tI8vertex_t6edge_t16store_transposed9multi_gpuERRNSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE8weight_tEEERRNSt8optionalIN3rmm14device_uvectorI8vertex_tEEEEbb) |
T
-
| | |
| --- | --- |
| * [TensorDictFeatureStore (class in cugraph\_pyg.data.feature\_store)](../api_docs/api/cugraph-pyg/cugraph_pyg.data.feature_store.TensorDictFeatureStore/#cugraph_pyg.data.feature_store.TensorDictFeatureStore)
* [to\_directed() (cugraph.Graph method)](../api_docs/api/cugraph/cugraph.Graph.to_directed/#cugraph.Graph.to_directed)
* [to\_internal\_vertex\_id() (cugraph.structure.NumberMap method)](../api_docs/api/cugraph/cugraph.structure.NumberMap.to_internal_vertex_id/#cugraph.structure.NumberMap.to_internal_vertex_id)
* [to\_numpy\_array() (in module cugraph)](../api_docs/api/cugraph/cugraph.to_numpy_array/#cugraph.to_numpy_array)
* [to\_numpy\_matrix() (in module cugraph)](../api_docs/api/cugraph/cugraph.to_numpy_matrix/#cugraph.to_numpy_matrix)
* [to\_pandas\_adjacency() (in module cugraph)](../api_docs/api/cugraph/cugraph.to_pandas_adjacency/#cugraph.to_pandas_adjacency) | * [to\_pandas\_edgelist() (in module cugraph)](../api_docs/api/cugraph/cugraph.to_pandas_edgelist/#cugraph.to_pandas_edgelist)
* [to\_undirected() (cugraph.Graph method)](../api_docs/api/cugraph/cugraph.Graph.to_undirected/#cugraph.Graph.to_undirected)
* [transform\_increment\_ints (C++ function)](../api_docs/cugraph_cpp/graph_utility_wrappers_cpp/#_CPPv4I0E24transform_increment_intsvN4raft11device_spanI7value_tEE7value_tRKN3rmm16cuda_stream_viewE)
* [transpose\_graph (C++ function)](../api_docs/cugraph_cpp/graph_functions_cpp/#_CPPv4I000_b_bE15transpose_graphNSt5tupleI7graph_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE8weight_tEEENSt8optionalIN3rmm14device_uvectorI8vertex_tEEEEEERKN4raft8handle_tERR7graph_tI8vertex_t6edge_t16store_transposed9multi_gpuERRNSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE8weight_tEEERRNSt8optionalIN3rmm14device_uvectorI8vertex_tEEEEb)
* [transpose\_graph\_storage (C++ function)](../api_docs/cugraph_cpp/graph_functions_cpp/#_CPPv4I000_b_bE23transpose_graph_storageNSt5tupleI7graph_tI8vertex_t6edge_tXnt16store_transposedE9multi_gpuENSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_tXnt16store_transposedE9multi_gpuE8weight_tEEENSt8optionalIN3rmm14device_uvectorI8vertex_tEEEEEERKN4raft8handle_tERR7graph_tI8vertex_t6edge_t16store_transposed9multi_gpuERRNSt8optionalI15edge_property_tI12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuE8weight_tEEERRNSt8optionalIN3rmm14device_uvectorI8vertex_tEEEEb)
* [triangle\_count (C++ function)](../api_docs/cugraph_cpp/algorithms/community_cpp/#_CPPv4I00_bE14triangle_countvRKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalIN4raft11device_spanIK8vertex_tEEEEN4raft11device_spanI6edge_tEEb)
* [triangle\_count() (in module cugraph)](../api_docs/api/cugraph/cugraph.triangle_count/#cugraph.triangle_count) |
U
-
| | |
| --- | --- |
| * [uniform\_neighbor\_sample (C++ function)](../api_docs/cugraph_cpp/graph_sampling_cpp/#_CPPv4I00000_b_bE23uniform_neighbor_sampleNSt5tupleIN3rmm14device_uvectorI8vertex_tEEN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEENSt8optionalIN3rmm14device_uvectorI6edge_tEEEENSt8optionalIN3rmm14device_uvectorI11edge_type_tEEEENSt8optionalIN3rmm14device_uvectorI7int32_tEEEENSt8optionalIN3rmm14device_uvectorI7label_tEEEENSt8optionalIN3rmm14device_uvectorI6size_tEEEEEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_t16store_transposed9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEENSt8optionalI20edge_property_view_tI6edge_tPK6edge_tEEENSt8optionalI20edge_property_view_tI6edge_tPK11edge_type_tEEEN4raft11device_spanIK8vertex_tEENSt8optionalIN4raft11device_spanIK7label_tEEEENSt8optionalINSt5tupleIN4raft11device_spanIK7label_tEEN4raft11device_spanIK7int32_tEEEEEEN4raft9host_spanIK7int32_tEERN4raft6random8RngStateEbb24prior_sources_behavior_tbb)
* [uniform\_neighbor\_sample() (in module cugraph)](../api_docs/api/cugraph/cugraph.uniform_neighbor_sample/#cugraph.uniform_neighbor_sample)
* [uniform\_random\_fill (C++ function)](../api_docs/cugraph_cpp/graph_utility_wrappers_cpp/#_CPPv4I0E19uniform_random_fillvRKN3rmm16cuda_stream_viewEP7value_t6size_t7value_t7value_tRN4raft6random8RngStateE)
* [uniform\_random\_walks (C++ function)](../api_docs/cugraph_cpp/algorithms/sampling_cpp/#_CPPv4I000_bE20uniform_random_walksNSt5tupleIN3rmm14device_uvectorI8vertex_tEENSt8optionalIN3rmm14device_uvectorI8weight_tEEEEEERKN4raft8handle_tERN4raft6random8RngStateERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuENSt8optionalI20edge_property_view_tI6edge_tPK8weight_tEEEN4raft11device_spanIK8vertex_tEE6size_t)
* [unique\_ints (C++ function)](../api_docs/cugraph_cpp/graph_utility_wrappers_cpp/#_CPPv4I0E11unique_ints6size_tRKN4raft8handle_tEN4raft11device_spanI7value_tEE) | * [unrenumber() (cugraph.Graph method)](../api_docs/api/cugraph/cugraph.Graph.unrenumber/#cugraph.Graph.unrenumber)
* [(cugraph.structure.NumberMap method)](../api_docs/api/cugraph/cugraph.structure.NumberMap.unrenumber/#cugraph.structure.NumberMap.unrenumber)
* [unrenumber\_int\_vertices (C++ function)](../api_docs/cugraph_cpp/graph_functions_cpp/#_CPPv4I0_bE23unrenumber_int_verticesvRKN4raft8handle_tEP8vertex_t6size_tPK8vertex_tRKNSt6vectorI8vertex_tEEb)
* [unrenumber\_local\_int\_edges (C++ function)](../api_docs/cugraph_cpp/graph_functions_cpp/#_CPPv4I0_b_bE26unrenumber_local_int_edgesNSt11enable_if_tI9multi_gpuvEERKN4raft8handle_tERKNSt6vectorIP8vertex_tEERKNSt6vectorIP8vertex_tEERKNSt6vectorI6size_tEEPK8vertex_tRKNSt6vectorI8vertex_tEERKNSt8optionalINSt6vectorINSt6vectorI6size_tEEEEEEb)
, [\[1\]](../api_docs/cugraph_cpp/graph_functions_cpp/#_CPPv4I0_b_bE26unrenumber_local_int_edgesNSt11enable_if_tIXnt9multi_gpuEvEERKN4raft8handle_tEP8vertex_tP8vertex_t6size_tPK8vertex_t8vertex_tb)
* [unrenumber\_local\_int\_vertices (C++ function)](../api_docs/cugraph_cpp/graph_functions_cpp/#_CPPv4I0E29unrenumber_local_int_verticesvRKN4raft8handle_tEP8vertex_t6size_tPK8vertex_t8vertex_t8vertex_tb) |
V
-
| | |
| --- | --- |
| * [vertex\_coloring (C++ function)](../api_docs/cugraph_cpp/algorithms/utility_cpp/#_CPPv4I00_bE15vertex_coloringN3rmm14device_uvectorI8vertex_tEERKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuERN4raft6random8RngStateE)
* [vertex\_column\_size() (cugraph.structure.graph\_implementation.simpleGraphImpl method)](../api_docs/api/cugraph/cugraph.structure.graph_implementation.simpleGraphImpl.vertex_column_size/#cugraph.structure.graph_implementation.simpleGraphImpl.vertex_column_size)
* [(cugraph.structure.NumberMap method)](../api_docs/api/cugraph/cugraph.structure.NumberMap.vertex_column_size/#cugraph.structure.NumberMap.vertex_column_size) | * [view\_adj\_list() (cugraph.structure.graph\_implementation.simpleGraphImpl method)](../api_docs/api/cugraph/cugraph.structure.graph_implementation.simpleGraphImpl.view_adj_list/#cugraph.structure.graph_implementation.simpleGraphImpl.view_adj_list)
* [view\_edge\_list() (cugraph.structure.graph\_implementation.simpleGraphImpl method)](../api_docs/api/cugraph/cugraph.structure.graph_implementation.simpleGraphImpl.view_edge_list/#cugraph.structure.graph_implementation.simpleGraphImpl.view_edge_list)
* [view\_transposed\_adj\_list() (cugraph.structure.graph\_implementation.simpleGraphImpl method)](../api_docs/api/cugraph/cugraph.structure.graph_implementation.simpleGraphImpl.view_transposed_adj_list/#cugraph.structure.graph_implementation.simpleGraphImpl.view_transposed_adj_list) |
W
-
| | |
| --- | --- |
| * [weakly\_connected\_components (C++ function)](../api_docs/cugraph_cpp/algorithms/components_cpp/#_CPPv4I00_bE27weakly_connected_componentsvRKN4raft8handle_tERK12graph_view_tI8vertex_t6edge_tXL0EE9multi_gpuEP8vertex_tb)
* [weakly\_connected\_components() (in module cugraph)](../api_docs/api/cugraph/cugraph.weakly_connected_components/#cugraph.weakly_connected_components)
* [(in module cugraph.dask.components.connectivity)](../api_docs/api/cugraph/cugraph.dask.components.connectivity.weakly_connected_components/#cugraph.dask.components.connectivity.weakly_connected_components)
* [(in module pylibcugraph)](../api_docs/api/plc/pylibcugraph.weakly_connected_components/#pylibcugraph.weakly_connected_components)
* [WholeFeatureStore (class in cugraph\_pyg.data.feature\_store)](../api_docs/api/cugraph-pyg/cugraph_pyg.data.feature_store.WholeFeatureStore/#cugraph_pyg.data.feature_store.WholeFeatureStore)
* [wholegraph\_csr\_unweighted\_sample\_without\_replacement (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv452wholegraph_csr_unweighted_sample_without_replacement20wholememory_tensor_t20wholememory_tensor_t20wholememory_tensor_ti20wholememory_tensor_tPvPvPvyP22wholememory_env_func_tPv)
* [wholegraph\_csr\_weighted\_sample\_without\_replacement (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv450wholegraph_csr_weighted_sample_without_replacement20wholememory_tensor_t20wholememory_tensor_t20wholememory_tensor_t20wholememory_tensor_ti20wholememory_tensor_tPvPvPvyP22wholememory_env_func_tPv)
* [wholememory\_access\_type\_t (C++ enum)](../api_docs/wholegraph/libwholegraph/#_CPPv425wholememory_access_type_t)
* [wholememory\_access\_type\_t::WHOLEMEMORY\_AT\_NONE (C++ enumerator)](../api_docs/wholegraph/libwholegraph/#_CPPv4N25wholememory_access_type_t19WHOLEMEMORY_AT_NONEE)
* [wholememory\_access\_type\_t::WHOLEMEMORY\_AT\_READONLY (C++ enumerator)](../api_docs/wholegraph/libwholegraph/#_CPPv4N25wholememory_access_type_t23WHOLEMEMORY_AT_READONLYE)
* [wholememory\_access\_type\_t::WHOLEMEMORY\_AT\_READWRITE (C++ enumerator)](../api_docs/wholegraph/libwholegraph/#_CPPv4N25wholememory_access_type_t24WHOLEMEMORY_AT_READWRITEE)
* [wholememory\_array\_description\_t (C++ struct)](../api_docs/wholegraph/libwholegraph/#_CPPv431wholememory_array_description_t)
* [wholememory\_comm\_t (C++ type)](../api_docs/wholegraph/libwholegraph/#_CPPv418wholememory_comm_t)
* [wholememory\_communicator\_barrier (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv432wholememory_communicator_barrier18wholememory_comm_t)
* [wholememory\_communicator\_get\_rank (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv433wholememory_communicator_get_rankPi18wholememory_comm_t)
* [wholememory\_communicator\_get\_size (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv433wholememory_communicator_get_sizePi18wholememory_comm_t)
* [wholememory\_convert\_tensor\_desc\_to\_array (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv440wholememory_convert_tensor_desc_to_arrayP31wholememory_array_description_tP32wholememory_tensor_description_t)
* [wholememory\_convert\_tensor\_desc\_to\_matrix (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv441wholememory_convert_tensor_desc_to_matrixP32wholememory_matrix_description_tP32wholememory_tensor_description_t)
* [wholememory\_copy\_array\_desc\_to\_matrix (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv437wholememory_copy_array_desc_to_matrixP32wholememory_matrix_description_tP31wholememory_array_description_t)
* [wholememory\_copy\_array\_desc\_to\_tensor (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv437wholememory_copy_array_desc_to_tensorP32wholememory_tensor_description_tP31wholememory_array_description_t)
* [wholememory\_copy\_matrix\_desc\_to\_tensor (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv438wholememory_copy_matrix_desc_to_tensorP32wholememory_tensor_description_tP32wholememory_matrix_description_t)
* [wholememory\_create\_array\_desc (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv429wholememory_create_array_desc7int64_t7int64_t19wholememory_dtype_t)
* [wholememory\_create\_communicator (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv431wholememory_create_communicatorP18wholememory_comm_t23wholememory_unique_id_tii)
* [wholememory\_create\_embedding (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv428wholememory_create_embeddingP23wholememory_embedding_tP32wholememory_tensor_description_t18wholememory_comm_t25wholememory_memory_type_t29wholememory_memory_location_t36wholememory_embedding_cache_policy_tP6size_tii)
* [wholememory\_create\_embedding\_cache\_policy (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv441wholememory_create_embedding_cache_policyP36wholememory_embedding_cache_policy_t18wholememory_comm_t25wholememory_memory_type_t29wholememory_memory_location_t25wholememory_access_type_tf)
* [wholememory\_create\_embedding\_optimizer (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv438wholememory_create_embedding_optimizerP33wholememory_embedding_optimizer_t28wholememory_optimizer_type_t)
* [wholememory\_create\_matrix\_desc (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv430wholememory_create_matrix_descAL2E_7int64_t7int64_t7int64_t19wholememory_dtype_t)
* [wholememory\_create\_tensor (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv425wholememory_create_tensorP20wholememory_tensor_tP32wholememory_tensor_description_t18wholememory_comm_t25wholememory_memory_type_t29wholememory_memory_location_tP6size_t)
* [wholememory\_create\_unique\_id (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv428wholememory_create_unique_idP23wholememory_unique_id_t)
* [wholememory\_destroy\_communicator (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv432wholememory_destroy_communicator18wholememory_comm_t)
* [wholememory\_destroy\_embedding (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv429wholememory_destroy_embedding23wholememory_embedding_t)
* [wholememory\_destroy\_embedding\_cache\_policy (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv442wholememory_destroy_embedding_cache_policy36wholememory_embedding_cache_policy_t)
* [wholememory\_destroy\_embedding\_optimizer (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv439wholememory_destroy_embedding_optimizer33wholememory_embedding_optimizer_t)
* [wholememory\_destroy\_tensor (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv426wholememory_destroy_tensor20wholememory_tensor_t)
* [wholememory\_dtype\_get\_element\_size (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv434wholememory_dtype_get_element_size19wholememory_dtype_t)
* [wholememory\_dtype\_is\_floating\_number (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv436wholememory_dtype_is_floating_number19wholememory_dtype_t)
* [wholememory\_dtype\_is\_integer\_number (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv435wholememory_dtype_is_integer_number19wholememory_dtype_t)
* [wholememory\_dtype\_t (C++ enum)](../api_docs/wholegraph/libwholegraph/#_CPPv419wholememory_dtype_t)
* [wholememory\_dtype\_t::WHOLEMEMORY\_DT\_BF16 (C++ enumerator)](../api_docs/wholegraph/libwholegraph/#_CPPv4N19wholememory_dtype_t19WHOLEMEMORY_DT_BF16E)
* [wholememory\_dtype\_t::WHOLEMEMORY\_DT\_COUNT (C++ enumerator)](../api_docs/wholegraph/libwholegraph/#_CPPv4N19wholememory_dtype_t20WHOLEMEMORY_DT_COUNTE)
* [wholememory\_dtype\_t::WHOLEMEMORY\_DT\_DOUBLE (C++ enumerator)](../api_docs/wholegraph/libwholegraph/#_CPPv4N19wholememory_dtype_t21WHOLEMEMORY_DT_DOUBLEE)
* [wholememory\_dtype\_t::WHOLEMEMORY\_DT\_FLOAT (C++ enumerator)](../api_docs/wholegraph/libwholegraph/#_CPPv4N19wholememory_dtype_t20WHOLEMEMORY_DT_FLOATE)
* [wholememory\_dtype\_t::WHOLEMEMORY\_DT\_HALF (C++ enumerator)](../api_docs/wholegraph/libwholegraph/#_CPPv4N19wholememory_dtype_t19WHOLEMEMORY_DT_HALFE)
* [wholememory\_dtype\_t::WHOLEMEMORY\_DT\_INT (C++ enumerator)](../api_docs/wholegraph/libwholegraph/#_CPPv4N19wholememory_dtype_t18WHOLEMEMORY_DT_INTE)
* [wholememory\_dtype\_t::WHOLEMEMORY\_DT\_INT16 (C++ enumerator)](../api_docs/wholegraph/libwholegraph/#_CPPv4N19wholememory_dtype_t20WHOLEMEMORY_DT_INT16E)
* [wholememory\_dtype\_t::WHOLEMEMORY\_DT\_INT64 (C++ enumerator)](../api_docs/wholegraph/libwholegraph/#_CPPv4N19wholememory_dtype_t20WHOLEMEMORY_DT_INT64E)
* [wholememory\_dtype\_t::WHOLEMEMORY\_DT\_INT8 (C++ enumerator)](../api_docs/wholegraph/libwholegraph/#_CPPv4N19wholememory_dtype_t19WHOLEMEMORY_DT_INT8E)
* [wholememory\_dtype\_t::WHOLEMEMORY\_DT\_UNKNOWN (C++ enumerator)](../api_docs/wholegraph/libwholegraph/#_CPPv4N19wholememory_dtype_t22WHOLEMEMORY_DT_UNKNOWNE)
* [wholememory\_embedding\_cache\_policy\_t (C++ type)](../api_docs/wholegraph/libwholegraph/#_CPPv436wholememory_embedding_cache_policy_t)
* [wholememory\_embedding\_drop\_all\_cache (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv436wholememory_embedding_drop_all_cache23wholememory_embedding_t7int64_t)
* [wholememory\_embedding\_gather (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv428wholememory_embedding_gather23wholememory_embedding_t20wholememory_tensor_t20wholememory_tensor_tbP22wholememory_env_func_t7int64_t)
* [wholememory\_embedding\_gather\_gradient\_apply (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv443wholememory_embedding_gather_gradient_apply23wholememory_embedding_t20wholememory_tensor_t20wholememory_tensor_tbfP22wholememory_env_func_t7int64_t)
* [wholememory\_embedding\_get\_embedding\_tensor (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv442wholememory_embedding_get_embedding_tensor23wholememory_embedding_t)
* [wholememory\_embedding\_get\_optimizer\_state (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv441wholememory_embedding_get_optimizer_state23wholememory_embedding_tPKc)
* [wholememory\_embedding\_get\_optimizer\_state\_names (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv447wholememory_embedding_get_optimizer_state_names23wholememory_embedding_t)
* [wholememory\_embedding\_optimizer\_t (C++ type)](../api_docs/wholegraph/libwholegraph/#_CPPv433wholememory_embedding_optimizer_t)
* [wholememory\_embedding\_t (C++ type)](../api_docs/wholegraph/libwholegraph/#_CPPv423wholememory_embedding_t)
* [wholememory\_embedding\_writeback\_cache (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv437wholememory_embedding_writeback_cache23wholememory_embedding_t7int64_t)
* [wholememory\_error\_code\_t (C++ enum)](../api_docs/wholegraph/libwholegraph/#_CPPv424wholememory_error_code_t)
* [wholememory\_error\_code\_t::WHOLEMEMORY\_COMMUNICATION\_ERROR (C++ enumerator)](../api_docs/wholegraph/libwholegraph/#_CPPv4N24wholememory_error_code_t31WHOLEMEMORY_COMMUNICATION_ERRORE)
* [wholememory\_error\_code\_t::WHOLEMEMORY\_CUDA\_ERROR (C++ enumerator)](../api_docs/wholegraph/libwholegraph/#_CPPv4N24wholememory_error_code_t22WHOLEMEMORY_CUDA_ERRORE)
* [wholememory\_error\_code\_t::WHOLEMEMORY\_INVALID\_INPUT (C++ enumerator)](../api_docs/wholegraph/libwholegraph/#_CPPv4N24wholememory_error_code_t25WHOLEMEMORY_INVALID_INPUTE)
* [wholememory\_error\_code\_t::WHOLEMEMORY\_INVALID\_VALUE (C++ enumerator)](../api_docs/wholegraph/libwholegraph/#_CPPv4N24wholememory_error_code_t25WHOLEMEMORY_INVALID_VALUEE)
* [wholememory\_error\_code\_t::WHOLEMEMORY\_LOGIC\_ERROR (C++ enumerator)](../api_docs/wholegraph/libwholegraph/#_CPPv4N24wholememory_error_code_t23WHOLEMEMORY_LOGIC_ERRORE)
* [wholememory\_error\_code\_t::WHOLEMEMORY\_NOT\_IMPLEMENTED (C++ enumerator)](../api_docs/wholegraph/libwholegraph/#_CPPv4N24wholememory_error_code_t27WHOLEMEMORY_NOT_IMPLEMENTEDE)
* [wholememory\_error\_code\_t::WHOLEMEMORY\_NOT\_SUPPORTED (C++ enumerator)](../api_docs/wholegraph/libwholegraph/#_CPPv4N24wholememory_error_code_t25WHOLEMEMORY_NOT_SUPPORTEDE)
* [wholememory\_error\_code\_t::WHOLEMEMORY\_OUT\_OF\_MEMORY (C++ enumerator)](../api_docs/wholegraph/libwholegraph/#_CPPv4N24wholememory_error_code_t25WHOLEMEMORY_OUT_OF_MEMORYE) | * [wholememory\_error\_code\_t::WHOLEMEMORY\_SUCCESS (C++ enumerator)](../api_docs/wholegraph/libwholegraph/#_CPPv4N24wholememory_error_code_t19WHOLEMEMORY_SUCCESSE)
* [wholememory\_error\_code\_t::WHOLEMEMORY\_SYSTEM\_ERROR (C++ enumerator)](../api_docs/wholegraph/libwholegraph/#_CPPv4N24wholememory_error_code_t24WHOLEMEMORY_SYSTEM_ERRORE)
* [wholememory\_error\_code\_t::WHOLEMEMORY\_UNKNOW\_ERROR (C++ enumerator)](../api_docs/wholegraph/libwholegraph/#_CPPv4N24wholememory_error_code_t24WHOLEMEMORY_UNKNOW_ERRORE)
* [wholememory\_finalize (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv420wholememory_finalizev)
* [wholememory\_free (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv416wholememory_free20wholememory_handle_t)
* [wholememory\_gather (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv418wholememory_gather20wholememory_tensor_t20wholememory_tensor_t20wholememory_tensor_tP22wholememory_env_func_tPvi)
* [wholememory\_get\_communicator (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv428wholememory_get_communicatorP18wholememory_comm_t20wholememory_handle_t)
* [wholememory\_get\_data\_granularity (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv432wholememory_get_data_granularity20wholememory_handle_t)
* [wholememory\_get\_global\_pointer (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv430wholememory_get_global_pointerPPv20wholememory_handle_t)
* [wholememory\_get\_global\_reference (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv432wholememory_get_global_referenceP18wholememory_gref_t20wholememory_handle_t)
* [wholememory\_get\_local\_memory (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv428wholememory_get_local_memoryPPvP6size_tP6size_t20wholememory_handle_t)
* [wholememory\_get\_memory\_element\_count\_from\_array (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv447wholememory_get_memory_element_count_from_arrayP31wholememory_array_description_t)
* [wholememory\_get\_memory\_element\_count\_from\_matrix (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv448wholememory_get_memory_element_count_from_matrixP32wholememory_matrix_description_t)
* [wholememory\_get\_memory\_element\_count\_from\_tensor (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv448wholememory_get_memory_element_count_from_tensorP32wholememory_tensor_description_t)
* [wholememory\_get\_memory\_location (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv431wholememory_get_memory_location20wholememory_handle_t)
* [wholememory\_get\_memory\_size\_from\_array (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv438wholememory_get_memory_size_from_arrayP31wholememory_array_description_t)
* [wholememory\_get\_memory\_size\_from\_matrix (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv439wholememory_get_memory_size_from_matrixP32wholememory_matrix_description_t)
* [wholememory\_get\_memory\_size\_from\_tensor (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv439wholememory_get_memory_size_from_tensorP32wholememory_tensor_description_t)
* [wholememory\_get\_memory\_type (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv427wholememory_get_memory_type20wholememory_handle_t)
* [wholememory\_get\_rank\_memory (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv427wholememory_get_rank_memoryPPvP6size_tP6size_ti20wholememory_handle_t)
* [wholememory\_get\_total\_size (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv426wholememory_get_total_size20wholememory_handle_t)
* [wholememory\_gref\_t (C++ struct)](../api_docs/wholegraph/libwholegraph/#_CPPv418wholememory_gref_t)
* [wholememory\_handle\_t (C++ type)](../api_docs/wholegraph/libwholegraph/#_CPPv420wholememory_handle_t)
* [wholememory\_init (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv416wholememory_initj8LogLevel)
* [wholememory\_initialize\_tensor\_desc (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv434wholememory_initialize_tensor_descP32wholememory_tensor_description_t)
* [wholememory\_load\_from\_file (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv426wholememory_load_from_file20wholememory_handle_t6size_t6size_t6size_tPPKcii)
* [wholememory\_make\_tensor\_from\_handle (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv435wholememory_make_tensor_from_handleP20wholememory_tensor_t20wholememory_handle_tP32wholememory_tensor_description_t)
* [wholememory\_make\_tensor\_from\_pointer (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv436wholememory_make_tensor_from_pointerP20wholememory_tensor_tPvP32wholememory_tensor_description_t)
* [wholememory\_malloc (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv418wholememory_mallocP20wholememory_handle_t6size_t18wholememory_comm_t25wholememory_memory_type_t29wholememory_memory_location_t6size_tP6size_t)
* [wholememory\_matrix\_description\_t (C++ struct)](../api_docs/wholegraph/libwholegraph/#_CPPv432wholememory_matrix_description_t)
* [wholememory\_memory\_location\_t (C++ enum)](../api_docs/wholegraph/libwholegraph/#_CPPv429wholememory_memory_location_t)
* [wholememory\_memory\_location\_t::WHOLEMEMORY\_ML\_DEVICE (C++ enumerator)](../api_docs/wholegraph/libwholegraph/#_CPPv4N29wholememory_memory_location_t21WHOLEMEMORY_ML_DEVICEE)
* [wholememory\_memory\_location\_t::WHOLEMEMORY\_ML\_HOST (C++ enumerator)](../api_docs/wholegraph/libwholegraph/#_CPPv4N29wholememory_memory_location_t19WHOLEMEMORY_ML_HOSTE)
* [wholememory\_memory\_location\_t::WHOLEMEMORY\_ML\_NONE (C++ enumerator)](../api_docs/wholegraph/libwholegraph/#_CPPv4N29wholememory_memory_location_t19WHOLEMEMORY_ML_NONEE)
* [wholememory\_memory\_type\_t (C++ enum)](../api_docs/wholegraph/libwholegraph/#_CPPv425wholememory_memory_type_t)
* [wholememory\_memory\_type\_t::WHOLEMEMORY\_MT\_CHUNKED (C++ enumerator)](../api_docs/wholegraph/libwholegraph/#_CPPv4N25wholememory_memory_type_t22WHOLEMEMORY_MT_CHUNKEDE)
* [wholememory\_memory\_type\_t::WHOLEMEMORY\_MT\_CONTINUOUS (C++ enumerator)](../api_docs/wholegraph/libwholegraph/#_CPPv4N25wholememory_memory_type_t25WHOLEMEMORY_MT_CONTINUOUSE)
* [wholememory\_memory\_type\_t::WHOLEMEMORY\_MT\_DISTRIBUTED (C++ enumerator)](../api_docs/wholegraph/libwholegraph/#_CPPv4N25wholememory_memory_type_t26WHOLEMEMORY_MT_DISTRIBUTEDE)
* [wholememory\_memory\_type\_t::WHOLEMEMORY\_MT\_HIERARCHY (C++ enumerator)](../api_docs/wholegraph/libwholegraph/#_CPPv4N25wholememory_memory_type_t24WHOLEMEMORY_MT_HIERARCHYE)
* [wholememory\_memory\_type\_t::WHOLEMEMORY\_MT\_NONE (C++ enumerator)](../api_docs/wholegraph/libwholegraph/#_CPPv4N25wholememory_memory_type_t19WHOLEMEMORY_MT_NONEE)
* [wholememory\_optimizer\_set\_parameter (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv435wholememory_optimizer_set_parameter33wholememory_embedding_optimizer_tPKcPv)
* [wholememory\_optimizer\_type\_t (C++ enum)](../api_docs/wholegraph/libwholegraph/#_CPPv428wholememory_optimizer_type_t)
* [wholememory\_optimizer\_type\_t::WHOLEMEMORY\_OPT\_ADAGRAD (C++ enumerator)](../api_docs/wholegraph/libwholegraph/#_CPPv4N28wholememory_optimizer_type_t23WHOLEMEMORY_OPT_ADAGRADE)
* [wholememory\_optimizer\_type\_t::WHOLEMEMORY\_OPT\_LAZY\_ADAM (C++ enumerator)](../api_docs/wholegraph/libwholegraph/#_CPPv4N28wholememory_optimizer_type_t25WHOLEMEMORY_OPT_LAZY_ADAME)
* [wholememory\_optimizer\_type\_t::WHOLEMEMORY\_OPT\_NONE (C++ enumerator)](../api_docs/wholegraph/libwholegraph/#_CPPv4N28wholememory_optimizer_type_t20WHOLEMEMORY_OPT_NONEE)
* [wholememory\_optimizer\_type\_t::WHOLEMEMORY\_OPT\_RMSPROP (C++ enumerator)](../api_docs/wholegraph/libwholegraph/#_CPPv4N28wholememory_optimizer_type_t23WHOLEMEMORY_OPT_RMSPROPE)
* [wholememory\_optimizer\_type\_t::WHOLEMEMORY\_OPT\_SGD (C++ enumerator)](../api_docs/wholegraph/libwholegraph/#_CPPv4N28wholememory_optimizer_type_t19WHOLEMEMORY_OPT_SGDE)
* [wholememory\_scatter (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv419wholememory_scatter20wholememory_tensor_t20wholememory_tensor_t20wholememory_tensor_tP22wholememory_env_func_tPvi)
* [wholememory\_store\_to\_file (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv425wholememory_store_to_file20wholememory_handle_t6size_t6size_t6size_tPKc)
* [wholememory\_tensor\_description\_t (C++ struct)](../api_docs/wholegraph/libwholegraph/#_CPPv432wholememory_tensor_description_t)
* [wholememory\_tensor\_get\_data\_pointer (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv435wholememory_tensor_get_data_pointer20wholememory_tensor_t)
* [wholememory\_tensor\_get\_global\_reference (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv439wholememory_tensor_get_global_reference20wholememory_tensor_tP18wholememory_gref_t)
* [wholememory\_tensor\_get\_memory\_handle (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv436wholememory_tensor_get_memory_handle20wholememory_tensor_t)
* [wholememory\_tensor\_get\_root (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv427wholememory_tensor_get_root20wholememory_tensor_t)
* [wholememory\_tensor\_get\_subtensor (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv432wholememory_tensor_get_subtensor20wholememory_tensor_tP7int64_tP7int64_tP20wholememory_tensor_t)
* [wholememory\_tensor\_get\_tensor\_description (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv441wholememory_tensor_get_tensor_description20wholememory_tensor_t)
* [wholememory\_tensor\_has\_handle (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv429wholememory_tensor_has_handle20wholememory_tensor_t)
* [wholememory\_tensor\_map\_local\_tensor (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv435wholememory_tensor_map_local_tensor20wholememory_tensor_tP20wholememory_tensor_t)
* [wholememory\_tensor\_t (C++ type)](../api_docs/wholegraph/libwholegraph/#_CPPv420wholememory_tensor_t)
* [wholememory\_unique\_id\_t (C++ struct)](../api_docs/wholegraph/libwholegraph/#_CPPv423wholememory_unique_id_t)
* [wholememory\_unsqueeze\_tensor (C++ function)](../api_docs/wholegraph/libwholegraph/#_CPPv428wholememory_unsqueeze_tensorP32wholememory_tensor_description_ti)
* [WholeMemoryCachePolicy (class in pylibwholegraph.torch.embedding)](../api_docs/api/wg/pylibwholegraph.torch.embedding.WholeMemoryCachePolicy/#pylibwholegraph.torch.embedding.WholeMemoryCachePolicy)
* [WholeMemoryCommunicator (class in pylibwholegraph.torch.comm)](../api_docs/api/wg/pylibwholegraph.torch.comm.WholeMemoryCommunicator/#pylibwholegraph.torch.comm.WholeMemoryCommunicator)
* [WholeMemoryEmbedding (class in pylibwholegraph.torch.embedding)](../api_docs/api/wg/pylibwholegraph.torch.embedding.WholeMemoryEmbedding/#pylibwholegraph.torch.embedding.WholeMemoryEmbedding)
* [WholeMemoryEmbeddingModule (class in pylibwholegraph.torch.embedding)](../api_docs/api/wg/pylibwholegraph.torch.embedding.WholeMemoryEmbeddingModule/#pylibwholegraph.torch.embedding.WholeMemoryEmbeddingModule)
* [WholeMemoryOptimizer (class in pylibwholegraph.torch.embedding)](../api_docs/api/wg/pylibwholegraph.torch.embedding.WholeMemoryOptimizer/#pylibwholegraph.torch.embedding.WholeMemoryOptimizer)
* [WholeMemoryTensor (class in pylibwholegraph.torch.tensor)](../api_docs/api/wg/pylibwholegraph.torch.tensor.WholeMemoryTensor/#pylibwholegraph.torch.tensor.WholeMemoryTensor) |
---
# Welcome to cuML’s documentation! — cuml 25.04.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cuml
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
nightly (25.04)
[nightly (25.04)](/api/cuml/nightly)
[stable (25.02)](/api/cuml/stable)
[legacy (24.12)](/api/cuml/legacy)
* [GitHub](https://github.com/rapidsai/cuml "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
Welcome to cuML’s documentation
=============================================================================================
cuML is a suite of fast, GPU-accelerated machine learning algorithms designed for data science and analytical tasks. Our API mirrors Sklearn’s, and we provide practitioners with the easy fit-predict-transform paradigm without ever having to program on a GPU.
As data gets larger, algorithms running on a CPU becomes slow and cumbersome. RAPIDS provides users a streamlined approach where data is initially loaded in the GPU, and compute tasks can be performed on it directly.
cuML is fully open source, and the RAPIDS team welcomes new and seasoned contributors, users and hobbyists! Thank you for your wonderful support!
An installation requirement for cuML is that your system must be Linux-like. Support for Windows is possible in the near future.
Contents:
* [Introduction](cuml_intro/)
* [1\. Where possible, match the scikit-learn API](cuml_intro/#where-possible-match-the-scikit-learn-api)
* [2\. Accept flexible input types, return predictable output types](cuml_intro/#accept-flexible-input-types-return-predictable-output-types)
* [3\. Be fast!](cuml_intro/#be-fast)
* [Learn more](cuml_intro/#learn-more)
* [API Reference](api/)
* [Module Configuration](api/#module-configuration)
* [Preprocessing, Metrics, and Utilities](api/#preprocessing-metrics-and-utilities)
* [Regression and Classification](api/#regression-and-classification)
* [Clustering](api/#clustering)
* [Dimensionality Reduction and Manifold Learning](api/#dimensionality-reduction-and-manifold-learning)
* [Neighbors](api/#neighbors)
* [Time Series](api/#time-series)
* [Model Explainability](api/#model-explainability)
* [Multi-Node, Multi-GPU Algorithms](api/#multi-node-multi-gpu-algorithms)
* [Experimental](api/#experimental)
* [User Guide](user_guide/)
* [Training and Evaluating Machine Learning Models](estimator_intro/)
* [Pickling Models for Persistence](pickling_cuml_models/)
* [cuML on GPU and CPU](execution_device_interoperability/)
* [Blogs and other references](cuml_blogs/)
* [Integrations, applications, and general concepts](cuml_blogs/#integrations-applications-and-general-concepts)
* [Tree and forest models](cuml_blogs/#tree-and-forest-models)
* [Other popular models](cuml_blogs/#other-popular-models)
* [Academic Papers](cuml_blogs/#academic-papers)
Indices and tables[#](#indices-and-tables "Link to this heading")
==================================================================
* [Index](genindex/)
* [Module Index](py-modindex/)
* [Search Page](search/)
On this page
### This Page
* [Show Source](_sources/index.rst.txt)
---
# How To Guides — cugraph-docs 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cugraph
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cugraph/nightly)
[stable (25.02)](/api/cugraph/stable)
[legacy (24.12)](/api/cugraph/legacy)
* [GitHub](https://github.com/rapidsai/cugraph "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
How To Guides[#](#how-to-guides "Link to this heading")
========================================================
* [Basic use of cuGraph](../basic_cugraph/)
* GNN – model building
* MNMG Graph – dask, rmm basics and examples
* Pylibcugraph – why and how
* Cugraph for C, C++ users
* Use of nvidia-smi with cugraph
### This Page
* [Show Source](../../_sources/tutorials/how_to_guides.md.txt)
---
# Welcome to cuxfilter’s documentation — cuxfilter 25.04.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cuxfilter
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
nightly (25.04)
[nightly (25.04)](/api/cuxfilter/nightly)
[stable (25.02)](/api/cuxfilter/stable)
[legacy (24.12)](/api/cuxfilter/legacy)
* [GitHub](https://github.com/rapidsai/cuxfilter "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
Welcome to cuxfilter’s documentation[#](#welcome-to-cuxfilter-s-documentation "Link to this heading")
======================================================================================================
cuxfilter enables GPU accelerated cross-filtering dashboards from notebooks, in just a few lines of Python code. Well integrated with the HoloViz ecosystem, it also incorporates other outstanding visualization libraries. RAPIDS cuxfilter is ideal for multi-chart exploratory data analysis and dashboard prototyping within the RAPIDS ecosystem.
Contents:
* [User Guide](user_guide/)
* [Installation](user_guide/installation/)
* [10 minutes to cuxfilter](user_guide/10_minutes_to_cuxfilter/)
* [Charts](user_guide/charts/)
* [Layouts](user_guide/layouts/Layouts/)
* [Dashboard Themes](user_guide/themes/Themes/)
* [Example Dashboards](user_guide/examples/)
* [cuxfilter with multi-GPU using dask\_cudf](user_guide/Dask-cudf-support/)
* [Deploying a multi-user Dashboard](user_guide/deployment/)
* [API Reference](api_reference/dataframe/)
* [DataFrame](api_reference/dataframe/#dataframe)
* [DashBoard](api_reference/dataframe/#dashboard)
Indices and tables[#](#indices-and-tables "Link to this heading")
==================================================================
* [Index](genindex/)
* [Search Page](search/)
On this page
### This Page
* [Show Source](_sources/index.rst.txt)
---
# Welcome to cuxfilter’s documentation — cuxfilter 24.12.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cuxfilter
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
legacy (24.12)
[nightly (25.04)](/api/cuxfilter/nightly)
[stable (25.02)](/api/cuxfilter/stable)
[legacy (24.12)](/api/cuxfilter/legacy)
* [GitHub](https://github.com/rapidsai/cuxfilter "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
Welcome to cuxfilter’s documentation[#](#welcome-to-cuxfilter-s-documentation "Link to this heading")
======================================================================================================
cuxfilter enables GPU accelerated cross-filtering dashboards from notebooks, in just a few lines of Python code. Well integrated with the HoloViz ecosystem, it also incorporates other outstanding visualization libraries. RAPIDS cuxfilter is ideal for multi-chart exploratory data analysis and dashboard prototyping within the RAPIDS ecosystem.
Contents:
* [User Guide](user_guide/)
* [Installation](user_guide/installation/)
* [10 minutes to cuxfilter](user_guide/10_minutes_to_cuxfilter/)
* [Charts](user_guide/charts/)
* [Layouts](user_guide/layouts/Layouts/)
* [Dashboard Themes](user_guide/themes/Themes/)
* [Example Dashboards](user_guide/examples/)
* [cuxfilter with multi-GPU using dask\_cudf](user_guide/Dask-cudf-support/)
* [Deploying a multi-user Dashboard](user_guide/deployment/)
* [API Reference](api_reference/dataframe/)
* [DataFrame](api_reference/dataframe/#dataframe)
* [DashBoard](api_reference/dataframe/#dashboard)
Indices and tables[#](#indices-and-tables "Link to this heading")
==================================================================
* [Index](genindex/)
* [Search Page](search/)
On this page
[Show Source](_sources/index.rst.txt)
---
# Welcome to cuSpatial’s documentation! — cuspatial 25.04.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cuspatial
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
nightly (25.04)
[nightly (25.04)](/api/cuspatial/nightly)
[stable (25.02)](/api/cuspatial/stable)
[legacy (24.12)](/api/cuspatial/legacy)
* [GitHub](https://github.com/rapidsai/cuspatial "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
Welcome to cuSpatial’s documentation
=======================================================================================================
cuSpatial is a general, vector-based, GPU accelerated GIS library that provides functionalities to spatial computation, indexing, joins and trajectory computations. Example functions include:
* Spatial indexing and joins supported by GPU accelerated point-in-polygon
* Trajectory identification and reconstruction
* Haversine distance and grid projection
cuSpatial integrate neatly with [GeoPandas](https://geopandas.org/en/stable/)
and [cuDF](https://docs.rapids.ai/api/cuspatial/stable/)
. This enables you to accelerate performance critical sections in your `GeoPandas` workflow using and `cuSpatial` and `cuDF`.
Contents
* [User Guide](user_guide/)
* [cuSpatial Python User’s Guide](user_guide/cuspatial_api_examples/)
* [API Reference](api_docs/)
* [Spatial](api_docs/spatial/)
* [Trajectory](api_docs/trajectory/)
* [GeoPandas Compatibility](api_docs/geopandas_compatibility/)
* [IO](api_docs/io/)
* [Developer Guide](developer_guide/)
* [Creating a Development Environment](developer_guide/development_environment/)
* [Build and Install cuSpatial From Source](developer_guide/build/)
* [How to Contribute to cuSpatial](developer_guide/contributing_guide/)
* [cuSpatial Library Design](developer_guide/library_design/)
* [Benchmarking cuSpatial](developer_guide/benchmarking/)
Indices and tables[#](#indices-and-tables "Link to this heading")
==================================================================
* [Index](genindex/)
* [Search Page](search/)
On this page
### This Page
* [Show Source](_sources/index.md.txt)
---
# Welcome to cuSpatial’s documentation! — cuspatial 24.12.00 documentation
[Skip to main content](#main-content)
Back to top
Ctrl+K
[Home](/api)
cuspatial
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
legacy (24.12)
[nightly (25.04)](/api/cuspatial/nightly)
[stable (25.02)](/api/cuspatial/stable)
[legacy (24.12)](/api/cuspatial/legacy)
* [GitHub](https://github.com/rapidsai/cuspatial "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
Welcome to cuSpatial’s documentation
============================================================================================================
cuSpatial is a general, vector-based, GPU accelerated GIS library that provides functionalities to spatial computation, indexing, joins and trajectory computations. Example functions include:
* Spatial indexing and joins supported by GPU accelerated point-in-polygon
* Trajectory identification and reconstruction
* Haversine distance and grid projection
cuSpatial integrate neatly with [GeoPandas](https://geopandas.org/en/stable/)
and [cuDF](https://docs.rapids.ai/api/cuspatial/stable/)
. This enables you to accelerate performance critical sections in your `GeoPandas` workflow using and `cuSpatial` and `cuDF`.
Contents
* [User Guide](user_guide/)
* [cuSpatial Python User’s Guide](user_guide/cuspatial_api_examples/)
* [API Reference](api_docs/)
* [Spatial](api_docs/spatial/)
* [Trajectory](api_docs/trajectory/)
* [GeoPandas Compatibility](api_docs/geopandas_compatibility/)
* [IO](api_docs/io/)
* [Developer Guide](developer_guide/)
* [Creating a Development Environment](developer_guide/development_environment/)
* [Build and Install cuSpatial From Source](developer_guide/build/)
* [How to Contribute to cuSpatial](developer_guide/contributing_guide/)
* [cuSpatial Library Design](developer_guide/library_design/)
* [Benchmarking cuSpatial](developer_guide/benchmarking/)
Indices and tables[#](#indices-and-tables "Permalink to this heading")
=======================================================================
* [Index](genindex/)
* [Search Page](search/)
On this page
[Show Source](_sources/index.md.txt)
---
# Basics — cugraph-docs 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cugraph
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cugraph/nightly)
[stable (25.02)](/api/cugraph/stable)
[legacy (24.12)](/api/cugraph/legacy)
* [GitHub](https://github.com/rapidsai/cugraph "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
Basics[#](#basics "Link to this heading")
==========================================
* [WholeGraph Introduction](wholegraph_intro/)
* [WholeMemory](wholegraph_intro/#wholememory)
* [Graph Structure](wholegraph_intro/#graph-structure)
* [WholeMemory](wholememory_intro/)
* [WholeMemory Basics](wholememory_intro/#wholememory-basics)
* [WholeMemory Communicator](wholememory_intro/#wholememory-communicator)
* [WholeMemory Granularity](wholememory_intro/#wholememory-granularity)
* [WholeMemory Mapping](wholememory_intro/#wholememory-mapping)
* [Operations on WholeMemory](wholememory_intro/#operations-on-wholememory)
* [WholeMemory Tensor](wholememory_intro/#wholememory-tensor)
* [WholeMemory Embedding](wholememory_intro/#wholememory-embedding)
* [WholeMemory Implementation Details](wholememory_implementation_details/)
* [WholeMemory Layout](wholememory_implementation_details/#wholememory-layout)
* [WholeMemory Allocation](wholememory_implementation_details/#wholememory-allocation)
### This Page
* [Show Source](../../_sources/wholegraph/basics/index.rst.txt)
---
# Contributing to cuGraph — cugraph-docs 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cugraph
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cugraph/nightly)
[stable (25.02)](/api/cugraph/stable)
[legacy (24.12)](/api/cugraph/legacy)
* [GitHub](https://github.com/rapidsai/cugraph "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
Contributing to cuGraph[#](#contributing-to-cugraph "Link to this heading")
============================================================================
cuGraph is an open-source project where we encourage community involvement.
There are multiple ways to be involved and contribute to the cuGraph community, the top paths are listed below:
* [File an Issue](https://github.com/rapidsai/docs/issues/new)
* [Implement a New Feature](https://docs.rapids.ai/contributing/code/#your-first-issue)
* Work on an Existing Issue
If you are ready to contribute, jump right to the [Contribute Code](https://docs.rapids.ai/contributing/issues/)
section.
**Style Formatting Tools:**
* `clang-format` version 16.0+
* `flake8` version 6.0.0+
* `black` version 21+
New Issue[#](#new-issue "Link to this heading")
------------------------------------------------
1. File an Issue for the RAPIDS cuGraph team to work To file an issue, go to the RAPIDS cuGraph [issue](https://github.com/rapidsai/cugraph/issues/new/choose)
page an select the appropriate issue type. Once an issue is filed the RAPIDS cuGraph team will evaluate and triage the issue. If you believe the issue needs priority attention, please include that in the issue to notify the team.
Find a Bug[#](#find-a-bug "Link to this heading")
--------------------------------------------------
_**Bug Report**_ If you notice something not working please file an issue
* Select **Bug** Report
* Describing what you encountered and the severity of the issue: Does code crash or just not return the correct results
* Include a sequence of step to reproduce the error
_**Propose a new Feature or Enhancement**_ If there is a feature or enhancement to an existing feature, please file an issue
* Select either **Enhancement Request** or **Feature Report**
* describing what you want to see added or changed. For new features, if there is a white paper on the analytic, please include a reference to it
_**Ask a Question**_ There are several ways to ask questions, including [Stack Overflow](https://stackoverflow.com/)
, the quickest is by submiting a GitHub question issue.
* Select Question
* describing your question
2) Propose a New Feature and Implement It [#](#propose-a-new-feature-and-implement-it-a-name-implement-a "Link to this heading")
---------------------------------------------------------------------------------------------------------------------------------
We love when people want to get involved, and if you have a suggestion for a new feature or enhancement and want to be the one doing the development work, we fully encourage that.
* Submit a New Feature Issue (see above) and state that you are working on it.
* The team will give feedback on the issue and happy to make suggestions
* Once we agree that the plan looks good, go ahead and implement it
* Follow the [code contributions](#so-you-want-to-contribute-code)
guide below.
3) You want to implement a feature or bug-fix for an outstanding issue [#](#you-want-to-implement-a-feature-or-bug-fix-for-an-outstanding-issue-a-name-bugfix-a "Link to this heading")
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
* Find an open Issue, and post that you would like to work that issues
* Once we agree that the plan looks good, go ahead and implement it
* Follow the [code contributions](#so-you-want-to-contribute-code)
guide below.
If you need more context on a particular issue, please ask.
* * *
So you want to contribute code[#](#so-you-want-to-contribute-code "Link to this heading")
------------------------------------------------------------------------------------------
**TL;DR General Development Process**
1. Read the documentation on [building from source](https://docs.rapids.ai/api/cugraph/nightly/installation/source_build/)
to learn how to setup, and validate, the development environment
2. Read the RAPIDS [Code of Conduct](https://docs.rapids.ai/resources/conduct/)
3. Find or submit an issue to work on (include a comment that you are working issue)
4. Fork the cuGraph repo and Code (make sure to add unit tests)!
5. All RAPIDS projects are released under the Apache-2.0 license, so also make sure all source files that support comments include a copyright and the Apache-2.0 license text.
6. When done, and code passes local CI, create your pull request (PR)
1. Ensure the code matches the [style guide](https://docs.rapids.ai/resources/style/)
7. Verify that cuGraph CI passes all [status checks](https://help.github.com/articles/about-status-checks/)
. Fix if needed
8. Wait for other developers to review your code and update code as needed
9. PR will require the proper [tags](https://docs.rapids.ai/resources/label-checker/)
be added by someone with repository permission.
10. Once reviewed and approved, a RAPIDS developer will merge your pull request
Remember, if you are unsure about anything, don’t hesitate to comment on issues and ask for clarifications!
**The _FIXME_** comment
Use the _FIXME_ comment to capture technical debt. It should not be used to flag bugs since those need to be cleaned up before code is submitted. We are implementing a script to count and track the number of FIXME in the code. Usage of TODO or any other tag will not be accepted.
Fork a private copy of cuGraph [#](#fork-a-private-copy-of-cugraph-a-name-fork-a "Link to this heading")
---------------------------------------------------------------------------------------------------------
The RAPIDS cuGraph repo cannot directly be modified. Contributions must come in the form of a _Pull Request_ from a forked version of cugraph. GitHub as a nice write up ion the process: https://help.github.com/en/github/getting-started-with-github/fork-a-repo
1. Fork the cugraph repo to your GitHub account
2. clone your version `git clone https://github.com//cugraph.git`
Read the section on [building cuGraph from source](https://docs.rapids.ai/api/cugraph/nightly/installation/source_build/)
to validate that the environment is correct.
**Pro Tip** add an upstream remote repository so that you can keep your forked repo in sync `git remote add upstream https://github.com/rapidsai/cugraph.git`
1. Checkout the latest branch cuGraph only allows contribution to the current branch and not main or a future branch. Please check the [cuGraph](https://github.com/rapidsai/cugraph)
page for the name of the current branch.
`git checkout branch-x.x`
1. Code …..
2. Once your code works and passes tests
1. Run pre-commit to verify and correct come style convension `pre-commit run --all-files`
2. commit your code `git push`
3. From the GitHub web page, open a Pull Request
1. follow the Pull Request [tagging policy](./PRTAGS)
### Development Environment[#](#development-environment "Link to this heading")
There is no recommended or preferred development environment. There are a few _must have_ conditions on GPU hardware and library versions. But for the most part, users can work in the environment that they are familiar and comfortable with.
**Hardware**
* You need to have accesses to a NVIDIA GPU, currently Volta or later. Look here for [latest RAPIDS system requirements](https://docs.rapids.ai/install/)
.
**IDEs**
There is no recommended IDE, here is just a list of what cuGraph developers currently use (not in any priority order)
* NSIGHT
* Eclipse (with the C++ and Python modules)
* VSCode
* VIM / VI (old school programming)
* With plug-ins like [FZF](https://github.com/junegunn/fzf)
, [Rg](https://github.com/BurntSushi/ripgrep)
Using VSCode, you can develop remotely from the hardware if you so wish. Alex Fender has a setting up remote development: https://github.com/afender/cugraph-vscode
**Debug**
* cuda-memcheck
* cuda-gdb
A debug launch can also be enabled in VSCode with something like: https://github.com/harrism/cudf-vscode/blob/master/.vscode/launch.json
### Seasoned developers[#](#seasoned-developers "Link to this heading")
Once you have gotten your feet wet and are more comfortable with the code, you can look at the prioritized issues of our next release in our [project boards](https://github.com/rapidsai/cugraph/projects)
.
> **Pro Tip:** Always look at the release board with the lowest number for issues to work on. This is where RAPIDS developers also focus their efforts. cuGraph maintains a project board for the current release plus out two future releases. This allows to better long term planning
Look at the unassigned issues, and find an issue you are comfortable with contributing to. Start with _Step 3_ from above, commenting on the issue to let others know you are working on it. If you have any questions related to the implementation of the issue, ask them in the issue instead of the PR.
### Style Guide[#](#style-guide "Link to this heading")
All Python code most pass flake8 style checking All C++ code must pass clang style checking All code must adhere to the [RAPIDS Style Guide](https://docs.rapids.ai/resources/style/)
### Tests[#](#tests "Link to this heading")
All code must have associate test cases. Code without test will not be accepted
On this page
### This Page
* [Show Source](../../_sources/dev_resources/contributing.md.txt)
---
# cuProj: GPU-Accelerated Cartographic Projections and Coordinate Transformations — cuProj 25.04.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cuproj
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
nightly (25.04)
[nightly (25.04)](/api/cuproj/nightly)
[stable (25.02)](/api/cuproj/stable)
[legacy (24.12)](/api/cuproj/legacy)
* [GitHub](https://github.com/rapidsai/cuspatial "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
cuProj: GPU-Accelerated Cartographic Projections and Coordinate Transformations[#](#cuproj-gpu-accelerated-cartographic-projections-and-coordinate-transformations "Link to this heading")
===========================================================================================================================================================================================
cuProj is a generic coordinate transformation library that transforms geospatial coordinates from one coordinate reference system (CRS) to another. This includes cartographic projections as well as geodetic transformations. cuProj is implemented in CUDA C++ to run on GPUs to provide the highest performance.
cuProj provides a Python API that closely matches the [PyProj](https://pyproj4.github.io/pyproj/stable/)
API.
Currently cuProj only supports a subset of the Proj transformations. The following transformations are supported:
* WGS84 to/from UTM
Contents
* [User Guide](user_guide/)
* [cuProj Python User’s Guide](user_guide/cuproj_api_examples/)
* [API Reference](api_docs/)
* [Transformer](api_docs/transformer/)
* [Developer Guide](developer_guide/)
Indices and tables[#](#indices-and-tables "Link to this heading")
==================================================================
* [Index](genindex/)
* [Search Page](search/)
On this page
### This Page
* [Show Source](_sources/index.md.txt)
---
# cuGraph Blogs and Presentations — cugraph-docs 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cugraph
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cugraph/nightly)
[stable (25.02)](/api/cugraph/stable)
[legacy (24.12)](/api/cugraph/legacy)
* [GitHub](https://github.com/rapidsai/cugraph "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
cuGraph Blogs and Presentations[#](#cugraph-blogs-and-presentations "Link to this heading")
============================================================================================
The RAPIDS team blogs at [https://medium.com/rapids-ai](https://medium.com/rapids-ai)
, and many of these blog posts provide deeper dives into features from cuGraph. Here, we’ve selected just a few that are of particular interest to cuGraph users:
Blogs & Conferences[#](#blogs-conferences "Link to this heading")
------------------------------------------------------------------
### 2025[#](#id1 "Link to this heading")
Coming Soon
### 2024[#](#id2 "Link to this heading")
> * [NVIDIA cuGraph: 500x faster alternate for NetworkX for Graphs](https://medium.com/data-science-in-your-pocket/nvidia-cugraph-500x-faster-alternate-for-networkx-for-graphs-ef7e2ad9fbda)
>
> * [Revolutionizing Graph Analytics: Next-Gen Architecture with NVIDIA cuGraph Acceleration](https://developer.nvidia.com/blog/revolutionizing-graph-analytics-next-gen-architecture-with-nvidia-cugraph-acceleration/)
>
> * [Accelerated, Production-Ready Graph Analytics for NetworkX Users](https://developer.nvidia.com/blog/accelerated-production-ready-graph-analytics-for-networkx-users/)
>
> * [NetworkX Introduces Zero Code Change Acceleration Using NVIDIA cuGraph](https://developer.nvidia.com/blog/networkx-introduces-zero-code-change-acceleration-using-nvidia-cugraph/)
>
> * [NVIDIA cuGraph: Accelerate Graph Analytics with GPUs](https://medium.com/data-science-in-your-pocket/nvidia-cugraph-accelerate-graph-analytics-with-gpus-4d809345040f)
>
> * [Enhanced Data Analytics: Integrating NVIDIA Rapids cuGraph with TigerGraph](https://www.tigergraph.com/blog/tigergraph-copilot-enters-public-alpha-release-copy/)
>
> * [Insights, Techniques, and Evaluation for LLM-Driven Knowledge Graphs](https://developer.nvidia.com/blog/insights-techniques-and-evaluation-for-llm-driven-knowledge-graphs/)
>
> * [Accelerating NetworkX on NVIDIA GPUs for High Performance Graph Analytics](https://developer.nvidia.com/blog/accelerating-networkx-on-nvidia-gpus-for-high-performance-graph-analytics/)
>
> * [Introduction to Graph Neural Networks with NVIDIA cuGraph-DGL](https://developer.nvidia.com/blog/introduction-to-graph-neural-networks-with-nvidia-cugraph-dgl/)
>
> * [Supercharge Graph Analytics at Scale with GPU-CPU Fusion for 100x Performance](https://developer.nvidia.com/blog/supercharge-graph-analytics-at-scale-with-gpu-cpu-fusion-for-100x-performance/)
>
> * [Introduction to Graph Analysis using cuGraph](https://medium.com/rapids-ai/introduction-to-graph-analysis-using-cugraph-a9dc2fbc3c5e)
>
### 2022[#](#id3 "Link to this heading")
> * [GTC: State of cuGraph (video & slides)](https://www.nvidia.com/gtc/session-catalog/?search=cuGraph&tab.scheduledorondemand=1583520458947001NJiE&search=cuGraph#/session/1635793340204001n4p2)
>
> * [GTC: Scaling and Validating Louvain in cuGraph against Massive Graphs (video & slides)](https://www.nvidia.com/gtc/session-catalog/?tab.scheduledorondemand=1583520458947001NJiE&search=cuGraph#/session/1635797342151001A9kR)
>
> * [KDD Tutorial on Accelerated GNN Training with DGL/PyG and cuGraph](https://github.com/rapidsai-community/event-notebooks/tree/main/KDD_2022)
>
### 2021[#](#id4 "Link to this heading")
> * [GTC 21 - State of RAPIDS cuGraph and what’s comming next](https://www.nvidia.com/en-us/on-demand/session/gtcspring21-s32418/)
>
### 2020[#](#id5 "Link to this heading")
> * [Status of RAPIDS cuGraph — Refactoring Code And Rethinking Graphs](https://medium.com/rapids-ai/status-of-rapids-cugraph-refactoring-code-and-rethinking-graphs-efe9956d5528)
>
> * [Tackling Large Graphs with RAPIDS cuGraph and CUDA Unified Memory on GPUs](https://medium.com/rapids-ai/tackling-large-graphs-with-rapids-cugraph-and-unified-virtual-memory-b5b69a065d4)
>
> * [RAPIDS cuGraph adds NetworkX and DiGraph Compatibility](https://t.co/6DEhyarVGa)
>
> * [Large Graph Visualization with RAPIDS cuGraph](https://medium.com/rapids-ai/large-graph-visualization-with-rapids-cugraph-590d07edce33)
>
> * [GTC 20 Fall - cuGraph Goes Big](https://www.nvidia.com/en-us/on-demand/session/gtcfall20-a21128/)
>
### 2019[#](#id6 "Link to this heading")
> * [RAPIDS cuGraph](https://medium.com/rapids-ai/rapids-cugraph-1ab2d9a39ec6)
>
> * [RAPIDS cuGraph — The vision and journey to version 1.0 and beyond](https://towardsdatascience.com/rapids-cugraph-the-vision-and-journey-to-version-1-0-and-beyond-88eff2ce3e76)
>
> * [RAPIDS cuGraph : multi-GPU PageRank](https://medium.com/rapids-ai/rapids-cugraph-multi-gpu-pagerank-363aed1a2503)
>
> * [Similarity in graphs: Jaccard versus the Overlap Coefficient](https://medium.com/rapids-ai/similarity-in-graphs-jaccard-versus-the-overlap-coefficient-610e083b877d)
>
> * [GTC19 Spring - Accelerating Graph Algorithms with RAPIDS](https://www.nvidia.com/en-us/on-demand/session/gtcsiliconvalley2019-s9783/)
>
> * [GTC19 Fall - Multi-Node Multi-GPU Machine Learning and Graph Analytics with RAPIDS](https://www.nvidia.com/en-us/on-demand/session/gtcdc19-dc91231/)
>
### 2018[#](#id7 "Link to this heading")
> * [GTC18 Fall - RAPIDS: Benchmarking Graph Analytics on the DGX-2](https://www.nvidia.com/en-us/on-demand/session/gtcwashingtondc2018-dc8110/)
>
Media[#](#media "Link to this heading")
----------------------------------------
> * NetworkX GPU Acceleration with cuGraph in Python
>
> * NVIDIA RAPIDS cuGraph : GPU acceleration for NetworkX, Graph Analytics
>
> * Accelerating Graph Analysis on GPUs
>
> * [Nvidia Rapids cuGraph: Making graph analysis ubiquitous](https://www.zdnet.com/article/nvidia-rapids-cugraph-making-graph-analysis-ubiquitous/)
>
> * [RAPIDS cuGraph – Accelerating all your Graph needs](https://www.youtube.com/watch?v=kAw7-IGH9N4)
>
Academic Papers[#](#academic-papers "Link to this heading")
------------------------------------------------------------
> * Seunghwa Kang, Chuck Hastings, Joe Eaton, Brad Rees [cuGraph C++ primitives: vertex/edge-centric building blocks for parallel graph computing](https://ieeexplore.ieee.org/abstract/document/10196665)
>
> * Alex Fender, Brad Rees, Joe Eaton (2022) [Massive Graph Analytics](https://books.google.com/books?hl=en&lr=&id=QspxEAAAQBAJ&oi=fnd&pg=PT8&dq=book:%22Massive+Graph+Analytics%22&ots=3HAGJ0njKO&sig=8e4v0azmzA6LTQNUNgPw-uTLkoc#v=onepage&q&f=false)
> Bader, D. (Editor) CRC Press
>
> * S Kang, A. Fender, J. Eaton, B. Rees. [Computing PageRank Scores of Web Crawl Data Using DGX A100 Clusters](https://ieeexplore.ieee.org/abstract/document/9286216)
> . In IEEE HPEC, Sep. 2020
>
> * Hricik, T., Bader, D., & Green, O. (2020, September). [Using RAPIDS AI to accelerate graph data science workflows](https://ieeexplore.ieee.org/abstract/document/9286224)
> . In 2020 IEEE High Performance Extreme Computing Conference (HPEC) (pp. 1-4). IEEE.
>
> * Richardson, B., Rees, B., Drabas, T., Oldridge, E., Bader, D. A., & Allen, R. (2020, August). Accelerating and Expanding End-to-End Data Science Workflows with DL/ML Interoperability Using RAPIDS. In Proceedings of the 26th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining (pp. 3503-3504).
>
> * A Gondhalekar, P Sathre, W Feng [Hybrid CPU-GPU Implementation of Edge-Connected Jaccard Similarity in Graph Datasets](https://sc23.supercomputing.org/proceedings/tech_poster/poster_files/rpost221s3-file3.pdf)
>
Other Blogs[#](#other-blogs "Link to this heading")
----------------------------------------------------
* [4 graph algorithms on steroids for data scientists with cugraph](https://towardsdatascience.com/4-graph-algorithms-on-steroids-for-data-scientists-with-cugraph-43d784de8d0e)
* [Where should I walk](https://towardsdatascience.com/where-should-i-walk-e66b26735de5)
* [Where really are the parking spots?](https://towardsdatascience.com/where-really-are-the-parking-spots-ed6a1129035e)
* [Accelerating Single Cell Genomic Analysis using RAPIDS](https://developer.nvidia.com/blog/accelerating-single-cell-genomic-analysis-using-rapids/)
* [Running Large-Scale Graph Analytics with Memgraph and NVIDIA cuGraph Algorithms](https://developer.nvidia.com/blog/running-large-scale-graph-analytics-with-memgraph-and-nvidia-cugraph-algorithms/)
* [Dev Blog Repost: Similarity in Graphs: Jaccard Versus the Overlap Coefficient](https://developer.nvidia.com/blog/similarity-in-graphs-jaccard-versus-the-overlap-coefficient-2/)
RAPIDS Event Notebooks[#](#rapids-event-notebooks "Link to this heading")
--------------------------------------------------------------------------
* [KDD 2022 Notebook that demonstates using cuDF for ETL/data cleaning and XGBoost for training a fraud predection model.](https://github.com/rapidsai-community/event-notebooks/blob/main/KDD_2022/notebooks/NonGNN-Graph.ipynb)
* [SciPy 22 Notebook comparing cuGraph to NetworkX](https://github.com/rapidsai-community/event-notebooks/blob/8a9b660fada8186615a642b52b5ca78f20205838/SCIPY_2022/cugraph_presentation/SciPy_cuGraph_comparison.ipynb)
* [KDD 2020 Tutorial Notebooks - Accelerating and Expanding End-to-End Data Science Workflows with DL/ML Interoperability Using RAPIDS](https://github.com/rapidsai-community/event-notebooks/tree/8a9b660fada8186615a642b52b5ca78f20205838/KDD_2020/notebooks)
On this page
### This Page
* [Show Source](../../_sources/tutorials/cugraph_blogs.rst.txt)
---
# Installation — cugraph-docs 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cugraph
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cugraph/nightly)
[stable (25.02)](/api/cugraph/stable)
[legacy (24.12)](/api/cugraph/legacy)
* [GitHub](https://github.com/rapidsai/cugraph "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
Installation[#](#installation "Link to this heading")
======================================================
* [Getting the WholeGraph Packages](getting_wholegraph/)
* [Docker](getting_wholegraph/#docker)
* [Conda](getting_wholegraph/#conda)
* [PIP](getting_wholegraph/#pip)
* [Build Container for WholeGraph](container/)
* [Building from Source](source_build/)
* [Prerequisites](source_build/#prerequisites)
* [Building wholegraph](source_build/#building-wholegraph)
* [Building each section independently](source_build/#building-each-section-independently)
* [Run tests](source_build/#run-tests)
* [Creating documentation](source_build/#creating-documentation)
* [Attribution](source_build/#attribution)
### This Page
* [Show Source](../../_sources/wholegraph/installation/index.rst.txt)
---
# API — cugraph-docs 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cugraph
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cugraph/nightly)
[stable (25.02)](/api/cugraph/stable)
[legacy (24.12)](/api/cugraph/legacy)
* [GitHub](https://github.com/rapidsai/cugraph "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
API[#](#api "Link to this heading")
====================================
[https://docs.rapids.ai/api/cugraph/nightly/api\_docs/index.html](https://docs.rapids.ai/api/cugraph/nightly/api_docs/)
### This Page
* [Show Source](../../_sources/dev_resources/API.rst.txt)
---
# Commmunity Resources — cugraph-docs 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cugraph
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cugraph/nightly)
[stable (25.02)](/api/cugraph/stable)
[legacy (24.12)](/api/cugraph/legacy)
* [GitHub](https://github.com/rapidsai/cugraph "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
Commmunity Resources[#](#commmunity-resources "Link to this heading")
======================================================================
* [Rapids Community Repository](https://github.com/rapidsai-community/notebooks-contrib)
* [RAPIDS Containers on Docker Hub](https://catalog.ngc.nvidia.com/containers)
* [RAPIDS PyTorch Container in Docker](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/pyg)
### This Page
* [Show Source](../../_sources/tutorials/community_resources.md.txt)
---
# cuProj: GPU-Accelerated Cartographic Projections and Coordinate Transformations — cuProj 24.12.00 documentation
[Skip to main content](#main-content)
Back to top
Ctrl+K
[Home](/api)
cuproj
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
legacy (24.12)
[nightly (25.04)](/api/cuproj/nightly)
[stable (25.02)](/api/cuproj/stable)
[legacy (24.12)](/api/cuproj/legacy)
* [GitHub](https://github.com/rapidsai/cuspatial "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
cuProj: GPU-Accelerated Cartographic Projections and Coordinate Transformations[#](#cuproj-gpu-accelerated-cartographic-projections-and-coordinate-transformations "Permalink to this heading")
================================================================================================================================================================================================
cuProj is a generic coordinate transformation library that transforms geospatial coordinates from one coordinate reference system (CRS) to another. This includes cartographic projections as well as geodetic transformations. cuProj is implemented in CUDA C++ to run on GPUs to provide the highest performance.
cuProj provides a Python API that closely matches the [PyProj](https://pyproj4.github.io/pyproj/stable/)
API.
Currently cuProj only supports a subset of the Proj transformations. The following transformations are supported:
* WGS84 to/from UTM
Contents
* [User Guide](user_guide/)
* [cuProj Python User’s Guide](user_guide/cuproj_api_examples/)
* [API Reference](api_docs/)
* [Transformer](api_docs/transformer/)
* [Developer Guide](developer_guide/)
Indices and tables[#](#indices-and-tables "Permalink to this heading")
=======================================================================
* [Index](genindex/)
* [Search Page](search/)
On this page
[Show Source](_sources/index.md.txt)
---
# License — cugraph-docs 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cugraph
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cugraph/nightly)
[stable (25.02)](/api/cugraph/stable)
[legacy (24.12)](/api/cugraph/legacy)
* [GitHub](https://github.com/rapidsai/cugraph "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
License[#](#license "Link to this heading")
============================================
Most of the Graph code is open-sourced and developed under the Apache 2.0 licnese.
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
“License” shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.
“Licensor” shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.
“Legal Entity” shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, “control” means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.
“You” (or “Your”) shall mean an individual or Legal Entity exercising permissions granted by this License.
“Source” form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.
“Object” form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.
“Work” shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).
“Derivative Works” shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.
“Contribution” shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, “submitted” means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as “Not a Contribution.”
“Contributor” shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:
(a) You must give any other recipients of the Work or Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and
(d) If the Work includes a “NOTICE” text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.
You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an “AS IS” BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "{}"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright 2018 NVIDIA CORPORATION
Licensed under the Apache License, Version 2.0 (the “License”); you may not use this file except in compliance with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE\-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an “AS IS” BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
### This Page
* [Show Source](../../_sources/references/licenses.md.txt)
---
# CuGraph Service — cugraph-docs 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cugraph
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cugraph/nightly)
[stable (25.02)](/api/cugraph/stable)
[legacy (24.12)](/api/cugraph/legacy)
* [GitHub](https://github.com/rapidsai/cugraph "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
CuGraph Service[#](#cugraph-service "Link to this heading")
============================================================
Cugraph Service for remote access to a server-based cuGraph([rapidsai/cugraph](https://github.com/rapidsai/cugraph/blob/branch-23.04/python/cugraph-service/README.md)
)
### This Page
* [Show Source](../../_sources/graph_support/cugraph_service.rst.txt)
---
# cuGraph Notebooks — cugraph-docs 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cugraph
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cugraph/nightly)
[stable (25.02)](/api/cugraph/stable)
[legacy (24.12)](/api/cugraph/legacy)
* [GitHub](https://github.com/rapidsai/cugraph "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
cuGraph Notebooks[#](#cugraph-notebooks "Link to this heading")
================================================================
This repository contains a collection of Jupyter Notebooks that outline how to run various cuGraph analytics. The notebooks do not address a complete data science problem. The notebooks are simply examples of how to run the graph analytics. Manipulation of the data before or after the graph analytic is not covered here. Extended, more problem focused, notebooks are being created and available https://github.com/rapidsai/notebooks-extended
Summary[#](#summary "Link to this heading")
--------------------------------------------
| Folder | Notebook | Description |
| --- | --- | --- |
| Centrality | | |
| | [Centrality](https://github.com/rapidsai/cugraph/blob/main/notebooks/algorithms/centrality/Centrality.ipynb) | Compute and compare multiple (currently 5) centrality scores |
| | [Katz](https://github.com/rapidsai/cugraph/blob/main/notebooks/algorithms/centrality/Katz.ipynb) | Compute the Katz centrality for every vertex |
| | [Betweenness](https://github.com/rapidsai/cugraph/blob/main/notebooks/algorithms/centrality/Betweenness.ipynb) | Compute both Edge and Vertex Betweenness centrality |
| | [Degree](https://github.com/rapidsai/cugraph/blob/main/notebooks/algorithms/centrality/Degree.ipynb) | Compute Degree Centraility for each vertex |
| | [Eigenvector](https://github.com/rapidsai/cugraph/blob/main/notebooks/algorithms/centrality/Eigenvector.ipynb) | Compute Eigenvector for every vertex |
| Community | | |
| | [Louvain and Leiden](https://github.com/rapidsai/cugraph/blob/main/notebooks/algorithms/community/Louvain.ipynb) | Identify clusters in a graph using both the Louvain and Leiden algorithms |
| | [ECG](https://github.com/rapidsai/cugraph/blob/main/notebooks/algorithms/community/ECG.ipynb) | Identify clusters in a graph using the Ensemble Clustering for Graph |
| | [K-Truss](https://github.com/rapidsai/cugraph/blob/main/notebooks/algorithms/community/ktruss.ipynb) | Extracts the K-Truss cluster |
| | [Spectral-Clustering](https://github.com/rapidsai/cugraph/blob/main/notebooks/algorithms/community/Spectral-Clustering.ipynb) | Identify clusters in a graph using Spectral Clustering with both
\- Balanced Cut
\- Modularity Modularity |
| | [Subgraph Extraction](https://github.com/rapidsai/cugraph/blob/main/notebooks/algorithms/community/Subgraph-Extraction.ipynb) | Compute a subgraph of the existing graph including only the specified vertices |
| | [Triangle Counting](https://github.com/rapidsai/cugraph/blob/main/notebooks/algorithms/community/Triangle-Counting.ipynb) | Count the number of Triangle in a graph |
| Components | | |
| | [Connected Components](https://github.com/rapidsai/cugraph/blob/main/notebooks/algorithms/components/ConnectedComponents.ipynb) | Find weakly and strongly connected components in a graph |
| Core | | |
| | [K-Core](https://github.com/rapidsai/cugraph/blob/main/notebooks/algorithms/cores/kcore.ipynb) | Extracts the K-core cluster |
| | [Core Number](https://github.com/rapidsai/cugraph/blob/main/notebooks/algorithms/cores/core-number.ipynb) | Computer the Core number for each vertex in a graph |
| Layout | | |
| | [Force-Atlas2](https://github.com/rapidsai/cugraph/blob/main/notebooks/algorithms/layout/Force-Atlas2.ipynb) | A large graph visualization achieved with cuGraph. |
| Link Analysis | | |
| | [Pagerank](https://github.com/rapidsai/cugraph/blob/main/notebooks/algorithms/link_analysis/Pagerank.ipynb) | Compute the PageRank of every vertex in a graph |
| | [HITS](https://github.com/rapidsai/cugraph/blob/main/notebooks/algorithms/link_analysis/HITS.ipynb) | Compute the HITS' Hub and Authority scores for every vertex in a graph |
| Link Prediction | | |
| | [Jaccard Similarity](https://github.com/rapidsai/cugraph/blob/main/notebooks/algorithms/link_prediction/Jaccard-Similarity.ipynb) | Compute vertex similarity score using both:
\- Jaccard Similarity
\- Weighted Jaccard |
| | [Overlap Similarity](https://github.com/rapidsai/cugraph/blob/main/notebooks/algorithms/link_prediction/Overlap-Similarity.ipynb) | Compute vertex similarity score using the Overlap Coefficient |
| Sampling | | |
| | [Random Walk](https://github.com/rapidsai/cugraph/blob/main/notebooks/algorithms/sampling/RandomWalk.ipynb) | Compute Random Walk for a various number of seeds and path lengths |
| Traversal | | |
| | [BFS](https://github.com/rapidsai/cugraph/blob/main/notebooks/algorithms/traversal/BFS.ipynb) | Compute the Breadth First Search path from a starting vertex to every other vertex in a graph |
| | [SSSP](https://github.com/rapidsai/cugraph/blob/main/notebooks/algorithms/traversal/SSSP.ipynb) | Single Source Shortest Path - compute the shortest path from a starting vertex to every other vertex |
| Structure | | |
| | [Renumbering](algorithms/structure/Renumber.ipynb)
[Renumbering 2](https://github.com/rapidsai/cugraph/blob/main/notebooks/algorithms/structure/Renumber-2.ipynb) | Renumber the vertex IDs in a graph (two sample notebooks) |
| | [Symmetrize](https://github.com/rapidsai/cugraph/blob/main/notebooks/algorithms/structure/Symmetrize.ipynb) | Symmetrize the edges in a graph |
RAPIDS notebooks[#](#rapids-notebooks "Link to this heading")
--------------------------------------------------------------
Visit the main RAPIDS [notebooks](https://github.com/rapidsai/cugraph/blob/main/notebooks/)
repo for a listing of all notebooks across all RAPIDS libraries.
Requirements[#](#requirements "Link to this heading")
------------------------------------------------------
Running the example in these notebooks requires:
* The latest version of RAPIDS with cuGraph.
* Download via Docker, Conda (See [**Getting Started**](https://rapids.ai/start.html)
)
* cuGraph is dependent on the latest version of cuDF. Please install all components of RAPIDS
* Python 3.10+
* A system with an NVIDIA GPU: Volta architecture or newer
* CUDA 11.4+
Copyright[#](#copyright "Link to this heading")
------------------------------------------------
Copyright (c) 2019-2025, NVIDIA CORPORATION. All rights reserved.
Licensed under the Apache License, Version 2.0 (the “License”); you may not use this file except in compliance with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an “AS IS” BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
* * *
On this page
### This Page
* [Show Source](../../_sources/tutorials/cugraph_notebooks.md.txt)
---
# Welcome to cuCIM’s documentation! — cuCIM 25.04.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cucim
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
nightly (25.04)
[nightly (25.04)](/api/cucim/nightly)
[stable (25.02)](/api/cucim/stable)
[legacy (24.12)](/api/cucim/legacy)
Welcome to cuCIM’s documentation
===============================================================================================
cuCIM (Compute Unified Device Architecture Clara IMage) is an open-source, accelerated computer vision and image processing software library for multidimensional images used in biomedical, geospatial, material and life science, and remote sensing use cases.
cuCIM provides GPU-accelearted I/O, computer vision and image processing primitives for N-Dimensional images including:
* color conversion
* exposure
* feature extraction
* filters
* measure
* metrics
* morphology
* registration
* restoration
* segmentation
* transforms
cuCIM supports the following formats:
* Aperio ScanScope Virtual Slide (SVS)
* Philips TIFF
* Generic Tiled, Multi-resolution RGB TIFF files with the following compression schemes:
* No Compression
* JPEG
* JPEG2000
* Lempel-Ziv-Welch (LZW)
* Deflate
Our API mirrors [scikit-image](https://scikit-image.org/)
for image manipulation and [OpenSlide](https://openslide.org/)
for image loading.
cuCIM is interoperable with the following workflows:
* Albumentations
* cuPY
* Data Loading Library (DALI)
* JFX
* MONAI
* Numba
* NumPy
* PyTorch
* Tensorflow
* Triton
cuCIM is fully open sourced under the Apache-2.0 license, and the Clara and RAPIDS teams welcomes new and seasoned contributors, users and hobbyists! You may download cuCIM via Anaconda [Conda](https://anaconda.org/rapidsai-nightly/cucim)
or [PyPI](https://pypi.org/project/cucim/)
Thank you for your wonderful support! Below, we provide some resources to help get you started.
**Blogs**
* [Accelerating Scikit-Image API with cuCIM: n-Dimensional Image Processing and IO on GPUs](https://developer.nvidia.com/blog/cucim-rapid-n-dimensional-image-processing-and-i-o-on-gpus/)
* [Accelerating Digital Pathology Pipelines with NVIDIA Clara™ Deploy](https://developer.nvidia.com/blog/accelerating-digital-pathology-pipelines-with-nvidia-clara-deploy-2/)
**Webinars**
* [cuCIM: a GPU Image IO and Processing Library](https://www.youtube.com/watch?v=G46kOOM9xbQ)
Contents[#](#contents "Link to this heading")
==============================================
* [cuCIM API Reference](api/)
* [Clara Submodules](api/#module-cucim.clara)
* [`CuImage`](api/#cucim.clara.CuImage)
* [`CuImage.associated_image()`](api/#cucim.clara.CuImage.associated_image)
* [`CuImage.associated_images`](api/#cucim.clara.CuImage.associated_images)
* [`CuImage.cache()`](api/#cucim.clara.CuImage.cache)
* [`CuImage.channel_names`](api/#cucim.clara.CuImage.channel_names)
* [`CuImage.close()`](api/#cucim.clara.CuImage.close)
* [`CuImage.coord_sys`](api/#cucim.clara.CuImage.coord_sys)
* [`CuImage.device`](api/#cucim.clara.CuImage.device)
* [`CuImage.dims`](api/#cucim.clara.CuImage.dims)
* [`CuImage.direction`](api/#cucim.clara.CuImage.direction)
* [`CuImage.dtype`](api/#cucim.clara.CuImage.dtype)
* [`CuImage.is_loaded`](api/#cucim.clara.CuImage.is_loaded)
* [`CuImage.is_trace_enabled`](api/#cucim.clara.CuImage.is_trace_enabled)
* [`CuImage.metadata`](api/#cucim.clara.CuImage.metadata)
* [`CuImage.ndim`](api/#cucim.clara.CuImage.ndim)
* [`CuImage.origin`](api/#cucim.clara.CuImage.origin)
* [`CuImage.path`](api/#cucim.clara.CuImage.path)
* [`CuImage.profiler()`](api/#cucim.clara.CuImage.profiler)
* [`CuImage.raw_metadata`](api/#cucim.clara.CuImage.raw_metadata)
* [`CuImage.read_region()`](api/#cucim.clara.CuImage.read_region)
* [`CuImage.resolutions`](api/#cucim.clara.CuImage.resolutions)
* [`CuImage.save()`](api/#cucim.clara.CuImage.save)
* [`CuImage.shape`](api/#cucim.clara.CuImage.shape)
* [`CuImage.size()`](api/#cucim.clara.CuImage.size)
* [`CuImage.spacing()`](api/#cucim.clara.CuImage.spacing)
* [`CuImage.spacing_units()`](api/#cucim.clara.CuImage.spacing_units)
* [`CuImage.typestr`](api/#cucim.clara.CuImage.typestr)
* [`DLDataType`](api/#cucim.clara.DLDataType)
* [`DLDataType.bits`](api/#cucim.clara.DLDataType.bits)
* [`DLDataType.code`](api/#cucim.clara.DLDataType.code)
* [`DLDataType.lanes`](api/#cucim.clara.DLDataType.lanes)
* [`DLDataTypeCode`](api/#cucim.clara.DLDataTypeCode)
* [`DLDataTypeCode.DLBfloat`](api/#cucim.clara.DLDataTypeCode.DLBfloat)
* [`DLDataTypeCode.DLFloat`](api/#cucim.clara.DLDataTypeCode.DLFloat)
* [`DLDataTypeCode.DLInt`](api/#cucim.clara.DLDataTypeCode.DLInt)
* [`DLDataTypeCode.DLUInt`](api/#cucim.clara.DLDataTypeCode.DLUInt)
* [`DLDataTypeCode.name`](api/#cucim.clara.DLDataTypeCode.name)
* [`DLDataTypeCode.value`](api/#cucim.clara.DLDataTypeCode.value)
* [cache](api/#module-cucim.clara.cache)
* [`CacheType`](api/#cucim.clara.cache.CacheType)
* [`ImageCache`](api/#cucim.clara.cache.ImageCache)
* [`preferred_memory_capacity()`](api/#cucim.clara.cache.preferred_memory_capacity)
* [filesystem](api/#module-cucim.clara.filesystem)
* [`CuFileDriver`](api/#cucim.clara.filesystem.CuFileDriver)
* [`close()`](api/#cucim.clara.filesystem.close)
* [`discard_page_cache()`](api/#cucim.clara.filesystem.discard_page_cache)
* [`open()`](api/#cucim.clara.filesystem.open)
* [`pread()`](api/#cucim.clara.filesystem.pread)
* [`pwrite()`](api/#cucim.clara.filesystem.pwrite)
* [io](api/#module-cucim.clara.io)
* [`Device`](api/#cucim.clara.io.Device)
* [`DeviceType`](api/#cucim.clara.io.DeviceType)
* [core Submodules](api/#core-submodules)
* [color](api/#module-cucim.core.operations.color)
* [`color_jitter()`](api/#cucim.core.operations.color.color_jitter)
* [`image_to_absorbance()`](api/#cucim.core.operations.color.image_to_absorbance)
* [`normalize_colors_pca()`](api/#cucim.core.operations.color.normalize_colors_pca)
* [`stain_extraction_pca()`](api/#cucim.core.operations.color.stain_extraction_pca)
* [expose](api/#module-cucim.core.operations.expose)
* [intensity](api/#module-cucim.core.operations.intensity)
* [`normalize_data()`](api/#cucim.core.operations.intensity.normalize_data)
* [`rand_zoom()`](api/#cucim.core.operations.intensity.rand_zoom)
* [`scale_intensity_range()`](api/#cucim.core.operations.intensity.scale_intensity_range)
* [`zoom()`](api/#cucim.core.operations.intensity.zoom)
* [morphology](api/#module-cucim.core.operations.morphology)
* [`distance_transform_edt()`](api/#cucim.core.operations.morphology.distance_transform_edt)
* [spatial](api/#module-cucim.core.operations.spatial)
* [`image_flip()`](api/#cucim.core.operations.spatial.image_flip)
* [`image_rotate_90()`](api/#cucim.core.operations.spatial.image_rotate_90)
* [`rand_image_flip()`](api/#cucim.core.operations.spatial.rand_image_flip)
* [`rand_image_rotate_90()`](api/#cucim.core.operations.spatial.rand_image_rotate_90)
* [skimage Submodules](api/#skimage-submodules)
* [color](api/#id13)
* [`combine_stains()`](api/#cucim.skimage.color.combine_stains)
* [`convert_colorspace()`](api/#cucim.skimage.color.convert_colorspace)
* [`deltaE_cie76()`](api/#cucim.skimage.color.deltaE_cie76)
* [`deltaE_ciede2000()`](api/#cucim.skimage.color.deltaE_ciede2000)
* [`deltaE_ciede94()`](api/#cucim.skimage.color.deltaE_ciede94)
* [`deltaE_cmc()`](api/#cucim.skimage.color.deltaE_cmc)
* [`gray2rgb()`](api/#cucim.skimage.color.gray2rgb)
* [`gray2rgba()`](api/#cucim.skimage.color.gray2rgba)
* [`hed2rgb()`](api/#cucim.skimage.color.hed2rgb)
* [`hsv2rgb()`](api/#cucim.skimage.color.hsv2rgb)
* [`lab2lch()`](api/#cucim.skimage.color.lab2lch)
* [`lab2rgb()`](api/#cucim.skimage.color.lab2rgb)
* [`lab2xyz()`](api/#cucim.skimage.color.lab2xyz)
* [`label2rgb()`](api/#cucim.skimage.color.label2rgb)
* [`lch2lab()`](api/#cucim.skimage.color.lch2lab)
* [`luv2rgb()`](api/#cucim.skimage.color.luv2rgb)
* [`luv2xyz()`](api/#cucim.skimage.color.luv2xyz)
* [`rgb2gray()`](api/#cucim.skimage.color.rgb2gray)
* [`rgb2hed()`](api/#cucim.skimage.color.rgb2hed)
* [`rgb2hsv()`](api/#cucim.skimage.color.rgb2hsv)
* [`rgb2lab()`](api/#cucim.skimage.color.rgb2lab)
* [`rgb2luv()`](api/#cucim.skimage.color.rgb2luv)
* [`rgb2rgbcie()`](api/#cucim.skimage.color.rgb2rgbcie)
* [`rgb2xyz()`](api/#cucim.skimage.color.rgb2xyz)
* [`rgb2ycbcr()`](api/#cucim.skimage.color.rgb2ycbcr)
* [`rgb2ydbdr()`](api/#cucim.skimage.color.rgb2ydbdr)
* [`rgb2yiq()`](api/#cucim.skimage.color.rgb2yiq)
* [`rgb2ypbpr()`](api/#cucim.skimage.color.rgb2ypbpr)
* [`rgb2yuv()`](api/#cucim.skimage.color.rgb2yuv)
* [`rgba2rgb()`](api/#cucim.skimage.color.rgba2rgb)
* [`rgbcie2rgb()`](api/#cucim.skimage.color.rgbcie2rgb)
* [`separate_stains()`](api/#cucim.skimage.color.separate_stains)
* [`xyz2lab()`](api/#cucim.skimage.color.xyz2lab)
* [`xyz2luv()`](api/#cucim.skimage.color.xyz2luv)
* [`xyz2rgb()`](api/#cucim.skimage.color.xyz2rgb)
* [`xyz_tristimulus_values()`](api/#cucim.skimage.color.xyz_tristimulus_values)
* [`ycbcr2rgb()`](api/#cucim.skimage.color.ycbcr2rgb)
* [`ydbdr2rgb()`](api/#cucim.skimage.color.ydbdr2rgb)
* [`yiq2rgb()`](api/#cucim.skimage.color.yiq2rgb)
* [`ypbpr2rgb()`](api/#cucim.skimage.color.ypbpr2rgb)
* [`yuv2rgb()`](api/#cucim.skimage.color.yuv2rgb)
* [data](api/#module-cucim.skimage.data)
* [`binary_blobs()`](api/#cucim.skimage.data.binary_blobs)
* [exposure](api/#module-cucim.skimage.exposure)
* [`adjust_gamma()`](api/#cucim.skimage.exposure.adjust_gamma)
* [`adjust_log()`](api/#cucim.skimage.exposure.adjust_log)
* [`adjust_sigmoid()`](api/#cucim.skimage.exposure.adjust_sigmoid)
* [`cumulative_distribution()`](api/#cucim.skimage.exposure.cumulative_distribution)
* [`equalize_adapthist()`](api/#cucim.skimage.exposure.equalize_adapthist)
* [`equalize_hist()`](api/#cucim.skimage.exposure.equalize_hist)
* [`histogram()`](api/#cucim.skimage.exposure.histogram)
* [`is_low_contrast()`](api/#cucim.skimage.exposure.is_low_contrast)
* [`match_histograms()`](api/#cucim.skimage.exposure.match_histograms)
* [`rescale_intensity()`](api/#cucim.skimage.exposure.rescale_intensity)
* [feature](api/#module-cucim.skimage.feature)
* [`blob_dog()`](api/#cucim.skimage.feature.blob_dog)
* [`blob_doh()`](api/#cucim.skimage.feature.blob_doh)
* [`blob_log()`](api/#cucim.skimage.feature.blob_log)
* [`canny()`](api/#cucim.skimage.feature.canny)
* [`corner_foerstner()`](api/#cucim.skimage.feature.corner_foerstner)
* [`corner_harris()`](api/#cucim.skimage.feature.corner_harris)
* [`corner_kitchen_rosenfeld()`](api/#cucim.skimage.feature.corner_kitchen_rosenfeld)
* [`corner_peaks()`](api/#cucim.skimage.feature.corner_peaks)
* [`corner_shi_tomasi()`](api/#cucim.skimage.feature.corner_shi_tomasi)
* [`daisy()`](api/#cucim.skimage.feature.daisy)
* [`hessian_matrix()`](api/#cucim.skimage.feature.hessian_matrix)
* [`hessian_matrix_det()`](api/#cucim.skimage.feature.hessian_matrix_det)
* [`hessian_matrix_eigvals()`](api/#cucim.skimage.feature.hessian_matrix_eigvals)
* [`match_descriptors()`](api/#cucim.skimage.feature.match_descriptors)
* [`match_template()`](api/#cucim.skimage.feature.match_template)
* [`multiscale_basic_features()`](api/#cucim.skimage.feature.multiscale_basic_features)
* [`peak_local_max()`](api/#cucim.skimage.feature.peak_local_max)
* [`shape_index()`](api/#cucim.skimage.feature.shape_index)
* [`structure_tensor()`](api/#cucim.skimage.feature.structure_tensor)
* [`structure_tensor_eigenvalues()`](api/#cucim.skimage.feature.structure_tensor_eigenvalues)
* [filters](api/#module-cucim.skimage.filters)
* [`LPIFilter2D`](api/#cucim.skimage.filters.LPIFilter2D)
* [`apply_hysteresis_threshold()`](api/#cucim.skimage.filters.apply_hysteresis_threshold)
* [`butterworth()`](api/#cucim.skimage.filters.butterworth)
* [`correlate_sparse()`](api/#cucim.skimage.filters.correlate_sparse)
* [`difference_of_gaussians()`](api/#cucim.skimage.filters.difference_of_gaussians)
* [`farid()`](api/#cucim.skimage.filters.farid)
* [`farid_h()`](api/#cucim.skimage.filters.farid_h)
* [`farid_v()`](api/#cucim.skimage.filters.farid_v)
* [`filter_forward()`](api/#cucim.skimage.filters.filter_forward)
* [`filter_inverse()`](api/#cucim.skimage.filters.filter_inverse)
* [`frangi()`](api/#cucim.skimage.filters.frangi)
* [`gabor()`](api/#cucim.skimage.filters.gabor)
* [`gabor_kernel()`](api/#cucim.skimage.filters.gabor_kernel)
* [`gaussian()`](api/#cucim.skimage.filters.gaussian)
* [`hessian()`](api/#cucim.skimage.filters.hessian)
* [`laplace()`](api/#cucim.skimage.filters.laplace)
* [`median()`](api/#cucim.skimage.filters.median)
* [`meijering()`](api/#cucim.skimage.filters.meijering)
* [`prewitt()`](api/#cucim.skimage.filters.prewitt)
* [`prewitt_h()`](api/#cucim.skimage.filters.prewitt_h)
* [`prewitt_v()`](api/#cucim.skimage.filters.prewitt_v)
* [`rank_order()`](api/#cucim.skimage.filters.rank_order)
* [`roberts()`](api/#cucim.skimage.filters.roberts)
* [`roberts_neg_diag()`](api/#cucim.skimage.filters.roberts_neg_diag)
* [`roberts_pos_diag()`](api/#cucim.skimage.filters.roberts_pos_diag)
* [`sato()`](api/#cucim.skimage.filters.sato)
* [`scharr()`](api/#cucim.skimage.filters.scharr)
* [`scharr_h()`](api/#cucim.skimage.filters.scharr_h)
* [`scharr_v()`](api/#cucim.skimage.filters.scharr_v)
* [`sobel()`](api/#cucim.skimage.filters.sobel)
* [`sobel_h()`](api/#cucim.skimage.filters.sobel_h)
* [`sobel_v()`](api/#cucim.skimage.filters.sobel_v)
* [`threshold_isodata()`](api/#cucim.skimage.filters.threshold_isodata)
* [`threshold_li()`](api/#cucim.skimage.filters.threshold_li)
* [`threshold_local()`](api/#cucim.skimage.filters.threshold_local)
* [`threshold_mean()`](api/#cucim.skimage.filters.threshold_mean)
* [`threshold_minimum()`](api/#cucim.skimage.filters.threshold_minimum)
* [`threshold_multiotsu()`](api/#cucim.skimage.filters.threshold_multiotsu)
* [`threshold_niblack()`](api/#cucim.skimage.filters.threshold_niblack)
* [`threshold_otsu()`](api/#cucim.skimage.filters.threshold_otsu)
* [`threshold_sauvola()`](api/#cucim.skimage.filters.threshold_sauvola)
* [`threshold_triangle()`](api/#cucim.skimage.filters.threshold_triangle)
* [`threshold_yen()`](api/#cucim.skimage.filters.threshold_yen)
* [`try_all_threshold()`](api/#cucim.skimage.filters.try_all_threshold)
* [`unsharp_mask()`](api/#cucim.skimage.filters.unsharp_mask)
* [`wiener()`](api/#cucim.skimage.filters.wiener)
* [`window()`](api/#cucim.skimage.filters.window)
* [measure](api/#module-cucim.skimage.measure)
* [`approximate_polygon()`](api/#cucim.skimage.measure.approximate_polygon)
* [`block_reduce()`](api/#cucim.skimage.measure.block_reduce)
* [`blur_effect()`](api/#cucim.skimage.measure.blur_effect)
* [`centroid()`](api/#cucim.skimage.measure.centroid)
* [`euler_number()`](api/#cucim.skimage.measure.euler_number)
* [`inertia_tensor()`](api/#cucim.skimage.measure.inertia_tensor)
* [`inertia_tensor_eigvals()`](api/#cucim.skimage.measure.inertia_tensor_eigvals)
* [`intersection_coeff()`](api/#cucim.skimage.measure.intersection_coeff)
* [`label()`](api/#cucim.skimage.measure.label)
* [`manders_coloc_coeff()`](api/#cucim.skimage.measure.manders_coloc_coeff)
* [`manders_overlap_coeff()`](api/#cucim.skimage.measure.manders_overlap_coeff)
* [`moments()`](api/#cucim.skimage.measure.moments)
* [`moments_central()`](api/#cucim.skimage.measure.moments_central)
* [`moments_coords()`](api/#cucim.skimage.measure.moments_coords)
* [`moments_coords_central()`](api/#cucim.skimage.measure.moments_coords_central)
* [`moments_hu()`](api/#cucim.skimage.measure.moments_hu)
* [`moments_normalized()`](api/#cucim.skimage.measure.moments_normalized)
* [`pearson_corr_coeff()`](api/#cucim.skimage.measure.pearson_corr_coeff)
* [`perimeter()`](api/#cucim.skimage.measure.perimeter)
* [`perimeter_crofton()`](api/#cucim.skimage.measure.perimeter_crofton)
* [`profile_line()`](api/#cucim.skimage.measure.profile_line)
* [`regionprops()`](api/#cucim.skimage.measure.regionprops)
* [`regionprops_table()`](api/#cucim.skimage.measure.regionprops_table)
* [`shannon_entropy()`](api/#cucim.skimage.measure.shannon_entropy)
* [`subdivide_polygon()`](api/#cucim.skimage.measure.subdivide_polygon)
* [metrics](api/#module-cucim.skimage.metrics)
* [`adapted_rand_error()`](api/#cucim.skimage.metrics.adapted_rand_error)
* [`contingency_table()`](api/#cucim.skimage.metrics.contingency_table)
* [`mean_squared_error()`](api/#cucim.skimage.metrics.mean_squared_error)
* [`normalized_mutual_information()`](api/#cucim.skimage.metrics.normalized_mutual_information)
* [`normalized_root_mse()`](api/#cucim.skimage.metrics.normalized_root_mse)
* [`peak_signal_noise_ratio()`](api/#cucim.skimage.metrics.peak_signal_noise_ratio)
* [`structural_similarity()`](api/#cucim.skimage.metrics.structural_similarity)
* [`variation_of_information()`](api/#cucim.skimage.metrics.variation_of_information)
* [morphology](api/#id263)
* [`ball()`](api/#cucim.skimage.morphology.ball)
* [`binary_closing()`](api/#cucim.skimage.morphology.binary_closing)
* [`binary_dilation()`](api/#cucim.skimage.morphology.binary_dilation)
* [`binary_erosion()`](api/#cucim.skimage.morphology.binary_erosion)
* [`binary_opening()`](api/#cucim.skimage.morphology.binary_opening)
* [`black_tophat()`](api/#cucim.skimage.morphology.black_tophat)
* [`closing()`](api/#cucim.skimage.morphology.closing)
* [`convex_hull_image()`](api/#cucim.skimage.morphology.convex_hull_image)
* [`convex_hull_object()`](api/#cucim.skimage.morphology.convex_hull_object)
* [`diamond()`](api/#cucim.skimage.morphology.diamond)
* [`dilation()`](api/#cucim.skimage.morphology.dilation)
* [`disk()`](api/#cucim.skimage.morphology.disk)
* [`erosion()`](api/#cucim.skimage.morphology.erosion)
* [`footprint_from_sequence()`](api/#cucim.skimage.morphology.footprint_from_sequence)
* [`footprint_rectangle()`](api/#cucim.skimage.morphology.footprint_rectangle)
* [`isotropic_closing()`](api/#cucim.skimage.morphology.isotropic_closing)
* [`isotropic_dilation()`](api/#cucim.skimage.morphology.isotropic_dilation)
* [`isotropic_erosion()`](api/#cucim.skimage.morphology.isotropic_erosion)
* [`isotropic_opening()`](api/#cucim.skimage.morphology.isotropic_opening)
* [`medial_axis()`](api/#cucim.skimage.morphology.medial_axis)
* [`octagon()`](api/#cucim.skimage.morphology.octagon)
* [`octahedron()`](api/#cucim.skimage.morphology.octahedron)
* [`opening()`](api/#cucim.skimage.morphology.opening)
* [`reconstruction()`](api/#cucim.skimage.morphology.reconstruction)
* [`remove_small_holes()`](api/#cucim.skimage.morphology.remove_small_holes)
* [`remove_small_objects()`](api/#cucim.skimage.morphology.remove_small_objects)
* [`star()`](api/#cucim.skimage.morphology.star)
* [`thin()`](api/#cucim.skimage.morphology.thin)
* [`white_tophat()`](api/#cucim.skimage.morphology.white_tophat)
* [registration](api/#module-cucim.skimage.registration)
* [`optical_flow_ilk()`](api/#cucim.skimage.registration.optical_flow_ilk)
* [`optical_flow_tvl1()`](api/#cucim.skimage.registration.optical_flow_tvl1)
* [`phase_cross_correlation()`](api/#cucim.skimage.registration.phase_cross_correlation)
* [restoration](api/#module-cucim.skimage.restoration)
* [`calibrate_denoiser()`](api/#cucim.skimage.restoration.calibrate_denoiser)
* [`denoise_invariant()`](api/#cucim.skimage.restoration.denoise_invariant)
* [`denoise_tv_chambolle()`](api/#cucim.skimage.restoration.denoise_tv_chambolle)
* [`richardson_lucy()`](api/#cucim.skimage.restoration.richardson_lucy)
* [`unsupervised_wiener()`](api/#cucim.skimage.restoration.unsupervised_wiener)
* [`wiener()`](api/#cucim.skimage.restoration.wiener)
* [segmentation](api/#module-cucim.skimage.segmentation)
* [`chan_vese()`](api/#cucim.skimage.segmentation.chan_vese)
* [`checkerboard_level_set()`](api/#cucim.skimage.segmentation.checkerboard_level_set)
* [`clear_border()`](api/#cucim.skimage.segmentation.clear_border)
* [`disk_level_set()`](api/#cucim.skimage.segmentation.disk_level_set)
* [`expand_labels()`](api/#cucim.skimage.segmentation.expand_labels)
* [`find_boundaries()`](api/#cucim.skimage.segmentation.find_boundaries)
* [`inverse_gaussian_gradient()`](api/#cucim.skimage.segmentation.inverse_gaussian_gradient)
* [`join_segmentations()`](api/#cucim.skimage.segmentation.join_segmentations)
* [`mark_boundaries()`](api/#cucim.skimage.segmentation.mark_boundaries)
* [`morphological_chan_vese()`](api/#cucim.skimage.segmentation.morphological_chan_vese)
* [`morphological_geodesic_active_contour()`](api/#cucim.skimage.segmentation.morphological_geodesic_active_contour)
* [`random_walker()`](api/#cucim.skimage.segmentation.random_walker)
* [`relabel_sequential()`](api/#cucim.skimage.segmentation.relabel_sequential)
* [transform](api/#module-cucim.skimage.transform)
* [`AffineTransform`](api/#cucim.skimage.transform.AffineTransform)
* [`EssentialMatrixTransform`](api/#cucim.skimage.transform.EssentialMatrixTransform)
* [`EuclideanTransform`](api/#cucim.skimage.transform.EuclideanTransform)
* [`FundamentalMatrixTransform`](api/#cucim.skimage.transform.FundamentalMatrixTransform)
* [`PiecewiseAffineTransform`](api/#cucim.skimage.transform.PiecewiseAffineTransform)
* [`PolynomialTransform`](api/#cucim.skimage.transform.PolynomialTransform)
* [`ProjectiveTransform`](api/#cucim.skimage.transform.ProjectiveTransform)
* [`SimilarityTransform`](api/#cucim.skimage.transform.SimilarityTransform)
* [`downscale_local_mean()`](api/#cucim.skimage.transform.downscale_local_mean)
* [`estimate_transform()`](api/#cucim.skimage.transform.estimate_transform)
* [`integral_image()`](api/#cucim.skimage.transform.integral_image)
* [`integrate()`](api/#cucim.skimage.transform.integrate)
* [`matrix_transform()`](api/#cucim.skimage.transform.matrix_transform)
* [`pyramid_expand()`](api/#cucim.skimage.transform.pyramid_expand)
* [`pyramid_gaussian()`](api/#cucim.skimage.transform.pyramid_gaussian)
* [`pyramid_laplacian()`](api/#cucim.skimage.transform.pyramid_laplacian)
* [`pyramid_reduce()`](api/#cucim.skimage.transform.pyramid_reduce)
* [`rescale()`](api/#cucim.skimage.transform.rescale)
* [`resize()`](api/#cucim.skimage.transform.resize)
* [`resize_local_mean()`](api/#cucim.skimage.transform.resize_local_mean)
* [`rotate()`](api/#cucim.skimage.transform.rotate)
* [`swirl()`](api/#cucim.skimage.transform.swirl)
* [`warp()`](api/#cucim.skimage.transform.warp)
* [`warp_coords()`](api/#cucim.skimage.transform.warp_coords)
* [`warp_polar()`](api/#cucim.skimage.transform.warp_polar)
* [util](api/#module-cucim.skimage.util)
* [`crop()`](api/#cucim.skimage.util.crop)
* [`dtype_limits()`](api/#cucim.skimage.util.dtype_limits)
* [`img_as_bool()`](api/#cucim.skimage.util.img_as_bool)
* [`img_as_float()`](api/#cucim.skimage.util.img_as_float)
* [`img_as_float32()`](api/#cucim.skimage.util.img_as_float32)
* [`img_as_float64()`](api/#cucim.skimage.util.img_as_float64)
* [`img_as_int()`](api/#cucim.skimage.util.img_as_int)
* [`img_as_ubyte()`](api/#cucim.skimage.util.img_as_ubyte)
* [`img_as_uint()`](api/#cucim.skimage.util.img_as_uint)
* [`invert()`](api/#cucim.skimage.util.invert)
* [`map_array()`](api/#cucim.skimage.util.map_array)
* [`random_noise()`](api/#cucim.skimage.util.random_noise)
* [`view_as_blocks()`](api/#cucim.skimage.util.view_as_blocks)
* [`view_as_windows()`](api/#cucim.skimage.util.view_as_windows)
* [Submodule Contents](api/#submodule-contents)
* [skimage](api/#module-cucim.skimage)
* [Subpackages](api/#subpackages)
* [Utility Functions](api/#utility-functions)
Indices and tables[#](#indices-and-tables "Link to this heading")
==================================================================
* [Index](genindex/)
* [Module Index](py-modindex/)
* [Search Page](search/)
On this page
### This Page
* [Show Source](_sources/index.rst.txt)
---
# Building from Source — cugraph-docs 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cugraph
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cugraph/nightly)
[stable (25.02)](/api/cugraph/stable)
[legacy (24.12)](/api/cugraph/legacy)
* [GitHub](https://github.com/rapidsai/cugraph "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
Building from Source[#](#building-from-source "Link to this heading")
======================================================================
These instructions are tested on supported versions/distributions of Linux, CUDA, and Python - See [RAPIDS Getting Started](https://rapids.ai/start.html)
for the list of supported environments. Other environments _might be_ compatible, but are not currently tested.
Prerequisites[#](#prerequisites "Link to this heading")
--------------------------------------------------------
**Compilers:**
* `gcc` version 9.3+
* `nvcc` version 11.5+
**CUDA:**
* CUDA 11.8+
* NVIDIA GPU, Volta architecture or later, with [compute capability](https://developer.nvidia.com/cuda-gpus)
7.0+
Further details and download links for these prerequisites are available on the [RAPIDS System Requirements page](https://docs.rapids.ai/install#system-req)
.
Setting up the development environment[#](#setting-up-the-development-environment "Link to this heading")
----------------------------------------------------------------------------------------------------------
### Clone the repository:[#](#clone-the-repository "Link to this heading")
CUGRAPH\_HOME\=$(pwd)/cugraph
git clone https://github.com/rapidsai/cugraph.git $CUGRAPH\_HOME
cd $CUGRAPH\_HOME
### Create the conda environment[#](#create-the-conda-environment "Link to this heading")
Using conda is the easiest way to install both the build and runtime dependencies for cugraph. While it is possible to build and run cugraph without conda, the required packages occasionally change, making it difficult to document here. The best way to see the current dependencies needed for a build and run environment is to examine the list of packages in the [conda environment YAML files](https://github.com/rapidsai/cugraph/blob/main/conda/environments)
.
\# for CUDA 11.x
conda env create \--name cugraph\_dev \--file $CUGRAPH\_HOME/conda/environments/all\_cuda-118\_arch-x86\_64.yaml
\# for CUDA 12.x
conda env create \--name cugraph\_dev \--file $CUGRAPH\_HOME/conda/environments/all\_cuda-125\_arch-x86\_64.yaml
\# activate the environment
conda activate cugraph\_dev
\# to deactivate an environment
conda deactivate
The environment can be updated as cugraph adds/removes/updates its dependencies. To do so, run:
\# for CUDA 11.x
conda env update \--name cugraph\_dev \--file $CUGRAPH\_HOME/conda/environments/all\_cuda-118\_arch-x86\_64.yaml
conda activate cugraph\_dev
\# for CUDA 12.x
conda env update \--name cugraph\_dev \--file $CUGRAPH\_HOME/conda/environments/all\_cuda-125\_arch-x86\_64.yaml
conda activate cugraph\_dev
### Build and Install[#](#build-and-install "Link to this heading")
#### Build and install using `build.sh`[#](#build-and-install-using-build-sh "Link to this heading")
Using the `build.sh` script, located in the `$CUGRAPH_HOME` directory, is the recommended way to build and install the cugraph libraries. By default, `build.sh` will build and install a predefined set of targets (packages/libraries), but can also accept a list of targets to build.
For example, to build only the cugraph C++ library (`libcugraph`) and the high-level python library (`cugraph`) without building the C++ test binaries, run this command:
$ cd $CUGRAPH\_HOME
$ ./build.sh libcugraph pylibcugraph cugraph \--skip\_cpp\_tests
There are several other options available on the build script for advanced users. Refer to the output of `--help` for details.
Note that libraries will be installed to the location set in `$PREFIX` if set (i.e. `export PREFIX=/install/path`), otherwise to `$CONDA_PREFIX`.
#### Updating the RAFT branch[#](#updating-the-raft-branch "Link to this heading")
`libcugraph` uses the [RAFT](https://github.com/rapidsai/raft)
library and there are times when it might be desirable to build against a different RAFT branch, such as when working on new features that might span both RAFT and cuGraph.
For local development, the `CPM_raft_SOURCE=` option can be passed to the `cmake` command to enable `libcugraph` to use the local RAFT branch. The `build.sh` script calls `cmake` to build the C/C++ targets, but developers can call `cmake` directly in order to pass it options like those described here. Refer to the `build.sh` script to see how to call `cmake` and other commands directly.
To have CI test a `cugraph` pull request against a different RAFT branch, modify the bottom of the `cpp/cmake/thirdparty/get_raft.cmake` file as follows:
\# Change pinned tag and fork here to test a commit in CI
\# To use a different RAFT locally, set the CMake variable
\# RPM\_raft\_SOURCE=/path/to/local/raft
find\_and\_configure\_raft(VERSION ${CUGRAPH\_MIN\_VERSION\_raft}
FORK
PINNED\_TAG
\# When PINNED\_TAG above doesn't match cugraph,
\# force local raft clone in build directory
\# even if it's already installed.
CLONE\_ON\_PIN ON
)
When the above change is pushed to a pull request, the continuous integration servers will use the specified RAFT branch to run the cuGraph tests. After the changes in the RAFT branch are merged to the release branch, remember to revert the `get_raft.cmake` file back to the original cuGraph branch.
Run tests[#](#run-tests "Link to this heading")
------------------------------------------------
If you already have the datasets:
export RAPIDS\_DATASET\_ROOT\_DIR\=
If you do not have the datasets:
cd $CUGRAPH\_HOME/datasets
source get\_test\_data.sh #This takes about 10 minutes and downloads 1GB data (>5 GB uncompressed)
Run either the C++ or the Python tests with datasets
* **Python tests with datasets**
pip install python-louvain #some tests require this package to run
cd $CUGRAPH\_HOME
cd python
pytest
* **C++ stand alone tests**
From the build directory :
\# Run the cugraph tests
cd $CUGRAPH\_HOME
cd cpp/build
gtests/GDFGRAPH\_TEST \# this is an executable file
* **C++ tests with larger datasets**
Run the C++ tests on large input:
cd $CUGRAPH\_HOME/cpp/build
#test one particular analytics (eg. pagerank)
gtests/PAGERANK\_TEST
#test everything
make test
Note: This conda installation only applies to Linux and Python versions 3.10, 3.11, and 3.12.
### (OPTIONAL) Set environment variable on activation[#](#optional-set-environment-variable-on-activation "Link to this heading")
It is possible to configure the conda environment to set environment variables on activation. Providing instructions to set PATH to include the CUDA toolkit bin directory and LD\_LIBRARY\_PATH to include the CUDA lib64 directory will be helpful.
cd ~/anaconda3/envs/cugraph\_dev
mkdir \-p ./etc/conda/activate.d
mkdir \-p ./etc/conda/deactivate.d
touch ./etc/conda/activate.d/env\_vars.sh
touch ./etc/conda/deactivate.d/env\_vars.sh
Next the env\_vars.sh file needs to be edited
vi ./etc/conda/activate.d/env\_vars.sh
#!/bin/bash
export PATH\=/usr/local/cuda-11.0/bin:$PATH \# or cuda-11.1 if using CUDA 11.1 and cuda-11.2 if using CUDA 11.2, respectively
export LD\_LIBRARY\_PATH\=/usr/local/cuda-11.0/lib64:$LD\_LIBRARY\_PATH \# or cuda-11.1 if using CUDA 11.1 and cuda-11.2 if using CUDA 11.2, respectively
vi ./etc/conda/deactivate.d/env\_vars.sh
#!/bin/bash
unset PATH
unset LD\_LIBRARY\_PATH
Creating documentation[#](#creating-documentation "Link to this heading")
--------------------------------------------------------------------------
Python API documentation can be generated from _./docs/cugraph directory_. Or through using “./build.sh docs”
Attribution[#](#attribution "Link to this heading")
----------------------------------------------------
Portions adopted from https://github.com/pytorch/pytorch/blob/master/CONTRIBUTING.md
On this page
### This Page
* [Show Source](../../_sources/installation/source_build.md.txt)
---
# cuVS: Vector Search and Clustering on the GPU — cuvs 24.12.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cuvs
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
legacy (24.12)
[nightly (25.04)](/api/cuvs/nightly)
[stable (25.02)](/api/cuvs/stable)
[legacy (24.12)](/api/cuvs/legacy)
* [GitHub](https://github.com/rapidsai/cuvs "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
cuVS: Vector Search and Clustering on the GPU[#](#cuvs-vector-search-and-clustering-on-the-gpu "Permalink to this heading")
============================================================================================================================
Welcome to cuVS, the premier library for GPU-accelerated vector search and clustering! cuVS provides several core building blocks for constructing new algorithms, as well as end-to-end vector search and clustering algorithms for use either standalone or through a growing list of [integrations](integrations/)
.
Useful Resources[#](#useful-resources "Permalink to this heading")
-------------------------------------------------------------------
* [Example Notebooks](https://github.com/rapidsai/cuvs/tree/HEAD/notebooks)
: Example notebooks
* [Code Examples](https://github.com/rapidsai/cuvs/tree/HEAD/examples)
: Self-contained code examples
* [RAPIDS Community](https://rapids.ai/community.html)
: Get help, contribute, and collaborate.
* [GitHub repository](https://github.com/rapidsai/cuvs)
: Download the cuVS source code.
* [Issue tracker](https://github.com/rapidsai/cuvs/issues)
: Report issues or request features.
What is cuVS?[#](#what-is-cuvs "Permalink to this heading")
------------------------------------------------------------
cuVS contains state-of-the-art implementations of several algorithms for running approximate and exact nearest neighbors and clustering on the GPU. It can be used directly or through the various databases and other libraries that have integrated it. The primary goal of cuVS is to simplify the use of GPUs for vector similarity search and clustering.
Vector search is an information retrieval method that has been growing in popularity over the past few years, partly because of the rising importance of multimedia embeddings created from unstructured data and the need to perform semantic search on the embeddings to find items which are semantically similar to each other.
Vector search is also used in _data mining and machine learning_ tasks and comprises an important step in many _clustering_ and _visualization_ algorithms like [UMAP](https://arxiv.org/abs/2008.00325)
, [t-SNE](https://lvdmaaten.github.io/tsne/)
, K-means, and [HDBSCAN](https://hdbscan.readthedocs.io/en/latest/how_hdbscan_works.html)
.
Finally, faster vector search enables interactions between dense vectors and graphs. Converting a pile of dense vectors into nearest neighbors graphs unlocks the entire world of graph analysis algorithms, such as those found in [GraphBLAS](https://graphblas.org/)
and [cuGraph](https://github.com/rapidsai/cugraph)
.
Below are some common use-cases for vector search
### Semantic search[#](#semantic-search "Permalink to this heading")
* Generative AI & Retrieval augmented generation (RAG)
* Recommender systems
* Computer vision
* Image search
* Text search
* Audio search
* Molecular search
* Model training
### Data mining[#](#data-mining "Permalink to this heading")
* Clustering algorithms
* Visualization algorithms
* Sampling algorithms
* Class balancing
* Ensemble methods
* k-NN graph construction
Why cuVS?[#](#why-cuvs "Permalink to this heading")
----------------------------------------------------
There are several benefits to using cuVS and GPUs for vector search, including
1. Fast index build
2. Latency critical and high throughput search
3. Parameter tuning
4. Cost savings
5. Interoperability (build on GPU, deploy on CPU)
6. Multiple language support
7. Building blocks for composing new or accelerating existing algorithms
In addition to the items above, cuVS shoulders the responsibility of keeping non-trivial accelerated code up to date as new NVIDIA architectures and CUDA versions are released. This provides a deslightful development experimence, guaranteeing that any libraries, databases, or applications built on top of it will always be receiving the best performance and scale.
cuVS Technology Stack[#](#cuvs-technology-stack "Permalink to this heading")
-----------------------------------------------------------------------------
cuVS is built on top of the RAPIDS RAFT library of high performance machine learning primitives and provides all the necessary routines for vector search and clustering on the GPU.
[](_images/tech_stack.png)
Contents[#](#contents "Permalink to this heading")
---------------------------------------------------
* [Installation](build/)
* [Installing Pre-compiled Packages](build/#installing-pre-compiled-packages)
* [C, C++, and Python through Conda](build/#c-c-and-python-through-conda)
* [C/C++ Package](build/#c-c-package)
* [Python Package](build/#python-package)
* [Python through Pip](build/#python-through-pip)
* [Build from source](build/#build-from-source)
* [Prerequisites](build/#prerequisites)
* [Create a build environment](build/#create-a-build-environment)
* [C and C++ libraries](build/#c-and-c-libraries)
* [Multi-GPU features](build/#multi-gpu-features)
* [Building the Googletests](build/#building-the-googletests)
* [Python library](build/#python-library)
* [Rust library](build/#rust-library)
* [Using CMake directly](build/#using-cmake-directly)
* [Build documentation](build/#build-documentation)
* [Getting Started](getting_started/)
* [New to vector search?](getting_started/#new-to-vector-search)
* [Supported indexes](getting_started/#supported-indexes)
* [Using cuVS APIs](getting_started/#using-cuvs-apis)
* [Where to next?](getting_started/#where-to-next)
* [Social media](getting_started/#social-media)
* [Blogs](getting_started/#blogs)
* [Research](getting_started/#research)
* [Get involved](getting_started/#get-involved)
* [Integrations](integrations/)
* [FAISS](integrations/faiss/)
* [Milvus](integrations/milvus/)
* [Lucene](integrations/lucene/)
* [Kinetica](integrations/kinetica/)
* [cuVS Bench](cuvs_bench/)
* [Installing the benchmarks](cuvs_bench/#installing-the-benchmarks)
* [Conda](cuvs_bench/#conda)
* [Docker](cuvs_bench/#docker)
* [How to run the benchmarks](cuvs_bench/#how-to-run-the-benchmarks)
* [Step 1: Prepare the dataset](cuvs_bench/#step-1-prepare-the-dataset)
* [Step 2: Build and search index](cuvs_bench/#step-2-build-and-search-index)
* [Step 3: Data export](cuvs_bench/#step-3-data-export)
* [Step 4: Plot the results](cuvs_bench/#step-4-plot-the-results)
* [Running the benchmarks](cuvs_bench/#running-the-benchmarks)
* [End-to-end: smaller-scale benchmarks (<1M to 10M)](cuvs_bench/#end-to-end-smaller-scale-benchmarks-1m-to-10m)
* [End-to-end: large-scale benchmarks (>10M vectors)](cuvs_bench/#end-to-end-large-scale-benchmarks-10m-vectors)
* [Running with Docker containers](cuvs_bench/#running-with-docker-containers)
* [End-to-end run on GPU](cuvs_bench/#end-to-end-run-on-gpu)
* [End-to-end run on CPU](cuvs_bench/#end-to-end-run-on-cpu)
* [Manually run the scripts inside the container](cuvs_bench/#manually-run-the-scripts-inside-the-container)
* [Evaluating the results](cuvs_bench/#evaluating-the-results)
* [Creating and customizing dataset configurations](cuvs_bench/#creating-and-customizing-dataset-configurations)
* [Multi-GPU benchmarks](cuvs_bench/#multi-gpu-benchmarks)
* [Adding a new index algorithm](cuvs_bench/#adding-a-new-index-algorithm)
* [Implementation and configuration](cuvs_bench/#implementation-and-configuration)
* [Adding a Cmake target](cuvs_bench/#adding-a-cmake-target)
* [API Reference](api_docs/)
* [C API Documentation](c_api/)
* [Core Routines](c_api/core_c_api/)
* [Resources Handle](c_api/core_c_api/#resources-handle)
* [Error Handling](c_api/core_c_api/#error-handling)
* [Nearest Neighbors](c_api/neighbors/)
* [Bruteforce](c_api/neighbors_bruteforce_c/)
* [IVF-Flat](c_api/neighbors_ivf_flat_c/)
* [IVF-PQ](c_api/neighbors_ivf_pq_c/)
* [CAGRA](c_api/neighbors_cagra_c/)
* [HNSW](c_api/neighbors_hnsw_c/)
* [C++ API Documentation](cpp_api/)
* [Cluster](cpp_api/cluster/)
* [Cluster](cpp_api/cluster_kmeans/)
* [Cluster](cpp_api/cluster_agglomerative/)
* [Distance](cpp_api/distance/)
* [Distance Types](cpp_api/distance/#distance-types)
* [Pairwise Distances](cpp_api/distance/#pairwise-distances)
* [Nearest Neighbors](cpp_api/neighbors/)
* [Bruteforce](cpp_api/neighbors_bruteforce/)
* [CAGRA](cpp_api/neighbors_cagra/)
* [Dynamic Batching](cpp_api/neighbors_dynamic_batching/)
* [HNSW](cpp_api/neighbors_hnsw/)
* [IVF-Flat](cpp_api/neighbors_ivf_flat/)
* [IVF-PQ](cpp_api/neighbors_ivf_pq/)
* [NN-Descent](cpp_api/neighbors_nn_descent/)
* [Refinement](cpp_api/neighbors_refine/)
* [Distributed ANN](cpp_api/neighbors_mg/)
* [Preprocessing](cpp_api/preprocessing/)
* [Quantize](cpp_api/preprocessing_quantize/)
* [Selection](cpp_api/selection/)
* [Select-K](cpp_api/selection/#select-k)
* [Stats](cpp_api/stats/)
* [Silhouette Score](cpp_api/stats/#silhouette-score)
* [Trustworthiness Score](cpp_api/stats/#trustworthiness-score)
* [Python API Documentation](python_api/)
* [Distance](python_api/distance/)
* [Pairwise Distance](python_api/distance/#pairwise-distance)
* [Nearest Neighbors](python_api/neighbors/)
* [Brute Force KNN](python_api/neighbors_brute_force/)
* [CAGRA](python_api/neighbors_cagra/)
* [HNSW](python_api/neighbors_hnsw/)
* [IVF-Flat](python_api/neighbors_ivf_flat/)
* [IVF-PQ](python_api/neighbors_ivf_pq/)
* [Rust API Documentation](rust_api/)
* [Contributing](contributing/)
* [Code contributions](contributing/#code-contributions)
* [Your first issue](contributing/#your-first-issue)
* [Python / Pre-commit hooks](contributing/#python-pre-commit-hooks)
* [Seasoned developers](contributing/#seasoned-developers)
* [Attribution](contributing/#attribution)
On this page
[Show Source](_sources/index.rst.txt)
---
# cuVS: Vector Search and Clustering on the GPU — cuvs
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cuvs
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
nightly (25.04)
[nightly (25.04)](/api/cuvs/nightly)
[stable (25.02)](/api/cuvs/stable)
[legacy (24.12)](/api/cuvs/legacy)
[ \
\
cuvs](#)
* [GitHub](https://github.com/rapidsai/cuvs "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
cuVS: Vector Search and Clustering on the GPU[#](#cuvs-vector-search-and-clustering-on-the-gpu "Link to this heading")
=======================================================================================================================
Welcome to cuVS, the premier library for GPU-accelerated vector search and clustering! cuVS provides several core building blocks for constructing new algorithms, as well as end-to-end vector search and clustering algorithms for use either standalone or through a growing list of [integrations](integrations/)
.
Useful Resources[#](#useful-resources "Link to this heading")
--------------------------------------------------------------
* [Example Notebooks](https://github.com/rapidsai/cuvs/tree/HEAD/notebooks)
: Example notebooks
* [Code Examples](https://github.com/rapidsai/cuvs/tree/HEAD/examples)
: Self-contained code examples
* [RAPIDS Community](https://rapids.ai/community.html)
: Get help, contribute, and collaborate.
* [GitHub repository](https://github.com/rapidsai/cuvs)
: Download the cuVS source code.
* [Issue tracker](https://github.com/rapidsai/cuvs/issues)
: Report issues or request features.
What is cuVS?[#](#what-is-cuvs "Link to this heading")
-------------------------------------------------------
cuVS contains state-of-the-art implementations of several algorithms for running approximate and exact nearest neighbors and clustering on the GPU. It can be used directly or through the various databases and other libraries that have integrated it. The primary goal of cuVS is to simplify the use of GPUs for vector similarity search and clustering.
Vector search is an information retrieval method that has been growing in popularity over the past few years, partly because of the rising importance of multimedia embeddings created from unstructured data and the need to perform semantic search on the embeddings to find items which are semantically similar to each other.
Vector search is also used in _data mining and machine learning_ tasks and comprises an important step in many _clustering_ and _visualization_ algorithms like [UMAP](https://arxiv.org/abs/2008.00325)
, [t-SNE](https://lvdmaaten.github.io/tsne/)
, K-means, and [HDBSCAN](https://hdbscan.readthedocs.io/en/latest/how_hdbscan_works.html)
.
Finally, faster vector search enables interactions between dense vectors and graphs. Converting a pile of dense vectors into nearest neighbors graphs unlocks the entire world of graph analysis algorithms, such as those found in [GraphBLAS](https://graphblas.org/)
and [cuGraph](https://github.com/rapidsai/cugraph)
.
Below are some common use-cases for vector search
### Semantic search[#](#semantic-search "Link to this heading")
* Generative AI & Retrieval augmented generation (RAG)
* Recommender systems
* Computer vision
* Image search
* Text search
* Audio search
* Molecular search
* Model training
### Data mining[#](#data-mining "Link to this heading")
* Clustering algorithms
* Visualization algorithms
* Sampling algorithms
* Class balancing
* Ensemble methods
* k-NN graph construction
Why cuVS?[#](#why-cuvs "Link to this heading")
-----------------------------------------------
There are several benefits to using cuVS and GPUs for vector search, including
1. Fast index build
2. Latency critical and high throughput search
3. Parameter tuning
4. Cost savings
5. Interoperability (build on GPU, deploy on CPU)
6. Multiple language support
7. Building blocks for composing new or accelerating existing algorithms
In addition to the items above, cuVS shoulders the responsibility of keeping non-trivial accelerated code up to date as new NVIDIA architectures and CUDA versions are released. This provides a deslightful development experimence, guaranteeing that any libraries, databases, or applications built on top of it will always be receiving the best performance and scale.
cuVS Technology Stack[#](#cuvs-technology-stack "Link to this heading")
------------------------------------------------------------------------
cuVS is built on top of the RAPIDS RAFT library of high performance machine learning primitives and provides all the necessary routines for vector search and clustering on the GPU.
[](_images/tech_stack.png)
Contents[#](#contents "Link to this heading")
----------------------------------------------
* [Installation](build/)
* [Installing Pre-compiled Packages](build/#installing-pre-compiled-packages)
* [C, C++, and Python through Conda](build/#c-c-and-python-through-conda)
* [C/C++ Package](build/#c-c-package)
* [Python Package](build/#python-package)
* [Python through Pip](build/#python-through-pip)
* [Build from source](build/#build-from-source)
* [Prerequisites](build/#prerequisites)
* [Create a build environment](build/#create-a-build-environment)
* [C and C++ libraries](build/#c-and-c-libraries)
* [Multi-GPU features](build/#multi-gpu-features)
* [Building the Googletests](build/#building-the-googletests)
* [Python library](build/#python-library)
* [Rust library](build/#rust-library)
* [Using CMake directly](build/#using-cmake-directly)
* [Build documentation](build/#build-documentation)
* [Getting Started](getting_started/)
* [New to vector search?](getting_started/#new-to-vector-search)
* [Supported indexes](getting_started/#supported-indexes)
* [Using cuVS APIs](getting_started/#using-cuvs-apis)
* [Where to next?](getting_started/#where-to-next)
* [Social media](getting_started/#social-media)
* [Blogs](getting_started/#blogs)
* [Research](getting_started/#research)
* [Get involved](getting_started/#get-involved)
* [Integrations](integrations/)
* [FAISS](integrations/faiss/)
* [Milvus](integrations/milvus/)
* [Lucene](integrations/lucene/)
* [Kinetica](integrations/kinetica/)
* [cuVS Bench](cuvs_bench/)
* [Installing the benchmarks](cuvs_bench/#installing-the-benchmarks)
* [Conda](cuvs_bench/#conda)
* [Docker](cuvs_bench/#docker)
* [Running the benchmarks](cuvs_bench/#running-the-benchmarks)
* [End-to-end: smaller-scale benchmarks (<1M to 10M)](cuvs_bench/#end-to-end-smaller-scale-benchmarks-1m-to-10m)
* [End-to-end: large-scale benchmarks (>10M vectors)](cuvs_bench/#end-to-end-large-scale-benchmarks-10m-vectors)
* [Running with Docker containers](cuvs_bench/#running-with-docker-containers)
* [End-to-end run on GPU](cuvs_bench/#end-to-end-run-on-gpu)
* [End-to-end run on CPU](cuvs_bench/#end-to-end-run-on-cpu)
* [Manually run the scripts inside the container](cuvs_bench/#manually-run-the-scripts-inside-the-container)
* [Evaluating the results](cuvs_bench/#evaluating-the-results)
* [Creating and customizing dataset configurations](cuvs_bench/#creating-and-customizing-dataset-configurations)
* [Multi-GPU benchmarks](cuvs_bench/#multi-gpu-benchmarks)
* [Adding a new index algorithm](cuvs_bench/#adding-a-new-index-algorithm)
* [Implementation and configuration](cuvs_bench/#implementation-and-configuration)
* [Adding a Cmake target](cuvs_bench/#adding-a-cmake-target)
* [API Reference](api_docs/)
* [C API Documentation](c_api/)
* [Core Routines](c_api/core_c_api/)
* [Resources Handle](c_api/core_c_api/#resources-handle)
* [Error Handling](c_api/core_c_api/#error-handling)
* [Nearest Neighbors](c_api/neighbors/)
* [Bruteforce](c_api/neighbors_bruteforce_c/)
* [IVF-Flat](c_api/neighbors_ivf_flat_c/)
* [IVF-PQ](c_api/neighbors_ivf_pq_c/)
* [CAGRA](c_api/neighbors_cagra_c/)
* [HNSW](c_api/neighbors_hnsw_c/)
* [C++ API Documentation](cpp_api/)
* [Cluster](cpp_api/cluster/)
* [Cluster](cpp_api/cluster_kmeans/)
* [Cluster](cpp_api/cluster_agglomerative/)
* [Distance](cpp_api/distance/)
* [Distance Types](cpp_api/distance/#distance-types)
* [Pairwise Distances](cpp_api/distance/#pairwise-distances)
* [Nearest Neighbors](cpp_api/neighbors/)
* [Bruteforce](cpp_api/neighbors_bruteforce/)
* [CAGRA](cpp_api/neighbors_cagra/)
* [Dynamic Batching](cpp_api/neighbors_dynamic_batching/)
* [Filtering](cpp_api/neighbors_filter/)
* [HNSW](cpp_api/neighbors_hnsw/)
* [IVF-Flat](cpp_api/neighbors_ivf_flat/)
* [IVF-PQ](cpp_api/neighbors_ivf_pq/)
* [NN-Descent](cpp_api/neighbors_nn_descent/)
* [Refinement](cpp_api/neighbors_refine/)
* [Distributed ANN](cpp_api/neighbors_mg/)
* [Vamana](cpp_api/neighbors_vamana/)
* [Preprocessing](cpp_api/preprocessing/)
* [Quantize](cpp_api/preprocessing_quantize/)
* [Selection](cpp_api/selection/)
* [Select-K](cpp_api/selection/#select-k)
* [Stats](cpp_api/stats/)
* [Silhouette Score](cpp_api/stats/#silhouette-score)
* [Trustworthiness Score](cpp_api/stats/#trustworthiness-score)
* [Python API Documentation](python_api/)
* [Distance](python_api/distance/)
* [Pairwise Distance](python_api/distance/#pairwise-distance)
* [Nearest Neighbors](python_api/neighbors/)
* [Brute Force KNN](python_api/neighbors_brute_force/)
* [CAGRA](python_api/neighbors_cagra/)
* [HNSW](python_api/neighbors_hnsw/)
* [IVF-Flat](python_api/neighbors_ivf_flat/)
* [IVF-PQ](python_api/neighbors_ivf_pq/)
* [NN-Descent](python_api/neighbors_nn_decent/)
* [Preprocessing](python_api/preprocessing/)
* [Scalar Quantizer](python_api/preprocessing/#scalar-quantizer)
* [Rust API Documentation](rust_api/)
* [Contributing](contributing/)
* [Code contributions](contributing/#code-contributions)
* [Your first issue](contributing/#your-first-issue)
* [Python / Pre-commit hooks](contributing/#python-pre-commit-hooks)
* [Seasoned developers](contributing/#seasoned-developers)
* [Attribution](contributing/#attribution)
On this page
---
# Welcome to cuCIM’s documentation! — cuCIM 24.12.00 documentation
[Skip to main content](#main-content)
Back to top
Ctrl+K
[Home](/api)
cucim
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
legacy (24.12)
[nightly (25.04)](/api/cucim/nightly)
[stable (25.02)](/api/cucim/stable)
[legacy (24.12)](/api/cucim/legacy)
Welcome to cuCIM’s documentation
====================================================================================================
cuCIM (Compute Unified Device Architecture Clara IMage) is an open-source, accelerated computer vision and image processing software library for multidimensional images used in biomedical, geospatial, material and life science, and remote sensing use cases.
cuCIM provides GPU-accelearted I/O, computer vision and image processing primitives for N-Dimensional images including:
* color conversion
* exposure
* feature extraction
* filters
* measure
* metrics
* morphology
* registration
* restoration
* segmentation
* transforms
cuCIM supports the following formats:
* Aperio ScanScope Virtual Slide (SVS)
* Philips TIFF
* Generic Tiled, Multi-resolution RGB TIFF files with the following compression schemes:
* No Compression
* JPEG
* JPEG2000
* Lempel-Ziv-Welch (LZW)
* Deflate
Our API mirrors [scikit-image](https://scikit-image.org/)
for image manipulation and [OpenSlide](https://openslide.org/)
for image loading.
cuCIM is interoperable with the following workflows:
* Albumentations
* cuPY
* Data Loading Library (DALI)
* JFX
* MONAI
* Numba
* NumPy
* PyTorch
* Tensorflow
* Triton
cuCIM is fully open sourced under the Apache-2.0 license, and the Clara and RAPIDS teams welcomes new and seasoned contributors, users and hobbyists! You may download cuCIM via Anaconda [Conda](https://anaconda.org/rapidsai-nightly/cucim)
or [PyPI](https://pypi.org/project/cucim/)
Thank you for your wonderful support! Below, we provide some resources to help get you started.
**Blogs**
* [Accelerating Scikit-Image API with cuCIM: n-Dimensional Image Processing and IO on GPUs](https://developer.nvidia.com/blog/cucim-rapid-n-dimensional-image-processing-and-i-o-on-gpus/)
* [Accelerating Digital Pathology Pipelines with NVIDIA Clara™ Deploy](https://developer.nvidia.com/blog/accelerating-digital-pathology-pipelines-with-nvidia-clara-deploy-2/)
**Webinars**
* [cuCIM: a GPU Image IO and Processing Library](https://www.youtube.com/watch?v=G46kOOM9xbQ)
Contents[#](#contents "Permalink to this heading")
===================================================
* [cuCIM API Reference](api/)
* [Clara Submodules](api/#module-cucim.clara)
* [`CuImage`](api/#cucim.clara.CuImage)
* [`CuImage.associated_image()`](api/#cucim.clara.CuImage.associated_image)
* [`CuImage.associated_images`](api/#cucim.clara.CuImage.associated_images)
* [`CuImage.cache()`](api/#cucim.clara.CuImage.cache)
* [`CuImage.channel_names`](api/#cucim.clara.CuImage.channel_names)
* [`CuImage.close()`](api/#cucim.clara.CuImage.close)
* [`CuImage.coord_sys`](api/#cucim.clara.CuImage.coord_sys)
* [`CuImage.device`](api/#cucim.clara.CuImage.device)
* [`CuImage.dims`](api/#cucim.clara.CuImage.dims)
* [`CuImage.direction`](api/#cucim.clara.CuImage.direction)
* [`CuImage.dtype`](api/#cucim.clara.CuImage.dtype)
* [`CuImage.is_loaded`](api/#cucim.clara.CuImage.is_loaded)
* [`CuImage.is_trace_enabled`](api/#cucim.clara.CuImage.is_trace_enabled)
* [`CuImage.metadata`](api/#cucim.clara.CuImage.metadata)
* [`CuImage.ndim`](api/#cucim.clara.CuImage.ndim)
* [`CuImage.origin`](api/#cucim.clara.CuImage.origin)
* [`CuImage.path`](api/#cucim.clara.CuImage.path)
* [`CuImage.profiler()`](api/#cucim.clara.CuImage.profiler)
* [`CuImage.raw_metadata`](api/#cucim.clara.CuImage.raw_metadata)
* [`CuImage.read_region()`](api/#cucim.clara.CuImage.read_region)
* [`CuImage.resolutions`](api/#cucim.clara.CuImage.resolutions)
* [`CuImage.save()`](api/#cucim.clara.CuImage.save)
* [`CuImage.shape`](api/#cucim.clara.CuImage.shape)
* [`CuImage.size()`](api/#cucim.clara.CuImage.size)
* [`CuImage.spacing()`](api/#cucim.clara.CuImage.spacing)
* [`CuImage.spacing_units()`](api/#cucim.clara.CuImage.spacing_units)
* [`CuImage.typestr`](api/#cucim.clara.CuImage.typestr)
* [`DLDataType`](api/#cucim.clara.DLDataType)
* [`DLDataType.bits`](api/#cucim.clara.DLDataType.bits)
* [`DLDataType.code`](api/#cucim.clara.DLDataType.code)
* [`DLDataType.lanes`](api/#cucim.clara.DLDataType.lanes)
* [`DLDataTypeCode`](api/#cucim.clara.DLDataTypeCode)
* [`DLDataTypeCode.DLBfloat`](api/#cucim.clara.DLDataTypeCode.DLBfloat)
* [`DLDataTypeCode.DLFloat`](api/#cucim.clara.DLDataTypeCode.DLFloat)
* [`DLDataTypeCode.DLInt`](api/#cucim.clara.DLDataTypeCode.DLInt)
* [`DLDataTypeCode.DLUInt`](api/#cucim.clara.DLDataTypeCode.DLUInt)
* [`DLDataTypeCode.name`](api/#cucim.clara.DLDataTypeCode.name)
* [`DLDataTypeCode.value`](api/#cucim.clara.DLDataTypeCode.value)
* [cache](api/#module-cucim.clara.cache)
* [`CacheType`](api/#cucim.clara.cache.CacheType)
* [`ImageCache`](api/#cucim.clara.cache.ImageCache)
* [`preferred_memory_capacity()`](api/#cucim.clara.cache.preferred_memory_capacity)
* [filesystem](api/#module-cucim.clara.filesystem)
* [`CuFileDriver`](api/#cucim.clara.filesystem.CuFileDriver)
* [`close()`](api/#cucim.clara.filesystem.close)
* [`discard_page_cache()`](api/#cucim.clara.filesystem.discard_page_cache)
* [`open()`](api/#cucim.clara.filesystem.open)
* [`pread()`](api/#cucim.clara.filesystem.pread)
* [`pwrite()`](api/#cucim.clara.filesystem.pwrite)
* [io](api/#module-cucim.clara.io)
* [`Device`](api/#cucim.clara.io.Device)
* [`DeviceType`](api/#cucim.clara.io.DeviceType)
* [core Submodules](api/#core-submodules)
* [color](api/#module-cucim.core.operations.color)
* [`color_jitter()`](api/#cucim.core.operations.color.color_jitter)
* [`image_to_absorbance()`](api/#cucim.core.operations.color.image_to_absorbance)
* [`normalize_colors_pca()`](api/#cucim.core.operations.color.normalize_colors_pca)
* [`stain_extraction_pca()`](api/#cucim.core.operations.color.stain_extraction_pca)
* [expose](api/#module-cucim.core.operations.expose)
* [intensity](api/#module-cucim.core.operations.intensity)
* [`normalize_data()`](api/#cucim.core.operations.intensity.normalize_data)
* [`rand_zoom()`](api/#cucim.core.operations.intensity.rand_zoom)
* [`scale_intensity_range()`](api/#cucim.core.operations.intensity.scale_intensity_range)
* [`zoom()`](api/#cucim.core.operations.intensity.zoom)
* [morphology](api/#module-cucim.core.operations.morphology)
* [`distance_transform_edt()`](api/#cucim.core.operations.morphology.distance_transform_edt)
* [spatial](api/#module-cucim.core.operations.spatial)
* [`image_flip()`](api/#cucim.core.operations.spatial.image_flip)
* [`image_rotate_90()`](api/#cucim.core.operations.spatial.image_rotate_90)
* [`rand_image_flip()`](api/#cucim.core.operations.spatial.rand_image_flip)
* [`rand_image_rotate_90()`](api/#cucim.core.operations.spatial.rand_image_rotate_90)
* [skimage Submodules](api/#skimage-submodules)
* [color](api/#id13)
* [`combine_stains()`](api/#cucim.skimage.color.combine_stains)
* [`convert_colorspace()`](api/#cucim.skimage.color.convert_colorspace)
* [`deltaE_cie76()`](api/#cucim.skimage.color.deltaE_cie76)
* [`deltaE_ciede2000()`](api/#cucim.skimage.color.deltaE_ciede2000)
* [`deltaE_ciede94()`](api/#cucim.skimage.color.deltaE_ciede94)
* [`deltaE_cmc()`](api/#cucim.skimage.color.deltaE_cmc)
* [`gray2rgb()`](api/#cucim.skimage.color.gray2rgb)
* [`gray2rgba()`](api/#cucim.skimage.color.gray2rgba)
* [`hed2rgb()`](api/#cucim.skimage.color.hed2rgb)
* [`hsv2rgb()`](api/#cucim.skimage.color.hsv2rgb)
* [`lab2lch()`](api/#cucim.skimage.color.lab2lch)
* [`lab2rgb()`](api/#cucim.skimage.color.lab2rgb)
* [`lab2xyz()`](api/#cucim.skimage.color.lab2xyz)
* [`label2rgb()`](api/#cucim.skimage.color.label2rgb)
* [`lch2lab()`](api/#cucim.skimage.color.lch2lab)
* [`luv2rgb()`](api/#cucim.skimage.color.luv2rgb)
* [`luv2xyz()`](api/#cucim.skimage.color.luv2xyz)
* [`rgb2gray()`](api/#cucim.skimage.color.rgb2gray)
* [`rgb2hed()`](api/#cucim.skimage.color.rgb2hed)
* [`rgb2hsv()`](api/#cucim.skimage.color.rgb2hsv)
* [`rgb2lab()`](api/#cucim.skimage.color.rgb2lab)
* [`rgb2luv()`](api/#cucim.skimage.color.rgb2luv)
* [`rgb2rgbcie()`](api/#cucim.skimage.color.rgb2rgbcie)
* [`rgb2xyz()`](api/#cucim.skimage.color.rgb2xyz)
* [`rgb2ycbcr()`](api/#cucim.skimage.color.rgb2ycbcr)
* [`rgb2ydbdr()`](api/#cucim.skimage.color.rgb2ydbdr)
* [`rgb2yiq()`](api/#cucim.skimage.color.rgb2yiq)
* [`rgb2ypbpr()`](api/#cucim.skimage.color.rgb2ypbpr)
* [`rgb2yuv()`](api/#cucim.skimage.color.rgb2yuv)
* [`rgba2rgb()`](api/#cucim.skimage.color.rgba2rgb)
* [`rgbcie2rgb()`](api/#cucim.skimage.color.rgbcie2rgb)
* [`separate_stains()`](api/#cucim.skimage.color.separate_stains)
* [`xyz2lab()`](api/#cucim.skimage.color.xyz2lab)
* [`xyz2luv()`](api/#cucim.skimage.color.xyz2luv)
* [`xyz2rgb()`](api/#cucim.skimage.color.xyz2rgb)
* [`xyz_tristimulus_values()`](api/#cucim.skimage.color.xyz_tristimulus_values)
* [`ycbcr2rgb()`](api/#cucim.skimage.color.ycbcr2rgb)
* [`ydbdr2rgb()`](api/#cucim.skimage.color.ydbdr2rgb)
* [`yiq2rgb()`](api/#cucim.skimage.color.yiq2rgb)
* [`ypbpr2rgb()`](api/#cucim.skimage.color.ypbpr2rgb)
* [`yuv2rgb()`](api/#cucim.skimage.color.yuv2rgb)
* [data](api/#module-cucim.skimage.data)
* [`binary_blobs()`](api/#cucim.skimage.data.binary_blobs)
* [exposure](api/#module-cucim.skimage.exposure)
* [`adjust_gamma()`](api/#cucim.skimage.exposure.adjust_gamma)
* [`adjust_log()`](api/#cucim.skimage.exposure.adjust_log)
* [`adjust_sigmoid()`](api/#cucim.skimage.exposure.adjust_sigmoid)
* [`cumulative_distribution()`](api/#cucim.skimage.exposure.cumulative_distribution)
* [`equalize_adapthist()`](api/#cucim.skimage.exposure.equalize_adapthist)
* [`equalize_hist()`](api/#cucim.skimage.exposure.equalize_hist)
* [`histogram()`](api/#cucim.skimage.exposure.histogram)
* [`is_low_contrast()`](api/#cucim.skimage.exposure.is_low_contrast)
* [`match_histograms()`](api/#cucim.skimage.exposure.match_histograms)
* [`rescale_intensity()`](api/#cucim.skimage.exposure.rescale_intensity)
* [feature](api/#module-cucim.skimage.feature)
* [`blob_dog()`](api/#cucim.skimage.feature.blob_dog)
* [`blob_doh()`](api/#cucim.skimage.feature.blob_doh)
* [`blob_log()`](api/#cucim.skimage.feature.blob_log)
* [`canny()`](api/#cucim.skimage.feature.canny)
* [`corner_foerstner()`](api/#cucim.skimage.feature.corner_foerstner)
* [`corner_harris()`](api/#cucim.skimage.feature.corner_harris)
* [`corner_kitchen_rosenfeld()`](api/#cucim.skimage.feature.corner_kitchen_rosenfeld)
* [`corner_peaks()`](api/#cucim.skimage.feature.corner_peaks)
* [`corner_shi_tomasi()`](api/#cucim.skimage.feature.corner_shi_tomasi)
* [`daisy()`](api/#cucim.skimage.feature.daisy)
* [`hessian_matrix()`](api/#cucim.skimage.feature.hessian_matrix)
* [`hessian_matrix_det()`](api/#cucim.skimage.feature.hessian_matrix_det)
* [`hessian_matrix_eigvals()`](api/#cucim.skimage.feature.hessian_matrix_eigvals)
* [`match_descriptors()`](api/#cucim.skimage.feature.match_descriptors)
* [`match_template()`](api/#cucim.skimage.feature.match_template)
* [`multiscale_basic_features()`](api/#cucim.skimage.feature.multiscale_basic_features)
* [`peak_local_max()`](api/#cucim.skimage.feature.peak_local_max)
* [`shape_index()`](api/#cucim.skimage.feature.shape_index)
* [`structure_tensor()`](api/#cucim.skimage.feature.structure_tensor)
* [`structure_tensor_eigenvalues()`](api/#cucim.skimage.feature.structure_tensor_eigenvalues)
* [filters](api/#module-cucim.skimage.filters)
* [`LPIFilter2D`](api/#cucim.skimage.filters.LPIFilter2D)
* [`apply_hysteresis_threshold()`](api/#cucim.skimage.filters.apply_hysteresis_threshold)
* [`butterworth()`](api/#cucim.skimage.filters.butterworth)
* [`correlate_sparse()`](api/#cucim.skimage.filters.correlate_sparse)
* [`difference_of_gaussians()`](api/#cucim.skimage.filters.difference_of_gaussians)
* [`farid()`](api/#cucim.skimage.filters.farid)
* [`farid_h()`](api/#cucim.skimage.filters.farid_h)
* [`farid_v()`](api/#cucim.skimage.filters.farid_v)
* [`filter_forward()`](api/#cucim.skimage.filters.filter_forward)
* [`filter_inverse()`](api/#cucim.skimage.filters.filter_inverse)
* [`frangi()`](api/#cucim.skimage.filters.frangi)
* [`gabor()`](api/#cucim.skimage.filters.gabor)
* [`gabor_kernel()`](api/#cucim.skimage.filters.gabor_kernel)
* [`gaussian()`](api/#cucim.skimage.filters.gaussian)
* [`hessian()`](api/#cucim.skimage.filters.hessian)
* [`laplace()`](api/#cucim.skimage.filters.laplace)
* [`median()`](api/#cucim.skimage.filters.median)
* [`meijering()`](api/#cucim.skimage.filters.meijering)
* [`prewitt()`](api/#cucim.skimage.filters.prewitt)
* [`prewitt_h()`](api/#cucim.skimage.filters.prewitt_h)
* [`prewitt_v()`](api/#cucim.skimage.filters.prewitt_v)
* [`rank_order()`](api/#cucim.skimage.filters.rank_order)
* [`roberts()`](api/#cucim.skimage.filters.roberts)
* [`roberts_neg_diag()`](api/#cucim.skimage.filters.roberts_neg_diag)
* [`roberts_pos_diag()`](api/#cucim.skimage.filters.roberts_pos_diag)
* [`sato()`](api/#cucim.skimage.filters.sato)
* [`scharr()`](api/#cucim.skimage.filters.scharr)
* [`scharr_h()`](api/#cucim.skimage.filters.scharr_h)
* [`scharr_v()`](api/#cucim.skimage.filters.scharr_v)
* [`sobel()`](api/#cucim.skimage.filters.sobel)
* [`sobel_h()`](api/#cucim.skimage.filters.sobel_h)
* [`sobel_v()`](api/#cucim.skimage.filters.sobel_v)
* [`threshold_isodata()`](api/#cucim.skimage.filters.threshold_isodata)
* [`threshold_li()`](api/#cucim.skimage.filters.threshold_li)
* [`threshold_local()`](api/#cucim.skimage.filters.threshold_local)
* [`threshold_mean()`](api/#cucim.skimage.filters.threshold_mean)
* [`threshold_minimum()`](api/#cucim.skimage.filters.threshold_minimum)
* [`threshold_multiotsu()`](api/#cucim.skimage.filters.threshold_multiotsu)
* [`threshold_niblack()`](api/#cucim.skimage.filters.threshold_niblack)
* [`threshold_otsu()`](api/#cucim.skimage.filters.threshold_otsu)
* [`threshold_sauvola()`](api/#cucim.skimage.filters.threshold_sauvola)
* [`threshold_triangle()`](api/#cucim.skimage.filters.threshold_triangle)
* [`threshold_yen()`](api/#cucim.skimage.filters.threshold_yen)
* [`try_all_threshold()`](api/#cucim.skimage.filters.try_all_threshold)
* [`unsharp_mask()`](api/#cucim.skimage.filters.unsharp_mask)
* [`wiener()`](api/#cucim.skimage.filters.wiener)
* [`window()`](api/#cucim.skimage.filters.window)
* [measure](api/#module-cucim.skimage.measure)
* [`approximate_polygon()`](api/#cucim.skimage.measure.approximate_polygon)
* [`block_reduce()`](api/#cucim.skimage.measure.block_reduce)
* [`blur_effect()`](api/#cucim.skimage.measure.blur_effect)
* [`centroid()`](api/#cucim.skimage.measure.centroid)
* [`euler_number()`](api/#cucim.skimage.measure.euler_number)
* [`inertia_tensor()`](api/#cucim.skimage.measure.inertia_tensor)
* [`inertia_tensor_eigvals()`](api/#cucim.skimage.measure.inertia_tensor_eigvals)
* [`intersection_coeff()`](api/#cucim.skimage.measure.intersection_coeff)
* [`label()`](api/#cucim.skimage.measure.label)
* [`manders_coloc_coeff()`](api/#cucim.skimage.measure.manders_coloc_coeff)
* [`manders_overlap_coeff()`](api/#cucim.skimage.measure.manders_overlap_coeff)
* [`moments()`](api/#cucim.skimage.measure.moments)
* [`moments_central()`](api/#cucim.skimage.measure.moments_central)
* [`moments_coords()`](api/#cucim.skimage.measure.moments_coords)
* [`moments_coords_central()`](api/#cucim.skimage.measure.moments_coords_central)
* [`moments_hu()`](api/#cucim.skimage.measure.moments_hu)
* [`moments_normalized()`](api/#cucim.skimage.measure.moments_normalized)
* [`pearson_corr_coeff()`](api/#cucim.skimage.measure.pearson_corr_coeff)
* [`perimeter()`](api/#cucim.skimage.measure.perimeter)
* [`perimeter_crofton()`](api/#cucim.skimage.measure.perimeter_crofton)
* [`profile_line()`](api/#cucim.skimage.measure.profile_line)
* [`regionprops()`](api/#cucim.skimage.measure.regionprops)
* [`regionprops_table()`](api/#cucim.skimage.measure.regionprops_table)
* [`shannon_entropy()`](api/#cucim.skimage.measure.shannon_entropy)
* [`subdivide_polygon()`](api/#cucim.skimage.measure.subdivide_polygon)
* [metrics](api/#module-cucim.skimage.metrics)
* [`adapted_rand_error()`](api/#cucim.skimage.metrics.adapted_rand_error)
* [`contingency_table()`](api/#cucim.skimage.metrics.contingency_table)
* [`mean_squared_error()`](api/#cucim.skimage.metrics.mean_squared_error)
* [`normalized_mutual_information()`](api/#cucim.skimage.metrics.normalized_mutual_information)
* [`normalized_root_mse()`](api/#cucim.skimage.metrics.normalized_root_mse)
* [`peak_signal_noise_ratio()`](api/#cucim.skimage.metrics.peak_signal_noise_ratio)
* [`structural_similarity()`](api/#cucim.skimage.metrics.structural_similarity)
* [`variation_of_information()`](api/#cucim.skimage.metrics.variation_of_information)
* [morphology](api/#id263)
* [`ball()`](api/#cucim.skimage.morphology.ball)
* [`binary_closing()`](api/#cucim.skimage.morphology.binary_closing)
* [`binary_dilation()`](api/#cucim.skimage.morphology.binary_dilation)
* [`binary_erosion()`](api/#cucim.skimage.morphology.binary_erosion)
* [`binary_opening()`](api/#cucim.skimage.morphology.binary_opening)
* [`black_tophat()`](api/#cucim.skimage.morphology.black_tophat)
* [`closing()`](api/#cucim.skimage.morphology.closing)
* [`cube()`](api/#cucim.skimage.morphology.cube)
* [`diamond()`](api/#cucim.skimage.morphology.diamond)
* [`dilation()`](api/#cucim.skimage.morphology.dilation)
* [`disk()`](api/#cucim.skimage.morphology.disk)
* [`erosion()`](api/#cucim.skimage.morphology.erosion)
* [`isotropic_closing()`](api/#cucim.skimage.morphology.isotropic_closing)
* [`isotropic_dilation()`](api/#cucim.skimage.morphology.isotropic_dilation)
* [`isotropic_erosion()`](api/#cucim.skimage.morphology.isotropic_erosion)
* [`isotropic_opening()`](api/#cucim.skimage.morphology.isotropic_opening)
* [`medial_axis()`](api/#cucim.skimage.morphology.medial_axis)
* [`octagon()`](api/#cucim.skimage.morphology.octagon)
* [`octahedron()`](api/#cucim.skimage.morphology.octahedron)
* [`opening()`](api/#cucim.skimage.morphology.opening)
* [`reconstruction()`](api/#cucim.skimage.morphology.reconstruction)
* [`rectangle()`](api/#cucim.skimage.morphology.rectangle)
* [`remove_small_holes()`](api/#cucim.skimage.morphology.remove_small_holes)
* [`remove_small_objects()`](api/#cucim.skimage.morphology.remove_small_objects)
* [`square()`](api/#cucim.skimage.morphology.square)
* [`star()`](api/#cucim.skimage.morphology.star)
* [`thin()`](api/#cucim.skimage.morphology.thin)
* [`white_tophat()`](api/#cucim.skimage.morphology.white_tophat)
* [registration](api/#module-cucim.skimage.registration)
* [`optical_flow_ilk()`](api/#cucim.skimage.registration.optical_flow_ilk)
* [`optical_flow_tvl1()`](api/#cucim.skimage.registration.optical_flow_tvl1)
* [`phase_cross_correlation()`](api/#cucim.skimage.registration.phase_cross_correlation)
* [restoration](api/#module-cucim.skimage.restoration)
* [`calibrate_denoiser()`](api/#cucim.skimage.restoration.calibrate_denoiser)
* [`denoise_invariant()`](api/#cucim.skimage.restoration.denoise_invariant)
* [`denoise_tv_chambolle()`](api/#cucim.skimage.restoration.denoise_tv_chambolle)
* [`richardson_lucy()`](api/#cucim.skimage.restoration.richardson_lucy)
* [`unsupervised_wiener()`](api/#cucim.skimage.restoration.unsupervised_wiener)
* [`wiener()`](api/#cucim.skimage.restoration.wiener)
* [segmentation](api/#module-cucim.skimage.segmentation)
* [`chan_vese()`](api/#cucim.skimage.segmentation.chan_vese)
* [`checkerboard_level_set()`](api/#cucim.skimage.segmentation.checkerboard_level_set)
* [`clear_border()`](api/#cucim.skimage.segmentation.clear_border)
* [`disk_level_set()`](api/#cucim.skimage.segmentation.disk_level_set)
* [`expand_labels()`](api/#cucim.skimage.segmentation.expand_labels)
* [`find_boundaries()`](api/#cucim.skimage.segmentation.find_boundaries)
* [`inverse_gaussian_gradient()`](api/#cucim.skimage.segmentation.inverse_gaussian_gradient)
* [`join_segmentations()`](api/#cucim.skimage.segmentation.join_segmentations)
* [`mark_boundaries()`](api/#cucim.skimage.segmentation.mark_boundaries)
* [`morphological_chan_vese()`](api/#cucim.skimage.segmentation.morphological_chan_vese)
* [`morphological_geodesic_active_contour()`](api/#cucim.skimage.segmentation.morphological_geodesic_active_contour)
* [`random_walker()`](api/#cucim.skimage.segmentation.random_walker)
* [`relabel_sequential()`](api/#cucim.skimage.segmentation.relabel_sequential)
* [transform](api/#module-cucim.skimage.transform)
* [`AffineTransform`](api/#cucim.skimage.transform.AffineTransform)
* [`EssentialMatrixTransform`](api/#cucim.skimage.transform.EssentialMatrixTransform)
* [`EuclideanTransform`](api/#cucim.skimage.transform.EuclideanTransform)
* [`FundamentalMatrixTransform`](api/#cucim.skimage.transform.FundamentalMatrixTransform)
* [`PiecewiseAffineTransform`](api/#cucim.skimage.transform.PiecewiseAffineTransform)
* [`PolynomialTransform`](api/#cucim.skimage.transform.PolynomialTransform)
* [`ProjectiveTransform`](api/#cucim.skimage.transform.ProjectiveTransform)
* [`SimilarityTransform`](api/#cucim.skimage.transform.SimilarityTransform)
* [`downscale_local_mean()`](api/#cucim.skimage.transform.downscale_local_mean)
* [`estimate_transform()`](api/#cucim.skimage.transform.estimate_transform)
* [`integral_image()`](api/#cucim.skimage.transform.integral_image)
* [`integrate()`](api/#cucim.skimage.transform.integrate)
* [`matrix_transform()`](api/#cucim.skimage.transform.matrix_transform)
* [`pyramid_expand()`](api/#cucim.skimage.transform.pyramid_expand)
* [`pyramid_gaussian()`](api/#cucim.skimage.transform.pyramid_gaussian)
* [`pyramid_laplacian()`](api/#cucim.skimage.transform.pyramid_laplacian)
* [`pyramid_reduce()`](api/#cucim.skimage.transform.pyramid_reduce)
* [`rescale()`](api/#cucim.skimage.transform.rescale)
* [`resize()`](api/#cucim.skimage.transform.resize)
* [`resize_local_mean()`](api/#cucim.skimage.transform.resize_local_mean)
* [`rotate()`](api/#cucim.skimage.transform.rotate)
* [`swirl()`](api/#cucim.skimage.transform.swirl)
* [`warp()`](api/#cucim.skimage.transform.warp)
* [`warp_coords()`](api/#cucim.skimage.transform.warp_coords)
* [`warp_polar()`](api/#cucim.skimage.transform.warp_polar)
* [util](api/#module-cucim.skimage.util)
* [`crop()`](api/#cucim.skimage.util.crop)
* [`dtype_limits()`](api/#cucim.skimage.util.dtype_limits)
* [`img_as_bool()`](api/#cucim.skimage.util.img_as_bool)
* [`img_as_float()`](api/#cucim.skimage.util.img_as_float)
* [`img_as_float32()`](api/#cucim.skimage.util.img_as_float32)
* [`img_as_float64()`](api/#cucim.skimage.util.img_as_float64)
* [`img_as_int()`](api/#cucim.skimage.util.img_as_int)
* [`img_as_ubyte()`](api/#cucim.skimage.util.img_as_ubyte)
* [`img_as_uint()`](api/#cucim.skimage.util.img_as_uint)
* [`invert()`](api/#cucim.skimage.util.invert)
* [`map_array()`](api/#cucim.skimage.util.map_array)
* [`random_noise()`](api/#cucim.skimage.util.random_noise)
* [`view_as_blocks()`](api/#cucim.skimage.util.view_as_blocks)
* [`view_as_windows()`](api/#cucim.skimage.util.view_as_windows)
* [Submodule Contents](api/#submodule-contents)
* [skimage](api/#module-cucim.skimage)
* [Subpackages](api/#subpackages)
* [Utility Functions](api/#utility-functions)
Indices and tables[#](#indices-and-tables "Permalink to this heading")
=======================================================================
* [Index](genindex/)
* [Module Index](py-modindex/)
* [Search Page](search/)
On this page
[Show Source](_sources/index.rst.txt)
---
# Welcome to KvikIO’s Python documentation! — kvikio 24.12.00 documentation
* [](#)
* Welcome to KvikIO’s Python documentation!
* [View page source](_sources/index.rst.txt)
* * *
Welcome to KvikIO’s Python documentation
===============================================================================================================
KvikIO is a Python and C++ library for high performance file IO. It provides C++ and Python bindings to [cuFile](https://docs.nvidia.com/gpudirect-storage/api-reference-guide/index.html)
, which enables [GPUDirect Storage](https://developer.nvidia.com/blog/gpudirect-storage/)
(GDS). KvikIO also works efficiently when GDS isn’t available and can read/write both host and device data seamlessly.
KvikIO is a part of the [RAPIDS](https://rapids.ai/)
suite of open-source software libraries for GPU-accelerated data science.
Note
This is the documentation for the Python library. For the C++ documentation, see under [libkvikio](https://docs.rapids.ai/api/libkvikio/nightly/)
.
Contents[](#contents "Link to this heading")
----------------------------------------------
Getting Started
* [Installation](install/)
* [Quickstart](quickstart/)
* [Zarr](zarr/)
* [Remote File](remote_file/)
* [Runtime Settings](runtime_settings/)
* [API](api/)
* [Index](genindex/)
---
# RAPIDS RAFT: Reusable Accelerated Functions and Tools for Vector Search and More — raft 25.04.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
raft
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
nightly (25.04)
[nightly (25.04)](/api/raft/nightly)
[stable (25.02)](/api/raft/stable)
[legacy (24.12)](/api/raft/legacy)
* [GitHub](https://github.com/rapidsai/raft "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
Attention
The vector search and clustering algorithms in RAFT are being migrated to a new library dedicated to vector search called [cuVS](https://github.com/rapidsai/cuvs)
. We will continue to support the vector search algorithms in RAFT during this move, but will no longer update them after the RAPIDS 24.06 (June) release. We plan to complete the migration by RAPIDS 24.10 (October) release and they will be removed from RAFT altogether in the 24.12 (December) release.
RAPIDS RAFT: Reusable Accelerated Functions and Tools for Vector Search and More[#](#rapids-raft-reusable-accelerated-functions-and-tools-for-vector-search-and-more "Link to this heading")
=============================================================================================================================================================================================
[](_images/raft-tech-stack-vss.png)
Useful Resources[#](#useful-resources "Link to this heading")
--------------------------------------------------------------
* [RAPIDS Community](https://rapids.ai/community.html)
: Get help, contribute, and collaborate.
* [GitHub repository](https://github.com/rapidsai/raft)
: Download the RAFT source code.
* [Issue tracker](https://github.com/rapidsai/raft/issues)
: Report issues or request features.
What is RAFT?[#](#what-is-raft "Link to this heading")
-------------------------------------------------------
RAFT contains fundamental widely-used algorithms and primitives for machine learning and information retrieval. The algorithms are CUDA-accelerated and form building blocks for more easily writing high performance applications.
By taking a primitives-based approach to algorithm development, RAFT
* accelerates algorithm construction time
* reduces the maintenance burden by maximizing reuse across projects, and
* centralizes core reusable computations, allowing future optimizations to benefit all algorithms that use them.
While not exhaustive, the following general categories help summarize the accelerated building blocks that RAFT contains:
| Category | Examples |
| --- | --- |
| Data Formats | sparse & dense, conversions, data generation |
| Dense Operations | linear algebra, matrix and vector operations, slicing, norms, factorization, least squares, svd & eigenvalue problems |
| Sparse Operations | linear algebra, eigenvalue problems, slicing, norms, reductions, factorization, symmetrization, components & labeling |
| Solvers | combinatorial optimization, iterative solvers |
| Statistics | sampling, moments and summary statistics, metrics |
| Tools & Utilities | common utilities for developing CUDA applications, multi-node multi-gpu infrastructure |
Contents:
* [Quick Start](quick_start/)
* [Installation](build/)
* [C++ API](cpp_api/)
* [Python API](pylibraft_api/)
* [RAFT Dask API](raft_dask_api/)
* [Using RAFT Comms](using_raft_comms/)
* [Developer Guide](developer_guide/)
* [Contributing](contributing/)
Indices and tables[#](#indices-and-tables "Link to this heading")
==================================================================
* [Index](genindex/)
* [Module Index](py-modindex/)
* [Search Page](search/)
On this page
### This Page
* [Show Source](_sources/index.rst.txt)
---
# RAPIDS RAFT: Reusable Accelerated Functions and Tools for Vector Search and More — raft 24.12.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
raft
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
legacy (24.12)
[nightly (25.04)](/api/raft/nightly)
[stable (25.02)](/api/raft/stable)
[legacy (24.12)](/api/raft/legacy)
* [GitHub](https://github.com/rapidsai/raft "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
Attention
The vector search and clustering algorithms in RAFT are being migrated to a new library dedicated to vector search called [cuVS](https://github.com/rapidsai/cuvs)
. We will continue to support the vector search algorithms in RAFT during this move, but will no longer update them after the RAPIDS 24.06 (June) release. We plan to complete the migration by RAPIDS 24.10 (October) release and they will be removed from RAFT altogether in the 24.12 (December) release.
RAPIDS RAFT: Reusable Accelerated Functions and Tools for Vector Search and More[#](#rapids-raft-reusable-accelerated-functions-and-tools-for-vector-search-and-more "Permalink to this heading")
==================================================================================================================================================================================================
[](_images/raft-tech-stack-vss.png)
Useful Resources[#](#useful-resources "Permalink to this heading")
-------------------------------------------------------------------
* [RAPIDS Community](https://rapids.ai/community.html)
: Get help, contribute, and collaborate.
* [GitHub repository](https://github.com/rapidsai/raft)
: Download the RAFT source code.
* [Issue tracker](https://github.com/rapidsai/raft/issues)
: Report issues or request features.
What is RAFT?[#](#what-is-raft "Permalink to this heading")
------------------------------------------------------------
RAFT contains fundamental widely-used algorithms and primitives for machine learning and information retrieval. The algorithms are CUDA-accelerated and form building blocks for more easily writing high performance applications.
By taking a primitives-based approach to algorithm development, RAFT
* accelerates algorithm construction time
* reduces the maintenance burden by maximizing reuse across projects, and
* centralizes core reusable computations, allowing future optimizations to benefit all algorithms that use them.
While not exhaustive, the following general categories help summarize the accelerated building blocks that RAFT contains:
| Category | Examples |
| --- | --- |
| Data Formats | sparse & dense, conversions, data generation |
| Dense Operations | linear algebra, matrix and vector operations, slicing, norms, factorization, least squares, svd & eigenvalue problems |
| Sparse Operations | linear algebra, eigenvalue problems, slicing, norms, reductions, factorization, symmetrization, components & labeling |
| Solvers | combinatorial optimization, iterative solvers |
| Statistics | sampling, moments and summary statistics, metrics |
| Tools & Utilities | common utilities for developing CUDA applications, multi-node multi-gpu infrastructure |
Contents:
* [Quick Start](quick_start/)
* [Installation](build/)
* [C++ API](cpp_api/)
* [Python API](pylibraft_api/)
* [RAFT Dask API](raft_dask_api/)
* [Using RAFT Comms](using_raft_comms/)
* [Developer Guide](developer_guide/)
* [Contributing](contributing/)
Indices and tables[#](#indices-and-tables "Permalink to this heading")
=======================================================================
* [Index](genindex/)
* [Module Index](py-modindex/)
* [Search Page](search/)
On this page
[Show Source](_sources/index.rst.txt)
---
# Dask-CUDA — dask-cuda 25.04.00a24 documentation
* [](#)
* Dask-CUDA
* [View page source](_sources/index.rst.txt)
* * *
Dask-CUDA[](#dask-cuda "Link to this heading")
================================================
Dask-CUDA is a library extending [Dask.distributed](https://distributed.dask.org/en/latest/)
’s single-machine [LocalCluster](https://docs.dask.org/en/latest/setup/single-distributed.html#localcluster)
and [Worker](https://distributed.dask.org/en/latest/worker.html)
for use in distributed GPU workloads. It is a part of the [RAPIDS](https://rapids.ai/)
suite of open-source software libraries for GPU-accelerated data science.
Motivation[](#motivation "Link to this heading")
--------------------------------------------------
While Distributed can be used to leverage GPU workloads through libraries such as [cuDF](https://docs.rapids.ai/api/cudf/stable/)
, [CuPy](https://cupy.dev/)
, and [Numba](https://numba.pydata.org/)
, Dask-CUDA offers several unique features unavailable to Distributed:
* **Automatic instantiation of per-GPU workers** – Using Dask-CUDA’s LocalCUDACluster or `dask cuda worker` CLI will automatically launch one worker for each GPU available on the executing node, avoiding the need to explicitly select GPUs.
* **Automatic setting of CPU affinity** – The setting of CPU affinity for each GPU is done automatically, preventing memory transfers from taking suboptimal paths.
* **Automatic selection of InfiniBand devices** – When UCX communication is enabled over InfiniBand, Dask-CUDA automatically selects the optimal InfiniBand device for each GPU (see [UCX Integration](ucx)
for instructions on configuring UCX communication).
* **Memory spilling from GPU** – For memory-intensive workloads, Dask-CUDA supports spilling from GPU to host memory when a GPU reaches the default or user-specified memory utilization limit.
* **Allocation of GPU memory** – when using UCX communication, per-GPU memory pools can be allocated using [RAPIDS Memory Manager](https://github.com/rapidsai/rmm)
to circumvent the costly memory buffer mappings that would be required otherwise.
Contents[](#contents "Link to this heading")
----------------------------------------------
Getting Started
* [Installation](install/)
* [Quickstart](quickstart/)
* [Troubleshooting](troubleshooting/)
* [API](api/)
Additional Features
* [UCX Integration](ucx/)
* [Explicit-comms](explicit_comms/)
* [Spilling from device](spilling/)
Examples
* [Best Practices](examples/best-practices/)
* [Controlling number of workers](examples/worker_count/)
* [Enabling UCX communication](examples/ucx/)
---
# Dask-CUDA — dask-cuda 24.12.00a16 documentation
* [](#)
* Dask-CUDA
* [View page source](_sources/index.rst.txt)
* * *
Dask-CUDA[](#dask-cuda "Link to this heading")
================================================
Dask-CUDA is a library extending [Dask.distributed](https://distributed.dask.org/en/latest/)
’s single-machine [LocalCluster](https://docs.dask.org/en/latest/setup/single-distributed.html#localcluster)
and [Worker](https://distributed.dask.org/en/latest/worker.html)
for use in distributed GPU workloads. It is a part of the [RAPIDS](https://rapids.ai/)
suite of open-source software libraries for GPU-accelerated data science.
Motivation[](#motivation "Link to this heading")
--------------------------------------------------
While Distributed can be used to leverage GPU workloads through libraries such as [cuDF](https://docs.rapids.ai/api/cudf/stable/)
, [CuPy](https://cupy.dev/)
, and [Numba](https://numba.pydata.org/)
, Dask-CUDA offers several unique features unavailable to Distributed:
* **Automatic instantiation of per-GPU workers** – Using Dask-CUDA’s LocalCUDACluster or `dask cuda worker` CLI will automatically launch one worker for each GPU available on the executing node, avoiding the need to explicitly select GPUs.
* **Automatic setting of CPU affinity** – The setting of CPU affinity for each GPU is done automatically, preventing memory transfers from taking suboptimal paths.
* **Automatic selection of InfiniBand devices** – When UCX communication is enabled over InfiniBand, Dask-CUDA automatically selects the optimal InfiniBand device for each GPU (see [UCX Integration](ucx)
for instructions on configuring UCX communication).
* **Memory spilling from GPU** – For memory-intensive workloads, Dask-CUDA supports spilling from GPU to host memory when a GPU reaches the default or user-specified memory utilization limit.
* **Allocation of GPU memory** – when using UCX communication, per-GPU memory pools can be allocated using [RAPIDS Memory Manager](https://github.com/rapidsai/rmm)
to circumvent the costly memory buffer mappings that would be required otherwise.
Contents[](#contents "Link to this heading")
----------------------------------------------
Getting Started
* [Installation](install/)
* [Quickstart](quickstart/)
* [Troubleshooting](troubleshooting/)
* [API](api/)
Additional Features
* [UCX Integration](ucx/)
* [Explicit-comms](explicit_comms/)
* [Spilling from device](spilling/)
Examples
* [Best Practices](examples/best-practices/)
* [Controlling number of workers](examples/worker_count/)
* [Enabling UCX communication](examples/ucx/)
---
# Welcome to rmm’s documentation! — rmm 25.04.00 documentation
* [](#)
* Welcome to rmm’s documentation!
* [View page source](_sources/index.rst.txt)
* * *
Welcome to rmm’s documentation
===========================================================================================
Contents:
* [Python](python/)
* [User Guide](guide/)
* [API Reference](python_api/)
* [C++](cpp/)
* [API Reference](cpp_api/)
Indices and tables[](#indices-and-tables "Link to this heading")
==================================================================
* [Index](genindex/)
* [Module Index](py-modindex/)
* [Search Page](search/)
---
# libcudf: libcudf
[Home](/api)
libcudf
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/libcudf/nightly/namespacecudf/)
[stable (25.02)](/api/libcudf/stable/namespacecudf/)
[legacy (24.12)](/api/libcudf/legacy/namespacecudf/)
libcudf is a C++ GPU DataFrame library for loading, joining, aggregating, filtering, and otherwise manipulating data. A GPU DataFrame is a column-oriented tabular data structure, so libcudf provides two core data structures: [cudf::column](/api/libcudf/stable/classcudf_1_1column "A container of nullable device data as a column of elements.")
, and [cudf::table](/api/libcudf/stable/classcudf_1_1table "A set of cudf::column\")
.
---
# Welcome to rmm’s documentation! — rmm 24.12.00 documentation
* [](#)
* Welcome to rmm’s documentation!
* [View page source](_sources/index.rst.txt)
* * *
Welcome to rmm’s documentation
================================================================================================
Contents:
* [Python](python/)
* [User Guide](guide/)
* [API Reference](python_api/)
* [C++](cpp/)
* [API Reference](cpp_api/)
Indices and tables[](#indices-and-tables "Permalink to this heading")
=======================================================================
* [Index](genindex/)
* [Module Index](py-modindex/)
* [Search Page](search/)
---
# libcudf: libcudf
[Home](/api)
libcudf
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
legacy (24.12)
[nightly (25.04)](/api/libcudf/nightly/namespacecudf/)
[stable (25.02)](/api/libcudf/stable/namespacecudf/)
[legacy (24.12)](/api/libcudf/legacy/namespacecudf/)
libcudf is a C++ GPU DataFrame library for loading, joining, aggregating, filtering, and otherwise manipulating data. A GPU DataFrame is a column-oriented tabular data structure, so libcudf provides two core data structures: [cudf::column](/api/libcudf/legacy/classcudf_1_1column "A container of nullable device data as a column of elements.")
, and [cudf::table](/api/libcudf/legacy/classcudf_1_1table "A set of cudf::column\")
.
---
# libcuspatial: libcuspatial
[Home](/api)
libcuspatial
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
nightly (25.04)
[nightly (25.04)](/api/libcuspatial/nightly)
[stable (25.02)](/api/libcuspatial/stable)
[legacy (24.12)](/api/libcuspatial/legacy)
Loading...
Searching...
No Matches
libcuspatial is a GPU-accelerated C++ library for spatial data analysis including distance and trajectory computations, spatial data indexing and spatial join operations. libcuspatial is the high-performance backend for the cuSpatial Python library.
libcuspatial has two interfaces. The generic header-only C++ API represents data as arrays of structures (e.g. 2D points). The header-only API uses iterators for input and output, and is similar in style to the C++ Standard Template Library (STL) and Thrust. All cuSpatial algorithms are implemented in this API.
The libcuspatial "column-based API" is a C++ API based on data types from libcudf, [the CUDA Dataframe library C++ API](https://docs.rapids.ai/api/libcudf/nightly/)
. The column-based API represents spatial data as cuDF tables of type-erased columns, and layers on top of the header-only API.
Useful Links
------------
* [cuSpatial Github Repository](https://github.com/rapidsai/cuspatial)
* [cuSpatial C++ Developer Guide](/api/libcuspatial/nightly/developer_guide)
* [cuSpatial Python API Documentation](https://docs.rapids.ai/api/cuspatial/stable/)
* [cuSpatial Python Developer Guide](https://docs.rapids.ai/api/cuspatial/stable/developer_guide/)
\]
* [RAPIDS Home Page](https://rapids.ai)
[](/api/libcuspatial/nightly/doxygen_crawl)
---
# libcuspatial: libcuspatial
[Home](/api)
libcuspatial
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
legacy (24.12)
[nightly (25.04)](/api/libcuspatial/nightly)
[stable (25.02)](/api/libcuspatial/stable)
[legacy (24.12)](/api/libcuspatial/legacy)
Loading...
Searching...
No Matches
libcuspatial is a GPU-accelerated C++ library for spatial data analysis including distance and trajectory computations, spatial data indexing and spatial join operations. libcuspatial is the high-performance backend for the cuSpatial Python library.
libcuspatial has two interfaces. The generic header-only C++ API represents data as arrays of structures (e.g. 2D points). The header-only API uses iterators for input and output, and is similar in style to the C++ Standard Template Library (STL) and Thrust. All cuSpatial algorithms are implemented in this API.
The libcuspatial "column-based API" is a C++ API based on data types from libcudf, [the CUDA Dataframe library C++ API](https://docs.rapids.ai/api/libcudf/nightly/)
. The column-based API represents spatial data as cuDF tables of type-erased columns, and layers on top of the header-only API.
Useful Links
------------
* [cuSpatial Github Repository](https://github.com/rapidsai/cuspatial)
* [cuSpatial C++ Developer Guide](/api/libcuspatial/legacy/developer_guide)
* [cuSpatial Python API Documentation](https://docs.rapids.ai/api/cuspatial/stable/)
* [cuSpatial Python Developer Guide](https://docs.rapids.ai/api/cuspatial/stable/developer_guide/)
\]
* [RAPIDS Home Page](https://rapids.ai)
[](/api/libcuspatial/legacy/doxygen_crawl)
[](/api/libcuspatial/legacy/doxygen_crawl)
---
# libcuproj: libcuproj
[Home](/api)
libcuproj
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
nightly (25.04)
[nightly (25.04)](/api/libcuproj/nightly)
[stable (25.02)](/api/libcuproj/stable)
[legacy (24.12)](/api/libcuproj/legacy)
Loading...
Searching...
No Matches
cuProj is a generic coordinate transformation library that transforms geospatial coordinates from one coordinate reference system (CRS) to another. This includes cartographic projections as well as geodetic transformations. cuProj is implemented in CUDA C++ to run on GPUs to provide the highest performance.
libcuproj is a CUDA C++ library that provides the header-only C++ API for cuProj. It is designed to implement coordinate projections and transforms compatible with the [Proj](https://proj.org/)
library. The C++ API does not match the API of Proj, but it is designed to eventually expand to support many of the same features and transformations that Proj supports.
Currently libcuproj only supports a subset of the Proj transformations. The following transformations are supported:
* WGS84 to/from UTM
There are some basic examples of using the libcuproj C++ API in the [cuProj README](https://github.com/rapidsai/cuspatial/cpp/cuproj/README.md)
.
Useful Links
------------
* [RAPIDS Home Page](https://rapids.ai)
* [cuSpatial Github](https://github.com/rapidsai/cuspatial)
[](/api/libcuproj/nightly/doxygen_crawl)
---
# libcuproj: libcuproj
[Home](/api)
libcuproj
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
legacy (24.12)
[nightly (25.04)](/api/libcuproj/nightly)
[stable (25.02)](/api/libcuproj/stable)
[legacy (24.12)](/api/libcuproj/legacy)
Loading...
Searching...
No Matches
cuProj is a generic coordinate transformation library that transforms geospatial coordinates from one coordinate reference system (CRS) to another. This includes cartographic projections as well as geodetic transformations. cuProj is implemented in CUDA C++ to run on GPUs to provide the highest performance.
libcuproj is a CUDA C++ library that provides the header-only C++ API for cuProj. It is designed to implement coordinate projections and transforms compatible with the [Proj](https://proj.org/)
library. The C++ API does not match the API of Proj, but it is designed to eventually expand to support many of the same features and transformations that Proj supports.
Currently libcuproj only supports a subset of the Proj transformations. The following transformations are supported:
* WGS84 to/from UTM
Example
-------
The C++ API is designed to be easy to use. The following example shows how to transform a point in Sydney, Australia from WGS84 (lat, lon) coordinates to UTM zone 56S (x, y) coordinates.
#include <[cuproj/projection\_factories.cuh](/api/libcuproj/legacy/projection__factories_8cuh)
\>
#include <[cuproj/vec\_2d.hpp](/api/libcuproj/legacy/vec__2d_8hpp)
\>
// Make a projection to convert WGS84 (lat, lon) coordinates to UTM zone 56S (x, y) coordinates
auto proj = [cuproj::make\_projection](/api/libcuproj/legacy/group__projection__factories#ga4aa48ebecd97e1b6dec026087c90a3f6)
\>("EPSG:4326", "EPSG:32756");
[cuproj::vec\_2d](/api/libcuproj/legacy/classcuproj_1_1vec__2d)
sydney{-33.858700, 151.214000}; // Sydney, NSW, Australia
thrust::device\_vector> d\_in{1, sydney};
thrust::device\_vector> d\_out(d\_in.size());
// Convert the coordinates. Works the same with a vector of many coordinates.
proj.transform(d\_in.begin(), d\_in.end(), d\_out.begin(), cuproj::direction::FORWARD);
[cuproj::vec\_2d](/api/libcuproj/legacy/classcuproj_1_1vec__2d)
A generic 2D vector type.
**Definition** [vec\_2d.hpp:42](/api/libcuproj/legacy/vec__2d_8hpp_source#l00042)
[cuproj::make\_projection](/api/libcuproj/legacy/group__projection__factories#ga4aa48ebecd97e1b6dec026087c90a3f6)
cuproj::projection< Coordinate > \* make\_projection(detail::epsg\_code const &src\_epsg, detail::epsg\_code const &dst\_epsg)
Create a projection object from EPSG codes.
**Definition** [projection\_factories.cuh:128](/api/libcuproj/legacy/projection__factories_8cuh_source#l00128)
[projection\_factories.cuh](/api/libcuproj/legacy/projection__factories_8cuh)
[vec\_2d.hpp](/api/libcuproj/legacy/vec__2d_8hpp)
Useful Links
------------
* [RAPIDS Home Page](https://rapids.ai)
[](/api/libcuproj/legacy/doxygen_crawl)
[](/api/libcuproj/legacy/doxygen_crawl)
---
# cuML C++ API: Main Page
[Home](/api)
libcuml
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
nightly (25.04)
[nightly (25.04)](/api/libcuml/nightly)
[stable (25.02)](/api/libcuml/stable)
[legacy (24.12)](/api/libcuml/legacy)
---
# cuML C++ API: Main Page
[Home](/api)
libcuml
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
legacy (24.12)
[nightly (25.04)](/api/libcuml/nightly)
[stable (25.02)](/api/libcuml/stable)
[legacy (24.12)](/api/libcuml/legacy)
---
# libkvikio: Welcome to KvikIO's C++ documentation!
[Home](/api)
libkvikio
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
legacy (24.12)
[nightly (25.04)](/api/libkvikio/nightly)
[stable (25.02)](/api/libkvikio/stable)
[legacy (24.12)](/api/libkvikio/legacy)
KvikIO is a Python and C++ library for high performance file IO. It provides C++ and Python bindings to [cuFile](https://docs.nvidia.com/gpudirect-storage/api-reference-guide/index.html)
which enables [GPUDirect Storage (GDS)](https://developer.nvidia.com/blog/gpudirect-storage/)
. KvikIO also works efficiently when GDS isn't available and can read/write both host and device data seamlessly.
KvikIO C++ is part of the [RAPIDS](https://rapids.ai/)
suite of open-source software libraries for GPU-accelerated data science.
* * *
**Notice** this is the documentation for the C++ library. For the Python documentation, see under [kvikio](https://docs.rapids.ai/api/kvikio/nightly/)
.
* * *
Features
========
* Object Oriented API.
* Exception handling.
* Concurrent reads and writes using an internal thread pool.
* Non-blocking API.
* Handle both host and device IO seamlessly.
Installation
============
For convenience we release Conda packages that makes it easy to include KvikIO in your CMake projects.
Conda/Mamba
-----------
We strongly recommend using [mamba](https://github.com/mamba-org/mamba)
in place of conda, which we will do throughout the documentation.
Install the **stable release** from the `rapidsai` channel with the following:
\# Install in existing environment
mamba install -c rapidsai -c conda-forge libkvikio
\# Create new environment (CUDA 11.8)
mamba create -n libkvikio-env -c rapidsai -c conda-forge cuda-version=11.8 libkvikio
\# Create new environment (CUDA 12.5)
mamba create -n libkvikio-env -c rapidsai -c conda-forge cuda-version=12.5 libkvikio
Install the **nightly release** from the `rapidsai-nightly` channel with the following:
\# Install in existing environment
mamba install -c rapidsai-nightly -c conda-forge libkvikio
\# Create new environment (CUDA 11.8)
mamba create -n libkvikio-env -c rapidsai-nightly -c conda-forge python=3.12 cuda-version=11.8 libkvikio
\# Create new environment (CUDA 12.5)
mamba create -n libkvikio-env -c rapidsai-nightly -c conda-forge python=3.12 cuda-version=12.5 libkvikio
* * *
**Notice** if the nightly install doesn't work, set `channel_priority: flexible` in your `.condarc`.
* * *
Include KvikIO in a CMake project
---------------------------------
An example of how to include KvikIO in an existing CMake project can be found here: [https://github.com/rapidsai/kvikio/blob/HEAD/cpp/examples/downstream/](https://github.com/rapidsai/kvikio/blob/HEAD/cpp/examples/downstream/)
.
Build from source
-----------------
To build the C++ example run:
./build.sh libkvikio
Then run the example:
./examples/basic\_io
Runtime Settings
================
### Compatibility Mode (KVIKIO\_COMPAT\_MODE)
When KvikIO is running in compatibility mode, it doesn't load `libcufile.so`. Instead, reads and writes are done using POSIX. Notice, this is not the same as the compatibility mode in cuFile. It is possible that KvikIO performs I/O in the non-compatibility mode by using the cuFile library, but the cuFile library itself is configured to operate in its own compatibility mode. For more details, refer to [cuFile compatibility mode](https://docs.nvidia.com/gpudirect-storage/api-reference-guide/index.html#cufile-compatibility-mode)
and [cuFile environment variables](https://docs.nvidia.com/gpudirect-storage/troubleshooting-guide/index.html#environment-variables)
The environment variable `KVIKIO_COMPAT_MODE` has three options (case-insensitive):
* `ON` (aliases: `TRUE`, `YES`, `1`): Enable the compatibility mode.
* `OFF` (aliases: `FALSE`, `NO`, `0`): Disable the compatibility mode, and enforce cuFile I/O. GDS will be activated if the system requirements for cuFile are met and cuFile is properly configured. However, if the system is not suited for cuFile, I/O operations under the `OFF` option may error out, crash or hang.
* `AUTO`: Try cuFile I/O first, and fall back to POSIX I/O if the system requirements for cuFile are not met.
Under `AUTO`, KvikIO falls back to the compatibility mode:
* when `libcufile.so` cannot be found.
* when running in Windows Subsystem for Linux (WSL).
* when `/run/udev` isn't readable, which typically happens when running inside a docker image not launched with `--volume /run/udev:/run/udev:ro`.
This setting can also be programmatically controlled by `defaults::set_compat_mode()` and `defaults::compat_mode_reset()`.
### Thread Pool (KVIKIO\_NTHREADS)
KvikIO can use multiple threads for IO automatically. Set the environment variable `KVIKIO_NTHREADS` to the number of threads in the thread pool. If not set, the default value is 1.
This setting can also be controlled by `defaults::thread_pool_nthreads()` and `defaults::thread_pool_nthreads_reset()`.
### Task Size (KVIKIO\_TASK\_SIZE)
KvikIO splits parallel IO operations into multiple tasks. Set the environment variable `KVIKIO_TASK_SIZE` to the maximum task size (in bytes). If not set, the default value is 4194304 (4 MiB).
This setting can also be controlled by `defaults::task_size()` and `defaults::task_size_reset()`.
### GDS Threshold (KVIKIO\_GDS\_THRESHOLD)
To improve performance of small IO requests, `.pread()` and `.pwrite()` implement a shortcut that circumvents the threadpool and uses the POSIX backend directly. Set the environment variable `KVIKIO_GDS_THRESHOLD` to the minimum size (in bytes) to use GDS. If not set, the default value is 1048576 (1 MiB).
This setting can also be controlled by `defaults::gds_threshold()` and `defaults::gds_threshold_reset()`.
### Size of the Bounce Buffer (KVIKIO\_GDS\_THRESHOLD)
KvikIO might have to use intermediate host buffers (one per thread) when copying between files and device memory. Set the environment variable `KVIKIO_BOUNCE_BUFFER_SIZE` to the size (in bytes) of these "bounce" buffers. If not set, the default value is 16777216 (16 MiB).
This setting can also be controlled by `defaults::bounce_buffer_size()` and `defaults::bounce_buffer_size_reset()`.
Example
=======
#include
#include
#include
using namespace std;
int main()
{
// Create two arrays \`a\` and \`b\`
constexpr std::size\_t size = 100;
void \*a = nullptr;
void \*b = nullptr;
cudaMalloc(&a, size);
cudaMalloc(&b, size);
// Write \`a\` to file
[kvikio::FileHandle](/api/libkvikio/legacy/classkvikio_1_1filehandle)
fw("test-file", "w");
size\_t written = fw.write(a, size);
fw.close();
// Read file into \`b\`
[kvikio::FileHandle](/api/libkvikio/legacy/classkvikio_1_1filehandle)
fr("test-file", "r");
size\_t read = fr.read(b, size);
fr.close();
// Read file into \`b\` in parallel using 16 threads
kvikio::default\_thread\_pool::reset(16);
{
[kvikio::FileHandle](/api/libkvikio/legacy/classkvikio_1_1filehandle)
f("test-file", "r");
future future = f.pread(b\_dev, sizeof(a), 0); // Non-blocking
size\_t read = future.get(); // Blocking
// Notice, \`f\` closes automatically on destruction.
}
}
[kvikio::FileHandle](/api/libkvikio/legacy/classkvikio_1_1filehandle)
Handle of an open file registered with cufile.
**Definition:** [file\_handle.hpp:44](/api/libkvikio/legacy/file__handle_8hpp_source#l00044)
For a full runnable example see [https://github.com/rapidsai/kvikio/blob/HEAD/cpp/examples/basic\_io.cpp](https://github.com/rapidsai/kvikio/blob/HEAD/cpp/examples/basic_io.cpp)
.
---
# libucxx: Main Page
[Home](/api)
libucxx
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
nightly (0.43)
[nightly (0.43)](/api/libucxx/nightly)
[stable (0.42)](/api/libucxx/stable)
[legacy (0.41)](/api/libucxx/legacy)
---
# libucxx: Main Page
[Home](/api)
libucxx
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
legacy (0.41)
[nightly (0.43)](/api/libucxx/nightly)
[stable (0.42)](/api/libucxx/stable)
[legacy (0.41)](/api/libucxx/legacy)
---
# Welcome to rapids-cmake’s documentation! — rapids-cmake 25.04.00 documentation
* [](#)
* Welcome to rapids-cmake’s documentation!
* [View page source](_sources/index.rst.txt)
* * *
Welcome to rapids-cmake’s documentation
=============================================================================================================
This is a collection of CMake modules that are useful for all RAPIDS projects. By sharing the code in a single place it makes rolling out CMake fixes easier.
Contents:
* [API Reference](api/)
* [RAPIDS-CMake Basics](basics/)
* [CPM Reference](cpm/)
* [rapids-cmake package defaults](cpm/#rapids-cmake-package-defaults)
* [rapids-cmake package override](cpm/#rapids-cmake-package-override)
* [Reproducible rapids-cmake builds](cpm/#reproducible-rapids-cmake-builds)
* [rapids-cpm command line controls](cpm/#rapids-cpm-command-line-controls)
* [rapids-cmake package version format](cpm/#rapids-cmake-package-version-format)
* [rapids-cmake package versions](cpm/#rapids-cmake-package-versions)
* [Dependency Tracking](dependency_tracking/)
* [Hardware Resources and Testing](hardware_resources_and_testing/)
Indices and tables[](#indices-and-tables "Link to this heading")
==================================================================
* [Index](genindex/)
* [Search Page](search/)
---
# cudf.pandas — cudf 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cudf
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cudf/nightly/)
[stable (25.02)](/api/cudf/stable/)
[legacy (24.12)](/api/cudf/legacy/)
* [GitHub](https://github.com/rapidsai/cudf "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
cudf.pandas[#](#cudf-pandas "Link to this heading")
====================================================
cuDF pandas accelerator mode (`cudf.pandas`) is built on cuDF and **accelerates pandas code** on the GPU. It supports **100% of the Pandas API**, using the GPU for supported operations, and automatically **falling back to pandas** for other operations.
%load\_ext cudf.pandas
\# pandas API is now GPU accelerated
import pandas as pd
df \= pd.read\_csv("filepath") \# uses the GPU!
df.groupby("col").mean() \# uses the GPU!
df.rolling(window\=3).sum() \# uses the GPU!
df.apply(set, axis\=1) \# uses the CPU (fallback)
[](https://nvda.ws/3BnjYjN)
Try it on Google Colab
| | |
| --- | --- |
| **Zero Code Change Acceleration**
Just `%load_ext cudf.pandas` in Jupyter, or pass `-m cudf.pandas` on the command line. | **Third-Party Library Compatible**
`cudf.pandas` is compatible with most third-party libraries that use pandas. |
| **Run the same code on CPU or GPU**
Nothing changes, not even your import statements, when going from CPU to GPU. | **100% of the Pandas API**
Combines the full flexibility of Pandas with blazing fast performance of cuDF |
`cudf.pandas` is now Generally Available (GA) as part of the `cudf` package. See [RAPIDS Quick Start](https://rapids.ai/#quick-start)
to get up-and-running with `cudf`.
Contents:
* [Usage](usage/)
* [Benchmarks](benchmarks/)
* [How it Works](how-it-works/)
* [FAQ and Known Issues](faq/)
### This Page
* [Show Source](../_sources/cudf_pandas/index.rst.txt)
---
# Welcome to rapids-cmake’s documentation! — rapids-cmake 24.12.00 documentation
* [](#)
* Welcome to rapids-cmake’s documentation!
* [View page source](_sources/index.rst.txt)
* * *
Welcome to rapids-cmake’s documentation
=============================================================================================================
This is a collection of CMake modules that are useful for all RAPIDS projects. By sharing the code in a single place it makes rolling out CMake fixes easier.
Contents:
* [API Reference](api/)
* [RAPIDS-CMake Basics](basics/)
* [CPM Reference](cpm/)
* [rapids-cmake package defaults](cpm/#rapids-cmake-package-defaults)
* [rapids-cmake package override](cpm/#rapids-cmake-package-override)
* [Reproducible rapids-cmake builds](cpm/#reproducible-rapids-cmake-builds)
* [rapids-cpm command line controls](cpm/#rapids-cpm-command-line-controls)
* [rapids-cmake package version format](cpm/#rapids-cmake-package-version-format)
* [rapids-cmake package versions](cpm/#rapids-cmake-package-versions)
* [Dependency Tracking](dependency_tracking/)
* [Hardware Resources and Testing](hardware_resources_and_testing/)
Indices and tables[](#indices-and-tables "Link to this heading")
==================================================================
* [Index](genindex/)
* [Search Page](search/)
---
# Introduction — cuml 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cuml
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cuml/nightly)
[stable (25.02)](/api/cuml/stable)
[legacy (24.12)](/api/cuml/legacy)
* [GitHub](https://github.com/rapidsai/cuml "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
Introduction[#](#introduction "Link to this heading")
======================================================
cuML accelerates machine learning on GPUs. The library follows a couple of key principles, and understanding these will help you take full advantage cuML.
1\. Where possible, match the scikit-learn API[#](#where-possible-match-the-scikit-learn-api "Link to this heading")
---------------------------------------------------------------------------------------------------------------------
cuML estimators look and feel just like [scikit-learn estimators](https://scikit-learn.org/stable/developers/develop.html)
. You initialize them with key parameters, fit them with a `fit` method, then call `predict` or `transform` for inference.
import cuml.LinearRegression
model \= cuml.LinearRegression()
model.fit(X\_train, y)
y\_prediction \= model.predict(X\_test)
You can find many more complete examples in the [Introductory Notebook](../estimator_intro/)
and in the cuML API documentation.
2\. Accept flexible input types, return predictable output types[#](#accept-flexible-input-types-return-predictable-output-types "Link to this heading")
---------------------------------------------------------------------------------------------------------------------------------------------------------
cuML estimators can accept NumPy arrays, cuDF dataframes, cuPy arrays, 2d PyTorch tensors, and really any kind of standards-based Python array input you can throw at them. This relies on the `__array__` and `__cuda_array_interface__` standards, widely used throughout the PyData community.
By default, outputs will mirror the data type you provided. So, if you fit a model with a NumPy array, the `model.coef_` property containing fitted coefficients will also be a NumPy array. If you fit a model using cuDF’s GPU-based DataFrame and Series objects, the model’s output properties will be cuDF objects. You can always override this behavior and select a default datatype with the [memory\_utils.set\_global\_output\_type](https://docs.rapids.ai/api/cuml/nightly/api.html#datatype-configuration)
function.
The [RAPIDS Configurable Input and Output Types](https://medium.com/@dantegd/e719d72c135b)
blog post goes into much more detail explaining this approach.
3\. Be fast
-------------------------------------------------
cuML’s estimators rely on highly-optimized CUDA primitives and algorithms within `libcuml`. On a modern GPU, these can exceed the performance of CPU-based equivalents by a factor of anything from 4x (for a medium-sized linear regression) to over 1000x (for large-scale tSNE dimensionality reduction). The [cuml.benchmark](https://docs.rapids.ai/api/cuml/nightly/api.html#benchmarking)
module provides an easy interface to benchmark your own hardware.
To maximize performance, keep in mind - a modern GPU can have over 5000 cores, so make sure you’re providing enough data to keep it busy! In many cases, performance advantages appear as the dataset grows.
Learn more[#](#learn-more "Link to this heading")
--------------------------------------------------
To get started learning cuML, walk through the [Introductory Notebook](../estimator_intro/)
. Then try out some of the other notebook examples in the `notebooks` directory of the repository. Finally, do a deeper dive with the [cuML blogs](../cuml_blogs/)
.
On this page
### This Page
* [Show Source](../_sources/cuml_intro.rst.txt)
---
# Polars GPU engine — cudf 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cudf
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cudf/nightly/)
[stable (25.02)](/api/cudf/stable/)
[legacy (24.12)](/api/cudf/legacy/)
* [GitHub](https://github.com/rapidsai/cudf "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
Polars GPU engine[#](#polars-gpu-engine "Link to this heading")
================================================================
cuDF provides an in-memory, GPU-accelerated execution engine for Python users of the Polars Lazy API. The engine supports most of the core expressions and data types as well as a growing set of more advanced dataframe manipulations and data file formats. When using the GPU engine, Polars will convert expressions into an optimized query plan and determine whether the plan is supported on the GPU. If it is not, the execution will transparently fall back to the standard Polars engine and run on the CPU. This functionality is available in Open Beta, is undergoing rapid development, and is currently a single GPU implementation.
Benchmark[#](#benchmark "Link to this heading")
------------------------------------------------
Note
The following benchmarks were performed with POLARS\_GPU\_ENABLE\_CUDA\_MANAGED\_MEMORY environment variable set to “0”. Using managed memory (the default) imposes a performance cost in order to avoid out of memory errors. Peak performance can still be attained by setting the environment variable to 1.
We reproduced the [Polars Decision Support (PDS)](https://github.com/pola-rs/polars-benchmark)
benchmark to compare Polars GPU engine with the default CPU settings across several dataset sizes. Here are the results:
[](../_images/pds_benchmark_polars.png)
You can see up to 13x speedup using the GPU engine on the compute-heavy PDS queries involving complex aggregation and join operations. Below are the speedups for the top performing queries:
[](../_images/compute_heavy_queries_polars.png)
_PDS-H benchmark | GPU: NVIDIA H100 PCIe | CPU: Intel Xeon W9-3495X (Sapphire Rapids) | Storage: Local NVMe_
You can reproduce the results by visiting the [Polars Decision Support (PDS) GitHub repository](https://github.com/pola-rs/polars-benchmark)
.
Learn More[#](#learn-more "Link to this heading")
--------------------------------------------------
The GPU engine for Polars is now available in Open Beta and the engine is undergoing rapid development. To learn more, visit the [GPU Support page](https://docs.pola.rs/user-guide/gpu-support/)
on the Polars website.
Launch on Google Colab[#](#launch-on-google-colab "Link to this heading")
--------------------------------------------------------------------------
[](https://nvda.ws/4eKlWZW)
Try out the GPU engine for Polars in a free GPU notebook environment. Sign in with your Google account and [launch the demo on Colab](https://nvda.ws/4eKlWZW)
.[#](#id1 "Link to this image")
Engine Config Options:
* [GPUEngine Configuration Options](engine_options/)
On this page
### This Page
* [Show Source](../_sources/cudf_polars/index.rst.txt)
---
# pylibcudf documentation — cudf 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cudf
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cudf/nightly/)
[stable (25.02)](/api/cudf/stable/)
[legacy (24.12)](/api/cudf/legacy/)
* [GitHub](https://github.com/rapidsai/cudf "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
pylibcudf documentation[#](#pylibcudf-documentation "Link to this heading")
============================================================================
pylibcudf is a lightweight Cython interface to libcudf that provides near-zero overhead for GPU-accelerated data processing in Python. It aims to provide minimal overhead interfaces to the C++ libcudf library, while integrating seamlessly with community protocols like `__cuda_array_interface__`, and common libraries such as CuPy and Numba. Both our zero-code pandas accelerator (`cudf.pandas`) and our polars GPU execution engine (`cudf.polars`) are built on top of pylibcudf.
Ex: Reading data from a parquet file
pylibcudf:
import pylibcudf as plc
source \= plc.io.SourceInfo(\["dataset.parquet"\])
options \= plc.io.parquet.ParquetReaderOptions.builder(source).build()
table \= plc.io.parquet.read\_parquet(options)
libcudf:
#include
int main()
{
auto source \= cudf::io::source\_info("dataset.parquet");
auto options \= cudf::io::parquet\_reader\_options::builder(source).build();
auto table \= cudf::io::read\_parquet(options);
}
Contents:
* [API Reference](api_docs/)
* [Developer Documentation](developer_docs/)
### This Page
* [Show Source](../_sources/pylibcudf/index.rst.txt)
---
# User Guide — cuml 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cuml
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cuml/nightly)
[stable (25.02)](/api/cuml/stable)
[legacy (24.12)](/api/cuml/legacy)
* [GitHub](https://github.com/rapidsai/cuml "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
User Guide[#](#user-guide "Link to this heading")
==================================================
* [Training and Evaluating Machine Learning Models](../estimator_intro/)
* [Shared Library Imports](../estimator_intro/#Shared-Library-Imports)
* [Random Forest Classification and Accuracy metrics](../estimator_intro/#Random-Forest-Classification-and-Accuracy-metrics)
* [UMAP and Trustworthiness metrics](../estimator_intro/#UMAP-and-Trustworthiness-metrics)
* [DBSCAN and Adjusted Random Index](../estimator_intro/#DBSCAN-and-Adjusted-Random-Index)
* [Linear regression and R^2 score](../estimator_intro/#Linear-regression-and-R^2-score)
* [Pickling Models for Persistence](../pickling_cuml_models/)
* [Single GPU Model Pickling](../pickling_cuml_models/#Single-GPU-Model-Pickling)
* [Distributed Model Pickling](../pickling_cuml_models/#Distributed-Model-Pickling)
* [Exporting cuML Random Forest models for inferencing on machines without GPUs](../pickling_cuml_models/#Exporting-cuML-Random-Forest-models-for-inferencing-on-machines-without-GPUs)
* [cuML on GPU and CPU](../execution_device_interoperability/)
* [Installation](../execution_device_interoperability/#Installation)
* [Cross Device Training and Inference Serialization](../execution_device_interoperability/#Cross-Device-Training-and-Inference-Serialization)
* [Conclusion](../execution_device_interoperability/#Conclusion)
### This Page
* [Show Source](../_sources/user_guide.rst.txt)
---
# libcudf documentation — cudf 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cudf
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cudf/nightly/)
[stable (25.02)](/api/cudf/stable/)
[legacy (24.12)](/api/cudf/legacy/)
* [GitHub](https://github.com/rapidsai/cudf "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
libcudf documentation[#](#libcudf-documentation "Link to this heading")
========================================================================
Contents:
* [libcudf documentation](api_docs/)
* [libcudf](api_docs/cudf_namespace/)
* [Default Stream](api_docs/default_stream/)
* [Memory Resource Management](api_docs/memory_resource/)
* [Cudf Classes](api_docs/cudf_classes/)
* [Column APIs](api_docs/column_apis/)
* [Datetime APIs](api_docs/datetime_apis/)
* [Strings APIs](api_docs/strings_apis/)
* [Dictionary APIs](api_docs/dictionary_apis/)
* [Io APIs](api_docs/io_apis/)
* [JSON APIs](api_docs/json_apis/)
* [Lists APIs](api_docs/lists_apis/)
* [Nvtext APIs](api_docs/nvtext_apis/)
* [Utility APIs](api_docs/utility_apis/)
* [Labeling APIs](api_docs/labeling_apis/)
* [Expression Evaluation](api_docs/expressions/)
* [tdigest](api_docs/tdigest/)
* [Indices and tables](api_docs/#indices-and-tables)
* [Regex Features](md_regex/)
* [Features Supported](md_regex/#features-supported)
* [Unicode Limitations](unicode_limitations/)
Indices and tables[#](#indices-and-tables "Link to this heading")
==================================================================
* [Index](../genindex/)
* [Search Page](../search/)
On this page
### This Page
* [Show Source](../_sources/libcudf_docs/index.rst.txt)
---
# Blogs and other references — cuml 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cuml
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cuml/nightly)
[stable (25.02)](/api/cuml/stable)
[legacy (24.12)](/api/cuml/legacy)
* [GitHub](https://github.com/rapidsai/cuml "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
Blogs and other references[#](#blogs-and-other-references "Link to this heading")
==================================================================================
The RAPIDS team blogs at [https://medium.com/rapids-ai](https://medium.com/rapids-ai)
, and many of these blog posts provide deeper dives into models or key features from cuML. Here, we’ve selected just a few that are of particular interest to cuML users:
Integrations, applications, and general concepts[#](#integrations-applications-and-general-concepts "Link to this heading")
----------------------------------------------------------------------------------------------------------------------------
* [RAPIDS Configurable Input and Output Types](https://medium.com/@dantegd/e719d72c135b)
* [RAPIDS on AWS Sagemaker](https://medium.com/rapids-ai/running-rapids-experiments-at-scale-using-amazon-sagemaker-d516420f165b)
Tree and forest models[#](#tree-and-forest-models "Link to this heading")
--------------------------------------------------------------------------
* [Accelerating Random Forests up to 45x using cuML](https://medium.com/rapids-ai/accelerating-random-forests-up-to-45x-using-cuml-dfb782a31bea)
* [RAPIDS Forest Inference Library: Prediction at 100 million rows per second](https://medium.com/rapids-ai/rapids-forest-inference-library-prediction-at-100-million-rows-per-second-19558890bc35)
* [Sparse Forests with FIL](https://medium.com/rapids-ai/sparse-forests-with-fil-ffbb42b0c7e3)
Other popular models[#](#other-popular-models "Link to this heading")
----------------------------------------------------------------------
* [Accelerating TSNE with GPUs: From hours to seconds](https://medium.com/rapids-ai/tsne-with-gpus-hours-to-seconds-9d9c17c941db)
* [Combining Speed and Scale to Accelerate K-Means in RAPIDS cuML](https://medium.com/rapids-ai/combining-speed-scale-to-accelerate-k-means-in-rapids-cuml-8d45e5ce39f5)
* [Accelerating k-nearest neighbors 600x using RAPIDS cuML](https://medium.com/rapids-ai/accelerating-k-nearest-neighbors-600x-using-rapids-cuml-82725d56401e)
Academic Papers[#](#academic-papers "Link to this heading")
------------------------------------------------------------
* [Machine Learning in Python: Main developments and technology trends in data science, machine learning, and artificial intelligence (Sebastian Raschka, Joshua Patterson, Corey Nolet)](https://arxiv.org/abs/2002.04803)
On this page
### This Page
* [Show Source](../_sources/cuml_blogs.rst.txt)
---
# Python Module Index — cuCIM 25.02.00 documentation
[Skip to main content](#main-content)
Back to top
Ctrl+K
[Home](/api)
cucim
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cucim/nightly)
[stable (25.02)](/api/cucim/stable)
[legacy (24.12)](/api/cucim/legacy)
Python Module Index
===================
[**c**](#cap-c)
| | | |
| --- | --- | --- |
| | | |
| | **c** | |
|  | `cucim` | |
| | [`cucim.clara`](../api/#module-cucim.clara) | |
| | [`cucim.clara.cache`](../api/#module-cucim.clara.cache) | |
| | [`cucim.clara.filesystem`](../api/#module-cucim.clara.filesystem) | |
| | [`cucim.clara.io`](../api/#module-cucim.clara.io) | |
| | [`cucim.core.operations.color`](../api/#module-cucim.core.operations.color) | |
| | [`cucim.core.operations.expose`](../api/#module-cucim.core.operations.expose) | |
| | [`cucim.core.operations.intensity`](../api/#module-cucim.core.operations.intensity) | |
| | [`cucim.core.operations.morphology`](../api/#module-cucim.core.operations.morphology) | |
| | [`cucim.core.operations.spatial`](../api/#module-cucim.core.operations.spatial) | |
| | [`cucim.skimage`](../api/#module-cucim.skimage) | |
| | [`cucim.skimage.color`](../api/#module-cucim.skimage.color) | |
| | [`cucim.skimage.data`](../api/#module-cucim.skimage.data) | |
| | [`cucim.skimage.exposure`](../api/#module-cucim.skimage.exposure) | |
| | [`cucim.skimage.feature`](../api/#module-cucim.skimage.feature) | |
| | [`cucim.skimage.filters`](../api/#module-cucim.skimage.filters) | |
| | [`cucim.skimage.measure`](../api/#module-cucim.skimage.measure) | |
| | [`cucim.skimage.metrics`](../api/#module-cucim.skimage.metrics) | |
| | [`cucim.skimage.morphology`](../api/#module-cucim.skimage.morphology) | |
| | [`cucim.skimage.registration`](../api/#module-cucim.skimage.registration) | |
| | [`cucim.skimage.restoration`](../api/#module-cucim.skimage.restoration) | |
| | [`cucim.skimage.segmentation`](../api/#module-cucim.skimage.segmentation) | |
| | [`cucim.skimage.transform`](../api/#module-cucim.skimage.transform) | |
| | [`cucim.skimage.util`](../api/#module-cucim.skimage.util) | |
---
# Developer Guide — cudf 25.02.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cudf
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cudf/nightly/)
[stable (25.02)](/api/cudf/stable/)
[legacy (24.12)](/api/cudf/legacy/)
* [GitHub](https://github.com/rapidsai/cudf "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
Developer Guide[#](#developer-guide "Link to this heading")
============================================================
Note
At present, this guide only covers the main cuDF library. In the future, it may be expanded to also cover dask\_cudf, cudf\_kafka, and custreamz.
cuDF is a GPU-accelerated, [Pandas-like](https://pandas.pydata.org/)
DataFrame library. Under the hood, all of cuDF’s functionality relies on the CUDA-accelerated `libcudf` C++ library. Thus, cuDF’s internals are designed to efficiently and robustly map pandas APIs to `libcudf` functions. For more information about the `libcudf` library, a good starting point is the [developer guide](https://docs.rapids.ai/api/libcudf/stable/developer_guide)
.
This document assumes familiarity with the [overall contributing guide](https://github.com/rapidsai/cudf/blob/main/CONTRIBUTING.md)
. The goal of this document is to provide more specific guidance for Python developers. It covers the structure of the Python code and discusses best practices. Additionally, it includes longer sections on more specific topics like testing and benchmarking.
* [Library Design](library_design/)
* [The Frame layer](library_design/#the-frame-layer)
* [The Column layer](library_design/#the-column-layer)
* [The Cython layer](library_design/#the-cython-layer)
* [Putting It All Together](library_design/#putting-it-all-together)
* [Copy-on-write](library_design/#copy-on-write)
* [Contributing Guide](contributing_guide/)
* [Directory structure and file naming](contributing_guide/#directory-structure-and-file-naming)
* [Code style](contributing_guide/#code-style)
* [Deprecating and removing code](contributing_guide/#deprecating-and-removing-code)
* [`pandas` compatibility](contributing_guide/#pandas-compatibility)
* [Python vs Cython](contributing_guide/#python-vs-cython)
* [Exception handling](contributing_guide/#exception-handling)
* [Writing documentation](documentation/)
* [Docstrings](documentation/#docstrings)
* [Published documentation](documentation/#published-documentation)
* [Comparing to pandas](documentation/#comparing-to-pandas)
* [Writing documentation pages](documentation/#writing-documentation-pages)
* [Building documentation](documentation/#building-documentation)
* [Documenting cuDF internals](documentation/#documenting-cudf-internals)
* [Testing cuDF](testing/)
* [Tooling](testing/#tooling)
* [Test organization](testing/#test-organization)
* [Test contents](testing/#test-contents)
* [Benchmarking cuDF](benchmarking/)
* [Benchmark organization](benchmarking/#benchmark-organization)
* [Running benchmarks](benchmarking/#running-benchmarks)
* [Benchmark contents](benchmarking/#benchmark-contents)
* [Comparing to pandas](benchmarking/#comparing-to-pandas)
* [Testing benchmarks](benchmarking/#testing-benchmarks)
* [Profiling](benchmarking/#profiling)
* [Advanced Topics](benchmarking/#advanced-topics)
* [Options](options/)
* [cudf.pandas](cudf_pandas/)
* [fast-slow proxy mechanism](cudf_pandas/#fast-slow-proxy-mechanism)
* [debugging `cudf.pandas`](cudf_pandas/#debugging-cudf-pandas)
### This Page
* [Show Source](../_sources/developer_guide/index.md.txt)
---
# Search - cuCIM 25.02.00 documentation
[Skip to main content](#main-content)
Back to top
Ctrl+K
[Home](/api)
cucim
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cucim/nightly)
[stable (25.02)](/api/cucim/stable)
[legacy (24.12)](/api/cucim/legacy)
Search
======
Ctrl+K
---
# Index — cuCIM 25.02.00 documentation
[Skip to main content](#main-content)
Back to top
Ctrl+K
[Home](/api)
cucim
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cucim/nightly)
[stable (25.02)](/api/cucim/stable)
[legacy (24.12)](/api/cucim/legacy)
Index
=====
[**A**](#A)
| [**B**](#B)
| [**C**](#C)
| [**D**](#D)
| [**E**](#E)
| [**F**](#F)
| [**G**](#G)
| [**H**](#H)
| [**I**](#I)
| [**J**](#J)
| [**L**](#L)
| [**M**](#M)
| [**N**](#N)
| [**O**](#O)
| [**P**](#P)
| [**R**](#R)
| [**S**](#S)
| [**T**](#T)
| [**U**](#U)
| [**V**](#V)
| [**W**](#W)
| [**X**](#X)
| [**Y**](#Y)
| [**Z**](#Z)
A
-
| | |
| --- | --- |
| * [adapted\_rand\_error() (in module cucim.skimage.metrics)](../api/#cucim.skimage.metrics.adapted_rand_error)
* [adjust\_gamma() (in module cucim.skimage.exposure)](../api/#cucim.skimage.exposure.adjust_gamma)
* [adjust\_log() (in module cucim.skimage.exposure)](../api/#cucim.skimage.exposure.adjust_log)
* [adjust\_sigmoid() (in module cucim.skimage.exposure)](../api/#cucim.skimage.exposure.adjust_sigmoid) | * [AffineTransform (class in cucim.skimage.transform)](../api/#cucim.skimage.transform.AffineTransform)
* [apply\_hysteresis\_threshold() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.apply_hysteresis_threshold)
* [approximate\_polygon() (in module cucim.skimage.measure)](../api/#cucim.skimage.measure.approximate_polygon)
* [associated\_image() (cucim.clara.CuImage method)](../api/#cucim.clara.CuImage.associated_image)
* [associated\_images (cucim.clara.CuImage property)](../api/#cucim.clara.CuImage.associated_images) |
B
-
| | |
| --- | --- |
| * [ball() (in module cucim.skimage.morphology)](../api/#cucim.skimage.morphology.ball)
* [binary\_blobs() (in module cucim.skimage.data)](../api/#cucim.skimage.data.binary_blobs)
* [binary\_closing() (in module cucim.skimage.morphology)](../api/#cucim.skimage.morphology.binary_closing)
* [binary\_dilation() (in module cucim.skimage.morphology)](../api/#cucim.skimage.morphology.binary_dilation)
* [binary\_erosion() (in module cucim.skimage.morphology)](../api/#cucim.skimage.morphology.binary_erosion)
* [binary\_opening() (in module cucim.skimage.morphology)](../api/#cucim.skimage.morphology.binary_opening)
* [bits (cucim.clara.DLDataType property)](../api/#cucim.clara.DLDataType.bits) | * [black\_tophat() (in module cucim.skimage.morphology)](../api/#cucim.skimage.morphology.black_tophat)
* [blob\_dog() (in module cucim.skimage.feature)](../api/#cucim.skimage.feature.blob_dog)
* [blob\_doh() (in module cucim.skimage.feature)](../api/#cucim.skimage.feature.blob_doh)
* [blob\_log() (in module cucim.skimage.feature)](../api/#cucim.skimage.feature.blob_log)
* [block\_reduce() (in module cucim.skimage.measure)](../api/#cucim.skimage.measure.block_reduce)
* [blur\_effect() (in module cucim.skimage.measure)](../api/#cucim.skimage.measure.blur_effect)
* [butterworth() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.butterworth) |
C
-
| | |
| --- | --- |
| * [cache() (cucim.clara.CuImage static method)](../api/#cucim.clara.CuImage.cache)
* [CacheType (class in cucim.clara.cache)](../api/#cucim.clara.cache.CacheType)
* [calibrate\_denoiser() (in module cucim.skimage.restoration)](../api/#cucim.skimage.restoration.calibrate_denoiser)
* [canny() (in module cucim.skimage.feature)](../api/#cucim.skimage.feature.canny)
* [capacity (cucim.clara.cache.ImageCache property)](../api/#cucim.clara.cache.ImageCache.capacity)
* [centroid() (in module cucim.skimage.measure)](../api/#cucim.skimage.measure.centroid)
* [chan\_vese() (in module cucim.skimage.segmentation)](../api/#cucim.skimage.segmentation.chan_vese)
* [channel\_names (cucim.clara.CuImage property)](../api/#cucim.clara.CuImage.channel_names)
* [checkerboard\_level\_set() (in module cucim.skimage.segmentation)](../api/#cucim.skimage.segmentation.checkerboard_level_set)
* [clear\_border() (in module cucim.skimage.segmentation)](../api/#cucim.skimage.segmentation.clear_border)
* [close() (cucim.clara.CuImage method)](../api/#cucim.clara.CuImage.close)
* [(cucim.clara.filesystem.CuFileDriver method)](../api/#cucim.clara.filesystem.CuFileDriver.close)
* [(in module cucim.clara.filesystem)](../api/#cucim.clara.filesystem.close)
* [closing() (in module cucim.skimage.morphology)](../api/#cucim.skimage.morphology.closing)
* [code (cucim.clara.DLDataType property)](../api/#cucim.clara.DLDataType.code)
* [color\_jitter() (in module cucim.core.operations.color)](../api/#cucim.core.operations.color.color_jitter)
* [combine\_stains() (in module cucim.skimage.color)](../api/#cucim.skimage.color.combine_stains)
* [config (cucim.clara.cache.ImageCache property)](../api/#cucim.clara.cache.ImageCache.config)
* [contingency\_table() (in module cucim.skimage.metrics)](../api/#cucim.skimage.metrics.contingency_table)
* [convert\_colorspace() (in module cucim.skimage.color)](../api/#cucim.skimage.color.convert_colorspace)
* [coord\_sys (cucim.clara.CuImage property)](../api/#cucim.clara.CuImage.coord_sys)
* [corner\_foerstner() (in module cucim.skimage.feature)](../api/#cucim.skimage.feature.corner_foerstner)
* [corner\_harris() (in module cucim.skimage.feature)](../api/#cucim.skimage.feature.corner_harris)
* [corner\_kitchen\_rosenfeld() (in module cucim.skimage.feature)](../api/#cucim.skimage.feature.corner_kitchen_rosenfeld)
* [corner\_peaks() (in module cucim.skimage.feature)](../api/#cucim.skimage.feature.corner_peaks)
* [corner\_shi\_tomasi() (in module cucim.skimage.feature)](../api/#cucim.skimage.feature.corner_shi_tomasi)
* [correlate\_sparse() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.correlate_sparse)
* [CPU (cucim.clara.io.DeviceType attribute)](../api/#cucim.clara.io.DeviceType.CPU)
* [CPUShared (cucim.clara.io.DeviceType attribute)](../api/#cucim.clara.io.DeviceType.CPUShared)
* [crop() (in module cucim.skimage.util)](../api/#cucim.skimage.util.crop)
* cucim.clara
* [module](../api/#module-cucim.clara)
* cucim.clara.cache
* [module](../api/#module-cucim.clara.cache)
* cucim.clara.filesystem
* [module](../api/#module-cucim.clara.filesystem)
* cucim.clara.io
* [module](../api/#module-cucim.clara.io)
* cucim.core.operations.color
* [module](../api/#module-cucim.core.operations.color)
* cucim.core.operations.expose
* [module](../api/#module-cucim.core.operations.expose) | * cucim.core.operations.intensity
* [module](../api/#module-cucim.core.operations.intensity)
* cucim.core.operations.morphology
* [module](../api/#module-cucim.core.operations.morphology)
* cucim.core.operations.spatial
* [module](../api/#module-cucim.core.operations.spatial)
* cucim.skimage
* [module](../api/#module-cucim.skimage)
* cucim.skimage.color
* [module](../api/#module-cucim.skimage.color)
* cucim.skimage.data
* [module](../api/#module-cucim.skimage.data)
* cucim.skimage.exposure
* [module](../api/#module-cucim.skimage.exposure)
* cucim.skimage.feature
* [module](../api/#module-cucim.skimage.feature)
* cucim.skimage.filters
* [module](../api/#module-cucim.skimage.filters)
* cucim.skimage.measure
* [module](../api/#module-cucim.skimage.measure)
* cucim.skimage.metrics
* [module](../api/#module-cucim.skimage.metrics)
* cucim.skimage.morphology
* [module](../api/#module-cucim.skimage.morphology)
* cucim.skimage.registration
* [module](../api/#module-cucim.skimage.registration)
* cucim.skimage.restoration
* [module](../api/#module-cucim.skimage.restoration)
* cucim.skimage.segmentation
* [module](../api/#module-cucim.skimage.segmentation)
* cucim.skimage.transform
* [module](../api/#module-cucim.skimage.transform)
* cucim.skimage.util
* [module](../api/#module-cucim.skimage.util)
* [CUDA (cucim.clara.io.DeviceType attribute)](../api/#cucim.clara.io.DeviceType.CUDA)
* [CUDAHost (cucim.clara.io.DeviceType attribute)](../api/#cucim.clara.io.DeviceType.CUDAHost)
* [CUDAManaged (cucim.clara.io.DeviceType attribute)](../api/#cucim.clara.io.DeviceType.CUDAManaged)
* [CUDAShared (cucim.clara.io.DeviceType attribute)](../api/#cucim.clara.io.DeviceType.CUDAShared)
* [CuFileDriver (class in cucim.clara.filesystem)](../api/#cucim.clara.filesystem.CuFileDriver)
* [CuImage (class in cucim.clara)](../api/#cucim.clara.CuImage)
* [cumulative\_distribution() (in module cucim.skimage.exposure)](../api/#cucim.skimage.exposure.cumulative_distribution) |
D
-
| | |
| --- | --- |
| * [daisy() (in module cucim.skimage.feature)](../api/#cucim.skimage.feature.daisy)
* [deltaE\_cie76() (in module cucim.skimage.color)](../api/#cucim.skimage.color.deltaE_cie76)
* [deltaE\_ciede2000() (in module cucim.skimage.color)](../api/#cucim.skimage.color.deltaE_ciede2000)
* [deltaE\_ciede94() (in module cucim.skimage.color)](../api/#cucim.skimage.color.deltaE_ciede94)
* [deltaE\_cmc() (in module cucim.skimage.color)](../api/#cucim.skimage.color.deltaE_cmc)
* [denoise\_invariant() (in module cucim.skimage.restoration)](../api/#cucim.skimage.restoration.denoise_invariant)
* [denoise\_tv\_chambolle() (in module cucim.skimage.restoration)](../api/#cucim.skimage.restoration.denoise_tv_chambolle)
* [Device (class in cucim.clara.io)](../api/#cucim.clara.io.Device)
* [device (cucim.clara.CuImage property)](../api/#cucim.clara.CuImage.device)
* [DeviceType (class in cucim.clara.io)](../api/#cucim.clara.io.DeviceType)
* [diamond() (in module cucim.skimage.morphology)](../api/#cucim.skimage.morphology.diamond)
* [difference\_of\_gaussians() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.difference_of_gaussians)
* [dilation() (in module cucim.skimage.morphology)](../api/#cucim.skimage.morphology.dilation)
* [dimensionality (cucim.skimage.transform.ProjectiveTransform property)](../api/#cucim.skimage.transform.ProjectiveTransform.dimensionality) | * [dims (cucim.clara.CuImage property)](../api/#cucim.clara.CuImage.dims)
* [direction (cucim.clara.CuImage property)](../api/#cucim.clara.CuImage.direction)
* [discard\_page\_cache() (in module cucim.clara.filesystem)](../api/#cucim.clara.filesystem.discard_page_cache)
* [disk() (in module cucim.skimage.morphology)](../api/#cucim.skimage.morphology.disk)
* [disk\_level\_set() (in module cucim.skimage.segmentation)](../api/#cucim.skimage.segmentation.disk_level_set)
* [distance\_transform\_edt() (in module cucim.core.operations.morphology)](../api/#cucim.core.operations.morphology.distance_transform_edt)
* [DLBfloat (cucim.clara.DLDataTypeCode attribute)](../api/#cucim.clara.DLDataTypeCode.DLBfloat)
* [DLDataType (class in cucim.clara)](../api/#cucim.clara.DLDataType)
* [DLDataTypeCode (class in cucim.clara)](../api/#cucim.clara.DLDataTypeCode)
* [DLFloat (cucim.clara.DLDataTypeCode attribute)](../api/#cucim.clara.DLDataTypeCode.DLFloat)
* [DLInt (cucim.clara.DLDataTypeCode attribute)](../api/#cucim.clara.DLDataTypeCode.DLInt)
* [DLUInt (cucim.clara.DLDataTypeCode attribute)](../api/#cucim.clara.DLDataTypeCode.DLUInt)
* [downscale\_local\_mean() (in module cucim.skimage.transform)](../api/#cucim.skimage.transform.downscale_local_mean)
* [dtype (cucim.clara.CuImage property)](../api/#cucim.clara.CuImage.dtype)
* [dtype\_limits() (in module cucim.skimage.util)](../api/#cucim.skimage.util.dtype_limits) |
E
-
| | |
| --- | --- |
| * [equalize\_adapthist() (in module cucim.skimage.exposure)](../api/#cucim.skimage.exposure.equalize_adapthist)
* [equalize\_hist() (in module cucim.skimage.exposure)](../api/#cucim.skimage.exposure.equalize_hist)
* [erosion() (in module cucim.skimage.morphology)](../api/#cucim.skimage.morphology.erosion)
* [EssentialMatrixTransform (class in cucim.skimage.transform)](../api/#cucim.skimage.transform.EssentialMatrixTransform)
* [estimate() (cucim.skimage.transform.EssentialMatrixTransform method)](../api/#cucim.skimage.transform.EssentialMatrixTransform.estimate)
* [(cucim.skimage.transform.EuclideanTransform method)](../api/#cucim.skimage.transform.EuclideanTransform.estimate)
* [(cucim.skimage.transform.FundamentalMatrixTransform method)](../api/#cucim.skimage.transform.FundamentalMatrixTransform.estimate)
* [(cucim.skimage.transform.PiecewiseAffineTransform method)](../api/#cucim.skimage.transform.PiecewiseAffineTransform.estimate)
* [(cucim.skimage.transform.PolynomialTransform method)](../api/#cucim.skimage.transform.PolynomialTransform.estimate)
* [(cucim.skimage.transform.ProjectiveTransform method)](../api/#cucim.skimage.transform.ProjectiveTransform.estimate)
* [(cucim.skimage.transform.SimilarityTransform method)](../api/#cucim.skimage.transform.SimilarityTransform.estimate) | * [estimate\_transform() (in module cucim.skimage.transform)](../api/#cucim.skimage.transform.estimate_transform)
* [EuclideanTransform (class in cucim.skimage.transform)](../api/#cucim.skimage.transform.EuclideanTransform)
* [euler\_number() (in module cucim.skimage.measure)](../api/#cucim.skimage.measure.euler_number)
* [expand\_labels() (in module cucim.skimage.segmentation)](../api/#cucim.skimage.segmentation.expand_labels) |
F
-
| | |
| --- | --- |
| * [farid() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.farid)
* [farid\_h() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.farid_h)
* [farid\_v() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.farid_v)
* [filter\_forward() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.filter_forward)
* [filter\_inverse() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.filter_inverse) | * [find\_boundaries() (in module cucim.skimage.segmentation)](../api/#cucim.skimage.segmentation.find_boundaries)
* [footprint\_from\_sequence() (in module cucim.skimage.morphology)](../api/#cucim.skimage.morphology.footprint_from_sequence)
* [footprint\_rectangle() (in module cucim.skimage.morphology)](../api/#cucim.skimage.morphology.footprint_rectangle)
* [frangi() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.frangi)
* [free\_memory (cucim.clara.cache.ImageCache property)](../api/#cucim.clara.cache.ImageCache.free_memory)
* [FundamentalMatrixTransform (class in cucim.skimage.transform)](../api/#cucim.skimage.transform.FundamentalMatrixTransform) |
G
-
| | |
| --- | --- |
| * [gabor() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.gabor)
* [gabor\_kernel() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.gabor_kernel) | * [gaussian() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.gaussian)
* [gray2rgb() (in module cucim.skimage.color)](../api/#cucim.skimage.color.gray2rgb)
* [gray2rgba() (in module cucim.skimage.color)](../api/#cucim.skimage.color.gray2rgba) |
H
-
| | |
| --- | --- |
| * [hed2rgb() (in module cucim.skimage.color)](../api/#cucim.skimage.color.hed2rgb)
* [hessian() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.hessian)
* [hessian\_matrix() (in module cucim.skimage.feature)](../api/#cucim.skimage.feature.hessian_matrix)
* [hessian\_matrix\_det() (in module cucim.skimage.feature)](../api/#cucim.skimage.feature.hessian_matrix_det) | * [hessian\_matrix\_eigvals() (in module cucim.skimage.feature)](../api/#cucim.skimage.feature.hessian_matrix_eigvals)
* [histogram() (in module cucim.skimage.exposure)](../api/#cucim.skimage.exposure.histogram)
* [hit\_count (cucim.clara.cache.ImageCache property)](../api/#cucim.clara.cache.ImageCache.hit_count)
* [hsv2rgb() (in module cucim.skimage.color)](../api/#cucim.skimage.color.hsv2rgb) |
I
-
| | |
| --- | --- |
| * [image\_flip() (in module cucim.core.operations.spatial)](../api/#cucim.core.operations.spatial.image_flip)
* [image\_rotate\_90() (in module cucim.core.operations.spatial)](../api/#cucim.core.operations.spatial.image_rotate_90)
* [image\_to\_absorbance() (in module cucim.core.operations.color)](../api/#cucim.core.operations.color.image_to_absorbance)
* [ImageCache (class in cucim.clara.cache)](../api/#cucim.clara.cache.ImageCache)
* [img\_as\_bool() (in module cucim.skimage.util)](../api/#cucim.skimage.util.img_as_bool)
* [img\_as\_float() (in module cucim.skimage.util)](../api/#cucim.skimage.util.img_as_float)
* [img\_as\_float32() (in module cucim.skimage.util)](../api/#cucim.skimage.util.img_as_float32)
* [img\_as\_float64() (in module cucim.skimage.util)](../api/#cucim.skimage.util.img_as_float64)
* [img\_as\_int() (in module cucim.skimage.util)](../api/#cucim.skimage.util.img_as_int)
* [img\_as\_ubyte() (in module cucim.skimage.util)](../api/#cucim.skimage.util.img_as_ubyte)
* [img\_as\_uint() (in module cucim.skimage.util)](../api/#cucim.skimage.util.img_as_uint)
* [index (cucim.clara.io.Device property)](../api/#cucim.clara.io.Device.index)
* [inertia\_tensor() (in module cucim.skimage.measure)](../api/#cucim.skimage.measure.inertia_tensor)
* [inertia\_tensor\_eigvals() (in module cucim.skimage.measure)](../api/#cucim.skimage.measure.inertia_tensor_eigvals)
* [integral\_image() (in module cucim.skimage.transform)](../api/#cucim.skimage.transform.integral_image) | * [integrate() (in module cucim.skimage.transform)](../api/#cucim.skimage.transform.integrate)
* [intersection\_coeff() (in module cucim.skimage.measure)](../api/#cucim.skimage.measure.intersection_coeff)
* [inverse() (cucim.skimage.transform.FundamentalMatrixTransform method)](../api/#cucim.skimage.transform.FundamentalMatrixTransform.inverse)
* [(cucim.skimage.transform.PiecewiseAffineTransform method)](../api/#cucim.skimage.transform.PiecewiseAffineTransform.inverse)
* [(cucim.skimage.transform.PolynomialTransform method)](../api/#cucim.skimage.transform.PolynomialTransform.inverse)
* [(cucim.skimage.transform.ProjectiveTransform method)](../api/#cucim.skimage.transform.ProjectiveTransform.inverse)
* [inverse\_gaussian\_gradient() (in module cucim.skimage.segmentation)](../api/#cucim.skimage.segmentation.inverse_gaussian_gradient)
* [invert() (in module cucim.skimage.util)](../api/#cucim.skimage.util.invert)
* [is\_loaded (cucim.clara.CuImage property)](../api/#cucim.clara.CuImage.is_loaded)
* [is\_low\_contrast() (in module cucim.skimage.exposure)](../api/#cucim.skimage.exposure.is_low_contrast)
* [is\_trace\_enabled (cucim.clara.CuImage attribute)](../api/#cucim.clara.CuImage.is_trace_enabled)
* [isotropic\_closing() (in module cucim.skimage.morphology)](../api/#cucim.skimage.morphology.isotropic_closing)
* [isotropic\_dilation() (in module cucim.skimage.morphology)](../api/#cucim.skimage.morphology.isotropic_dilation)
* [isotropic\_erosion() (in module cucim.skimage.morphology)](../api/#cucim.skimage.morphology.isotropic_erosion)
* [isotropic\_opening() (in module cucim.skimage.morphology)](../api/#cucim.skimage.morphology.isotropic_opening) |
J
-
* [join\_segmentations() (in module cucim.skimage.segmentation)](../api/#cucim.skimage.segmentation.join_segmentations)
L
-
| | |
| --- | --- |
| * [lab2lch() (in module cucim.skimage.color)](../api/#cucim.skimage.color.lab2lch)
* [lab2rgb() (in module cucim.skimage.color)](../api/#cucim.skimage.color.lab2rgb)
* [lab2xyz() (in module cucim.skimage.color)](../api/#cucim.skimage.color.lab2xyz)
* [label() (in module cucim.skimage.measure)](../api/#cucim.skimage.measure.label)
* [label2rgb() (in module cucim.skimage.color)](../api/#cucim.skimage.color.label2rgb) | * [lanes (cucim.clara.DLDataType property)](../api/#cucim.clara.DLDataType.lanes)
* [laplace() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.laplace)
* [lch2lab() (in module cucim.skimage.color)](../api/#cucim.skimage.color.lch2lab)
* [LPIFilter2D (class in cucim.skimage.filters)](../api/#cucim.skimage.filters.LPIFilter2D)
* [luv2rgb() (in module cucim.skimage.color)](../api/#cucim.skimage.color.luv2rgb)
* [luv2xyz() (in module cucim.skimage.color)](../api/#cucim.skimage.color.luv2xyz) |
M
-
| | |
| --- | --- |
| * [manders\_coloc\_coeff() (in module cucim.skimage.measure)](../api/#cucim.skimage.measure.manders_coloc_coeff)
* [manders\_overlap\_coeff() (in module cucim.skimage.measure)](../api/#cucim.skimage.measure.manders_overlap_coeff)
* [map\_array() (in module cucim.skimage.util)](../api/#cucim.skimage.util.map_array)
* [mark\_boundaries() (in module cucim.skimage.segmentation)](../api/#cucim.skimage.segmentation.mark_boundaries)
* [match\_descriptors() (in module cucim.skimage.feature)](../api/#cucim.skimage.feature.match_descriptors)
* [match\_histograms() (in module cucim.skimage.exposure)](../api/#cucim.skimage.exposure.match_histograms)
* [match\_template() (in module cucim.skimage.feature)](../api/#cucim.skimage.feature.match_template)
* [matrix\_transform() (in module cucim.skimage.transform)](../api/#cucim.skimage.transform.matrix_transform)
* [mean\_squared\_error() (in module cucim.skimage.metrics)](../api/#cucim.skimage.metrics.mean_squared_error)
* [medial\_axis() (in module cucim.skimage.morphology)](../api/#cucim.skimage.morphology.medial_axis)
* [median() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.median)
* [meijering() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.meijering)
* [memory\_capacity (cucim.clara.cache.ImageCache property)](../api/#cucim.clara.cache.ImageCache.memory_capacity)
* [memory\_size (cucim.clara.cache.ImageCache property)](../api/#cucim.clara.cache.ImageCache.memory_size)
* [metadata (cucim.clara.CuImage property)](../api/#cucim.clara.CuImage.metadata)
* [miss\_count (cucim.clara.cache.ImageCache property)](../api/#cucim.clara.cache.ImageCache.miss_count)
* module
* [cucim.clara](../api/#module-cucim.clara)
* [cucim.clara.cache](../api/#module-cucim.clara.cache)
* [cucim.clara.filesystem](../api/#module-cucim.clara.filesystem)
* [cucim.clara.io](../api/#module-cucim.clara.io)
* [cucim.core.operations.color](../api/#module-cucim.core.operations.color)
* [cucim.core.operations.expose](../api/#module-cucim.core.operations.expose)
* [cucim.core.operations.intensity](../api/#module-cucim.core.operations.intensity)
* [cucim.core.operations.morphology](../api/#module-cucim.core.operations.morphology)
* [cucim.core.operations.spatial](../api/#module-cucim.core.operations.spatial)
* [cucim.skimage](../api/#module-cucim.skimage)
* [cucim.skimage.color](../api/#module-cucim.skimage.color)
* [cucim.skimage.data](../api/#module-cucim.skimage.data)
* [cucim.skimage.exposure](../api/#module-cucim.skimage.exposure)
* [cucim.skimage.feature](../api/#module-cucim.skimage.feature)
* [cucim.skimage.filters](../api/#module-cucim.skimage.filters)
* [cucim.skimage.measure](../api/#module-cucim.skimage.measure)
* [cucim.skimage.metrics](../api/#module-cucim.skimage.metrics)
* [cucim.skimage.morphology](../api/#module-cucim.skimage.morphology)
* [cucim.skimage.registration](../api/#module-cucim.skimage.registration)
* [cucim.skimage.restoration](../api/#module-cucim.skimage.restoration)
* [cucim.skimage.segmentation](../api/#module-cucim.skimage.segmentation)
* [cucim.skimage.transform](../api/#module-cucim.skimage.transform)
* [cucim.skimage.util](../api/#module-cucim.skimage.util) | * [moments() (in module cucim.skimage.measure)](../api/#cucim.skimage.measure.moments)
* [moments\_central() (in module cucim.skimage.measure)](../api/#cucim.skimage.measure.moments_central)
* [moments\_coords() (in module cucim.skimage.measure)](../api/#cucim.skimage.measure.moments_coords)
* [moments\_coords\_central() (in module cucim.skimage.measure)](../api/#cucim.skimage.measure.moments_coords_central)
* [moments\_hu() (in module cucim.skimage.measure)](../api/#cucim.skimage.measure.moments_hu)
* [moments\_normalized() (in module cucim.skimage.measure)](../api/#cucim.skimage.measure.moments_normalized)
* [morphological\_chan\_vese() (in module cucim.skimage.segmentation)](../api/#cucim.skimage.segmentation.morphological_chan_vese)
* [morphological\_geodesic\_active\_contour() (in module cucim.skimage.segmentation)](../api/#cucim.skimage.segmentation.morphological_geodesic_active_contour)
* [multiscale\_basic\_features() (in module cucim.skimage.feature)](../api/#cucim.skimage.feature.multiscale_basic_features) |
N
-
| | |
| --- | --- |
| * [name (cucim.clara.cache.CacheType property)](../api/#cucim.clara.cache.CacheType.name)
* [(cucim.clara.DLDataTypeCode property)](../api/#cucim.clara.DLDataTypeCode.name)
* [(cucim.clara.io.DeviceType property)](../api/#cucim.clara.io.DeviceType.name)
* [ndim (cucim.clara.CuImage property)](../api/#cucim.clara.CuImage.ndim) | * [NoCache (cucim.clara.cache.CacheType attribute)](../api/#cucim.clara.cache.CacheType.NoCache)
* [normalize\_colors\_pca() (in module cucim.core.operations.color)](../api/#cucim.core.operations.color.normalize_colors_pca)
* [normalize\_data() (in module cucim.core.operations.intensity)](../api/#cucim.core.operations.intensity.normalize_data)
* [normalized\_mutual\_information() (in module cucim.skimage.metrics)](../api/#cucim.skimage.metrics.normalized_mutual_information)
* [normalized\_root\_mse() (in module cucim.skimage.metrics)](../api/#cucim.skimage.metrics.normalized_root_mse) |
O
-
| | |
| --- | --- |
| * [octagon() (in module cucim.skimage.morphology)](../api/#cucim.skimage.morphology.octagon)
* [octahedron() (in module cucim.skimage.morphology)](../api/#cucim.skimage.morphology.octahedron)
* [open() (in module cucim.clara.filesystem)](../api/#cucim.clara.filesystem.open) | * [opening() (in module cucim.skimage.morphology)](../api/#cucim.skimage.morphology.opening)
* [optical\_flow\_ilk() (in module cucim.skimage.registration)](../api/#cucim.skimage.registration.optical_flow_ilk)
* [optical\_flow\_tvl1() (in module cucim.skimage.registration)](../api/#cucim.skimage.registration.optical_flow_tvl1)
* [origin (cucim.clara.CuImage property)](../api/#cucim.clara.CuImage.origin) |
P
-
| | |
| --- | --- |
| * [parse\_type() (cucim.clara.io.Device static method)](../api/#cucim.clara.io.Device.parse_type)
* [path (cucim.clara.CuImage property)](../api/#cucim.clara.CuImage.path)
* [peak\_local\_max() (in module cucim.skimage.feature)](../api/#cucim.skimage.feature.peak_local_max)
* [peak\_signal\_noise\_ratio() (in module cucim.skimage.metrics)](../api/#cucim.skimage.metrics.peak_signal_noise_ratio)
* [pearson\_corr\_coeff() (in module cucim.skimage.measure)](../api/#cucim.skimage.measure.pearson_corr_coeff)
* [perimeter() (in module cucim.skimage.measure)](../api/#cucim.skimage.measure.perimeter)
* [perimeter\_crofton() (in module cucim.skimage.measure)](../api/#cucim.skimage.measure.perimeter_crofton)
* [PerProcess (cucim.clara.cache.CacheType attribute)](../api/#cucim.clara.cache.CacheType.PerProcess)
* [phase\_cross\_correlation() (in module cucim.skimage.registration)](../api/#cucim.skimage.registration.phase_cross_correlation)
* [PiecewiseAffineTransform (class in cucim.skimage.transform)](../api/#cucim.skimage.transform.PiecewiseAffineTransform)
* [PolynomialTransform (class in cucim.skimage.transform)](../api/#cucim.skimage.transform.PolynomialTransform)
* [pread() (cucim.clara.filesystem.CuFileDriver method)](../api/#cucim.clara.filesystem.CuFileDriver.pread)
* [(in module cucim.clara.filesystem)](../api/#cucim.clara.filesystem.pread) | * [preferred\_memory\_capacity() (in module cucim.clara.cache)](../api/#cucim.clara.cache.preferred_memory_capacity)
* [prewitt() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.prewitt)
* [prewitt\_h() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.prewitt_h)
* [prewitt\_v() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.prewitt_v)
* [profile\_line() (in module cucim.skimage.measure)](../api/#cucim.skimage.measure.profile_line)
* [profiler() (cucim.clara.CuImage static method)](../api/#cucim.clara.CuImage.profiler)
* [ProjectiveTransform (class in cucim.skimage.transform)](../api/#cucim.skimage.transform.ProjectiveTransform)
* [pwrite() (cucim.clara.filesystem.CuFileDriver method)](../api/#cucim.clara.filesystem.CuFileDriver.pwrite)
* [(in module cucim.clara.filesystem)](../api/#cucim.clara.filesystem.pwrite)
* [pyramid\_expand() (in module cucim.skimage.transform)](../api/#cucim.skimage.transform.pyramid_expand)
* [pyramid\_gaussian() (in module cucim.skimage.transform)](../api/#cucim.skimage.transform.pyramid_gaussian)
* [pyramid\_laplacian() (in module cucim.skimage.transform)](../api/#cucim.skimage.transform.pyramid_laplacian)
* [pyramid\_reduce() (in module cucim.skimage.transform)](../api/#cucim.skimage.transform.pyramid_reduce) |
R
-
| | |
| --- | --- |
| * [rand\_image\_flip() (in module cucim.core.operations.spatial)](../api/#cucim.core.operations.spatial.rand_image_flip)
* [rand\_image\_rotate\_90() (in module cucim.core.operations.spatial)](../api/#cucim.core.operations.spatial.rand_image_rotate_90)
* [rand\_zoom() (in module cucim.core.operations.intensity)](../api/#cucim.core.operations.intensity.rand_zoom)
* [random\_noise() (in module cucim.skimage.util)](../api/#cucim.skimage.util.random_noise)
* [random\_walker() (in module cucim.skimage.segmentation)](../api/#cucim.skimage.segmentation.random_walker)
* [rank\_order() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.rank_order)
* [raw\_metadata (cucim.clara.CuImage property)](../api/#cucim.clara.CuImage.raw_metadata)
* [read\_region() (cucim.clara.CuImage method)](../api/#cucim.clara.CuImage.read_region)
* [reconstruction() (in module cucim.skimage.morphology)](../api/#cucim.skimage.morphology.reconstruction)
* [record() (cucim.clara.cache.ImageCache method)](../api/#cucim.clara.cache.ImageCache.record)
* [regionprops() (in module cucim.skimage.measure)](../api/#cucim.skimage.measure.regionprops)
* [regionprops\_table() (in module cucim.skimage.measure)](../api/#cucim.skimage.measure.regionprops_table)
* [relabel\_sequential() (in module cucim.skimage.segmentation)](../api/#cucim.skimage.segmentation.relabel_sequential)
* [remove\_small\_holes() (in module cucim.skimage.morphology)](../api/#cucim.skimage.morphology.remove_small_holes)
* [remove\_small\_objects() (in module cucim.skimage.morphology)](../api/#cucim.skimage.morphology.remove_small_objects)
* [rescale() (in module cucim.skimage.transform)](../api/#cucim.skimage.transform.rescale)
* [rescale\_intensity() (in module cucim.skimage.exposure)](../api/#cucim.skimage.exposure.rescale_intensity)
* [reserve() (cucim.clara.cache.ImageCache method)](../api/#cucim.clara.cache.ImageCache.reserve)
* [residuals() (cucim.skimage.transform.FundamentalMatrixTransform method)](../api/#cucim.skimage.transform.FundamentalMatrixTransform.residuals)
* [resize() (in module cucim.skimage.transform)](../api/#cucim.skimage.transform.resize)
* [resize\_local\_mean() (in module cucim.skimage.transform)](../api/#cucim.skimage.transform.resize_local_mean) | * [resolutions (cucim.clara.CuImage property)](../api/#cucim.clara.CuImage.resolutions)
* [rgb2gray() (in module cucim.skimage.color)](../api/#cucim.skimage.color.rgb2gray)
* [rgb2hed() (in module cucim.skimage.color)](../api/#cucim.skimage.color.rgb2hed)
* [rgb2hsv() (in module cucim.skimage.color)](../api/#cucim.skimage.color.rgb2hsv)
* [rgb2lab() (in module cucim.skimage.color)](../api/#cucim.skimage.color.rgb2lab)
* [rgb2luv() (in module cucim.skimage.color)](../api/#cucim.skimage.color.rgb2luv)
* [rgb2rgbcie() (in module cucim.skimage.color)](../api/#cucim.skimage.color.rgb2rgbcie)
* [rgb2xyz() (in module cucim.skimage.color)](../api/#cucim.skimage.color.rgb2xyz)
* [rgb2ycbcr() (in module cucim.skimage.color)](../api/#cucim.skimage.color.rgb2ycbcr)
* [rgb2ydbdr() (in module cucim.skimage.color)](../api/#cucim.skimage.color.rgb2ydbdr)
* [rgb2yiq() (in module cucim.skimage.color)](../api/#cucim.skimage.color.rgb2yiq)
* [rgb2ypbpr() (in module cucim.skimage.color)](../api/#cucim.skimage.color.rgb2ypbpr)
* [rgb2yuv() (in module cucim.skimage.color)](../api/#cucim.skimage.color.rgb2yuv)
* [rgba2rgb() (in module cucim.skimage.color)](../api/#cucim.skimage.color.rgba2rgb)
* [rgbcie2rgb() (in module cucim.skimage.color)](../api/#cucim.skimage.color.rgbcie2rgb)
* [richardson\_lucy() (in module cucim.skimage.restoration)](../api/#cucim.skimage.restoration.richardson_lucy)
* [roberts() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.roberts)
* [roberts\_neg\_diag() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.roberts_neg_diag)
* [roberts\_pos\_diag() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.roberts_pos_diag)
* [rotate() (in module cucim.skimage.transform)](../api/#cucim.skimage.transform.rotate)
* [rotation (cucim.skimage.transform.AffineTransform property)](../api/#cucim.skimage.transform.AffineTransform.rotation)
* [(cucim.skimage.transform.EuclideanTransform property)](../api/#cucim.skimage.transform.EuclideanTransform.rotation) |
S
-
| | |
| --- | --- |
| * [sato() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.sato)
* [save() (cucim.clara.CuImage method)](../api/#cucim.clara.CuImage.save)
* [scale (cucim.skimage.transform.AffineTransform property)](../api/#cucim.skimage.transform.AffineTransform.scale)
* [(cucim.skimage.transform.SimilarityTransform property)](../api/#cucim.skimage.transform.SimilarityTransform.scale)
* [scale\_intensity\_range() (in module cucim.core.operations.intensity)](../api/#cucim.core.operations.intensity.scale_intensity_range)
* [scharr() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.scharr)
* [scharr\_h() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.scharr_h)
* [scharr\_v() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.scharr_v)
* [separate\_stains() (in module cucim.skimage.color)](../api/#cucim.skimage.color.separate_stains)
* [shannon\_entropy() (in module cucim.skimage.measure)](../api/#cucim.skimage.measure.shannon_entropy)
* [shape (cucim.clara.CuImage property)](../api/#cucim.clara.CuImage.shape)
* [shape\_index() (in module cucim.skimage.feature)](../api/#cucim.skimage.feature.shape_index)
* [SharedMemory (cucim.clara.cache.CacheType attribute)](../api/#cucim.clara.cache.CacheType.SharedMemory)
* [shear (cucim.skimage.transform.AffineTransform property)](../api/#cucim.skimage.transform.AffineTransform.shear) | * [SimilarityTransform (class in cucim.skimage.transform)](../api/#cucim.skimage.transform.SimilarityTransform)
* [size (cucim.clara.cache.ImageCache property)](../api/#cucim.clara.cache.ImageCache.size)
* [size() (cucim.clara.CuImage method)](../api/#cucim.clara.CuImage.size)
* [sobel() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.sobel)
* [sobel\_h() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.sobel_h)
* [sobel\_v() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.sobel_v)
* [spacing() (cucim.clara.CuImage method)](../api/#cucim.clara.CuImage.spacing)
* [spacing\_units() (cucim.clara.CuImage method)](../api/#cucim.clara.CuImage.spacing_units)
* [stain\_extraction\_pca() (in module cucim.core.operations.color)](../api/#cucim.core.operations.color.stain_extraction_pca)
* [star() (in module cucim.skimage.morphology)](../api/#cucim.skimage.morphology.star)
* [structural\_similarity() (in module cucim.skimage.metrics)](../api/#cucim.skimage.metrics.structural_similarity)
* [structure\_tensor() (in module cucim.skimage.feature)](../api/#cucim.skimage.feature.structure_tensor)
* [structure\_tensor\_eigenvalues() (in module cucim.skimage.feature)](../api/#cucim.skimage.feature.structure_tensor_eigenvalues)
* [subdivide\_polygon() (in module cucim.skimage.measure)](../api/#cucim.skimage.measure.subdivide_polygon)
* [swirl() (in module cucim.skimage.transform)](../api/#cucim.skimage.transform.swirl) |
T
-
| | |
| --- | --- |
| * [thin() (in module cucim.skimage.morphology)](../api/#cucim.skimage.morphology.thin)
* [threshold\_isodata() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.threshold_isodata)
* [threshold\_li() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.threshold_li)
* [threshold\_local() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.threshold_local)
* [threshold\_mean() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.threshold_mean)
* [threshold\_minimum() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.threshold_minimum)
* [threshold\_multiotsu() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.threshold_multiotsu)
* [threshold\_niblack() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.threshold_niblack)
* [threshold\_otsu() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.threshold_otsu) | * [threshold\_sauvola() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.threshold_sauvola)
* [threshold\_triangle() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.threshold_triangle)
* [threshold\_yen() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.threshold_yen)
* [translation (cucim.skimage.transform.AffineTransform property)](../api/#cucim.skimage.transform.AffineTransform.translation)
* [(cucim.skimage.transform.EuclideanTransform property)](../api/#cucim.skimage.transform.EuclideanTransform.translation)
* [try\_all\_threshold() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.try_all_threshold)
* [type (cucim.clara.cache.ImageCache property)](../api/#cucim.clara.cache.ImageCache.type)
* [(cucim.clara.io.Device property)](../api/#cucim.clara.io.Device.type)
* [typestr (cucim.clara.CuImage property)](../api/#cucim.clara.CuImage.typestr) |
U
-
| | |
| --- | --- |
| * [unsharp\_mask() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.unsharp_mask) | * [unsupervised\_wiener() (in module cucim.skimage.restoration)](../api/#cucim.skimage.restoration.unsupervised_wiener) |
V
-
| | |
| --- | --- |
| * [value (cucim.clara.cache.CacheType property)](../api/#cucim.clara.cache.CacheType.value)
* [(cucim.clara.DLDataTypeCode property)](../api/#cucim.clara.DLDataTypeCode.value)
* [(cucim.clara.io.DeviceType property)](../api/#cucim.clara.io.DeviceType.value) | * [variation\_of\_information() (in module cucim.skimage.metrics)](../api/#cucim.skimage.metrics.variation_of_information)
* [view\_as\_blocks() (in module cucim.skimage.util)](../api/#cucim.skimage.util.view_as_blocks)
* [view\_as\_windows() (in module cucim.skimage.util)](../api/#cucim.skimage.util.view_as_windows) |
W
-
| | |
| --- | --- |
| * [warp() (in module cucim.skimage.transform)](../api/#cucim.skimage.transform.warp)
* [warp\_coords() (in module cucim.skimage.transform)](../api/#cucim.skimage.transform.warp_coords)
* [warp\_polar() (in module cucim.skimage.transform)](../api/#cucim.skimage.transform.warp_polar) | * [white\_tophat() (in module cucim.skimage.morphology)](../api/#cucim.skimage.morphology.white_tophat)
* [wiener() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.wiener)
* [(in module cucim.skimage.restoration)](../api/#cucim.skimage.restoration.wiener)
* [window() (in module cucim.skimage.filters)](../api/#cucim.skimage.filters.window) |
X
-
| | |
| --- | --- |
| * [xyz2lab() (in module cucim.skimage.color)](../api/#cucim.skimage.color.xyz2lab)
* [xyz2luv() (in module cucim.skimage.color)](../api/#cucim.skimage.color.xyz2luv) | * [xyz2rgb() (in module cucim.skimage.color)](../api/#cucim.skimage.color.xyz2rgb)
* [xyz\_tristimulus\_values() (in module cucim.skimage.color)](../api/#cucim.skimage.color.xyz_tristimulus_values) |
Y
-
| | |
| --- | --- |
| * [ycbcr2rgb() (in module cucim.skimage.color)](../api/#cucim.skimage.color.ycbcr2rgb)
* [ydbdr2rgb() (in module cucim.skimage.color)](../api/#cucim.skimage.color.ydbdr2rgb) | * [yiq2rgb() (in module cucim.skimage.color)](../api/#cucim.skimage.color.yiq2rgb)
* [ypbpr2rgb() (in module cucim.skimage.color)](../api/#cucim.skimage.color.ypbpr2rgb)
* [yuv2rgb() (in module cucim.skimage.color)](../api/#cucim.skimage.color.yuv2rgb) |
Z
-
* [zoom() (in module cucim.core.operations.intensity)](../api/#cucim.core.operations.intensity.zoom)
---
# Welcome to the cuDF documentation! — cudf 25.04.00 documentation
[Skip to main content](#main-content)
Back to top Ctrl+K
[Home](/api)
cudf
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
nightly (25.04)
[nightly (25.04)](/api/cudf/nightly/)
[stable (25.02)](/api/cudf/stable/)
[legacy (24.12)](/api/cudf/legacy/)
* [GitHub](https://github.com/rapidsai/cudf "GitHub")
* [Twitter](https://twitter.com/rapidsai "Twitter")
Welcome to the cuDF documentation
=================================================================================================
[](_images/RAPIDS-logo-purple.png)
**cuDF** (pronounced “KOO-dee-eff”) is a Python GPU DataFrame library (built on the [Apache Arrow](https://arrow.apache.org/)
columnar memory format) for loading, joining, aggregating, filtering, and otherwise manipulating data. cuDF also provides a pandas-like API that will be familiar to data engineers & data scientists, so they can use it to easily accelerate their workflows without going into the details of CUDA programming.
`cudf.pandas` is built on cuDF and accelerates pandas code on the GPU. It supports 100% of the pandas API, using the GPU for supported operations, and automatically falling back to pandas for other operations.
[](_images/duckdb-benchmark-groupby-join.png)
Results of the [Database-like ops benchmark](https://duckdblabs.github.io/db-benchmark/)
including cudf.pandas. See details [here](cudf_pandas/benchmarks.html)
.[#](#id1 "Link to this image")
Contents:
* [cuDF User Guide](user_guide/)
* [cudf.pandas](cudf_pandas/)
* [Polars GPU engine](cudf_polars/)
* [pylibcudf documentation](pylibcudf/)
* [libcudf documentation](libcudf_docs/)
* [Indices and tables](libcudf_docs/#indices-and-tables)
* [Developer Guide](developer_guide/)
### This Page
* [Show Source](_sources/index.rst.txt)
---
# cuCIM API Reference — cuCIM 25.02.00 documentation
[Skip to main content](#main-content)
Back to top
Ctrl+K
[Home](/api)
cucim
[cucim](/api/cucim/stable)
[cudf-java](/api/cudf-java/stable)
[cudf](/api/cudf/stable/)
[cugraph](/api/cugraph/stable)
[cuml](/api/cuml/stable)
[cuproj](/api/cuproj/stable)
[cuspatial](/api/cuspatial/stable)
[cuvs](/api/cuvs/stable)
[cuxfilter](/api/cuxfilter/stable)
[dask-cuda](/api/dask-cuda/stable)
[dask-cudf](/api/dask-cudf/stable)
[kvikio](/api/kvikio/stable)
[libcudf](/api/libcudf/stable/namespacecudf/)
[libcuml](/api/libcuml/stable)
[libcuproj](/api/libcuproj/stable)
[libcuspatial](/api/libcuspatial/stable)
[libkvikio](/api/libkvikio/stable)
[librmm](/api/librmm/stable)
[libucxx](/api/libucxx/stable)
[raft](/api/raft/stable)
[rapids-cmake](/api/rapids-cmake/stable)
[rmm](/api/rmm/stable)
stable (25.02)
[nightly (25.04)](/api/cucim/nightly)
[stable (25.02)](/api/cucim/stable)
[legacy (24.12)](/api/cucim/legacy)
cuCIM API Reference[#](#cucim-api-reference "Permalink to this heading")
=========================================================================
Clara Submodules[#](#module-cucim.clara "Permalink to this heading")
---------------------------------------------------------------------
_class_ cucim.clara.CuImage[#](#cucim.clara.CuImage "Permalink to this definition")
Attributes:
[`associated_images`](#cucim.clara.CuImage.associated_images "cucim.clara.CuImage.associated_images")
Returns a set of associated image names.
[`channel_names`](#cucim.clara.CuImage.channel_names "cucim.clara.CuImage.channel_names")
A channel name list.
[`coord_sys`](#cucim.clara.CuImage.coord_sys "cucim.clara.CuImage.coord_sys")
Coordinate frame in which the direction cosines are measured.
[`device`](#cucim.clara.CuImage.device "cucim.clara.CuImage.device")
A device type.
[`dims`](#cucim.clara.CuImage.dims "cucim.clara.CuImage.dims")
A string containing a list of dimensions being requested.
[`direction`](#cucim.clara.CuImage.direction "cucim.clara.CuImage.direction")
Direction cosines (size is always 3x3).
[`dtype`](#cucim.clara.CuImage.dtype "cucim.clara.CuImage.dtype")
The data type of the image.
[`is_loaded`](#cucim.clara.CuImage.is_loaded "cucim.clara.CuImage.is_loaded")
True if image data is loaded & available.
[`metadata`](#cucim.clara.CuImage.metadata "cucim.clara.CuImage.metadata")
A metadata object as dict.
[`ndim`](#cucim.clara.CuImage.ndim "cucim.clara.CuImage.ndim")
The number of dimensions.
[`origin`](#cucim.clara.CuImage.origin "cucim.clara.CuImage.origin")
Physical location of (0, 0, 0) (size is always 3).
[`path`](#cucim.clara.CuImage.path "cucim.clara.CuImage.path")
Underlying file path for this object.
[`raw_metadata`](#cucim.clara.CuImage.raw_metadata "cucim.clara.CuImage.raw_metadata")
A raw metadata string.
[`resolutions`](#cucim.clara.CuImage.resolutions "cucim.clara.CuImage.resolutions")
Returns a dict that includes resolution information.
[`shape`](#cucim.clara.CuImage.shape "cucim.clara.CuImage.shape")
A tuple of dimension sizes (in the order of dims)
[`typestr`](#cucim.clara.CuImage.typestr "cucim.clara.CuImage.typestr")
The data type of the image in string format.
Methods
| | |
| --- | --- |
| [`associated_image`](#cucim.clara.CuImage.associated_image "cucim.clara.CuImage.associated_image")
(self\[, name, device\]) | Returns an associated image for the given name, as a CuImage object. |
| [`cache`](#cucim.clara.CuImage.cache "cucim.clara.CuImage.cache")
(\[type\]) | Get cache object. |
| [`close`](#cucim.clara.CuImage.close "cucim.clara.CuImage.close")
(self) | Closes the file handle. |
| [`profiler`](#cucim.clara.CuImage.profiler "cucim.clara.CuImage.profiler")
(\*\*kwargs) | Get profiler object. |
| [`read_region`](#cucim.clara.CuImage.read_region "cucim.clara.CuImage.read_region")
(self\[, location, size, level, ...\]) | Returns a subresolution image. |
| [`save`](#cucim.clara.CuImage.save "cucim.clara.CuImage.save")
(self, arg0) | Saves image data to the file path. |
| [`size`](#cucim.clara.CuImage.size "cucim.clara.CuImage.size")
(self\[, dim\_order\]) | Returns size as a tuple for the given dimension order. |
| [`spacing`](#cucim.clara.CuImage.spacing "cucim.clara.CuImage.spacing")
(self\[, dim\_order\]) | Returns physical size in tuple. |
| [`spacing_units`](#cucim.clara.CuImage.spacing_units "cucim.clara.CuImage.spacing_units")
(self\[, dim\_order\]) | Units for each spacing element (size is same with ndim). |
associated\_image(_self: [cucim.clara.\_cucim.CuImage](#cucim.clara.CuImage "cucim.clara._cucim.CuImage")
_, _name: [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.13)")
\= ''_, _device: [cucim.clara.\_cucim.io.Device](#cucim.clara.io.Device "cucim.clara._cucim.io.Device")
\= cpu_) → [object](https://docs.python.org/3/library/functions.html#object "(in Python v3.13)")
[#](#cucim.clara.CuImage.associated_image "Permalink to this definition")
Returns an associated image for the given name, as a CuImage object.
_property_ associated\_images[#](#cucim.clara.CuImage.associated_images "Permalink to this definition")
Returns a set of associated image names.
Digital Pathology image usually has a label/thumbnail or a macro image(low-power snapshot of the entire glass slide). Names of those images (such as ‘macro’ and ‘label’) are in associated\_images.
_static_ cache(_type: [object](https://docs.python.org/3/library/functions.html#object "(in Python v3.13)")
\= None_, _\*\*kwargs_) → [cucim.clara.\_cucim.cache.ImageCache](#cucim.clara.cache.ImageCache "cucim.clara._cucim.cache.ImageCache")
[#](#cucim.clara.CuImage.cache "Permalink to this definition")
Get cache object.
_property_ channel\_names[#](#cucim.clara.CuImage.channel_names "Permalink to this definition")
A channel name list.
close(_self: [cucim.clara.\_cucim.CuImage](#cucim.clara.CuImage "cucim.clara._cucim.CuImage")
_) → [None](https://docs.python.org/3/library/constants.html#None "(in Python v3.13)")
[#](#cucim.clara.CuImage.close "Permalink to this definition")
Closes the file handle.
Once the file handle is closed, the image object (if loaded before) still exists but cannot read additional images from the file.
_property_ coord\_sys[#](#cucim.clara.CuImage.coord_sys "Permalink to this definition")
Coordinate frame in which the direction cosines are measured.
Available Coordinate frame names are not finalized yet.
_property_ device[#](#cucim.clara.CuImage.device "Permalink to this definition")
A device type.
By default t is cpu (It will be changed since v0.19.0).
_property_ dims[#](#cucim.clara.CuImage.dims "Permalink to this definition")
A string containing a list of dimensions being requested.
The default is to return the six standard dims (‘STCZYX’) unless it is a DP multi-resolution image.
\[sites, time, channel(or wavelength), z, y, x\]. S - Sites or multiposition locations.
NOTE: in OME-TIFF’s metadata, dimension order would be specified as ‘XYZCTS’ (first one is fast-iterating dimension).
_property_ direction[#](#cucim.clara.CuImage.direction "Permalink to this definition")
Direction cosines (size is always 3x3).
_property_ dtype[#](#cucim.clara.CuImage.dtype "Permalink to this definition")
The data type of the image.
_property_ is\_loaded[#](#cucim.clara.CuImage.is_loaded "Permalink to this definition")
True if image data is loaded & available.
is\_trace\_enabled _\= False_[#](#cucim.clara.CuImage.is_trace_enabled "Permalink to this definition")
_property_ metadata[#](#cucim.clara.CuImage.metadata "Permalink to this definition")
A metadata object as dict.
It would be a dictionary(key-value pair) in general but can be a complex object (e.g., OME-TIFF metadata).
_property_ ndim[#](#cucim.clara.CuImage.ndim "Permalink to this definition")
The number of dimensions.
_property_ origin[#](#cucim.clara.CuImage.origin "Permalink to this definition")
Physical location of (0, 0, 0) (size is always 3).
_property_ path[#](#cucim.clara.CuImage.path "Permalink to this definition")
Underlying file path for this object.
_static_ profiler(_\*\*kwargs_) → cucim.clara.\_cucim.profiler.Profiler[#](#cucim.clara.CuImage.profiler "Permalink to this definition")
Get profiler object.
_property_ raw\_metadata[#](#cucim.clara.CuImage.raw_metadata "Permalink to this definition")
A raw metadata string.
read\_region(_self: [cucim.clara.\_cucim.CuImage](#cucim.clara.CuImage "cucim.clara._cucim.CuImage")
_, _location: Iterable \= ()_, _size: List\[[int](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")\
\] \= ()_, _level: [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")
\= 0_, _num\_workers: [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")
\= 0_, _batch\_size: [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")
\= 1_, _drop\_last: [bool](https://docs.python.org/3/library/functions.html#bool "(in Python v3.13)")
\= False_, _prefetch\_factor: [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")
\= 2_, _shuffle: [bool](https://docs.python.org/3/library/functions.html#bool "(in Python v3.13)")
\= False_, _seed: [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")
\= 0_, _device: [cucim.clara.\_cucim.io.Device](#cucim.clara.io.Device "cucim.clara._cucim.io.Device")
\= cpu_, _buf: [object](https://docs.python.org/3/library/functions.html#object "(in Python v3.13)")
\= None_, _shm\_name: [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.13)")
\= ''_, _\*\*kwargs_) → [object](https://docs.python.org/3/library/functions.html#object "(in Python v3.13)")
[#](#cucim.clara.CuImage.read_region "Permalink to this definition")
Returns a subresolution image.
* location and size’s dimension order is reverse of image’s dimension order.
* Need to specify (X,Y) and (Width, Height) instead of (Y,X) and (Height, Width).
* If location is not specified, location would be (0, 0) if Z=0. Otherwise, location would be (0, 0, 0)
* Like OpenSlide, location is level-0 based coordinates (using the level-0 reference frame)
* If size is not specified, size would be (width, height) of the image at the specified level.
* Additional parameters (S,T,C,Z) are similar to <[https://allencellmodeling.github.io/aicsimageio/aicsimageio.html#aicsimageio.aics\_image.AICSImage.get\_image\_data](https://allencellmodeling.github.io/aicsimageio/aicsimageio.html#aicsimageio.aics_image.AICSImage.get_image_data)
\>
* Do not yet support indices/ranges for (S,T,C,Z).
* Default value for level, S, T, Z are zero.
* Default value for C is -1 (whole channels)
* device could be one of the following strings or Device object: e.g., ‘cpu’, ‘cuda’, ‘cuda:0’ (use index 0), cucim.clara.io.Device(cucim.clara.io.CUDA,0).
* If buf is specified (buf’s type can be either numpy object that implements \_\_array\_interface\_\_, or cupy-compatible object that implements \_\_cuda\_array\_interface\_\_), the read image would be saved into buf object without creating CPU/GPU memory.
* If shm\_name is specified, shared memory would be created and data would be read in the shared memory.
_property_ resolutions[#](#cucim.clara.CuImage.resolutions "Permalink to this definition")
Returns a dict that includes resolution information.
* level\_count: The number of levels
* level\_dimensions: A tuple of dimension tuples (width, height)
* level\_downsamples: A tuple of down-sample factors
* level\_tile\_sizes: A tuple of tile size tuple (tile width, tile\_height)
save(_self: [cucim.clara.\_cucim.CuImage](#cucim.clara.CuImage "cucim.clara._cucim.CuImage")
_, _arg0: [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.13)")
_) → [None](https://docs.python.org/3/library/constants.html#None "(in Python v3.13)")
[#](#cucim.clara.CuImage.save "Permalink to this definition")
Saves image data to the file path.
Currently it supports only .ppm file format that can be viewed by eog command in Ubuntu.
_property_ shape[#](#cucim.clara.CuImage.shape "Permalink to this definition")
A tuple of dimension sizes (in the order of dims)
size(_self: [cucim.clara.\_cucim.CuImage](#cucim.clara.CuImage "cucim.clara._cucim.CuImage")
_, _dim\_order: [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.13)")
\= ''_) → List\[[int](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")\
\][#](#cucim.clara.CuImage.size "Permalink to this definition")
Returns size as a tuple for the given dimension order.
spacing(_self: [cucim.clara.\_cucim.CuImage](#cucim.clara.CuImage "cucim.clara._cucim.CuImage")
_, _dim\_order: [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.13)")
\= ''_) → List\[[float](https://docs.python.org/3/library/functions.html#float "(in Python v3.13)")\
\][#](#cucim.clara.CuImage.spacing "Permalink to this definition")
Returns physical size in tuple.
If dim\_order is specified, it returns physical size for the dimensions. If a dimension given by the dim\_order doesn’t exist, it returns 1.0 by default for the missing dimension.
Args:
dim\_order: A dimension string (e.g., ‘XYZ’)
Returns:
A tuple with physical size for each dimension
spacing\_units(_self: [cucim.clara.\_cucim.CuImage](#cucim.clara.CuImage "cucim.clara._cucim.CuImage")
_, _dim\_order: [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.13)")
\= ''_) → List\[[str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.13)")\
\][#](#cucim.clara.CuImage.spacing_units "Permalink to this definition")
Units for each spacing element (size is same with ndim).
_property_ typestr[#](#cucim.clara.CuImage.typestr "Permalink to this definition")
The data type of the image in string format.
The value can be converted to NumPy’s dtype using numpy.dtype(). (e.g., numpy.dtype(img.typestr)).
_class_ cucim.clara.DLDataType[#](#cucim.clara.DLDataType "Permalink to this definition")
Attributes:
[`bits`](#cucim.clara.DLDataType.bits "cucim.clara.DLDataType.bits")
Number of bits, common choices are 8, 16, 32.
[`code`](#cucim.clara.DLDataType.code "cucim.clara.DLDataType.code")
Type code of base types.
[`lanes`](#cucim.clara.DLDataType.lanes "cucim.clara.DLDataType.lanes")
Number of lanes in the type, used for vector types.
_property_ bits[#](#cucim.clara.DLDataType.bits "Permalink to this definition")
Number of bits, common choices are 8, 16, 32.
_property_ code[#](#cucim.clara.DLDataType.code "Permalink to this definition")
Type code of base types.
_property_ lanes[#](#cucim.clara.DLDataType.lanes "Permalink to this definition")
Number of lanes in the type, used for vector types.
_class_ cucim.clara.DLDataTypeCode[#](#cucim.clara.DLDataTypeCode "Permalink to this definition")
Members:
DLInt
DLUInt
DLFloat
DLBfloat
Attributes:
[`name`](#cucim.clara.DLDataTypeCode.name "cucim.clara.DLDataTypeCode.name")
name(self: handle) -> str
**value**
DLBfloat _\= _[#](#cucim.clara.DLDataTypeCode.DLBfloat "Permalink to this definition")
DLFloat _\= _[#](#cucim.clara.DLDataTypeCode.DLFloat "Permalink to this definition")
DLInt _\= _[#](#cucim.clara.DLDataTypeCode.DLInt "Permalink to this definition")
DLUInt _\= _[#](#cucim.clara.DLDataTypeCode.DLUInt "Permalink to this definition")
_property_ name[#](#cucim.clara.DLDataTypeCode.name "Permalink to this definition")
_property_ value[#](#cucim.clara.DLDataTypeCode.value "Permalink to this definition")
### cache[#](#module-cucim.clara.cache "Permalink to this heading")
_class_ cucim.clara.cache.CacheType[#](#cucim.clara.cache.CacheType "Permalink to this definition")
Members:
NoCache
PerProcess
SharedMemory
Attributes:
[`name`](#cucim.clara.cache.CacheType.name "cucim.clara.cache.CacheType.name")
name(self: handle) -> str
**value**
NoCache _\= _[#](#cucim.clara.cache.CacheType.NoCache "Permalink to this definition")
PerProcess _\= _[#](#cucim.clara.cache.CacheType.PerProcess "Permalink to this definition")
SharedMemory _\= _[#](#cucim.clara.cache.CacheType.SharedMemory "Permalink to this definition")
_property_ name[#](#cucim.clara.cache.CacheType.name "Permalink to this definition")
_property_ value[#](#cucim.clara.cache.CacheType.value "Permalink to this definition")
_class_ cucim.clara.cache.ImageCache[#](#cucim.clara.cache.ImageCache "Permalink to this definition")
Attributes:
[`capacity`](#cucim.clara.cache.ImageCache.capacity "cucim.clara.cache.ImageCache.capacity")
A capacity of list/hashmap.
[`config`](#cucim.clara.cache.ImageCache.config "cucim.clara.cache.ImageCache.config")
Returns the dictionary of configuration.
[`free_memory`](#cucim.clara.cache.ImageCache.free_memory "cucim.clara.cache.ImageCache.free_memory")
A cache memory size available in the cache memory.
[`hit_count`](#cucim.clara.cache.ImageCache.hit_count "cucim.clara.cache.ImageCache.hit_count")
A cache hit count.
[`memory_capacity`](#cucim.clara.cache.ImageCache.memory_capacity "cucim.clara.cache.ImageCache.memory_capacity")
A capacity of cache memory.
[`memory_size`](#cucim.clara.cache.ImageCache.memory_size "cucim.clara.cache.ImageCache.memory_size")
A size of cache memory used.
[`miss_count`](#cucim.clara.cache.ImageCache.miss_count "cucim.clara.cache.ImageCache.miss_count")
A cache miss count.
[`size`](#cucim.clara.cache.ImageCache.size "cucim.clara.cache.ImageCache.size")
A size of list/hashmap.
[`type`](#cucim.clara.cache.ImageCache.type "cucim.clara.cache.ImageCache.type")
A Cache type.
Methods
| | |
| --- | --- |
| [`record`](#cucim.clara.cache.ImageCache.record "cucim.clara.cache.ImageCache.record")
(self\[, value\]) | Records the cache statistics. |
| [`reserve`](#cucim.clara.cache.ImageCache.reserve "cucim.clara.cache.ImageCache.reserve")
(self, memory\_capacity, \*\*kwargs) | Reserves more memory if possible. |
_property_ capacity[#](#cucim.clara.cache.ImageCache.capacity "Permalink to this definition")
A capacity of list/hashmap.
_property_ config[#](#cucim.clara.cache.ImageCache.config "Permalink to this definition")
Returns the dictionary of configuration.
_property_ free\_memory[#](#cucim.clara.cache.ImageCache.free_memory "Permalink to this definition")
A cache memory size available in the cache memory.
_property_ hit\_count[#](#cucim.clara.cache.ImageCache.hit_count "Permalink to this definition")
A cache hit count.
_property_ memory\_capacity[#](#cucim.clara.cache.ImageCache.memory_capacity "Permalink to this definition")
A capacity of cache memory.
_property_ memory\_size[#](#cucim.clara.cache.ImageCache.memory_size "Permalink to this definition")
A size of cache memory used.
_property_ miss\_count[#](#cucim.clara.cache.ImageCache.miss_count "Permalink to this definition")
A cache miss count.
record(_self: [cucim.clara.\_cucim.cache.ImageCache](#cucim.clara.cache.ImageCache "cucim.clara._cucim.cache.ImageCache")
_, _value: [object](https://docs.python.org/3/library/functions.html#object "(in Python v3.13)")
\= None_) → [bool](https://docs.python.org/3/library/functions.html#bool "(in Python v3.13)")
[#](#cucim.clara.cache.ImageCache.record "Permalink to this definition")
Records the cache statistics.
reserve(_self: [cucim.clara.\_cucim.cache.ImageCache](#cucim.clara.cache.ImageCache "cucim.clara._cucim.cache.ImageCache")
_, _memory\_capacity: [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")
_, _\*\*kwargs_) → [None](https://docs.python.org/3/library/constants.html#None "(in Python v3.13)")
[#](#cucim.clara.cache.ImageCache.reserve "Permalink to this definition")
Reserves more memory if possible.
_property_ size[#](#cucim.clara.cache.ImageCache.size "Permalink to this definition")
A size of list/hashmap.
_property_ type[#](#cucim.clara.cache.ImageCache.type "Permalink to this definition")
A Cache type.
cucim.clara.cache.preferred\_memory\_capacity(_img: [object](https://docs.python.org/3/library/functions.html#object "(in Python v3.13)")
\= None_, _image\_size: Optional\[List\[[int](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")\
\]\] \= None_, _tile\_size: Optional\[List\[[int](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")\
\]\] \= None_, _patch\_size: Optional\[List\[[int](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")\
\]\] \= None_, _bytes\_per\_pixel: [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")
\= 3_) → [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")
[#](#cucim.clara.cache.preferred_memory_capacity "Permalink to this definition")
Returns a good cache memory capacity value in MiB for the given conditions.
Please see how the value is calculated: [https://godbolt.org/z/8vxnPfKM5](https://godbolt.org/z/8vxnPfKM5)
Args:
img: A CuImage object that can provide image\_size, tile\_size, bytes\_per\_pixel information. If this argument is provided, only patch\_size from the arguments is used for the calculation. image\_size: A list of values that presents the image size (width, height). tile\_size: A list of values that presents the tile size (width, height). The default value is (256, 256). patch\_size: A list of values that presents the patch size (width, height). The default value is (256, 256). bytes\_per\_pixel: The number of bytes that each pixel in the 2D image takes place. The default value is 3.
Returns:
int: The suggested memory capacity in MiB.
### filesystem[#](#module-cucim.clara.filesystem "Permalink to this heading")
_class_ cucim.clara.filesystem.CuFileDriver[#](#cucim.clara.filesystem.CuFileDriver "Permalink to this definition")
Methods
| | |
| --- | --- |
| [`close`](#cucim.clara.filesystem.CuFileDriver.close "cucim.clara.filesystem.CuFileDriver.close")
(self) | Closes opened file if not closed. |
| [`pread`](#cucim.clara.filesystem.CuFileDriver.pread "cucim.clara.filesystem.CuFileDriver.pread")
(self, buf, count, file\_offset\[, ...\]) | Reads up to count bytes from the file driver at offset file\_offset (from the start of the file) into the buffer buf starting at offset buf\_offset. |
| [`pwrite`](#cucim.clara.filesystem.CuFileDriver.pwrite "cucim.clara.filesystem.CuFileDriver.pwrite")
(self, buf, count, file\_offset\[, ...\]) | Reads up to count bytes from the file driver at offset file\_offset (from the start of the file) into the buffer buf starting at offset buf\_offset. |
close(_self: [cucim.clara.\_cucim.filesystem.CuFileDriver](#cucim.clara.filesystem.CuFileDriver "cucim.clara._cucim.filesystem.CuFileDriver")
_) → [bool](https://docs.python.org/3/library/functions.html#bool "(in Python v3.13)")
[#](#cucim.clara.filesystem.CuFileDriver.close "Permalink to this definition")
Closes opened file if not closed.
pread(_self: [cucim.clara.\_cucim.filesystem.CuFileDriver](#cucim.clara.filesystem.CuFileDriver "cucim.clara._cucim.filesystem.CuFileDriver")
_, _buf: [object](https://docs.python.org/3/library/functions.html#object "(in Python v3.13)")
_, _count: [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")
_, _file\_offset: [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")
_, _buf\_offset: [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")
\= 0_) → [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")
[#](#cucim.clara.filesystem.CuFileDriver.pread "Permalink to this definition")
Reads up to count bytes from the file driver at offset file\_offset (from the start of the file) into the buffer buf starting at offset buf\_offset. The file offset is not changed.
Args:
buf: A buffer where read bytes are stored. Buffer can be either in CPU memory or (CUDA) GPU memory. count: The number of bytes to read. file\_offset: An offset from the start of the file. buf\_offset: An offset from the start of the buffer. Default value is 0.
Returns:
The number of bytes read if succeed, -1 otherwise.
pwrite(_self: [cucim.clara.\_cucim.filesystem.CuFileDriver](#cucim.clara.filesystem.CuFileDriver "cucim.clara._cucim.filesystem.CuFileDriver")
_, _buf: [object](https://docs.python.org/3/library/functions.html#object "(in Python v3.13)")
_, _count: [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")
_, _file\_offset: [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")
_, _buf\_offset: [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")
\= 0_) → [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")
[#](#cucim.clara.filesystem.CuFileDriver.pwrite "Permalink to this definition")
Reads up to count bytes from the file driver at offset file\_offset (from the start of the file) into the buffer buf starting at offset buf\_offset. The file offset is not changed.
Args:
buf: A buffer where write bytes come from. Buffer can be either in CPU memory or (CUDA) GPU memory. count: The number of bytes to write. file\_offset: An offset from the start of the file. buf\_offset: An offset from the start of the buffer. Default value is 0.
Returns:
The number of bytes written if succeed, -1 otherwise.
cucim.clara.filesystem.close(_arg0: [cucim.clara.\_cucim.filesystem.CuFileDriver](#cucim.clara.filesystem.CuFileDriver "cucim.clara._cucim.filesystem.CuFileDriver")
_) → [bool](https://docs.python.org/3/library/functions.html#bool "(in Python v3.13)")
[#](#cucim.clara.filesystem.close "Permalink to this definition")
Closes the given file driver.
Args:
fd: An CuFileDriver object.
Returns:
True if succeed, False otherwise.
cucim.clara.filesystem.discard\_page\_cache(_file\_path: [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.13)")
_) → [bool](https://docs.python.org/3/library/functions.html#bool "(in Python v3.13)")
[#](#cucim.clara.filesystem.discard_page_cache "Permalink to this definition")
Discards a system (page) cache for the given file path.
Args:
file\_path: A file path to drop system cache.
Returns:
True if succeed, False otherwise.
cucim.clara.filesystem.open(_file\_path: [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.13)")
_, _flags: [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.13)")
_, _mode: [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")
\= 420_) → [cucim.clara.\_cucim.filesystem.CuFileDriver](#cucim.clara.filesystem.CuFileDriver "cucim.clara._cucim.filesystem.CuFileDriver")
[#](#cucim.clara.filesystem.open "Permalink to this definition")
Open file with specific flags and mode.
‘flags’ can be one of the following flag string:
* “r”: os.O\_RDONLY
* “r+”: os.O\_RDWR
* “w”: os.O\_RDWR | os.O\_CREAT | os.O\_TRUNC
* “a”: os.O\_RDWR | os.O\_CREAT
In addition to above flags, the method append os.O\_CLOEXEC and os.O\_DIRECT by default.
The following is optional flags that can be added to above string:
* ‘p’: Use POSIX APIs only (first try to open with O\_DIRECT). It does not use GDS.
* ‘n’: Do not add O\_DIRECT flag.
* ‘m’: Use memory-mapped file. This flag is supported only for the read-only file descriptor.
When ‘m’ is used, PROT\_READ and MAP\_SHARED are used for the parameter of mmap() function.
Args:
file\_path: A file path to open. flags: File flags in string. Default value is “r”. mode: A file mode. Default value is ‘0o644’.
Returns:
An object of CuFileDriver.
cucim.clara.filesystem.pread(_fd: [cucim.clara.\_cucim.filesystem.CuFileDriver](#cucim.clara.filesystem.CuFileDriver "cucim.clara._cucim.filesystem.CuFileDriver")
_, _buf: [object](https://docs.python.org/3/library/functions.html#object "(in Python v3.13)")
_, _count: [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")
_, _file\_offset: [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")
_, _buf\_offset: [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")
\= 0_) → [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")
[#](#cucim.clara.filesystem.pread "Permalink to this definition")
Reads up to count bytes from file driver fd at offset offset (from the start of the file) into the buffer buf starting at offset buf\_offset. The file offset is not changed.
Args:
fd: An object of CuFileDriver. buf: A buffer where read bytes are stored. Buffer can be either in CPU memory or (CUDA) GPU memory. count: The number of bytes to read. file\_offset: An offset from the start of the file. buf\_offset: An offset from the start of the buffer. Default value is 0.
Returns:
The number of bytes read if succeed, -1 otherwise.
cucim.clara.filesystem.pwrite(_fd: [cucim.clara.\_cucim.filesystem.CuFileDriver](#cucim.clara.filesystem.CuFileDriver "cucim.clara._cucim.filesystem.CuFileDriver")
_, _buf: [object](https://docs.python.org/3/library/functions.html#object "(in Python v3.13)")
_, _count: [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")
_, _file\_offset: [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")
_, _buf\_offset: [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")
\= 0_) → [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")
[#](#cucim.clara.filesystem.pwrite "Permalink to this definition")
Write up to count bytes from the buffer buf starting at offset buf\_offset to the file driver fd at offset offset (from the start of the file). The file offset is not changed.
Args:
fd: An object of CuFileDriver. buf: A buffer where write bytes come from. Buffer can be either in CPU memory or (CUDA) GPU memory. count: The number of bytes to write. file\_offset: An offset from the start of the file. buf\_offset: An offset from the start of the buffer. Default value is 0.
Returns:
The number of bytes written if succeed, -1 otherwise.
### io[#](#module-cucim.clara.io "Permalink to this heading")
_class_ cucim.clara.io.Device[#](#cucim.clara.io.Device "Permalink to this definition")
Attributes:
[`index`](#cucim.clara.io.Device.index "cucim.clara.io.Device.index")
Device index.
[`type`](#cucim.clara.io.Device.type "cucim.clara.io.Device.type")
Device type.
Methods
| | |
| --- | --- |
| [`parse_type`](#cucim.clara.io.Device.parse_type "cucim.clara.io.Device.parse_type")
(arg0) | Create DeviceType object from the device name string. |
_property_ index[#](#cucim.clara.io.Device.index "Permalink to this definition")
Device index.
_static_ parse\_type(_arg0: [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.13)")
_) → [cucim.clara.\_cucim.io.DeviceType](#cucim.clara.io.DeviceType "cucim.clara._cucim.io.DeviceType")
[#](#cucim.clara.io.Device.parse_type "Permalink to this definition")
Create DeviceType object from the device name string.
_property_ type[#](#cucim.clara.io.Device.type "Permalink to this definition")
Device type.
_class_ cucim.clara.io.DeviceType[#](#cucim.clara.io.DeviceType "Permalink to this definition")
Members:
CPU
CUDA
CUDAHost
CUDAManaged
CPUShared
CUDAShared
Attributes:
[`name`](#cucim.clara.io.DeviceType.name "cucim.clara.io.DeviceType.name")
name(self: handle) -> str
**value**
CPU _\= _[#](#cucim.clara.io.DeviceType.CPU "Permalink to this definition")
CPUShared _\= _[#](#cucim.clara.io.DeviceType.CPUShared "Permalink to this definition")
CUDA _\= _[#](#cucim.clara.io.DeviceType.CUDA "Permalink to this definition")
CUDAHost _\= _[#](#cucim.clara.io.DeviceType.CUDAHost "Permalink to this definition")
CUDAManaged _\= _[#](#cucim.clara.io.DeviceType.CUDAManaged "Permalink to this definition")
CUDAShared _\= _[#](#cucim.clara.io.DeviceType.CUDAShared "Permalink to this definition")
_property_ name[#](#cucim.clara.io.DeviceType.name "Permalink to this definition")
_property_ value[#](#cucim.clara.io.DeviceType.value "Permalink to this definition")
core Submodules[#](#core-submodules "Permalink to this heading")
-----------------------------------------------------------------
### color[#](#module-cucim.core.operations.color "Permalink to this heading")
cucim.core.operations.color.color\_jitter(_img: [Any](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.13)")
_, _brightness\=0_, _contrast\=0_, _saturation\=0_, _hue\=0_)[#](#cucim.core.operations.color.color_jitter "Permalink to this definition")
Applies color jitter by random sequential application of 4 operations (brightness, contrast, saturation, hue).
Parameters:
**img**channel first, cupy.ndarray or numpy.ndarray
Input data of shape (C, H, W). Can also batch process input of shape (N, C, H, W). Can be a numpy.ndarray or cupy.ndarray.
**brightness**float or 2-tuple of float, optional
Non-negative factor to jitter the brightness by. When brightness is a scalar, scaling will be by a random value in range `[max(0, 1 - brightness), (1 + brightness)]`. brightness can also be a 2-tuple specifying the range for the random scaling factor. A value of 0 or (1, 1) will result in no change.
**contrast**float or 2-tuple of float, optional
Non-negative factor to jitter the contrast by. When contrast is a scalar, scaling will be by a random value between `[max(0, 1 - contrast), (1 + contrast)]`. contrast can also be a 2-tuple specifying the range for the random scaling factor. A value of 0 or (1, 1) will result in no change.
**saturation**float or 2-tuple of float, optional
Non-negative factor to jitter the saturation by. When saturation is a scalar, scaling will be by a random value between `[max(0, 1 - saturation), (1 + saturation)]`. saturation can also be a 2-tuple specifying the range for the random scaling factor. A value of 0 or (1, 1) will result in no change.
**hue**float or 2-tuple of float, optional
Factor between \[-0.5, 0.5\] to jitter hue by. When hue is a scalar, scaling will be by a random value between in the range `[-hue, hue]`. hue can also be a 2-tuple specifying the range. A value of 0 or (0, 0) will result in no change.
Returns:
**out**cupy.ndarray or numpy.ndarray
Output data. Same dimensions and type as input.
Raises:
ValueError
If ‘brightness’,’contrast’,’saturation’ or ‘hue’ is outside of allowed range
TypeError
If input ‘img’ is not cupy.ndarray or numpy.ndarray
Examples
\>>> import cucim.core.operations.color as ccl
\>>> \# input is channel first 3d array
\>>> output\_array \= ccl.color\_jitter(input\_arr,.25,.75,.25,.04)
cucim.core.operations.color.image\_to\_absorbance(_image_, _source\_intensity=255.0_, _dtype=_)[#](#cucim.core.operations.color.image_to_absorbance "Permalink to this definition")
Convert an image to units of absorbance (optical density).
Parameters:
**image**ndarray
The image to convert to absorbance. Can be single or multichannel.
**source\_intensity**float, optional
Reference intensity for image.
**dtype**numpy.dtype, optional
The floating point precision at which to compute the absorbance.
Returns:
**absorbance**ndarray
The absorbance computed from image.
Notes
If image has an integer dtype it will be clipped to range `[1, source_intensity]`, while float image inputs are clipped to range `[source_intensity/255, source_intensity]`. The minimum is to avoid log(0). Absorbance is then given by `absorbance = log(image / source_intensity)`.
cucim.core.operations.color.normalize\_colors\_pca(_image_, _source\_intensity: [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.13)")
\= 240.0_, _alpha: [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.13)")
\= 1.0_, _beta: [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.13)")
\= 0.345_, _ref\_stain\_coeff: [tuple](https://docs.python.org/3/library/stdtypes.html#tuple "(in Python v3.13)")
| [cupy.ndarray](https://docs.cupy.dev/en/stable/reference/generated/cupy.ndarray.html#cupy.ndarray "(in CuPy v13.4.0)")
\= ((0.5626, 0.2159), (0.7201, 0.8012), (0.4062, 0.5581))_, _ref\_max\_conc: [tuple](https://docs.python.org/3/library/stdtypes.html#tuple "(in Python v3.13)")
| [cupy.ndarray](https://docs.cupy.dev/en/stable/reference/generated/cupy.ndarray.html#cupy.ndarray "(in CuPy v13.4.0)")
\= (1.9705, 1.0308)_, _image\_type: [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.13)")
\= 'intensity'_, _channel\_axis: [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")
\= 0_)[#](#cucim.core.operations.color.normalize_colors_pca "Permalink to this definition")
Extract the matrix of stain coefficient from the image.
Parameters:
**image**np.ndarray
RGB image to determine concentrations for. Intensities should typically be within unsigned 8-bit integer intensity range (\[0, 255\]) when `image_type == "intensity"`.
**source\_intensity**float, optional
Transmitted light intensity. The algorithm will clip image intensities above the specified source\_intensity and then normalize by source\_intensity so that image intensities are <= 1.0. Only used when image\_type==”intensity”.
**alpha**float, optional
Algorithm parameter controlling the `[alpha, 100 - alpha]` percentile range used as a robust \[min, max\] estimate.
**beta**float, optional
Absorbance (optical density) threshold below which to consider pixels as transparent. Transparent pixels are excluded from the estimation.
**ref\_stain\_coeff**array-like
Reference stain coefficients as determined by the output of stain\_extraction\_pca for a reference image.
**ref\_max\_conc**tuple or cp.ndarray
The reference maximum concentrations.
**image\_type**{“intensity”, “absorbance”}, optional
With the default image\_type of “intensity”, the image will be transformed to an absorbance using `image_to_absorbance`. If the input image is already an absorbance image, then image\_type should be set to “absorbance” instead.
**channel\_axis**int, optional
The axis corresponding to color channels (default is the last axis).
Returns:
**stain\_coeff**np.ndarray
Stain attenuation coefficient matrix derived from the image, where the first column corresponds to H, the second column is E and the rows are RGB values.
Notes
The default beta of 0.345 is equivalent to the use of 0.15 in [\[1\]](#re6f8c058493f-1)
. The difference is due to our use of the natural log instead of a decadic log (log10) when computing the absorbance.
References
\[[1](#id1)\
\]
M. Macenko et al., “A method for normalizing histology slides for quantitative analysis,” 2009 IEEE International Symposium on Biomedical Imaging: From Nano to Macro, 2009, pp. 1107-1110, doi: 10.1109/ISBI.2009.5193250. [http://wwwx.cs.unc.edu/~mn/sites/default/files/macenko2009.pdf](http://wwwx.cs.unc.edu/~mn/sites/default/files/macenko2009.pdf)
cucim.core.operations.color.stain\_extraction\_pca(_image_, _source\_intensity\=240_, _alpha\=1_, _beta\=0.345_, _\*_, _channel\_axis\=0_, _image\_type\='intensity'_)[#](#cucim.core.operations.color.stain_extraction_pca "Permalink to this definition")
Extract the matrix of H & E stain coefficient from an image.
Uses a method that selects stain vectors based on the angle distribution within a best-fit plane determined by principle component analysis (PCA) [\[1\]](#r55f3accbd1ab-1)
.
Parameters:
**image**cp.ndarray
RGB image to perform stain extraction on. Intensities should typically be within unsigned 8-bit integer intensity range (\[0, 255\]) when `image_type == "intensity"`.
**source\_intensity**float, optional
Transmitted light intensity. The algorithm will clip image intensities above the specified source\_intensity and then normalize by source\_intensity so that image intensities are <= 1.0. Only used when image\_type==”intensity”.
**alpha**float, optional
Algorithm parameter controlling the `[alpha, 100 - alpha]` percentile range used as a robust \[min, max\] estimate.
**beta**float, optional
Absorbance (optical density) threshold below which to consider pixels as transparent. Transparent pixels are excluded from the estimation.
Returns:
**stain\_coeff**cp.ndarray
Stain attenuation coefficient matrix derived from the image, where the first column corresponds to H, the second column is E and the rows are RGB values.
Notes
The default beta of 0.345 is equivalent to the use of 0.15 in [\[1\]](#r55f3accbd1ab-1)
. The difference is due to our use of the natural log instead of a decadic log (log10) when computing the absorbance.
References
\[1\] ([1](#id3)
,[2](#id4)
)
M. Macenko et al., “A method for normalizing histology slides for quantitative analysis,” 2009 IEEE International Symposium on Biomedical Imaging: From Nano to Macro, 2009, pp. 1107-1110, doi: 10.1109/ISBI.2009.5193250. [http://wwwx.cs.unc.edu/~mn/sites/default/files/macenko2009.pdf](http://wwwx.cs.unc.edu/~mn/sites/default/files/macenko2009.pdf)
### expose[#](#module-cucim.core.operations.expose "Permalink to this heading")
### intensity[#](#module-cucim.core.operations.intensity "Permalink to this heading")
cucim.core.operations.intensity.normalize\_data(_img: [Any](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.13)")
_, _norm\_constant: [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.13)")
_, _min\_value: [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.13)")
_, _max\_value: [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.13)")
_, _type: [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.13)")
\= 'range'_) → [Any](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.13)")
[#](#cucim.core.operations.intensity.normalize_data "Permalink to this definition")
Apply intensity normalization to the input array. Normalize intensities to the range of \[0, norm\_constant\].
Parameters:
**img**channel first, cupy.ndarray or numpy.ndarray
Input data of shape (C, H, W). Can also batch process input of shape (N, C, H, W). Can be a numpy.ndarray or cupy.ndarray.
**norm\_constant: float**
Normalization range of the input data. \[0, norm\_constant\]
**min\_value**float
Minimum intensity value in input data.
**max\_value**float
Maximum intensity value in input data.
**type**{‘range’, ‘atan’}
Type of normalization.
Returns:
**out**cupy.ndarray or numpy.ndarray
Output data. Same dimensions and type as input.
Raises:
TypeError
If input ‘img’ is not cupy.ndarray or numpy.ndarray
ValueError
If input original intensity min and max are same
ValueError
If incorrect normalization type is invoked
Examples
\>>> import cucim.core.operations.intensity as its
\>>> \# input is channel first 3d array
\>>> output\_array \= its.normalize\_data(input\_arr,
10, 0 , 255)
cucim.core.operations.intensity.rand\_zoom(_img: [Any](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.13)")
_, _min\_zoom: [collections.abc.Sequence](https://docs.python.org/3/library/collections.abc.html#collections.abc.Sequence "(in Python v3.13)")
\[[float](https://docs.python.org/3/library/functions.html#float "(in Python v3.13)")\
\] | [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.13)")
\= 0.9_, _max\_zoom: [collections.abc.Sequence](https://docs.python.org/3/library/collections.abc.html#collections.abc.Sequence "(in Python v3.13)")
\[[float](https://docs.python.org/3/library/functions.html#float "(in Python v3.13)")\
\] | [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.13)")
\= 1.1_, _prob: [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.13)")
\= 0.1_, _whole\_batch: [bool](https://docs.python.org/3/library/functions.html#bool "(in Python v3.13)")
\= False_)[#](#cucim.core.operations.intensity.rand_zoom "Permalink to this definition")
Randomly Calls zoom with random zoom factor
Parameters:
**img**channel first, cupy.ndarray or numpy.ndarray
Input data of shape (C, H, W). Can also batch process input of shape (N, C, H, W). Can be a numpy.ndarray or cupy.ndarray.
**min\_zoom: Min zoom factor. Can be float or sequence same size as image.**
If a float, select a random factor from \[min\_zoom, max\_zoom\] then apply to all spatial dims to keep the original spatial shape ratio. If a sequence, min\_zoom should contain one value for each spatial axis. If 2 values provided for 3D data, use the first value for both H & W dims to keep the same zoom ratio.
**max\_zoom: Max zoom factor. Can be float or sequence same size as image.**
If a float, select a random factor from \[min\_zoom, max\_zoom\] then apply to all spatial dims to keep the original spatial shape ratio. If a sequence, max\_zoom should contain one value for each spatial axis. If 2 values provided for 3D data, use the first value for both H & W dims to keep the same zoom ratio.
**prob: Probability of zooming.**
**whole\_batch: Flag to apply transform on whole batch.**
If False, each image in the batch is randomly transformed It True, entire batch is transformed randomly.
Returns:
**out**cupy.ndarray or numpy.ndarray
Output data. Same dimensions and type as input.
Raises:
TypeError
If input ‘img’ is not cupy.ndarray or numpy.ndarray
Examples
\>>> import cucim.core.operations.intensity as its
\>>> \# input is channel first 3d array
\>>> output\_array \= its.rand\_zoom(input\_arr)
cucim.core.operations.intensity.scale\_intensity\_range(_img: [Any](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.13)")
_, _b\_max: [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.13)")
_, _b\_min: [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.13)")
_, _a\_max: [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.13)")
_, _a\_min: [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.13)")
_, _clip: [bool](https://docs.python.org/3/library/functions.html#bool "(in Python v3.13)")
\= False_) → [Any](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.13)")
[#](#cucim.core.operations.intensity.scale_intensity_range "Permalink to this definition")
Apply intensity scaling to the input array. Scaling from \[a\_min, a\_max\] to \[b\_min, b\_max\] with clip option.
Parameters:
**img**channel first, cupy.ndarray or numpy.ndarray
Input data of shape (C, H, W). Can also batch process input of shape (N, C, H, W). Can be a numpy.ndarray or cupy.ndarray.
**b\_min**float
intensity target range min.
**b\_max**float
intensity target range max.
**a\_min**float
intensity original range min.
**a\_max**float
intensity original range max.
**clip**float
whether to perform clip after scaling.
Returns:
**out**cupy.ndarray or numpy.ndarray
Output data. Same dimensions and type as input.
Raises:
TypeError
If input ‘img’ is not cupy.ndarray or numpy.ndarray
ValueError
If input original intensity min and max are same
Examples
\>>> import cucim.core.operations.intensity as its
\>>> \# input is channel first 3d array
\>>> output\_array \= its.scale\_intensity\_range(input\_arr,
0.0, 255.0,
-1.0, 1.0, False)
cucim.core.operations.intensity.zoom(_img: [Any](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.13)")
_, _zoom\_factor: [Sequence](https://docs.python.org/3/library/collections.abc.html#collections.abc.Sequence "(in Python v3.13)")
\[[float](https://docs.python.org/3/library/functions.html#float "(in Python v3.13)")\
\]_)[#](#cucim.core.operations.intensity.zoom "Permalink to this definition")
Zooms an ND image
Parameters:
**img**channel first, cupy.ndarray or numpy.ndarray
Input data of shape (C, H, W). Can also batch process input of shape (N, C, H, W). Can be a numpy.ndarray or cupy.ndarray.
**zoom\_factor: Sequence\[float\]**
The zoom factor along the spatial axes. Zoom factor should contain one value for each spatial axis.
**Returns**
**——-**
**out**cupy.ndarray or numpy.ndarray
Output data. Same dimensions and type as input.
Raises:
TypeError
If input ‘img’ is not cupy.ndarray or numpy.ndarray
Examples
\>>> import cucim.core.operations.intensity as its
\>>> \# input is channel first 3d array
\>>> output\_array \= its.zoom(input\_arr,\[1.1,1.1\])
### morphology[#](#module-cucim.core.operations.morphology "Permalink to this heading")
cucim.core.operations.morphology.distance\_transform\_edt(_image_, _sampling\=None_, _return\_distances\=True_, _return\_indices\=False_, _distances\=None_, _indices\=None_, _\*_, _block\_params\=None_, _float64\_distances\=False_)[#](#cucim.core.operations.morphology.distance_transform_edt "Permalink to this definition")
Exact Euclidean distance transform.
This function calculates the distance transform of the input, by replacing each foreground (non-zero) element, with its shortest distance to the background (any zero-valued element).
In addition to the distance transform, the feature transform can be calculated. In this case the index of the closest background element to each foreground element is returned in a separate array.
Parameters:
**image**array\_like
Input data to transform. Can be any type but will be converted into binary: 1 wherever image equates to True, 0 elsewhere.
**sampling**float, or sequence of float, optional
Spacing of elements along each dimension. If a sequence, must be of length equal to the image rank; if a single number, this is used for all axes. If not specified, a grid spacing of unity is implied.
**return\_distances**bool, optional
Whether to calculate the distance transform.
**return\_indices**bool, optional
Whether to calculate the feature transform.
**distances**cupy.ndarray, optional
An output array to store the calculated distance transform, instead of returning it. return\_distances must be `True`. It must be the same shape as image. Should have dtype `cp.float32` if float64\_distances is `False`, otherwise it should be `cp.float64`.
**indices**cupy.ndarray, optional
An output array to store the calculated feature transform, instead of returning it. return\_indicies must be `True`. Its shape must be `(image.ndim,) + image.shape`. Its dtype must be a signed or unsigned integer type of at least 16-bits in 2D or 32-bits in 3D.
Returns:
**distances**cupy.ndarray, optional
The calculated distance transform. Returned only when return\_distances is `True` and distances is not supplied. It will have the same shape as image. Will have dtype cp.float64 if float64\_distances is `True`, otherwise it will have dtype `cp.float32`.
**indices**ndarray, optional
The calculated feature transform. It has an image-shaped array for each dimension of the image. See example below. Returned only when return\_indices is `True` and indices is not supplied.
Other Parameters:
**block\_params**3-tuple of int
The m1, m2, m3 algorithm parameters as described in [\[2\]](#r8e5c1ce987ff-2)
. If None, suitable defaults will be chosen. Note: This parameter is specific to cuCIM and does not exist in SciPy.
**float64\_distances**bool, optional
If True, use double precision in the distance computation (to match SciPy behavior). Otherwise, single precision will be used for efficiency. Note: This parameter is specific to cuCIM and does not exist in SciPy.
Notes
The Euclidean distance transform gives values of the Euclidean distance.
\\\[y\_i = \\sqrt{\\sum\_{i}^{n} (x\[i\] - b\[i\])^2}\\\]
where \\(b\[i\]\\) is the background point (value 0) with the smallest Euclidean distance to input points \\(x\[i\]\\), and \\(n\\) is the number of dimensions.
Note that the indices output may differ from the one given by [`scipy.ndimage.distance_transform_edt()`](https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.distance_transform_edt.html#scipy.ndimage.distance_transform_edt "(in SciPy v1.15.2)")
in the case of input pixels that are equidistant from multiple background points.
The parallel banding algorithm implemented here was originally described in [\[1\]](#r8e5c1ce987ff-1)
. The kernels used here correspond to the revised PBA+ implementation that is described on the author’s website [\[2\]](#r8e5c1ce987ff-2)
. The source code of the author’s PBA+ implementation is available at [\[3\]](#r8e5c1ce987ff-3)
.
References
\[[1](#id7)\
\]
Thanh-Tung Cao, Ke Tang, Anis Mohamed, and Tiow-Seng Tan. 2010. Parallel Banding Algorithm to compute exact distance transform with the GPU. In Proceedings of the 2010 ACM SIGGRAPH symposium on Interactive 3D Graphics and Games (I3D ’10). Association for Computing Machinery, New York, NY, USA, 83–90. DOI:https://doi.org/10.1145/1730804.1730818
\[2\] ([1](#id6)
,[2](#id8)
)
[https://www.comp.nus.edu.sg/~tants/pba.html](https://www.comp.nus.edu.sg/~tants/pba.html)
\[[3](#id9)\
\]
[orzzzjq/Parallel-Banding-Algorithm-plus](https://github.com/orzzzjq/Parallel-Banding-Algorithm-plus)
Examples
\>>> import cupy as cp
\>>> from cucim.core.operations import morphology
\>>> a \= cp.array((\[0,1,1,1,1\],
... \[0,0,1,1,1\],
... \[0,1,1,1,1\],
... \[0,1,1,1,0\],
... \[0,1,1,0,0\]))
\>>> morphology.distance\_transform\_edt(a)
array(\[\[ 0. , 1. , 1.4142, 2.2361, 3. \],\
\[ 0. , 0. , 1. , 2. , 2. \],\
\[ 0. , 1. , 1.4142, 1.4142, 1. \],\
\[ 0. , 1. , 1.4142, 1. , 0. \],\
\[ 0. , 1. , 1. , 0. , 0. \]\])
With a sampling of 2 units along x, 1 along y:
\>>> morphology.distance\_transform\_edt(a, sampling\=\[2,1\])
array(\[\[ 0. , 1. , 2. , 2.8284, 3.6056\],\
\[ 0. , 0. , 1. , 2. , 3. \],\
\[ 0. , 1. , 2. , 2.2361, 2. \],\
\[ 0. , 1. , 2. , 1. , 0. \],\
\[ 0. , 1. , 1. , 0. , 0. \]\])
Asking for indices as well:
\>>> edt, inds \= morphology.distance\_transform\_edt(a, return\_indices\=True)
\>>> inds
array(\[\[\[0, 0, 1, 1, 3\],\
\[1, 1, 1, 1, 3\],\
\[2, 2, 1, 3, 3\],\
\[3, 3, 4, 4, 3\],\
\[4, 4, 4, 4, 4\]\],\
\[\[0, 0, 1, 1, 4\],\
\[0, 1, 1, 1, 4\],\
\[0, 0, 1, 4, 4\],\
\[0, 0, 3, 3, 4\],\
\[0, 0, 3, 3, 4\]\]\])
### spatial[#](#module-cucim.core.operations.spatial "Permalink to this heading")
cucim.core.operations.spatial.image\_flip(_img: [Any](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.13)")
_, _spatial\_axis: ()_) → [Any](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.13)")
[#](#cucim.core.operations.spatial.image_flip "Permalink to this definition")
Shape preserving order reversal of elements in input array along the given spatial axis
Parameters:
**img**cupy.ndarray or numpy.ndarray
Input data. Can be numpy.ndarray or cupy.ndarray
**spatial\_axis**tuple
spatial axis along which to flip over the input array
Returns:
**out**cupy.ndarray or numpy.ndarray
Output data. Same dimensions and type as input.
Raises:
TypeError
If input ‘img’ is not cupy.ndarray or numpy.ndarray
Examples
\>>> import cucim.core.operations.spatial as spt
\>>> \# input is channel first 3d array
\>>> output\_array \= spt.image\_flip(input\_arr, (1, 2))
cucim.core.operations.spatial.image\_rotate\_90(_img: [Any](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.13)")
_, _k: [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")
_, _spatial\_axis: ()_) → [Any](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.13)")
[#](#cucim.core.operations.spatial.image_rotate_90 "Permalink to this definition")
Rotate input array by 90 degrees along the given axis
Parameters:
**img**cupy.ndarray or numpy.ndarray
Input data. Can be numpy.ndarray or cupy.ndarray
**k**int
number of times to rotate
**spatial\_axis**tuple
spatial axis along which to rotate the input array by 90 degrees
Returns:
**out**cupy.ndarray or numpy.ndarray
Output data. Same dimensions and type as input.
Raises:
TypeError
If input ‘img’ is not cupy.ndarray or numpy.ndarray
Examples
\>>> import cucim.core.operations.spatial as spt
\>>> \# input is channel first 3d array
\>>> output\_array \= spt.image\_rotate\_90(input\_arr,1,(1,2))
cucim.core.operations.spatial.rand\_image\_flip(_img: [Any](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.13)")
_, _spatial\_axis: ()_, _prob: [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.13)")
\= 0.1_, _whole\_batch: [bool](https://docs.python.org/3/library/functions.html#bool "(in Python v3.13)")
\= False_) → [Any](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.13)")
[#](#cucim.core.operations.spatial.rand_image_flip "Permalink to this definition")
Randomly flips the image along axis.
Parameters:
**img**cupy.ndarray or numpy.ndarray
Input data. Can be numpy.ndarray or cupy.ndarray
**prob: Probability of flipping.**
**spatial\_axis**tuple
spatial axis along which to flip over the input array
**whole\_batch: Flag to apply transform on whole batch.**
If False, each image in the batch is randomly transformed It True, entire batch is transformed randomly.
Returns:
**out**cupy.ndarray or numpy.ndarray
Output data. Same dimensions and type as input.
Raises:
TypeError
If input ‘img’ is not cupy.ndarray or numpy.ndarray
Examples
\>>> import cucim.core.operations.spatial as spt
\>>> \# input is channel first 3d array
\>>> output\_array \= spt.rand\_image\_flip(input\_arr,spatial\_axis\=(1,2))
cucim.core.operations.spatial.rand\_image\_rotate\_90(_img: [Any](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.13)")
_, _spatial\_axis: ()_, _prob: [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.13)")
\= 0.1_, _max\_k: [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")
\= 3_, _whole\_batch: [bool](https://docs.python.org/3/library/functions.html#bool "(in Python v3.13)")
\= False_) → [Any](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.13)")
[#](#cucim.core.operations.spatial.rand_image_rotate_90 "Permalink to this definition")
With probability prob, input arrays are rotated by 90 degrees in the plane specified by spatial\_axis.
Parameters:
**img**cupy.ndarray or numpy.ndarray
Input data. Can be numpy.ndarray or cupy.ndarray
**prob: probability of rotating.**
(Default 0.1, with 10% probability it returns a rotated array)
**max\_k: number of rotations**
will be sampled from np.random.randint(max\_k) + 1, (Default 3).
**spatial\_axis**tuple
spatial axis along which to rotate the input array by 90 degrees
**whole\_batch: Flag to apply transform on whole batch.**
If False, each image in the batch is randomly transformed It True, entire batch is transformed randomly.
Returns:
**out**cupy.ndarray or numpy.ndarray
Output data. Same dimensions and type as input.
Raises:
TypeError
If input ‘img’ is not cupy.ndarray or numpy.ndarray
Examples
\>>> import cucim.core.operations.spatial as spt
\>>> \# input is channel first 3d array
\>>> output\_array \= spt.rand\_image\_rotate\_90(input\_arr, spatial\_axis\=(1, 2))
skimage Submodules[#](#skimage-submodules "Permalink to this heading")
-----------------------------------------------------------------------
### color[#](#id13 "Permalink to this heading")
Color space conversion.
cucim.skimage.color.combine\_stains(_stains_, _conv\_matrix_, _\*_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.combine_stains "Permalink to this definition")
Stain to RGB color space conversion.
Parameters:
**stains**(…, C=3, …) array\_like
The image in stain color space. By default, the final dimension denotes channels.
**conv\_matrix: ndarray**
The stain separation matrix as described by G. Landini [\[1\]](#rfb03de915426-1)
.
**channel\_axis**int, optional
This parameter indicates which axis of the array corresponds to channels.
Returns:
**out**(…, C=3, …) ndarray
The image in RGB format. Same dimensions as input.
Raises:
ValueError
If stains is not at least 2-D with shape (…, C=3, …).
Notes
Stain combination matrices available in the `color` module and their respective colorspace:
* `rgb_from_hed`: Hematoxylin + Eosin + DAB
* `rgb_from_hdx`: Hematoxylin + DAB
* `rgb_from_fgx`: Feulgen + Light Green
* `rgb_from_bex`: Giemsa stain : Methyl Blue + Eosin
* `rgb_from_rbd`: FastRed + FastBlue + DAB
* `rgb_from_gdx`: Methyl Green + DAB
* `rgb_from_hax`: Hematoxylin + AEC
* `rgb_from_bro`: Blue matrix Anilline Blue + Red matrix Azocarmine + Orange matrix Orange-G
* `rgb_from_bpx`: Methyl Blue + Ponceau Fuchsin
* `rgb_from_ahx`: Alcian Blue + Hematoxylin
* `rgb_from_hpx`: Hematoxylin + PAS
References
\[[1](#id14)\
\]
[https://web.archive.org/web/20160624145052/http://www.mecourse.com/landinig/software/cdeconv/cdeconv.html](https://web.archive.org/web/20160624145052/http://www.mecourse.com/landinig/software/cdeconv/cdeconv.html)
\[2\]
A. C. Ruifrok and D. A. Johnston, “Quantification of histochemical staining by color deconvolution,” Anal. Quant. Cytol. Histol., vol. 23, no. 4, pp. 291–299, Aug. 2001.
Examples
\>>> import cupy as cp
\>>> from skimage import data
\>>> from cucim.skimage.color import (separate\_stains, combine\_stains,
... hdx\_from\_rgb, rgb\_from\_hdx)
\>>> ihc \= cp.array(data.immunohistochemistry())
\>>> ihc\_hdx \= separate\_stains(ihc, hdx\_from\_rgb)
\>>> ihc\_rgb \= combine\_stains(ihc\_hdx, rgb\_from\_hdx)
cucim.skimage.color.convert\_colorspace(_arr_, _fromspace_, _tospace_, _\*_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.convert_colorspace "Permalink to this definition")
Convert an image array to a new color space.
Valid color spaces are:
‘RGB’, ‘HSV’, ‘RGB CIE’, ‘XYZ’, ‘YUV’, ‘YIQ’, ‘YPbPr’, ‘YCbCr’, ‘YDbDr’
Parameters:
**arr**(…, C=3, …) array\_like
The image to convert. By default, the final dimension denotes channels.
**fromspace**str
The color space to convert from. Can be specified in lower case.
**tospace**str
The color space to convert to. Can be specified in lower case.
**channel\_axis**int, optional
This parameter indicates which axis of the array corresponds to channels.
Returns:
**out**(…, C=3, …) ndarray
The converted image. Same dimensions as input.
Raises:
ValueError
If fromspace is not a valid color space
ValueError
If tospace is not a valid color space
Notes
Conversion is performed through the “central” RGB color space, i.e. conversion from XYZ to HSV is implemented as `XYZ -> RGB -> HSV` instead of directly.
Examples
\>>> import cupy as cp
\>>> from skimage import data
\>>> img \= cp.array(data.astronaut())
\>>> img\_hsv \= convert\_colorspace(img, 'RGB', 'HSV')
cucim.skimage.color.deltaE\_cie76(_lab1_, _lab2_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.deltaE_cie76 "Permalink to this definition")
Euclidean distance between two points in Lab color space
Parameters:
**lab1**array\_like
reference color (Lab colorspace)
**lab2**array\_like
comparison color (Lab colorspace)
**channel\_axis**int, optional
This parameter indicates which axis of the arrays corresponds to channels.
Returns:
**dE**array\_like
distance between colors lab1 and lab2
References
\[1\]
[https://en.wikipedia.org/wiki/Color\_difference](https://en.wikipedia.org/wiki/Color_difference)
\[2\]
A. R. Robertson, “The CIE 1976 color-difference formulae,” Color Res. Appl. 2, 7-11 (1977).
cucim.skimage.color.deltaE\_ciede2000(_lab1_, _lab2_, _kL\=1_, _kC\=1_, _kH\=1_, _\*_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.deltaE_ciede2000 "Permalink to this definition")
Color difference as given by the CIEDE 2000 standard.
CIEDE 2000 is a major revision of CIDE94. The perceptual calibration is largely based on experience with automotive paint on smooth surfaces.
Parameters:
**lab1**array\_like
reference color (Lab colorspace)
**lab2**array\_like
comparison color (Lab colorspace)
**kL**float (range), optional
lightness scale factor, 1 for “acceptably close”; 2 for “imperceptible” see deltaE\_cmc
**kC**float (range), optional
chroma scale factor, usually 1
**kH**float (range), optional
hue scale factor, usually 1
**channel\_axis**int, optional
This parameter indicates which axis of the arrays corresponds to channels.
Returns:
**deltaE**array\_like
The distance between lab1 and lab2
Notes
CIEDE 2000 assumes parametric weighting factors for the lightness, chroma, and hue (kL, kC, kH respectively). These default to 1.
References
\[1\]
[https://en.wikipedia.org/wiki/Color\_difference](https://en.wikipedia.org/wiki/Color_difference)
\[2\]
[http://www.ece.rochester.edu/~gsharma/ciede2000/ciede2000noteCRNA.pdf](http://www.ece.rochester.edu/~gsharma/ciede2000/ciede2000noteCRNA.pdf)
[DOI:10.1364/AO.33.008069](https://doi.org/10.1364/AO.33.008069)
\[3\]
M. Melgosa, J. Quesada, and E. Hita, “Uniformity of some recent color metrics tested with an accurate color-difference tolerance dataset,” Appl. Opt. 33, 8069-8077 (1994).
cucim.skimage.color.deltaE\_ciede94(_lab1_, _lab2_, _kH\=1_, _kC\=1_, _kL\=1_, _k1\=0.045_, _k2\=0.015_, _\*_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.deltaE_ciede94 "Permalink to this definition")
Color difference according to CIEDE 94 standard
Accommodates perceptual non-uniformities through the use of application specific scale factors (kH, kC, kL, k1, and k2).
Parameters:
**lab1**array\_like
reference color (Lab colorspace)
**lab2**array\_like
comparison color (Lab colorspace)
**kH**float, optional
Hue scale
**kC**float, optional
Chroma scale
**kL**float, optional
Lightness scale
**k1**float, optional
first scale parameter
**k2**float, optional
second scale parameter
**channel\_axis**int, optional
This parameter indicates which axis of the arrays corresponds to channels.
Returns:
**dE**array\_like
color difference between lab1 and lab2
Notes
deltaE\_ciede94 is not symmetric with respect to lab1 and lab2. CIEDE94 defines the scales for the lightness, hue, and chroma in terms of the first color. Consequently, the first color should be regarded as the “reference” color.
kL, k1, k2 depend on the application and default to the values suggested for graphic arts
| Parameter | Graphic Arts | Textiles |
| --- | --- | --- |
| kL | 1.000 | 2.000 |
| k1 | 0.045 | 0.048 |
| k2 | 0.015 | 0.014 |
References
\[1\]
[https://en.wikipedia.org/wiki/Color\_difference](https://en.wikipedia.org/wiki/Color_difference)
\[2\]
[http://www.brucelindbloom.com/index.html?Eqn\_DeltaE\_CIE94.html](http://www.brucelindbloom.com/?Eqn_DeltaE_CIE94.html)
cucim.skimage.color.deltaE\_cmc(_lab1_, _lab2_, _kL\=1_, _kC\=1_, _\*_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.deltaE_cmc "Permalink to this definition")
Color difference from the CMC l:c standard.
This color difference was developed by the Colour Measurement Committee (CMC) of the Society of Dyers and Colourists (United Kingdom). It is intended for use in the textile industry.
The scale factors kL, kC set the weight given to differences in lightness and chroma relative to differences in hue. The usual values are `kL=2`, `kC=1` for “acceptability” and `kL=1`, `kC=1` for “imperceptibility”. Colors with `dE > 1` are “different” for the given scale factors.
Parameters:
**lab1**array\_like
reference color (Lab colorspace)
**lab2**array\_like
comparison color (Lab colorspace)
**channel\_axis**int, optional
This parameter indicates which axis of the arrays corresponds to channels.
Returns:
**dE**array\_like
distance between colors lab1 and lab2
Notes
deltaE\_cmc the defines the scales for the lightness, hue, and chroma in terms of the first color. Consequently `deltaE_cmc(lab1, lab2) != deltaE_cmc(lab2, lab1)`
References
\[1\]
[https://en.wikipedia.org/wiki/Color\_difference](https://en.wikipedia.org/wiki/Color_difference)
\[2\]
[http://www.brucelindbloom.com/index.html?Eqn\_DeltaE\_CIE94.html](http://www.brucelindbloom.com/?Eqn_DeltaE_CIE94.html)
\[3\]
F. J. J. Clarke, R. McDonald, and B. Rigg, “Modification to the JPC79 colour-difference formula,” J. Soc. Dyers Colour. 100, 128-132 (1984).
cucim.skimage.color.gray2rgb(_image_, _\*_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.gray2rgb "Permalink to this definition")
Create an RGB representation of a gray-level image.
Parameters:
**image**array\_like
Input image.
**channel\_axis**int, optional
This parameter indicates which axis of the output array will correspond to channels.
Returns:
**rgb**(…, C=3, …) ndarray
RGB image. A new dimension of length 3 is added to input image.
Notes
If the input is a 1-dimensional image of shape `(M, )`, the output will be shape `(M, 3)`.
cucim.skimage.color.gray2rgba(_image_, _alpha\=None_, _\*_, _channel\_axis\=\-1_, _check\_alpha\=True_)[#](#cucim.skimage.color.gray2rgba "Permalink to this definition")
Create a RGBA representation of a gray-level image.
Parameters:
**image**array\_like
Input image.
**alpha**array\_like, optional
Alpha channel of the output image. It may be a scalar or an array that can be broadcast to `image`. If not specified it is set to the maximum limit corresponding to the `image` dtype.
**channel\_axis**int, optional
This parameter indicates which axis of the output array will correspond to channels.
**check\_alpha**bool, optional
Checking for unsafe casting of alpha adds overhead, so can be disabled on request. Note: This kwarg is not present in scikit-image (it always checks the alpha array).
Returns:
**rgba**ndarray
RGBA image. A new dimension of length 4 is added to input image shape.
cucim.skimage.color.hed2rgb(_hed_, _\*_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.hed2rgb "Permalink to this definition")
Haematoxylin-Eosin-DAB (HED) to RGB color space conversion.
Parameters:
**hed**(…, C=3, …) array\_like
The image in the HED color space. By default, the final dimension denotes channels.
**channel\_axis**int, optional
This parameter indicates which axis of the array corresponds to channels.
Returns:
**out**(…, C=3, …) ndarray
The image in RGB. Same dimensions as input.
Raises:
ValueError
If hed is not at least 2-D with shape (…, C=3, …).
References
\[1\]
A. C. Ruifrok and D. A. Johnston, “Quantification of histochemical staining by color deconvolution.,” Analytical and quantitative cytology and histology / the International Academy of Cytology \[and\] American Society of Cytology, vol. 23, no. 4, pp. 291-9, Aug. 2001.
Examples
\>>> import cupy as cp
\>>> from skimage import data
\>>> from cucim.skimage.color import rgb2hed, hed2rgb
\>>> ihc \= cp.array(data.immunohistochemistry())
\>>> ihc\_hed \= rgb2hed(ihc)
\>>> ihc\_rgb \= hed2rgb(ihc\_hed)
cucim.skimage.color.hsv2rgb(_hsv_, _\*_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.hsv2rgb "Permalink to this definition")
HSV to RGB color space conversion.
Parameters:
**hsv**(…, 3, …) array\_like
The image in HSV format. By default, the final dimension denotes channels.
**channel\_axis**int, optional
This parameter indicates which axis of the array corresponds to channels.
Returns:
**out**(…, 3, …) ndarray
The image in RGB format. Same dimensions as input.
Raises:
ValueError
If hsv is not at least 2-D with shape (…, 3, …).
Notes
Conversion between RGB and HSV color spaces results in some loss of precision, due to integer arithmetic and rounding [\[1\]](#r9b32ad9e2308-1)
.
References
\[[1](#id28)\
\]
[https://en.wikipedia.org/wiki/HSL\_and\_HSV](https://en.wikipedia.org/wiki/HSL_and_HSV)
Examples
\>>> import cupy as cp
\>>> from skimage import data
\>>> img \= cp.array(data.astronaut())
\>>> img\_hsv \= rgb2hsv(img)
\>>> img\_rgb \= hsv2rgb(img\_hsv)
cucim.skimage.color.lab2lch(_lab_, _\*_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.lab2lch "Permalink to this definition")
CIE-LAB to CIE-LCH color space conversion.
LCH is the cylindrical representation of the LAB (Cartesian) colorspace
Parameters:
**lab**(…, C=3, …) array\_like
The N-D image in CIE-LAB format. The last (`N+1`\-th) dimension must have at least 3 elements, corresponding to the `L`, `a`, and `b` color channels. Subsequent elements are copied.
**channel\_axis**int, optional
This parameter indicates which axis of the array corresponds to channels.
Returns:
**out**(…, C=3, …) ndarray
The image in LCH format, in a N-D array with same shape as input lab.
Raises:
ValueError
If lch does not have at least 3 color channels (i.e. l, a, b).
Notes
The Hue is expressed as an angle between `(0, 2*pi)`
Examples
\>>> from skimage import data
\>>> from cucim.skimage.color import rgb2lab, lab2lch
\>>> img \= cp.array(data.astronaut())
\>>> img\_lab \= rgb2lab(img)
\>>> img\_lch \= lab2lch(img\_lab)
cucim.skimage.color.lab2rgb(_lab_, _illuminant\='D65'_, _observer\='2'_, _\*_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.lab2rgb "Permalink to this definition")
Convert image in CIE-LAB to sRGB color space.
Parameters:
**lab**(…, C=3, …) array\_like
The input image in CIE-LAB color space. Unless channel\_axis is set, the final dimension denotes the CIE-LAB channels. The L\* values range from 0 to 100; the a\* and b\* values range from -128 to 127.
**illuminant**{“A”, “B”, “C”, “D50”, “D55”, “D65”, “D75”, “E”}, optional
The name of the illuminant (the function is NOT case sensitive).
**observer**{“2”, “10”, “R”}, optional
The aperture angle of the observer.
**channel\_axis**int, optional
This parameter indicates which axis of the array corresponds to channels.
Returns:
**out**(…, C=3, …) ndarray
The image in sRGB color space, of same shape as input.
Raises:
ValueError
If lab is not at least 2-D with shape (…, C=3, …).
See also
[`rgb2lab`](#cucim.skimage.color.rgb2lab "cucim.skimage.color.rgb2lab")
Notes
This function uses [`lab2xyz()`](#cucim.skimage.color.lab2xyz "cucim.skimage.color.lab2xyz")
and [`xyz2rgb()`](#cucim.skimage.color.xyz2rgb "cucim.skimage.color.xyz2rgb")
. The CIE XYZ tristimulus values are x\_ref = 95.047, y\_ref = 100., and z\_ref = 108.883. See function [`xyz_tristimulus_values()`](#cucim.skimage.color.xyz_tristimulus_values "cucim.skimage.color.xyz_tristimulus_values")
for a list of supported illuminants.
References
\[1\]
[https://en.wikipedia.org/wiki/Standard\_illuminant](https://en.wikipedia.org/wiki/Standard_illuminant)
\[2\]
[https://en.wikipedia.org/wiki/CIELAB\_color\_space](https://en.wikipedia.org/wiki/CIELAB_color_space)
cucim.skimage.color.lab2xyz(_lab_, _illuminant\='D65'_, _observer\='2'_, _\*_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.lab2xyz "Permalink to this definition")
Convert image in CIE-LAB to XYZ color space.
Parameters:
**lab**(…, C=3, …) array\_like
The input image in CIE-LAB color space. Unless channel\_axis is set, the final dimension denotes the CIE-LAB channels. The L\* values range from 0 to 100; the a\* and b\* values range from -128 to 127.
**illuminant**{“A”, “B”, “C”, “D50”, “D55”, “D65”, “D75”, “E”}, optional
The name of the illuminant (the function is NOT case sensitive).
**observer**{“2”, “10”, “R”}, optional
The aperture angle of the observer.
**channel\_axis**int, optional
This parameter indicates which axis of the array corresponds to channels.
Returns:
**out**(…, C=3, …) ndarray
The image in XYZ color space, of same shape as input.
Raises:
ValueError
If lab is not at least 2-D with shape (…, C=3, …).
ValueError
If either the illuminant or the observer angle are not supported or unknown.
UserWarning
If any of the pixels are invalid (Z < 0).
See also
[`xyz2lab`](#cucim.skimage.color.xyz2lab "cucim.skimage.color.xyz2lab")
Notes
The CIE XYZ tristimulus values are x\_ref = 95.047, y\_ref = 100., and z\_ref = 108.883. See function [`xyz_tristimulus_values()`](#cucim.skimage.color.xyz_tristimulus_values "cucim.skimage.color.xyz_tristimulus_values")
for a list of supported illuminants.
References
\[1\]
[http://www.easyrgb.com/en/math.php](http://www.easyrgb.com/en/math.php)
\[2\]
[https://en.wikipedia.org/wiki/CIELAB\_color\_space](https://en.wikipedia.org/wiki/CIELAB_color_space)
cucim.skimage.color.label2rgb(_label_, _image\=None_, _colors\=None_, _alpha\=0.3_, _bg\_label\=0_, _bg\_color\=(0, 0, 0)_, _image\_alpha\=1_, _kind\='overlay'_, _\*_, _saturation\=0_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.label2rgb "Permalink to this definition")
Return an RGB image where color-coded labels are painted over the image.
Parameters:
**label**ndarray
Integer array of labels with the same shape as image.
**image**ndarray, optional
Image used as underlay for labels. It should have the same shape as labels, optionally with an additional RGB (channels) axis. If image is an RGB image, it is converted to grayscale before coloring.
**colors**list, optional
List of colors. If the number of labels exceeds the number of colors, then the colors are cycled.
**alpha**float \[0, 1\], optional
Opacity of colorized labels. Ignored if image is None.
**bg\_label**int, optional
Label that’s treated as the background. If bg\_label is specified, bg\_color is None, and kind is overlay, background is not painted by any colors.
**bg\_color**str or array, optional
Background color. Must be a name in cucim.skimage.color.color\_dict or RGB float values between \[0, 1\].
**image\_alpha**float \[0, 1\], optional
Opacity of the image.
**kind**string, one of {‘overlay’, ‘avg’}
The kind of color image desired. ‘overlay’ cycles over defined colors and overlays the colored labels over the original image. ‘avg’ replaces each labeled segment with its average color, for a stained-class or pastel painting appearance.
**saturation**float \[0, 1\], optional
Parameter to control the saturation applied to the original image between fully saturated (original RGB, saturation=1) and fully unsaturated (grayscale, saturation=0). Only applies when kind=’overlay’.
**channel\_axis**int, optional
This parameter indicates which axis of the output array will correspond to channels. If image is provided, this must also match the axis of image that corresponds to channels.
Returns:
**result**array of float, shape (M, N, 3)
The result of blending a cycling colormap (colors) for each distinct value in label with the image, at a certain alpha value.
cucim.skimage.color.lch2lab(_lch_, _\*_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.lch2lab "Permalink to this definition")
CIE-LCH to CIE-LAB color space conversion.
LCH is the cylindrical representation of the LAB (Cartesian) colorspace
Parameters:
**lch**(…, C=3, …) array\_like
The N-D image in CIE-LCH format. The last (`N+1`\-th) dimension must have at least 3 elements, corresponding to the `L`, `a`, and `b` color channels. Subsequent elements are copied.
**channel\_axis**int, optional
This parameter indicates which axis of the array corresponds to channels.
Returns:
**out**(…, C=3, …) ndarray
The image in LAB format, with same shape as input lch.
Raises:
ValueError
If lch does not have at least 3 color channels (i.e. l, c, h).
Examples
\>>> from skimage import data
\>>> from cucim.skimage.color import rgb2lab, lch2lab
\>>> img \= cp.array(data.astronaut())
\>>> img\_lab \= rgb2lab(img)
\>>> img\_lch \= lab2lch(img\_lab)
\>>> img\_lab2 \= lch2lab(img\_lch)
cucim.skimage.color.luv2rgb(_luv_, _\*_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.luv2rgb "Permalink to this definition")
Luv to RGB color space conversion.
Parameters:
**luv**(…, C=3, …) array\_like
The image in CIE Luv format. By default, the final dimension denotes channels.
Returns:
**out**(…, C=3, …) ndarray
The image in RGB format. Same dimensions as input.
Raises:
ValueError
If luv is not at least 2-D with shape (…, C=3, …).
Notes
This function uses luv2xyz and xyz2rgb.
cucim.skimage.color.luv2xyz(_luv_, _illuminant\='D65'_, _observer\='2'_, _\*_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.luv2xyz "Permalink to this definition")
CIE-Luv to XYZ color space conversion.
Parameters:
**luv**(…, C=3, …) array\_like
The image in CIE-Luv format. By default, the final dimension denotes channels.
**illuminant**{“A”, “B”, “C”, “D50”, “D55”, “D65”, “D75”, “E”}, optional
The name of the illuminant (the function is NOT case sensitive).
**observer**{“2”, “10”, “R”}, optional
The aperture angle of the observer.
**channel\_axis**int, optional
This parameter indicates which axis of the array corresponds to channels.
Returns:
**out**(…, C=3, …) ndarray
The image in XYZ format. Same dimensions as input.
Raises:
ValueError
If luv is not at least 2-D with shape (…, C=3, …).
ValueError
If either the illuminant or the observer angle are not supported or unknown.
Notes
XYZ conversion weights use observer=2A. Reference whitepoint for D65 Illuminant, with XYZ tristimulus values of `(95.047, 100., 108.883)`. See function [`xyz_tristimulus_values()`](#cucim.skimage.color.xyz_tristimulus_values "cucim.skimage.color.xyz_tristimulus_values")
for a list of supported illuminants.
References
\[1\]
[http://www.easyrgb.com/en/math.php](http://www.easyrgb.com/en/math.php)
\[2\]
[https://en.wikipedia.org/wiki/CIELUV](https://en.wikipedia.org/wiki/CIELUV)
cucim.skimage.color.rgb2gray(_rgb_, _\*_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.rgb2gray "Permalink to this definition")
Compute luminance of an RGB image.
Parameters:
**rgb**(…, C=3, …) array\_like
The image in RGB format. By default, the final dimension denotes channels.
Returns:
**out**ndarray
The luminance image - an array which is the same size as the input array, but with the channel dimension removed.
Raises:
ValueError
If rgb is not at least 2-D with shape (…, C=3, …).
Notes
The weights used in this conversion are calibrated for contemporary CRT phosphors:
Y \= 0.2125 R + 0.7154 G + 0.0721 B
If there is an alpha channel present, it is ignored.
References
\[1\]
[http://poynton.ca/PDFs/ColorFAQ.pdf](http://poynton.ca/PDFs/ColorFAQ.pdf)
Examples
\>>> import cupy as cp
\>>> from cucim.skimage.color import rgb2gray
\>>> from skimage import data
\>>> img \= cp.array(data.astronaut())
\>>> img\_gray \= rgb2gray(img)
cucim.skimage.color.rgb2hed(_rgb_, _\*_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.rgb2hed "Permalink to this definition")
RGB to Haematoxylin-Eosin-DAB (HED) color space conversion.
Parameters:
**rgb**(…, C=3, …) array\_like
The image in RGB format. By default, the final dimension denotes channels.
**channel\_axis**int, optional
This parameter indicates which axis of the array corresponds to channels.
Returns:
**out**(…, C=3, …) ndarray
The image in HED format. Same dimensions as input.
Raises:
ValueError
If rgb is not at least 2-D with shape (…, C=3, …).
References
\[1\]
A. C. Ruifrok and D. A. Johnston, “Quantification of histochemical staining by color deconvolution.,” Analytical and quantitative cytology and histology / the International Academy of Cytology \[and\] American Society of Cytology, vol. 23, no. 4, pp. 291-9, Aug. 2001.
Examples
\>>> import cupy as cp
\>>> from skimage import data
\>>> from cucim.skimage.color import rgb2hed
\>>> ihc \= cp.array(data.immunohistochemistry())
\>>> ihc\_hed \= rgb2hed(ihc)
cucim.skimage.color.rgb2hsv(_rgb_, _\*_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.rgb2hsv "Permalink to this definition")
RGB to HSV color space conversion.
Parameters:
**rgb**(…, C=3, …) array\_like
The image in RGB format. By default, the final dimension denotes channels.
**channel\_axis**int, optional
This parameter indicates which axis of the array corresponds to channels.
Returns:
**out**(…, C=3, …) ndarray
The image in HSV format. Same dimensions as input.
Raises:
ValueError
If rgb is not at least 2-D with shape (…, C=3, …).
Notes
Conversion between RGB and HSV color spaces results in some loss of precision, due to integer arithmetic and rounding [\[1\]](#r67d3a639daac-1)
.
References
\[[1](#id38)\
\]
[https://en.wikipedia.org/wiki/HSL\_and\_HSV](https://en.wikipedia.org/wiki/HSL_and_HSV)
Examples
\>>> import cupy as cp
\>>> from cucim.skimage import color
\>>> from skimage import data
\>>> img \= cp.array(data.astronaut())
\>>> img\_hsv \= color.rgb2hsv(img)
cucim.skimage.color.rgb2lab(_rgb_, _illuminant\='D65'_, _observer\='2'_, _\*_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.rgb2lab "Permalink to this definition")
Conversion from the sRGB color space (IEC 61966-2-1:1999) to the CIE Lab colorspace under the given illuminant and observer.
Parameters:
**rgb**(…, C=3, …) array\_like
The image in RGB format. By default, the final dimension denotes channels.
**illuminant**{“A”, “B”, “C”, “D50”, “D55”, “D65”, “D75”, “E”}, optional
The name of the illuminant (the function is NOT case sensitive).
**observer**{“2”, “10”, “R”}, optional
The aperture angle of the observer.
**channel\_axis**int, optional
This parameter indicates which axis of the array corresponds to channels.
Returns:
**out**(…, C=3, …) ndarray
The image in Lab format. Same dimensions as input.
Raises:
ValueError
If rgb is not at least 2-D with shape (…, C=3, …).
Notes
RGB is a device-dependent color space so, if you use this function, be sure that the image you are analyzing has been mapped to the sRGB color space.
This function uses rgb2xyz and xyz2lab. By default Observer=”2”, Illuminant=”D65”. CIE XYZ tristimulus values x\_ref=95.047, y\_ref=100., z\_ref=108.883. See function [`xyz_tristimulus_values()`](#cucim.skimage.color.xyz_tristimulus_values "cucim.skimage.color.xyz_tristimulus_values")
for a list of supported illuminants.
References
\[1\]
[https://en.wikipedia.org/wiki/Standard\_illuminant](https://en.wikipedia.org/wiki/Standard_illuminant)
cucim.skimage.color.rgb2luv(_rgb_, _\*_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.rgb2luv "Permalink to this definition")
RGB to CIE-Luv color space conversion.
Parameters:
**rgb**(…, C=3, …) array\_like
The image in RGB format. By default, the final dimension denotes channels.
**channel\_axis**int, optional
This parameter indicates which axis of the array corresponds to channels.
Returns:
**out**(…, C=3, …) ndarray
The image in CIE Luv format. Same dimensions as input.
Raises:
ValueError
If rgb is not at least 2-D with shape (…, C=3, …).
Notes
This function uses rgb2xyz and xyz2luv.
References
\[1\]
[http://www.easyrgb.com/en/math.php](http://www.easyrgb.com/en/math.php)
\[2\]
[https://en.wikipedia.org/wiki/CIELUV](https://en.wikipedia.org/wiki/CIELUV)
cucim.skimage.color.rgb2rgbcie(_rgb_, _\*_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.rgb2rgbcie "Permalink to this definition")
RGB to RGB CIE color space conversion.
Parameters:
**rgb**(…, C=3, …) array\_like
The image in RGB format. By default, the final dimension denotes channels.
**channel\_axis**int, optional
This parameter indicates which axis of the array corresponds to channels.
Returns:
**out**(…, C=3, …) ndarray
The image in RGB CIE format. Same dimensions as input.
Raises:
ValueError
If rgb is not at least 2-D with shape (…, C=3, …).
References
\[1\]
[https://en.wikipedia.org/wiki/CIE\_1931\_color\_space](https://en.wikipedia.org/wiki/CIE_1931_color_space)
Examples
\>>> from skimage import data
\>>> from cucim.skimage.color import rgb2rgbcie
\>>> img \= cp.array(data.astronaut())
\>>> img\_rgbcie \= rgb2rgbcie(img)
cucim.skimage.color.rgb2xyz(_rgb_, _\*_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.rgb2xyz "Permalink to this definition")
RGB to XYZ color space conversion.
Parameters:
**rgb**(…, C=3, …) array\_like
The image in RGB format. By default, the final dimension denotes channels.
**channel\_axis**int, optional
This parameter indicates which axis of the array corresponds to channels.
Returns:
**out**(…, C=3, …) ndarray
The image in XYZ format. Same dimensions as input.
Raises:
ValueError
If rgb is not at least 2-D with shape (…, C=3, …).
Notes
The CIE XYZ color space is derived from the CIE RGB color space. Note however that this function converts from sRGB.
References
\[1\]
[https://en.wikipedia.org/wiki/CIE\_1931\_color\_space](https://en.wikipedia.org/wiki/CIE_1931_color_space)
Examples
\>>> import cupy as cp
\>>> from skimage import data
\>>> img \= cp.array(data.astronaut())
\>>> img\_xyz \= rgb2xyz(img)
cucim.skimage.color.rgb2ycbcr(_rgb_, _\*_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.rgb2ycbcr "Permalink to this definition")
RGB to YCbCr color space conversion.
Parameters:
**rgb**(…, C=3, …) array\_like
The image in RGB format. By default, the final dimension denotes channels.
**channel\_axis**int, optional
This parameter indicates which axis of the array corresponds to channels.
Returns:
**out**(…, C=3, …) ndarray
The image in YCbCr format. Same dimensions as input.
Raises:
ValueError
If rgb is not at least 2-D with shape (…, C=3, …).
Notes
Y is between 16 and 235. This is the color space commonly used by video codecs; it is sometimes incorrectly called “YUV”.
References
\[1\]
[https://en.wikipedia.org/wiki/YCbCr](https://en.wikipedia.org/wiki/YCbCr)
cucim.skimage.color.rgb2ydbdr(_rgb_, _\*_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.rgb2ydbdr "Permalink to this definition")
RGB to YDbDr color space conversion.
Parameters:
**rgb**(…, C=3, …) array\_like
The image in RGB format. By default, the final dimension denotes channels.
**channel\_axis**int, optional
This parameter indicates which axis of the array corresponds to channels.
Returns:
**out**(…, C=3, …) ndarray
The image in YDbDr format. Same dimensions as input.
Raises:
ValueError
If rgb is not at least 2-D with shape (…, C=3, …).
Notes
This is the color space commonly used by video codecs. It is also the reversible color transform in JPEG2000.
References
\[1\]
[https://en.wikipedia.org/wiki/YDbDr](https://en.wikipedia.org/wiki/YDbDr)
cucim.skimage.color.rgb2yiq(_rgb_, _\*_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.rgb2yiq "Permalink to this definition")
RGB to YIQ color space conversion.
Parameters:
**rgb**(…, C=3, …) array\_like
The image in RGB format. By default, the final dimension denotes channels.
**channel\_axis**int, optional
This parameter indicates which axis of the array corresponds to channels.
Returns:
**out**(…, C=3, …) ndarray
The image in YIQ format. Same dimensions as input.
Raises:
ValueError
If rgb is not at least 2-D with shape (…, C=3, …).
cucim.skimage.color.rgb2ypbpr(_rgb_, _\*_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.rgb2ypbpr "Permalink to this definition")
RGB to YPbPr color space conversion.
Parameters:
**rgb**(…, C=3, …) array\_like
The image in RGB format. By default, the final dimension denotes channels.
**channel\_axis**int, optional
This parameter indicates which axis of the array corresponds to channels.
Returns:
**out**(…, C=3, …) ndarray
The image in YPbPr format. Same dimensions as input.
Raises:
ValueError
If rgb is not at least 2-D with shape (…, C=3, …).
References
\[1\]
[https://en.wikipedia.org/wiki/YPbPr](https://en.wikipedia.org/wiki/YPbPr)
cucim.skimage.color.rgb2yuv(_rgb_, _\*_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.rgb2yuv "Permalink to this definition")
RGB to YUV color space conversion.
Parameters:
**rgb**(…, C=3, …) array\_like
The image in RGB format. By default, the final dimension denotes channels.
**channel\_axis**int, optional
This parameter indicates which axis of the array corresponds to channels.
Returns:
**out**(…, C=3, …) ndarray
The image in YUV format. Same dimensions as input.
Raises:
ValueError
If rgb is not at least 2-D with shape (…, C=3, …).
Notes
Y is between 0 and 1. Use YCbCr instead of YUV for the color space commonly used by video codecs, where Y ranges from 16 to 235.
References
\[1\]
[https://en.wikipedia.org/wiki/YUV](https://en.wikipedia.org/wiki/YUV)
cucim.skimage.color.rgba2rgb(_rgba_, _background\=(1, 1, 1)_, _\*_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.rgba2rgb "Permalink to this definition")
RGBA to RGB conversion using alpha blending [\[1\]](#r06de24b6b99b-1)
.
Parameters:
**rgba**(…, C=4, …) array\_like
The image in RGBA format. By default, the final dimension denotes channels.
**background**array\_like
The color of the background to blend the image with (3 floats between 0 to 1 - the RGB value of the background).
**channel\_axis**int, optional
This parameter indicates which axis of the array corresponds to channels.
Returns:
**out**(…, C=3, …) ndarray
The image in RGB format. Same dimensions as input.
Raises:
ValueError
If rgba is not at least 2D with shape (…, 4, …).
References
\[[1](#id49)\
\]
[https://en.wikipedia.org/wiki/Alpha\_compositing#Alpha\_blending](https://en.wikipedia.org/wiki/Alpha_compositing#Alpha_blending)
Examples
\>>> import cupy as cp
\>>> from cucim.skimage import color
\>>> from skimage import data
\>>> img\_rgba \= cp.array(data.logo())
\>>> img\_rgb \= color.rgba2rgb(img\_rgba)
cucim.skimage.color.rgbcie2rgb(_rgbcie_, _\*_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.rgbcie2rgb "Permalink to this definition")
RGB CIE to RGB color space conversion.
Parameters:
**rgbcie**(…, C=3, …) array\_like
The image in RGB CIE format. By default, the final dimension denotes channels.
**channel\_axis**int, optional
This parameter indicates which axis of the array corresponds to channels.
Returns:
**out**(…, C=3, …) ndarray
The image in RGB format. Same dimensions as input.
Raises:
ValueError
If rgbcie is not at least 2-D with shape (…, C=3, …).
References
\[1\]
[https://en.wikipedia.org/wiki/CIE\_1931\_color\_space](https://en.wikipedia.org/wiki/CIE_1931_color_space)
Examples
\>>> from skimage import data
\>>> from cucim.skimage.color import rgb2rgbcie, rgbcie2rgb
\>>> img \= cp.array(data.astronaut())
\>>> img\_rgbcie \= rgb2rgbcie(img)
\>>> img\_rgb \= rgbcie2rgb(img\_rgbcie)
cucim.skimage.color.separate\_stains(_rgb_, _conv\_matrix_, _\*_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.separate_stains "Permalink to this definition")
RGB to stain color space conversion.
Parameters:
**rgb**(…, C=3, …) array\_like
The image in RGB format. By default, the final dimension denotes channels.
**conv\_matrix: ndarray**
The stain separation matrix as described by G. Landini [\[1\]](#rc537717e7931-1)
.
**channel\_axis**int, optional
This parameter indicates which axis of the array corresponds to channels.
Returns:
**out**(…, C=3, …) ndarray
The image in stain color space. Same dimensions as input.
Raises:
ValueError
If rgb is not at least 2-D with shape (…, C=3, …).
Notes
Stain separation matrices available in the `color` module and their respective colorspace:
* `hed_from_rgb`: Hematoxylin + Eosin + DAB
* `hdx_from_rgb`: Hematoxylin + DAB
* `fgx_from_rgb`: Feulgen + Light Green
* `bex_from_rgb`: Giemsa stain : Methyl Blue + Eosin
* `rbd_from_rgb`: FastRed + FastBlue + DAB
* `gdx_from_rgb`: Methyl Green + DAB
* `hax_from_rgb`: Hematoxylin + AEC
* `bro_from_rgb`: Blue matrix Anilline Blue + Red matrix Azocarmine + Orange matrix Orange-G
* `bpx_from_rgb`: Methyl Blue + Ponceau Fuchsin
* `ahx_from_rgb`: Alcian Blue + Hematoxylin
* `hpx_from_rgb`: Hematoxylin + PAS
This implementation borrows some ideas from DIPlib [\[2\]](#rc537717e7931-2)
, e.g. the compensation using a small value to avoid log artifacts when calculating the Beer-Lambert law.
References
\[[1](#id52)\
\]
[https://web.archive.org/web/20160624145052/http://www.mecourse.com/landinig/software/cdeconv/cdeconv.html](https://web.archive.org/web/20160624145052/http://www.mecourse.com/landinig/software/cdeconv/cdeconv.html)
\[[2](#id53)\
\]
[DIPlib/diplib](https://github.com/DIPlib/diplib/)
\[3\]
A. C. Ruifrok and D. A. Johnston, “Quantification of histochemical staining by color deconvolution,” Anal. Quant. Cytol. Histol., vol. 23, no. 4, pp. 291–299, Aug. 2001.
Examples
\>>> import cupy as cp
\>>> from skimage import data
\>>> from cucim.skimage.color import separate\_stains, hdx\_from\_rgb
\>>> ihc \= cp.array(data.immunohistochemistry())
\>>> ihc\_hdx \= separate\_stains(ihc, hdx\_from\_rgb)
cucim.skimage.color.xyz2lab(_xyz_, _illuminant\='D65'_, _observer\='2'_, _\*_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.xyz2lab "Permalink to this definition")
XYZ to CIE-LAB color space conversion.
Parameters:
**xyz**(…, C=3, …) array\_like
The image in XYZ format. By default, the final dimension denotes channels.
**illuminant**{“A”, “B”, “C”, “D50”, “D55”, “D65”, “D75”, “E”}, optional
The name of the illuminant (the function is NOT case sensitive).
**observer**{“2”, “10”, “R”}, optional
One of: 2-degree observer, 10-degree observer, or ‘R’ observer as in R function grDevices::convertColor.
**channel\_axis**int, optional
This parameter indicates which axis of the array corresponds to channels.
Returns:
**out**(…, C=3, …) ndarray
The image in CIE-LAB format. Same dimensions as input.
Raises:
ValueError
If xyz is not at least 2-D with shape (…, C=3, …).
ValueError
If either the illuminant or the observer angle is unsupported or unknown.
Notes
By default Observer=”2”, Illuminant=”D65”. CIE XYZ tristimulus values x\_ref=95.047, y\_ref=100., z\_ref=108.883. See function [`xyz_tristimulus_values()`](#cucim.skimage.color.xyz_tristimulus_values "cucim.skimage.color.xyz_tristimulus_values")
for a list of supported illuminants.
References
\[1\]
[http://www.easyrgb.com/en/math.php](http://www.easyrgb.com/en/math.php)
\[2\]
[https://en.wikipedia.org/wiki/CIELAB\_color\_space](https://en.wikipedia.org/wiki/CIELAB_color_space)
Examples
\>>> import cupy as cp
\>>> from skimage import data
\>>> from cucim.skimage.color import rgb2xyz, xyz2lab
\>>> img \= cp.array(data.astronaut())
\>>> img\_xyz \= rgb2xyz(img)
\>>> img\_lab \= xyz2lab(img\_xyz)
cucim.skimage.color.xyz2luv(_xyz_, _illuminant\='D65'_, _observer\='2'_, _\*_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.xyz2luv "Permalink to this definition")
XYZ to CIE-Luv color space conversion.
Parameters:
**xyz**(…, C=3, …) array\_like
The image in XYZ format. By default, the final dimension denotes channels.
**illuminant**{“A”, “B”, “C”, “D50”, “D55”, “D65”, “D75”, “E”}, optional
The name of the illuminant (the function is NOT case sensitive).
**observer**{“2”, “10”, “R”}, optional
The aperture angle of the observer.
**channel\_axis**int, optional
This parameter indicates which axis of the array corresponds to channels.
Returns:
**out**(…, C=3, …) ndarray
The image in CIE-Luv format. Same dimensions as input.
Raises:
ValueError
If xyz is not at least 2-D with shape (…, C=3, …).
ValueError
If either the illuminant or the observer angle are not supported or unknown.
Notes
By default XYZ conversion weights use observer=2A. Reference whitepoint for D65 Illuminant, with XYZ tristimulus values of `(95.047, 100., 108.883)`. See function [`xyz_tristimulus_values()`](#cucim.skimage.color.xyz_tristimulus_values "cucim.skimage.color.xyz_tristimulus_values")
for a list of supported illuminants.
References
\[1\]
[http://www.easyrgb.com/en/math.php](http://www.easyrgb.com/en/math.php)
\[2\]
[https://en.wikipedia.org/wiki/CIELUV](https://en.wikipedia.org/wiki/CIELUV)
Examples
\>>> import cupy as cp
\>>> from skimage import data
\>>> from cucim.skimage.color import rgb2xyz, xyz2luv
\>>> img \= cp.array(data.astronaut())
\>>> img\_xyz \= rgb2xyz(img)
\>>> img\_luv \= xyz2luv(img\_xyz)
cucim.skimage.color.xyz2rgb(_xyz_, _\*_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.xyz2rgb "Permalink to this definition")
XYZ to RGB color space conversion.
Parameters:
**xyz**(…, C=3, …) array\_like
The image in XYZ format. By default, the final dimension denotes channels.
**channel\_axis**int, optional
This parameter indicates which axis of the array corresponds to channels.
Returns:
**out**(…, C=3, …) ndarray
The image in RGB format. Same dimensions as input.
Raises:
ValueError
If xyz is not at least 2-D with shape (…, C=3, …).
Notes
The CIE XYZ color space is derived from the CIE RGB color space. Note however that this function converts to sRGB.
References
\[1\]
[https://en.wikipedia.org/wiki/CIE\_1931\_color\_space](https://en.wikipedia.org/wiki/CIE_1931_color_space)
Examples
\>>> from skimage import data
\>>> from cucim.skimage.color import rgb2xyz, xyz2rgb
\>>> img \= cp.array(data.astronaut())
\>>> img\_xyz \= rgb2xyz(img)
\>>> img\_rgb \= xyz2rgb(img\_xyz)
cucim.skimage.color.xyz\_tristimulus\_values(_\*_, _illuminant_, _observer_, _dtype\=None_)[#](#cucim.skimage.color.xyz_tristimulus_values "Permalink to this definition")
Get the CIE XYZ tristimulus values.
Given an illuminant and observer, this function returns the CIE XYZ tristimulus values [\[2\]](#r7ef00e899e90-2)
scaled such that \\(Y = 1\\).
Parameters:
**illuminant**{“A”, “B”, “C”, “D50”, “D55”, “D65”, “D75”, “E”}
The name of the illuminant (the function is NOT case sensitive).
**observer**{“2”, “10”, “R”}
One of: 2-degree observer, 10-degree observer, or ‘R’ observer as in R function `grDevices::convertColor` [\[3\]](#r7ef00e899e90-3)
.
**dtype**np.dtype, optional
This argument is ignored in the cuCIM implementation of xyz\_tristimulus\_values since an array is not returned. The output is always a 3-tuple of float.
Returns:
**values**3-tuple of float
Three elements \\(X, Y, Z\\) containing the CIE XYZ tristimulus values of the given illuminant.
Raises:
ValueError
If either the illuminant or the observer angle are not supported or unknown.
Notes
The return type of this function differs from the one in scikit-image as it always returns a 3-tuple of float rather than an array with a user-specified dtype.
The CIE XYZ tristimulus values are calculated from \\(x, y\\) [\[1\]](#r7ef00e899e90-1)
, using the formula
\\\[X = x / y\\\]
\\\[Y = 1\\\]
\\\[Z = (1 - x - y) / y\\\]
The only exception is the illuminant “D65” with aperture angle 2° for backward-compatibility reasons.
References
\[[1](#id64)\
\]
[https://en.wikipedia.org/wiki/Standard\_illuminant#White\_points\_of\_standard\_illuminants](https://en.wikipedia.org/wiki/Standard_illuminant#White_points_of_standard_illuminants)
\[[2](#id62)\
\]
[https://en.wikipedia.org/wiki/CIE\_1931\_color\_space#Meaning\_of\_X,\_Y\_and\_Z](https://en.wikipedia.org/wiki/CIE_1931_color_space#Meaning_of_X,_Y_and_Z)
\[[3](#id63)\
\]
[https://www.rdocumentation.org/packages/grDevices/versions/3.6.2/topics/convertColor](https://www.rdocumentation.org/packages/grDevices/versions/3.6.2/topics/convertColor)
Examples
Get the CIE XYZ tristimulus values for a “D65” illuminant for a 10 degree field of view
\>>> xyz\_tristimulus\_values(illuminant\="D65", observer\="10")
array(\[0.94809668, 1. , 1.07305136\])
cucim.skimage.color.ycbcr2rgb(_ycbcr_, _\*_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.ycbcr2rgb "Permalink to this definition")
YCbCr to RGB color space conversion.
Parameters:
**ycbcr**(…, C=3, …) array\_like
The image in YCbCr format. By default, the final dimension denotes channels.
**channel\_axis**int, optional
This parameter indicates which axis of the array corresponds to channels.
Returns:
**out**(…, C=3, …) ndarray
The image in RGB format. Same dimensions as input.
Raises:
ValueError
If ycbcr is not at least 2-D with shape (…, C=3, …).
Notes
Y is between 16 and 235. This is the color space commonly used by video codecs; it is sometimes incorrectly called “YUV”.
References
\[1\]
[https://en.wikipedia.org/wiki/YCbCr](https://en.wikipedia.org/wiki/YCbCr)
cucim.skimage.color.ydbdr2rgb(_ydbdr_, _\*_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.ydbdr2rgb "Permalink to this definition")
YDbDr to RGB color space conversion.
Parameters:
**ydbdr**(…, C=3, …) array\_like
The image in YDbDr format. By default, the final dimension denotes channels.
**channel\_axis**int, optional
This parameter indicates which axis of the array corresponds to channels.
Returns:
**out**(…, C=3, …) ndarray
The image in RGB format. Same dimensions as input.
Raises:
ValueError
If ydbdr is not at least 2-D with shape (…, C=3, …).
Notes
This is the color space commonly used by video codecs, also called the reversible color transform in JPEG2000.
References
\[1\]
[https://en.wikipedia.org/wiki/YDbDr](https://en.wikipedia.org/wiki/YDbDr)
cucim.skimage.color.yiq2rgb(_yiq_, _\*_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.yiq2rgb "Permalink to this definition")
YIQ to RGB color space conversion.
Parameters:
**yiq**(…, C=3, …) array\_like
The image in YIQ format. By default, the final dimension denotes channels.
**channel\_axis**int, optional
This parameter indicates which axis of the array corresponds to channels.
Returns:
**out**(…, C=3, …) ndarray
The image in RGB format. Same dimensions as input.
Raises:
ValueError
If yiq is not at least 2-D with shape (…, C=3, …).
cucim.skimage.color.ypbpr2rgb(_ypbpr_, _\*_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.ypbpr2rgb "Permalink to this definition")
YPbPr to RGB color space conversion.
Parameters:
**ypbpr**(…, C=3, …) array\_like
The image in YPbPr format. By default, the final dimension denotes channels.
**channel\_axis**int, optional
This parameter indicates which axis of the array corresponds to channels.
Returns:
**out**(…, C=3) ndarray
The image in RGB format. Same dimensions as input.
Raises:
ValueError
If ypbpr is not at least 2-D with shape (…, C=3).
References
\[1\]
[https://en.wikipedia.org/wiki/YPbPr](https://en.wikipedia.org/wiki/YPbPr)
cucim.skimage.color.yuv2rgb(_yuv_, _\*_, _channel\_axis\=\-1_)[#](#cucim.skimage.color.yuv2rgb "Permalink to this definition")
YUV to RGB color space conversion.
Parameters:
**yuv**(…, C=3, …) array\_like
The image in YUV format. By default, the final dimension denotes channels.
Returns:
**out**(…, C=3, …) ndarray
The image in RGB format. Same dimensions as input.
Raises:
ValueError
If yuv is not at least 2-D with shape (…, C=3, …).
References
\[1\]
[https://en.wikipedia.org/wiki/YUV](https://en.wikipedia.org/wiki/YUV)
### data[#](#module-cucim.skimage.data "Permalink to this heading")
cucim.skimage.data.binary\_blobs(_length\=512_, _blob\_size\_fraction\=0.1_, _n\_dim\=2_, _volume\_fraction\=0.5_, _rng\=None_)[#](#cucim.skimage.data.binary_blobs "Permalink to this definition")
Generate synthetic binary image with several rounded blob-like objects.
Parameters:
**length**int, optional
Linear size of output image.
**blob\_size\_fraction**float, optional
Typical linear size of blob, as a fraction of `length`, should be smaller than 1.
**n\_dim**int, optional
Number of dimensions of output image.
**volume\_fraction**float, default 0.5
Fraction of image pixels covered by the blobs (where the output is 1). Should be in \[0, 1\].
**rng**{cupy.random.Generator, int}, optional
Pseudo-random number generator. By default, a PCG64 generator is used (see [`cupy.random.default_rng()`](https://docs.cupy.dev/en/stable/reference/generated/cupy.random.default_rng.html#cupy.random.default_rng "(in CuPy v13.4.0)")
). If rng is an int, it is used to seed the generator.
Returns:
**blobs**ndarray of bools
Output binary image
Notes
Warning: CuPy does not give identical randomly generated numbers as NumPy, so using a specific rng here will not give an identical pattern to the scikit-image implementation.
The behavior for a given random seed may also change across CuPy major versions. See: [https://docs.cupy.dev/en/stable/reference/random.html](https://docs.cupy.dev/en/stable/reference/random.html)
Examples
\>>> from cucim.skimage import data
\>>> \# tiny size (5, 5)
\>>> blobs \= data.binary\_blobs(length\=5, blob\_size\_fraction\=0.2)
\>>> \# larger size
\>>> blobs \= data.binary\_blobs(length\=256, blob\_size\_fraction\=0.1)
\>>> \# Finer structures
\>>> blobs \= data.binary\_blobs(length\=256, blob\_size\_fraction\=0.05)
\>>> \# Blobs cover a smaller volume fraction of the image
\>>> blobs \= data.binary\_blobs(length\=256, volume\_fraction\=0.3)
### exposure[#](#module-cucim.skimage.exposure "Permalink to this heading")
Image intensity adjustment, e.g., histogram equalization, etc.
cucim.skimage.exposure.adjust\_gamma(_image_, _gamma\=1_, _gain\=1_)[#](#cucim.skimage.exposure.adjust_gamma "Permalink to this definition")
Performs Gamma Correction on the input image.
Also known as Power Law Transform. This function transforms the input image pixelwise according to the equation `O = I**gamma` after scaling each pixel to the range 0 to 1.
Parameters:
**image**ndarray
Input image.
**gamma**float, optional
Non negative real number. Default value is 1.
**gain**float, optional
The constant multiplier. Default value is 1.
Returns:
**out**ndarray
Gamma corrected output image.
See also
[`adjust_log`](#cucim.skimage.exposure.adjust_log "cucim.skimage.exposure.adjust_log")
Notes
For gamma greater than 1, the histogram will shift towards left and the output image will be darker than the input image.
For gamma less than 1, the histogram will shift towards right and the output image will be brighter than the input image.
References
\[1\]
[https://en.wikipedia.org/wiki/Gamma\_correction](https://en.wikipedia.org/wiki/Gamma_correction)
Examples
\>>> from skimage import data
\>>> from cucim.skimage import exposure, img\_as\_float
\>>> image \= img\_as\_float(cp.array(data.moon()))
\>>> gamma\_corrected \= exposure.adjust\_gamma(image, 2)
\>>> \# Output is darker for gamma > 1
\>>> image.mean() \> gamma\_corrected.mean()
array(True)
cucim.skimage.exposure.adjust\_log(_image_, _gain\=1_, _inv\=False_)[#](#cucim.skimage.exposure.adjust_log "Permalink to this definition")
Performs Logarithmic correction on the input image.
This function transforms the input image pixelwise according to the equation `O = gain*log(1 + I)` after scaling each pixel to the range 0 to 1.
For inverse logarithmic correction, the equation is `O = gain*(2**I - 1)`.
Parameters:
**image**ndarray
Input image.
**gain**float, optional
The constant multiplier. Default value is 1.
**inv**float, optional
If True, it performs inverse logarithmic correction, else correction will be logarithmic. Defaults to False.
Returns:
**out**ndarray
Logarithm corrected output image.
See also
[`adjust_gamma`](#cucim.skimage.exposure.adjust_gamma "cucim.skimage.exposure.adjust_gamma")
References
\[1\]
[http://www.ece.ucsb.edu/Faculty/Manjunath/courses/ece178W03/EnhancePart1.pdf](http://www.ece.ucsb.edu/Faculty/Manjunath/courses/ece178W03/EnhancePart1.pdf)
cucim.skimage.exposure.adjust\_sigmoid(_image_, _cutoff\=0.5_, _gain\=10_, _inv\=False_)[#](#cucim.skimage.exposure.adjust_sigmoid "Permalink to this definition")
Performs Sigmoid Correction on the input image.
Also known as Contrast Adjustment. This function transforms the input image pixelwise according to the equation `O = 1/(1 + exp*(gain*(cutoff - I)))` after scaling each pixel to the range 0 to 1.
Parameters:
**image**ndarray
Input image.
**cutoff**float, optional
Cutoff of the sigmoid function that shifts the characteristic curve in horizontal direction. Default value is 0.5.
**gain**float, optional
The constant multiplier in exponential’s power of sigmoid function. Default value is 10.
**inv**bool, optional
If True, returns the negative sigmoid correction. Defaults to False.
Returns:
**out**ndarray
Sigmoid corrected output image.
See also
[`adjust_gamma`](#cucim.skimage.exposure.adjust_gamma "cucim.skimage.exposure.adjust_gamma")
References
\[1\]
Gustav J. Braun, “Image Lightness Rescaling Using Sigmoidal Contrast Enhancement Functions”, [http://markfairchild.org/PDFs/PAP07.pdf](http://markfairchild.org/PDFs/PAP07.pdf)
cucim.skimage.exposure.cumulative\_distribution(_image_, _nbins\=256_)[#](#cucim.skimage.exposure.cumulative_distribution "Permalink to this definition")
Return cumulative distribution function (cdf) for the given image.
Parameters:
**image**array
Image array.
**nbins**int, optional
Number of bins for image histogram.
Returns:
**img\_cdf**array
Values of cumulative distribution function.
**bin\_centers**array
Centers of bins.
See also
[`histogram`](#cucim.skimage.exposure.histogram "cucim.skimage.exposure.histogram")
References
\[1\]
[https://en.wikipedia.org/wiki/Cumulative\_distribution\_function](https://en.wikipedia.org/wiki/Cumulative_distribution_function)
Examples
\>>> import cupy as cp
\>>> from skimage import data
\>>> from cucim.skimage import exposure, img\_as\_float
\>>> image \= img\_as\_float(cp.array(data.camera()))
\>>> hi \= exposure.histogram(image)
\>>> cdf \= exposure.cumulative\_distribution(image)
\>>> cp.all(cdf\[0\] \== cp.cumsum(hi\[0\])/float(image.size))
array(True)
cucim.skimage.exposure.equalize\_adapthist(_image_, _kernel\_size\=None_, _clip\_limit\=0.01_, _nbins\=256_)[#](#cucim.skimage.exposure.equalize_adapthist "Permalink to this definition")
Contrast Limited Adaptive Histogram Equalization (CLAHE).
An algorithm for local contrast enhancement, that uses histograms computed over different tile regions of the image. Local details can therefore be enhanced even in regions that are darker or lighter than most of the image.
Parameters:
**image**(M\[, …\]\[, C\]) ndarray
Input image.
**kernel\_size**int or array\_like, optional
Defines the shape of contextual regions used in the algorithm. If iterable is passed, it must have the same number of elements as `image.ndim` (without color channel). If integer, it is broadcasted to each image dimension. By default, `kernel_size` is 1/8 of `image` height by 1/8 of its width.
**clip\_limit**float, optional
Clipping limit, normalized between 0 and 1 (higher values give more contrast).
**nbins**int, optional
Number of gray bins for histogram (“data range”).
Returns:
**out**(M\[, …\]\[, C\]) ndarray
Equalized image with float64 dtype.
See also
[`equalize_hist`](#cucim.skimage.exposure.equalize_hist "cucim.skimage.exposure.equalize_hist")
, [`rescale_intensity`](#cucim.skimage.exposure.rescale_intensity "cucim.skimage.exposure.rescale_intensity")
Notes
* For color images, the following steps are performed:
* The image is converted to HSV color space
* The CLAHE algorithm is run on the V (Value) channel
* The image is converted back to RGB space and returned
* For RGBA images, the original alpha channel is removed.
Changed in version 0.17: The values returned by this function are slightly shifted upwards because of an internal change in rounding behavior.
References
\[1\]
[http://tog.acm.org/resources/GraphicsGems/](http://tog.acm.org/resources/GraphicsGems/)
\[2\]
[https://en.wikipedia.org/wiki/CLAHE#CLAHE](https://en.wikipedia.org/wiki/CLAHE#CLAHE)
cucim.skimage.exposure.equalize\_hist(_image_, _nbins\=256_, _mask\=None_)[#](#cucim.skimage.exposure.equalize_hist "Permalink to this definition")
Return image after histogram equalization.
Parameters:
**image**array
Image array.
**nbins**int, optional
Number of bins for image histogram. Note: this argument is ignored for integer images, for which each integer is its own bin.
**mask: ndarray of bools or 0s and 1s, optional**
Array of same shape as image. Only points at which mask == True are used for the equalization, which is applied to the whole image.
Returns:
**out**float array
Image array after histogram equalization.
Notes
This function is adapted from [\[1\]](#r0b3e7653afbe-1)
with the author’s permission.
References
\[[1](#id78)\
\]
[http://www.janeriksolem.net/histogram-equalization-with-python-and.html](http://www.janeriksolem.net/histogram-equalization-with-python-and.html)
\[2\]
[https://en.wikipedia.org/wiki/Histogram\_equalization](https://en.wikipedia.org/wiki/Histogram_equalization)
cucim.skimage.exposure.histogram(_image_, _nbins\=256_, _source\_range\='image'_, _normalize\=False_, _\*_, _channel\_axis\=None_)[#](#cucim.skimage.exposure.histogram "Permalink to this definition")
Return histogram of image.
Unlike numpy.histogram, this function returns the centers of bins and does not rebin integer arrays. For integer arrays, each integer value has its own bin, which improves speed and intensity-resolution.
If channel\_axis is not set, the histogram is computed on the flattened image. For color or multichannel images, set `channel_axis` to use a common binning for all channels. Alternatively, one may apply the function separately on each channel to obtain a histogram for each color channel with separate binning.
Parameters:
**image**array
Input image.
**nbins**int, optional
Number of bins used to calculate histogram. This value is ignored for integer arrays.
**source\_range**string, optional
‘image’ (default) determines the range from the input image. ‘dtype’ determines the range from the expected range of the images of that data type.
**normalize**bool, optional
If True, normalize the histogram by the sum of its values.
**channel\_axis**int or None, optional
If None, the image is assumed to be a grayscale (single channel) image. Otherwise, this parameter indicates which axis of the array corresponds to channels.
Returns:
**hist**array
The values of the histogram. When `channel_axis` is not None, hist will be a 2D array where the first axis corresponds to channels.
**bin\_centers**array
The values at the center of the bins.
See also
[`cumulative_distribution`](#cucim.skimage.exposure.cumulative_distribution "cucim.skimage.exposure.cumulative_distribution")
Examples
\>>> import cupy as cp
\>>> from skimage import data
\>>> from cucim.skimage import exposure, img\_as\_float
\>>> image \= img\_as\_float(cp.array(data.camera()))
\>>> cp.histogram(image, bins\=2)
(array(\[ 93585, 168559\]), array(\[0. , 0.5, 1. \]))
\>>> exposure.histogram(image, nbins\=2)
(array(\[ 93585, 168559\]), array(\[0.25, 0.75\]))
cucim.skimage.exposure.is\_low\_contrast(_image_, _fraction\_threshold\=0.05_, _lower\_percentile\=1_, _upper\_percentile\=99_, _method\='linear'_)[#](#cucim.skimage.exposure.is_low_contrast "Permalink to this definition")
Determine if an image is low contrast.
Parameters:
**image**array-like
The image under test.
**fraction\_threshold**float, optional
The low contrast fraction threshold. An image is considered low- contrast when its range of brightness spans less than this fraction of its data type’s full range. [\[1\]](#r12f9fb47597e-1)
**lower\_percentile**float, optional
Disregard values below this percentile when computing image contrast.
**upper\_percentile**float, optional
Disregard values above this percentile when computing image contrast.
**method**str, optional
The contrast determination method. Right now the only available option is “linear”.
Returns:
**out**bool
True when the image is determined to be low contrast.
Notes
For boolean images, this function returns False only if all values are the same (the method, threshold, and percentile arguments are ignored).
References
\[[1](#id81)\
\]
[https://scikit-image.org/docs/dev/user\_guide/data\_types.html](https://scikit-image.org/docs/dev/user_guide/data_types.html)
Examples
\>>> import cupy as cp
\>>> image \= cp.linspace(0, 0.04, 100)
\>>> is\_low\_contrast(image)
array(True)
\>>> image\[\-1\] \= 1
\>>> is\_low\_contrast(image)
array(True)
\>>> is\_low\_contrast(image, upper\_percentile\=100)
array(False)
cucim.skimage.exposure.match\_histograms(_image_, _reference_, _\*_, _channel\_axis\=None_)[#](#cucim.skimage.exposure.match_histograms "Permalink to this definition")
Adjust an image so that its cumulative histogram matches that of another.
The adjustment is applied separately for each channel.
Parameters:
**image**ndarray
Input image. Can be gray-scale or in color.
**reference**ndarray
Image to match histogram of. Must have the same number of channels as image.
**channel\_axis**int or None, optional
If None, the image is assumed to be a grayscale (single channel) image. Otherwise, this parameter indicates which axis of the array corresponds to channels.
Returns:
**matched**ndarray
Transformed input image.
Raises:
ValueError
Thrown when the number of channels in the input image and the reference differ.
References
\[1\]
[http://paulbourke.net/miscellaneous/equalisation/](http://paulbourke.net/miscellaneous/equalisation/)
cucim.skimage.exposure.rescale\_intensity(_image_, _in\_range\='image'_, _out\_range\='dtype'_)[#](#cucim.skimage.exposure.rescale_intensity "Permalink to this definition")
Return image after stretching or shrinking its intensity levels.
The desired intensity range of the input and output, in\_range and out\_range respectively, are used to stretch or shrink the intensity range of the input image. See examples below.
Parameters:
**image**array
Image array.
**in\_range, out\_range**str or 2-tuple, optional
Min and max intensity values of input and output image. The possible values for this parameter are enumerated below.
‘image’
Use image min/max as the intensity range.
‘dtype’
Use min/max of the image’s dtype as the intensity range.
dtype-name
Use intensity range based on desired dtype. Must be valid key in DTYPE\_RANGE.
2-tuple
Use range\_values as explicit min/max intensities.
Returns:
**out**array
Image array after rescaling its intensity. This image is the same dtype as the input image.
See also
[`equalize_hist`](#cucim.skimage.exposure.equalize_hist "cucim.skimage.exposure.equalize_hist")
Notes
Changed in version 0.17: The dtype of the output array has changed to match the output dtype, or float if the output range is specified by a pair of values.
Examples
By default, the min/max intensities of the input image are stretched to the limits allowed by the image’s dtype, since in\_range defaults to ‘image’ and out\_range defaults to ‘dtype’:
\>>> image \= cp.array(\[51, 102, 153\], dtype\=np.uint8)
\>>> rescale\_intensity(image)
array(\[ 0, 127, 255\], dtype=uint8)
It’s easy to accidentally convert an image dtype from uint8 to float:
\>>> 1.0 \* image
array(\[ 51., 102., 153.\])
Use rescale\_intensity to rescale to the proper range for float dtypes:
\>>> image\_float \= 1.0 \* image
\>>> rescale\_intensity(image\_float)
array(\[0. , 0.5, 1. \])
To maintain the low contrast of the original, use the in\_range parameter:
\>>> rescale\_intensity(image\_float, in\_range\=(0, 255))
array(\[0.2, 0.4, 0.6\])
If the min/max value of in\_range is more/less than the min/max image intensity, then the intensity levels are clipped:
\>>> rescale\_intensity(image\_float, in\_range\=(0, 102))
array(\[0.5, 1. , 1. \])
If you have an image with signed integers but want to rescale the image to just the positive range, use the out\_range parameter. In that case, the output dtype will be float:
\>>> image \= cp.asarray(\[\-10, 0, 10\], dtype\=np.int8)
\>>> rescale\_intensity(image, out\_range\=(0, 127))
array(\[ 0. , 63.5, 127. \])
To get the desired range with a specific dtype, use `.astype()`:
\>>> rescale\_intensity(image, out\_range\=(0, 127)).astype(np.int8)
array(\[ 0, 63, 127\], dtype=int8)
If the input image is constant, the output will be clipped directly to the output range: >>> image = cp.asarray(\[130, 130, 130\], dtype=np.int32) >>> rescale\_intensity(image, out\_range=(0, 127)).astype(np.int32) array(\[127, 127, 127\], dtype=int32)
### feature[#](#module-cucim.skimage.feature "Permalink to this heading")
Feature detection and extraction, e.g., blobs, corners, etc.
cucim.skimage.feature.blob\_dog(_image_, _min\_sigma\=1_, _max\_sigma\=50_, _sigma\_ratio\=1.6_, _threshold\=0.5_, _overlap\=0.5_, _\*_, _threshold\_rel\=None_, _exclude\_border\=False_)[#](#cucim.skimage.feature.blob_dog "Permalink to this definition")
Finds blobs in the given grayscale image. Blobs are found using the Difference of Gaussian (DoG) method [\[1\]](#rec0029c70586-1)
, [\[2\]](#rec0029c70586-2)
. For each blob found, the method returns its coordinates and the standard deviation of the Gaussian kernel that detected the blob. Parameters ———- image : ndarray
> Input grayscale image, blobs are assumed to be light on dark background (white on black).
min\_sigmascalar or sequence of scalars, optional
The minimum standard deviation for Gaussian kernel. Keep this low to detect smaller blobs. The standard deviations of the Gaussian filter are given for each axis as a sequence, or as a single number, in which case it is equal for all axes.
max\_sigmascalar or sequence of scalars, optional
The maximum standard deviation for Gaussian kernel. Keep this high to detect larger blobs. The standard deviations of the Gaussian filter are given for each axis as a sequence, or as a single number, in which case it is equal for all axes.
sigma\_ratiofloat, optional
The ratio between the standard deviation of Gaussian Kernels used for computing the Difference of Gaussians
thresholdfloat or None, optional
The absolute lower bound for scale space maxima. Local maxima smaller than threshold are ignored. Reduce this to detect blobs with lower intensities. If threshold\_rel is also specified, whichever threshold is larger will be used. If None, threshold\_rel is used instead.
overlapfloat, optional
A value between 0 and 1. If the area of two blobs overlaps by a fraction greater than threshold, the smaller blob is eliminated.
threshold\_relfloat or None, optional
Minimum intensity of peaks, calculated as `max(dog_space) * threshold_rel`, where `dog_space` refers to the stack of Difference-of-Gaussian (DoG) images computed internally. This should have a value between 0 and 1. If None, threshold is used instead.
exclude\_bordertuple of ints, int, or False, optional
If tuple of ints, the length of the tuple must match the input array’s dimensionality. Each element of the tuple will exclude peaks from within exclude\_border\-pixels of the border of the image along that dimension. If nonzero int, exclude\_border excludes peaks from within exclude\_border\-pixels of the border of the image. If zero or False, peaks are identified regardless of their distance from the border.
Returns:
**A**(n, image.ndim + sigma) ndarray
A 2d array with each row representing 2 coordinate values for a 2D image, or 3 coordinate values for a 3D image, plus the sigma(s) used. When a single sigma is passed, outputs are: `(r, c, sigma)` or `(p, r, c, sigma)` where `(r, c)` or `(p, r, c)` are coordinates of the blob and `sigma` is the standard deviation of the Gaussian kernel which detected the blob. When an anisotropic gaussian is used (sigmas per dimension), the detected sigma is returned for each dimension.
See also
[`cucim.skimage.filters.difference_of_gaussians`](#cucim.skimage.filters.difference_of_gaussians "cucim.skimage.filters.difference_of_gaussians")
Notes
The radius of each blob is approximately \\(\\sqrt{2}\\sigma\\) for a 2-D image and \\(\\sqrt{3}\\sigma\\) for a 3-D image.
References
\[[1](#id84)\
\]
[https://en.wikipedia.org/wiki/Blob\_detection#The\_difference\_of\_Gaussians\_approach](https://en.wikipedia.org/wiki/Blob_detection#The_difference_of_Gaussians_approach)
\[[2](#id85)\
\]
Lowe, D. G. “Distinctive Image Features from Scale-Invariant Keypoints.” International Journal of Computer Vision 60, 91–110 (2004). [https://www.cs.ubc.ca/~lowe/papers/ijcv04.pdf](https://www.cs.ubc.ca/~lowe/papers/ijcv04.pdf)
[DOI:10.1023/B:VISI.0000029664.99615.94](https://doi.org/10.1023/B:VISI.0000029664.99615.94)
Examples
\>>> import cupy as cp
\>>> from skimage import data
\>>> from cucim.skimage import feature
\>>> coins \= cp.array(data.coins())
\>>> feature.blob\_dog(coins, threshold\=.05, min\_sigma\=10, max\_sigma\=40)
array(\[\[128., 155., 10.\],\
\[198., 155., 10.\],\
\[124., 338., 10.\],\
\[127., 102., 10.\],\
\[193., 281., 10.\],\
\[126., 208., 10.\],\
\[267., 115., 10.\],\
\[197., 102., 10.\],\
\[198., 215., 10.\],\
\[123., 279., 10.\],\
\[126., 46., 10.\],\
\[259., 247., 10.\],\
\[196., 43., 10.\],\
\[ 54., 276., 10.\],\
\[267., 358., 10.\],\
\[ 58., 100., 10.\],\
\[259., 305., 10.\],\
\[185., 347., 16.\],\
\[261., 174., 16.\],\
\[ 46., 336., 16.\],\
\[ 54., 217., 10.\],\
\[ 55., 157., 10.\],\
\[ 57., 41., 10.\],\
\[260., 47., 16.\]\])
cucim.skimage.feature.blob\_doh(_image_, _min\_sigma\=1_, _max\_sigma\=30_, _num\_sigma\=10_, _threshold\=0.01_, _overlap\=0.5_, _log\_scale\=False_, _\*_, _threshold\_rel\=None_)[#](#cucim.skimage.feature.blob_doh "Permalink to this definition")
Finds blobs in the given grayscale image.
Blobs are found using the Determinant of Hessian method [\[1\]](#r1074719b9b14-1)
. For each blob found, the method returns its coordinates and the standard deviation of the Gaussian Kernel used for the Hessian matrix whose determinant detected the blob. Determinant of Hessians is approximated using [\[2\]](#r1074719b9b14-2)
.
Parameters:
**image**2D ndarray
Input grayscale image.Blobs can either be light on dark or vice versa.
**min\_sigma**float, optional
The minimum standard deviation for Gaussian Kernel used to compute Hessian matrix. Keep this low to detect smaller blobs.
**max\_sigma**float, optional
The maximum standard deviation for Gaussian Kernel used to compute Hessian matrix. Keep this high to detect larger blobs.
**num\_sigma**int, optional
The number of intermediate values of standard deviations to consider between min\_sigma and max\_sigma.
**threshold**float or None, optional
The absolute lower bound for scale space maxima. Local maxima smaller than threshold are ignored. Reduce this to detect blobs with lower intensities. If threshold\_rel is also specified, whichever threshold is larger will be used. If None, threshold\_rel is used instead.
**overlap**float, optional
A value between 0 and 1. If the area of two blobs overlaps by a fraction greater than threshold, the smaller blob is eliminated.
**log\_scale**bool, optional
If set intermediate values of standard deviations are interpolated using a logarithmic scale to the base 10. If not, linear interpolation is used.
**threshold\_rel**float or None, optional
Minimum intensity of peaks, calculated as `max(doh_space) * threshold_rel`, where `doh_space` refers to the stack of Determinant-of-Hessian (DoH) images computed internally. This should have a value between 0 and 1. If None, threshold is used instead.
Returns:
**A**(n, 3) ndarray
A 2d array with each row representing 3 values, `(y,x,sigma)` where `(y,x)` are coordinates of the blob and `sigma` is the standard deviation of the Gaussian kernel of the Hessian Matrix whose determinant detected the blob.
Notes
The radius of each blob is approximately sigma. Computation of Determinant of Hessians is independent of the standard deviation. Therefore detecting larger blobs won’t take more time. In methods line [`blob_dog()`](#cucim.skimage.feature.blob_dog "cucim.skimage.feature.blob_dog")
and [`blob_log()`](#cucim.skimage.feature.blob_log "cucim.skimage.feature.blob_log")
the computation of Gaussians for larger sigma takes more time. The downside is that this method can’t be used for detecting blobs of radius less than 3px due to the box filters used in the approximation of Hessian Determinant.
References
\[[1](#id88)\
\]
[https://en.wikipedia.org/wiki/Blob\_detection#The\_determinant\_of\_the\_Hessian](https://en.wikipedia.org/wiki/Blob_detection#The_determinant_of_the_Hessian)
\[[2](#id89)\
\]
Herbert Bay, Andreas Ess, Tinne Tuytelaars, Luc Van Gool, “SURF: Speeded Up Robust Features” [ftp://ftp.vision.ee.ethz.ch/publications/articles/eth\_biwi\_00517.pdf](ftp://ftp.vision.ee.ethz.ch/publications/articles/eth_biwi_00517.pdf)
Examples
\>>> import cupy as cp
\>>> from skimage import data
\>>> from cucim.skimage import feature
\>>> img \= cp.array(data.coins())
\>>> feature.blob\_doh(img)
array(\[\[197. , 153. , 20.333334\],\
\[124. , 336. , 20.333334\],\
\[126. , 153. , 20.333334\],\
\[195. , 100. , 23.555555\],\
\[192. , 212. , 23.555555\],\
\[121. , 271. , 30. \],\
\[126. , 101. , 20.333334\],\
\[193. , 275. , 23.555555\],\
\[123. , 205. , 20.333334\],\
\[270. , 363. , 30. \],\
\[265. , 113. , 23.555555\],\
\[262. , 243. , 23.555555\],\
\[185. , 348. , 30. \],\
\[156. , 302. , 30. \],\
\[123. , 44. , 23.555555\],\
\[260. , 173. , 30. \],\
\[197. , 44. , 20.333334\]\], dtype=float32)
cucim.skimage.feature.blob\_log(_image_, _min\_sigma\=1_, _max\_sigma\=50_, _num\_sigma\=10_, _threshold\=0.2_, _overlap\=0.5_, _log\_scale\=False_, _\*_, _threshold\_rel\=None_, _exclude\_border\=False_)[#](#cucim.skimage.feature.blob_log "Permalink to this definition")
Finds blobs in the given grayscale image. Blobs are found using the Laplacian of Gaussian (LoG) method [\[1\]](#rc8921dc5b222-1)
. For each blob found, the method returns its coordinates and the standard deviation of the Gaussian kernel that detected the blob. Parameters ———- image : ndarray
> Input grayscale image, blobs are assumed to be light on dark background (white on black).
min\_sigmascalar or sequence of scalars, optional
the minimum standard deviation for Gaussian kernel. Keep this low to detect smaller blobs. The standard deviations of the Gaussian filter are given for each axis as a sequence, or as a single number, in which case it is equal for all axes.
max\_sigmascalar or sequence of scalars, optional
The maximum standard deviation for Gaussian kernel. Keep this high to detect larger blobs. The standard deviations of the Gaussian filter are given for each axis as a sequence, or as a single number, in which case it is equal for all axes.
num\_sigmaint, optional
The number of intermediate values of standard deviations to consider between min\_sigma and max\_sigma.
thresholdfloat or None, optional
The absolute lower bound for scale space maxima. Local maxima smaller than threshold are ignored. Reduce this to detect blobs with lower intensities. If threshold\_rel is also specified, whichever threshold is larger will be used. If None, threshold\_rel is used instead.
overlapfloat, optional
A value between 0 and 1. If the area of two blobs overlaps by a fraction greater than threshold, the smaller blob is eliminated.
log\_scalebool, optional
If set intermediate values of standard deviations are interpolated using a logarithmic scale to the base 10. If not, linear interpolation is used.
threshold\_relfloat or None, optional
Minimum intensity of peaks, calculated as `max(log_space) * threshold_rel`, where `log_space` refers to the stack of Laplacian-of-Gaussian (LoG) images computed internally. This should have a value between 0 and 1. If None, threshold is used instead.
exclude\_bordertuple of ints, int, or False, optional
If tuple of ints, the length of the tuple must match the input array’s dimensionality. Each element of the tuple will exclude peaks from within exclude\_border\-pixels of the border of the image along that dimension. If nonzero int, exclude\_border excludes peaks from within exclude\_border\-pixels of the border of the image. If zero or False, peaks are identified regardless of their distance from the border.
Returns:
**A**(n, image.ndim + sigma) ndarray
A 2d array with each row representing 2 coordinate values for a 2D image, or 3 coordinate values for a 3D image, plus the sigma(s) used. When a single sigma is passed, outputs are: `(r, c, sigma)` or `(p, r, c, sigma)` where `(r, c)` or `(p, r, c)` are coordinates of the blob and `sigma` is the standard deviation of the Gaussian kernel which detected the blob. When an anisotropic gaussian is used (sigmas per dimension), the detected sigma is returned for each dimension.
References
\[[1](#id92)\
\]
[https://en.wikipedia.org/wiki/Blob\_detection#The\_Laplacian\_of\_Gaussian](https://en.wikipedia.org/wiki/Blob_detection#The_Laplacian_of_Gaussian)
Examples
\>>> import cupy as cp
\>>> from skimage import data
\>>> from cucim.skimage import feature, exposure
\>>> img \= cp.array(data.coins())
\>>> img \= exposure.equalize\_hist(img) \# improves detection
\>>> feature.blob\_log(img, threshold \= .3)
array(\[\[124. , 336. , 11.88888889\],\
\[198. , 155. , 11.88888889\],\
\[194. , 213. , 17.33333333\],\
\[121. , 272. , 17.33333333\],\
\[263. , 244. , 17.33333333\],\
\[194. , 276. , 17.33333333\],\
\[266. , 115. , 11.88888889\],\
\[128. , 154. , 11.88888889\],\
\[260. , 174. , 17.33333333\],\
\[198. , 103. , 11.88888889\],\
\[126. , 208. , 11.88888889\],\
\[127. , 102. , 11.88888889\],\
\[263. , 302. , 17.33333333\],\
\[197. , 44. , 11.88888889\],\
\[185. , 344. , 17.33333333\],\
\[126. , 46. , 11.88888889\],\
\[113. , 323. , 1. \]\])
Notes
\-----
The radius of each blob is approximately :math:\`\\sqrt{2}\\sigma\` for
a 2-D image and :math:\`\\sqrt{3}\\sigma\` for a 3-D image.
cucim.skimage.feature.canny(_image_, _sigma\=1.0_, _low\_threshold\=None_, _high\_threshold\=None_, _mask\=None_, _use\_quantiles\=False_, _\*_, _mode\='constant'_, _cval\=0.0_)[#](#cucim.skimage.feature.canny "Permalink to this definition")
Edge filter an image using the Canny algorithm.
Parameters:
**image**2D array
Grayscale input image to detect edges on; can be of any dtype.
**sigma**float, optional
Standard deviation of the Gaussian filter.
**low\_threshold**float, optional
Lower bound for hysteresis thresholding (linking edges). If None, low\_threshold is set to 10% of dtype’s max.
**high\_threshold**float, optional
Upper bound for hysteresis thresholding (linking edges). If None, high\_threshold is set to 20% of dtype’s max.
**mask**array, dtype=bool, optional
Mask to limit the application of Canny to a certain area.
**use\_quantiles**bool, optional
If `True` then treat low\_threshold and high\_threshold as quantiles of the edge magnitude image, rather than absolute edge magnitude values. If `True` then the thresholds must be in the range \[0, 1\].
**mode**str, {‘reflect’, ‘constant’, ‘nearest’, ‘mirror’, ‘wrap’}
The `mode` parameter determines how the array borders are handled during Gaussian filtering, where `cval` is the value when mode is equal to ‘constant’.
**cval**float, optional
Value to fill past edges of input if mode is ‘constant’.
Returns:
**output**2D array (image)
The binary edge map.
See also
[`skimage.filters.sobel`](https://scikit-image.org/docs/stable/api/skimage.filters.html#skimage.filters.sobel "(in skimage v0.25.2)")
Notes
The steps of the algorithm are as follows:
* Smooth the image using a Gaussian with `sigma` width.
* Apply the horizontal and vertical Sobel operators to get the gradients within the image. The edge strength is the norm of the gradient.
* Thin potential edges to 1-pixel wide curves. First, find the normal to the edge at each point. This is done by looking at the signs and the relative magnitude of the X-Sobel and Y-Sobel to sort the points into 4 categories: horizontal, vertical, diagonal and antidiagonal. Then look in the normal and reverse directions to see if the values in either of those directions are greater than the point in question. Use interpolation to get a mix of points instead of picking the one that’s the closest to the normal.
* Perform a hysteresis thresholding: first label all points above the high threshold as edges. Then recursively label any point above the low threshold that is 8-connected to a labeled point as an edge.
References
\[1\]
Canny, J., A Computational Approach To Edge Detection, IEEE Trans. Pattern Analysis and Machine Intelligence, 8:679-714, 1986 [DOI:10.1109/TPAMI.1986.4767851](https://doi.org/10.1109/TPAMI.1986.4767851)
\[2\]
William Green’s Canny tutorial [https://en.wikipedia.org/wiki/Canny\_edge\_detector](https://en.wikipedia.org/wiki/Canny_edge_detector)
Examples
\>>> import cupy as cp
\>>> from cucim.skimage import feature
\>>> \# Generate noisy image of a square
\>>> im \= cp.zeros((256, 256))
\>>> im\[64:\-64, 64:\-64\] \= 1
\>>> im += 0.2 \* cp.random.rand(\*im.shape)
\>>> \# First trial with the Canny filter, with the default smoothing
\>>> edges1 \= feature.canny(im)
\>>> \# Increase the smoothing for better results
\>>> edges2 \= feature.canny(im, sigma\=3)
cucim.skimage.feature.corner\_foerstner(_image_, _sigma\=1_)[#](#cucim.skimage.feature.corner_foerstner "Permalink to this definition")
Compute Foerstner corner measure response image.
This corner detector uses information from the auto-correlation matrix A:
A \= \[(imx\*\*2) (imx\*imy)\] \= \[Axx Axy\]
\[(imx\*imy) (imy\*\*2)\] \[Axy Ayy\]
Where imx and imy are first derivatives, averaged with a gaussian filter. The corner measure is then defined as:
w \= det(A) / trace(A) (size of error ellipse)
q \= 4 \* det(A) / trace(A)\*\*2 (roundness of error ellipse)
Parameters:
**image**(M, N) ndarray
Input image.
**sigma**float, optional
Standard deviation used for the Gaussian kernel, which is used as weighting function for the auto-correlation matrix.
Returns:
**w**ndarray
Error ellipse sizes.
**q**ndarray
Roundness of error ellipse.
References
\[1\]
Förstner, W., & Gülch, E. (1987, June). A fast operator for detection and precise location of distinct points, corners and centres of circular features. In Proc. ISPRS intercommission conference on fast processing of photogrammetric data (pp. 281-305).
\[2\]
[https://en.wikipedia.org/wiki/Corner\_detection](https://en.wikipedia.org/wiki/Corner_detection)
Examples
\>>> from cucim.skimage.feature import corner\_foerstner, corner\_peaks
\>>> square \= cp.zeros(\[10, 10\])
\>>> square\[2:8, 2:8\] \= 1
\>>> square.astype(int)
array(\[\[0, 0, 0, 0, 0, 0, 0, 0, 0, 0\],\
\[0, 0, 0, 0, 0, 0, 0, 0, 0, 0\],\
\[0, 0, 1, 1, 1, 1, 1, 1, 0, 0\],\
\[0, 0, 1, 1, 1, 1, 1, 1, 0, 0\],\
\[0, 0, 1, 1, 1, 1, 1, 1, 0, 0\],\
\[0, 0, 1, 1, 1, 1, 1, 1, 0, 0\],\
\[0, 0, 1, 1, 1, 1, 1, 1, 0, 0\],\
\[0, 0, 1, 1, 1, 1, 1, 1, 0, 0\],\
\[0, 0, 0, 0, 0, 0, 0, 0, 0, 0\],\
\[0, 0, 0, 0, 0, 0, 0, 0, 0, 0\]\])
\>>> w, q \= corner\_foerstner(square)
\>>> accuracy\_thresh \= 0.5
\>>> roundness\_thresh \= 0.3
\>>> foerstner \= (q \> roundness\_thresh) \* (w \> accuracy\_thresh) \* w
\>>> corner\_peaks(foerstner, min\_distance\=1)
array(\[\[2, 2\],\
\[2, 7\],\
\[7, 2\],\
\[7, 7\]\])
cucim.skimage.feature.corner\_harris(_image_, _method\='k'_, _k\=0.05_, _eps\=1e-06_, _sigma\=1_)[#](#cucim.skimage.feature.corner_harris "Permalink to this definition")
Compute Harris corner measure response image.
This corner detector uses information from the auto-correlation matrix A:
A \= \[(imx\*\*2) (imx\*imy)\] \= \[Axx Axy\]
\[(imx\*imy) (imy\*\*2)\] \[Axy Ayy\]
Where imx and imy are first derivatives, averaged with a gaussian filter. The corner measure is then defined as:
det(A) \- k \* trace(A)\*\*2
or:
2 \* det(A) / (trace(A) + eps)
Parameters:
**image**(M, N) ndarray
Input image.
**method**{‘k’, ‘eps’}, optional
Method to compute the response image from the auto-correlation matrix.
**k**float, optional
Sensitivity factor to separate corners from edges, typically in range \[0, 0.2\]. Small values of k result in detection of sharp corners.
**eps**float, optional
Normalisation factor (Noble’s corner measure).
**sigma**float, optional
Standard deviation used for the Gaussian kernel, which is used as weighting function for the auto-correlation matrix.
Returns:
**response**ndarray
Harris response image.
References
\[1\]
[https://en.wikipedia.org/wiki/Corner\_detection](https://en.wikipedia.org/wiki/Corner_detection)
Examples
\>>> from cucim.skimage.feature import corner\_harris, corner\_peaks
\>>> square \= cp.zeros(\[10, 10\])
\>>> square\[2:8, 2:8\] \= 1
\>>> square.astype(int)
array(\[\[0, 0, 0, 0, 0, 0, 0, 0, 0, 0\],\
\[0, 0, 0, 0, 0, 0, 0, 0, 0, 0\],\
\[0, 0, 1, 1, 1, 1, 1, 1, 0, 0\],\
\[0, 0, 1, 1, 1, 1, 1, 1, 0, 0\],\
\[0, 0, 1, 1, 1, 1, 1, 1, 0, 0\],\
\[0, 0, 1, 1, 1, 1, 1, 1, 0, 0\],\
\[0, 0, 1, 1, 1, 1, 1, 1, 0, 0\],\
\[0, 0, 1, 1, 1, 1, 1, 1, 0, 0\],\
\[0, 0, 0, 0, 0, 0, 0, 0, 0, 0\],\
\[0, 0, 0, 0, 0, 0, 0, 0, 0, 0\]\])
\>>> corner\_peaks(corner\_harris(square), min\_distance\=1)
array(\[\[2, 2\],\
\[2, 7\],\
\[7, 2\],\
\[7, 7\]\])
cucim.skimage.feature.corner\_kitchen\_rosenfeld(_image_, _mode\='constant'_, _cval\=0_)[#](#cucim.skimage.feature.corner_kitchen_rosenfeld "Permalink to this definition")
Compute Kitchen and Rosenfeld corner measure response image.
The corner measure is calculated as follows:
(imxx \* imy\*\*2 + imyy \* imx\*\*2 \- 2 \* imxy \* imx \* imy)
/ (imx\*\*2 + imy\*\*2)
Where imx and imy are the first and imxx, imxy, imyy the second derivatives.
Parameters:
**image**(M, N) ndarray
Input image.
**mode**{‘constant’, ‘reflect’, ‘wrap’, ‘nearest’, ‘mirror’}, optional
How to handle values outside the image borders.
**cval**float, optional
Used in conjunction with mode ‘constant’, the value outside the image boundaries.
Returns:
**response**ndarray
Kitchen and Rosenfeld response image.
References
\[1\]
Kitchen, L., & Rosenfeld, A. (1982). Gray-level corner detection. Pattern recognition letters, 1(2), 95-102. [DOI:10.1016/0167-8655(82)90020-4](https://doi.org/10.1016/0167-8655(82)90020-4)
cucim.skimage.feature.corner\_peaks(_image_, _min\_distance\=1_, _threshold\_abs\=None_, _threshold\_rel\=None_, _exclude\_border\=True_, _indices\=True_, _num\_peaks\=inf_, _footprint\=None_, _labels\=None_, _\*_, _num\_peaks\_per\_label\=inf_, _p\_norm\=inf_)[#](#cucim.skimage.feature.corner_peaks "Permalink to this definition")
Find peaks in corner measure response image.
This differs from skimage.feature.peak\_local\_max in that it suppresses multiple connected peaks with the same accumulator value.
Parameters:
**image**(M, N) ndarray
Input image.
**min\_distance**int, optional
The minimal allowed distance separating peaks.
**\***\*
See `skimage.feature.peak_local_max()`.
**p\_norm**float
Which Minkowski p-norm to use. Should be in the range \[1, inf\]. A finite large p may cause a ValueError if overflow can occur. `inf` corresponds to the Chebyshev distance and 2 to the Euclidean distance.
Returns:
**output**ndarray or ndarray of bools
* If indices = True : (row, column, …) coordinates of peaks.
* If indices = False : Boolean array shaped like image, with peaks represented by True values.
See also
[`skimage.feature.peak_local_max`](https://scikit-image.org/docs/stable/api/skimage.feature.html#skimage.feature.peak_local_max "(in skimage v0.25.2)")
Notes
Changed in version 0.18: The default value of threshold\_rel has changed to None, which corresponds to letting skimage.feature.peak\_local\_max decide on the default. This is equivalent to threshold\_rel=0.
The num\_peaks limit is applied before suppression of connected peaks. To limit the number of peaks after suppression, set num\_peaks=np.inf and post-process the output of this function.
Examples
\>>> from cucim.skimage.feature import peak\_local\_max
\>>> response \= cp.zeros((5, 5))
\>>> response\[2:4, 2:4\] \= 1
\>>> response
array(\[\[0., 0., 0., 0., 0.\],\
\[0., 0., 0., 0., 0.\],\
\[0., 0., 1., 1., 0.\],\
\[0., 0., 1., 1., 0.\],\
\[0., 0., 0., 0., 0.\]\])
\>>> peak\_local\_max(response)
array(\[\[2, 2\],\
\[2, 3\],\
\[3, 2\],\
\[3, 3\]\])
\>>> corner\_peaks(response)
array(\[\[2, 2\]\])
cucim.skimage.feature.corner\_shi\_tomasi(_image_, _sigma\=1_)[#](#cucim.skimage.feature.corner_shi_tomasi "Permalink to this definition")
Compute Shi-Tomasi (Kanade-Tomasi) corner measure response image.
This corner detector uses information from the auto-correlation matrix A:
A \= \[(imx\*\*2) (imx\*imy)\] \= \[Axx Axy\]
\[(imx\*imy) (imy\*\*2)\] \[Axy Ayy\]
Where imx and imy are first derivatives, averaged with a gaussian filter. The corner measure is then defined as the smaller eigenvalue of A:
((Axx + Ayy) \- sqrt((Axx \- Ayy)\*\*2 + 4 \* Axy\*\*2)) / 2
Parameters:
**image**(M, N) ndarray
Input image.
**sigma**float, optional
Standard deviation used for the Gaussian kernel, which is used as weighting function for the auto-correlation matrix.
Returns:
**response**ndarray
Shi-Tomasi response image.
References
\[1\]
[https://en.wikipedia.org/wiki/Corner\_detection](https://en.wikipedia.org/wiki/Corner_detection)
Examples
\>>> from cucim.skimage.feature import corner\_shi\_tomasi, corner\_peaks
\>>> square \= cp.zeros(\[10, 10\])
\>>> square\[2:8, 2:8\] \= 1
\>>> square.astype(int)
array(\[\[0, 0, 0, 0, 0, 0, 0, 0, 0, 0\],\
\[0, 0, 0, 0, 0, 0, 0, 0, 0, 0\],\
\[0, 0, 1, 1, 1, 1, 1, 1, 0, 0\],\
\[0, 0, 1, 1, 1, 1, 1, 1, 0, 0\],\
\[0, 0, 1, 1, 1, 1, 1, 1, 0, 0\],\
\[0, 0, 1, 1, 1, 1, 1, 1, 0, 0\],\
\[0, 0, 1, 1, 1, 1, 1, 1, 0, 0\],\
\[0, 0, 1, 1, 1, 1, 1, 1, 0, 0\],\
\[0, 0, 0, 0, 0, 0, 0, 0, 0, 0\],\
\[0, 0, 0, 0, 0, 0, 0, 0, 0, 0\]\])
\>>> corner\_peaks(corner\_shi\_tomasi(square),
... min\_distance\=1)
array(\[\[2, 2\],\
\[2, 7\],\
\[7, 2\],\
\[7, 7\]\])
cucim.skimage.feature.daisy(_image_, _step\=4_, _radius\=15_, _rings\=3_, _histograms\=8_, _orientations\=8_, _normalization\='l1'_, _sigmas\=None_, _ring\_radii\=None_, _visualize\=False_)[#](#cucim.skimage.feature.daisy "Permalink to this definition")
Extract DAISY feature descriptors densely for the given image.
DAISY is a feature descriptor similar to SIFT formulated in a way that allows for fast dense extraction. Typically, this is practical for bag-of-features image representations.
The implementation follows Tola et al. [\[1\]](#r755485c8391d-1)
but deviate on the following points:
> * Histogram bin contribution are smoothed with a circular Gaussian window over the tonal range (the angular range).
>
> * The sigma values of the spatial Gaussian smoothing in this code do not match the sigma values in the original code by Tola et al. [\[2\]](#r755485c8391d-2)
> . In their code, spatial smoothing is applied to both the input image and the center histogram. However, this smoothing is not documented in [\[1\]](#r755485c8391d-1)
> and, therefore, it is omitted.
>
Parameters:
**image**(M, N) array
Input image (grayscale).
**step**int, optional
Distance between descriptor sampling points.
**radius**int, optional
Radius (in pixels) of the outermost ring.
**rings**int, optional
Number of rings.
**histograms**int, optional
Number of histograms sampled per ring.
**orientations**int, optional
Number of orientations (bins) per histogram.
**normalization**\[ ‘l1’ | ‘l2’ | ‘daisy’ | ‘off’ \], optional
How to normalize the descriptors
> * ‘l1’: L1-normalization of each descriptor.
>
> * ‘l2’: L2-normalization of each descriptor.
>
> * ‘daisy’: L2-normalization of individual histograms.
>
> * ‘off’: Disable normalization.
>
**sigmas**1D array of float, optional
Standard deviation of spatial Gaussian smoothing for the center histogram and for each ring of histograms. The array of sigmas should be sorted from the center and out. I.e. the first sigma value defines the spatial smoothing of the center histogram and the last sigma value defines the spatial smoothing of the outermost ring. Specifying sigmas overrides the following parameter.
> `rings = len(sigmas) - 1`
**ring\_radii**1D array of int, optional
Radius (in pixels) for each ring. Specifying ring\_radii overrides the following two parameters.
> `rings = len(ring_radii)` `radius = ring_radii[-1]`
If both sigmas and ring\_radii are given, they must satisfy the following predicate since no radius is needed for the center histogram.
> `len(ring_radii) == len(sigmas) + 1`
**visualize**bool, optional
Generate a visualization of the DAISY descriptors
Returns:
**descs**array
Grid of DAISY descriptors for the given image as an array dimensionality (P, Q, R) where
> `P = ceil((M - radius*2) / step)` `Q = ceil((N - radius*2) / step)` `R = (rings * histograms + 1) * orientations`
**descs\_img**(M, N, 3) array (only if visualize==True)
Visualization of the DAISY descriptors.
References
\[1\] ([1](#id101)
,[2](#id103)
)
Tola et al. “Daisy: An efficient dense descriptor applied to wide- baseline stereo.” Pattern Analysis and Machine Intelligence, IEEE Transactions on 32.5 (2010): 815-830.
\[[2](#id102)\
\]
[http://cvlab.epfl.ch/software/daisy](http://cvlab.epfl.ch/software/daisy)
cucim.skimage.feature.hessian\_matrix(_image_, _sigma\=1_, _mode\='constant'_, _cval\=0_, _order\='rc'_, _use\_gaussian\_derivatives\=None_)[#](#cucim.skimage.feature.hessian_matrix "Permalink to this definition")
Compute the Hessian matrix.
In 2D, the Hessian matrix is defined as:
H \= \[Hrr Hrc\]
\[Hrc Hcc\]
which is computed by convolving the image with the second derivatives of the Gaussian kernel in the respective r- and c-directions.
The implementation here also supports n-dimensional data.
Parameters:
**image**ndarray
Input image.
**sigma**float
Standard deviation used for the Gaussian kernel, which is used as weighting function for the auto-correlation matrix.
**mode**{‘constant’, ‘reflect’, ‘wrap’, ‘nearest’, ‘mirror’}, optional
How to handle values outside the image borders.
**cval**float, optional
Used in conjunction with mode ‘constant’, the value outside the image boundaries.
**order**{‘rc’, ‘xy’}, optional
NOTE: ‘xy’ is only an option for 2D images, higher dimensions must always use ‘rc’ order. This parameter allows for the use of reverse or forward order of the image axes in gradient computation. ‘rc’ indicates the use of the first axis initially (Hrr, Hrc, Hcc), whilst ‘xy’ indicates the usage of the last axis initially (Hxx, Hxy, Hyy).
**use\_gaussian\_derivatives**boolean, optional
Indicates whether the Hessian is computed by convolving with Gaussian derivatives, or by a simple finite-difference operation.
Returns:
**H\_elems**list of ndarray
Upper-diagonal elements of the hessian matrix for each pixel in the input image. In 2D, this will be a three element list containing \[Hrr, Hrc, Hcc\]. In nD, the list will contain `(n**2 + n) / 2` arrays.
Notes
The distributive property of derivatives and convolutions allows us to restate the derivative of an image, I, smoothed with a Gaussian kernel, G, as the convolution of the image with the derivative of G.
\\\[\\frac{\\partial }{\\partial x\_i}(I \* G) = I \* \\left( \\frac{\\partial }{\\partial x\_i} G \\right)\\\]
When `use_gaussian_derivatives` is `True`, this property is used to compute the second order derivatives that make up the Hessian matrix.
When `use_gaussian_derivatives` is `False`, simple finite differences on a Gaussian-smoothed image are used instead.
Examples
\>>> import cupy as cp
\>>> from cucim.skimage.feature import hessian\_matrix
\>>> square \= cp.zeros((5, 5))
\>>> square\[2, 2\] \= 4
\>>> Hrr, Hrc, Hcc \= hessian\_matrix(square, sigma\=0.1, order\='rc',
... use\_gaussian\_derivatives\=False)
\>>> Hrc
array(\[\[ 0., 0., 0., 0., 0.\],\
\[ 0., 1., 0., -1., 0.\],\
\[ 0., 0., 0., 0., 0.\],\
\[ 0., -1., 0., 1., 0.\],\
\[ 0., 0., 0., 0., 0.\]\])
cucim.skimage.feature.hessian\_matrix\_det(_image_, _sigma\=1_, _approximate\=True_)[#](#cucim.skimage.feature.hessian_matrix_det "Permalink to this definition")
Compute the approximate Hessian Determinant over an image.
The 2D approximate method uses box filters over integral images to compute the approximate Hessian Determinant.
Parameters:
**image**ndarray
The image over which to compute the Hessian Determinant.
**sigma**float, optional
Standard deviation of the Gaussian kernel used for the Hessian matrix.
**approximate**bool, optional
If `True` and the image is 2D, use a much faster approximate computation. This argument has no effect on 3D and higher images.
Returns:
**out**array
The array of the Determinant of Hessians.
Notes
For 2D images when `approximate=True`, the running time of this method only depends on size of the image. It is independent of sigma as one would expect. The downside is that the result for sigma less than 3 is not accurate, i.e., not similar to the result obtained if someone computed the Hessian and took its determinant.
References
\[1\]
Herbert Bay, Andreas Ess, Tinne Tuytelaars, Luc Van Gool, “SURF: Speeded Up Robust Features” [ftp://ftp.vision.ee.ethz.ch/publications/articles/eth\_biwi\_00517.pdf](ftp://ftp.vision.ee.ethz.ch/publications/articles/eth_biwi_00517.pdf)
cucim.skimage.feature.hessian\_matrix\_eigvals(_H\_elems_)[#](#cucim.skimage.feature.hessian_matrix_eigvals "Permalink to this definition")
Compute eigenvalues of Hessian matrix.
Parameters:
**H\_elems**list of ndarray
The upper-diagonal elements of the Hessian matrix, as returned by hessian\_matrix.
Returns:
**eigs**ndarray
The eigenvalues of the Hessian matrix, in decreasing order. The eigenvalues are the leading dimension. That is, `eigs[i, j, k]` contains the ith-largest eigenvalue at position (j, k).
Examples
\>>> import cupy as cp
\>>> from cucim.skimage.feature import (hessian\_matrix,
... hessian\_matrix\_eigvals)
\>>> square \= cp.zeros((5, 5))
\>>> square\[2, 2\] \= 4
\>>> H\_elems \= hessian\_matrix(square, sigma\=0.1, order\='rc',
... use\_gaussian\_derivatives\=False)
\>>> hessian\_matrix\_eigvals(H\_elems)\[0\]
array(\[\[ 0., 0., 2., 0., 0.\],\
\[ 0., 1., 0., 1., 0.\],\
\[ 2., 0., -2., 0., 2.\],\
\[ 0., 1., 0., 1., 0.\],\
\[ 0., 0., 2., 0., 0.\]\])
cucim.skimage.feature.match\_descriptors(_descriptors1_, _descriptors2_, _metric\=None_, _p\=2_, _max\_distance\=inf_, _cross\_check\=True_, _max\_ratio\=1.0_)[#](#cucim.skimage.feature.match_descriptors "Permalink to this definition")
Brute-force matching of descriptors.
For each descriptor in the first set this matcher finds the closest descriptor in the second set (and vice-versa in the case of enabled cross-checking).
Parameters:
**descriptors1**(M, P) array
Descriptors of size P about M keypoints in the first image.
**descriptors2**(N, P) array
Descriptors of size P about N keypoints in the second image.
**metric**{‘euclidean’, ‘cityblock’, ‘minkowski’, ‘hamming’, …} , optional
The metric to compute the distance between two descriptors. See scipy.spatial.distance.cdist for all possible types. The hamming distance should be used for binary descriptors. By default the L2-norm is used for all descriptors of dtype float or double and the Hamming distance is used for binary descriptors automatically.
**p**int, optional
The p-norm to apply for `metric='minkowski'`.
**max\_distance**float, optional
Maximum allowed distance between descriptors of two keypoints in separate images to be regarded as a match.
**cross\_check**bool, optional
If True, the matched keypoints are returned after cross checking i.e. a matched pair (keypoint1, keypoint2) is returned if keypoint2 is the best match for keypoint1 in second image and keypoint1 is the best match for keypoint2 in first image.
**max\_ratio**float, optional
Maximum ratio of distances between first and second closest descriptor in the second set of descriptors. This threshold is useful to filter ambiguous matches between the two descriptor sets. The choice of this value depends on the statistics of the chosen descriptor, e.g., for SIFT descriptors a value of 0.8 is usually chosen, see D.G. Lowe, “Distinctive Image Features from Scale-Invariant Keypoints”, International Journal of Computer Vision, 2004.
Returns:
**matches**(Q, 2) array
Indices of corresponding matches in first and second set of descriptors, where `matches[:, 0]` denote the indices in the first and `matches[:, 1]` the indices in the second set of descriptors.
cucim.skimage.feature.match\_template(_image_, _template_, _pad\_input\=False_, _mode\='constant'_, _constant\_values\=0_)[#](#cucim.skimage.feature.match_template "Permalink to this definition")
Match a template to a 2-D or 3-D image using normalized correlation.
The output is an array with values between -1.0 and 1.0. The value at a given position corresponds to the correlation coefficient between the image and the template.
For pad\_input=True matches correspond to the center and otherwise to the top-left corner of the template. To find the best match you must search for peaks in the response (output) image.
Parameters:
**image**(M, N\[, D\]) array
2-D or 3-D input image.
**template**(m, n\[, d\]) array
Template to locate. It must be (m <= M, n <= N\[, d <= D\]).
**pad\_input**bool
If True, pad image so that output is the same size as the image, and output values correspond to the template center. Otherwise, the output is an array with shape (M - m + 1, N - n + 1) for an (M, N) image and an (m, n) template, and matches correspond to origin (top-left corner) of the template.
**mode**see numpy.pad, optional
Padding mode.
**constant\_values**see numpy.pad, optional
Constant values used in conjunction with `mode='constant'`.
Returns:
**output**array
Response image with correlation coefficients.
Notes
Details on the cross-correlation are presented in [\[1\]](#r9f67d2173c8e-1)
. This implementation uses FFT convolutions of the image and the template. Reference [\[2\]](#r9f67d2173c8e-2)
presents similar derivations but the approximation presented in this reference is not used in our implementation.
This CuPy implementation does not force the image to float64 internally, but will use float32 for single-precision inputs.
References
\[[1](#id107)\
\]
J. P. Lewis, “Fast Normalized Cross-Correlation”, Industrial Light and Magic.
\[[2](#id108)\
\]
Briechle and Hanebeck, “Template Matching using Fast Normalized Cross Correlation”, Proceedings of the SPIE (2001). [DOI:10.1117/12.421129](https://doi.org/10.1117/12.421129)
Examples
\>>> import cupy as cp
\>>> template \= cp.zeros((3, 3))
\>>> template\[1, 1\] \= 1
\>>> template
array(\[\[0., 0., 0.\],\
\[0., 1., 0.\],\
\[0., 0., 0.\]\])
\>>> image \= cp.zeros((6, 6))
\>>> image\[1, 1\] \= 1
\>>> image\[4, 4\] \= \-1
\>>> image
array(\[\[ 0., 0., 0., 0., 0., 0.\],\
\[ 0., 1., 0., 0., 0., 0.\],\
\[ 0., 0., 0., 0., 0., 0.\],\
\[ 0., 0., 0., 0., 0., 0.\],\
\[ 0., 0., 0., 0., -1., 0.\],\
\[ 0., 0., 0., 0., 0., 0.\]\])
\>>> result \= match\_template(image, template)
\>>> cp.around(result, 3)
array(\[\[ 1. , -0.125, 0. , 0. \],\
\[-0.125, -0.125, 0. , 0. \],\
\[ 0. , 0. , 0.125, 0.125\],\
\[ 0. , 0. , 0.125, -1. \]\])
\>>> result \= match\_template(image, template, pad\_input\=True)
\>>> cp.around(result, 3)
array(\[\[-0.125, -0.125, -0.125, 0. , 0. , 0. \],\
\[-0.125, 1. , -0.125, 0. , 0. , 0. \],\
\[-0.125, -0.125, -0.125, 0. , 0. , 0. \],\
\[ 0. , 0. , 0. , 0.125, 0.125, 0.125\],\
\[ 0. , 0. , 0. , 0.125, -1. , 0.125\],\
\[ 0. , 0. , 0. , 0.125, 0.125, 0.125\]\])
cucim.skimage.feature.multiscale\_basic\_features(_image_, _intensity\=True_, _edges\=True_, _texture\=True_, _sigma\_min\=0.5_, _sigma\_max\=16_, _num\_sigma\=None_, _num\_workers\=None_, _\*_, _channel\_axis\=None_)[#](#cucim.skimage.feature.multiscale_basic_features "Permalink to this definition")
Local features for a single- or multi-channel nd image.
Intensity, gradient intensity and local structure are computed at different scales thanks to Gaussian blurring.
Parameters:
**image**ndarray
Input image, which can be grayscale or multichannel.
**intensity**bool, default True
If True, pixel intensities averaged over the different scales are added to the feature set.
**edges**bool, default True
If True, intensities of local gradients averaged over the different scales are added to the feature set.
**texture**bool, default True
If True, eigenvalues of the Hessian matrix after Gaussian blurring at different scales are added to the feature set.
**sigma\_min**float, optional
Smallest value of the Gaussian kernel used to average local neighborhoods before extracting features.
**sigma\_max**float, optional
Largest value of the Gaussian kernel used to average local neighborhoods before extracting features.
**num\_sigma**int, optional
Number of values of the Gaussian kernel between sigma\_min and sigma\_max. If None, sigma\_min multiplied by powers of 2 are used.
**num\_workers**int or None, optional
The number of parallel threads to use. If set to `None`, the full set of available cores are used.
**channel\_axis**int or None, optional
If None, the image is assumed to be a grayscale (single channel) image. Otherwise, this parameter indicates which axis of the array corresponds to channels.
Returns:
**features**np.ndarray
Array of shape `image.shape + (n_features,)`. When channel\_axis is not None, all channels are concatenated along the features dimension. (i.e. `n_features == n_features_singlechannel * n_channels`)
cucim.skimage.feature.peak\_local\_max(_image_, _min\_distance\=1_, _threshold\_abs\=None_, _threshold\_rel\=None_, _exclude\_border\=True_, _num\_peaks\=inf_, _footprint\=None_, _labels\=None_, _num\_peaks\_per\_label\=inf_, _p\_norm\=inf_)[#](#cucim.skimage.feature.peak_local_max "Permalink to this definition")
Find peaks in an image as coordinate list.
Peaks are the local maxima in a region of 2 \* min\_distance + 1 (i.e. peaks are separated by at least min\_distance).
If both threshold\_abs and threshold\_rel are provided, the maximum of the two is chosen as the minimum intensity threshold of peaks.
Changed in version 0.18: Prior to version 0.18, peaks of the same height within a radius of min\_distance were all returned, but this could cause unexpected behaviour. From 0.18 onwards, an arbitrary peak within the region is returned. See issue gh-2592.
Parameters:
**image**ndarray
Input image.
**min\_distance**int, optional
The minimal allowed distance separating peaks. To find the maximum number of peaks, use min\_distance=1.
**threshold\_abs**float or None, optional
Minimum intensity of peaks. By default, the absolute threshold is the minimum intensity of the image.
**threshold\_rel**float or None, optional
Minimum intensity of peaks, calculated as `max(image) * threshold_rel`.
**exclude\_border**int, tuple of ints, or bool, optional
If positive integer, exclude\_border excludes peaks from within exclude\_border\-pixels of the border of the image. If tuple of non-negative ints, the length of the tuple must match the input array’s dimensionality. Each element of the tuple will exclude peaks from within exclude\_border\-pixels of the border of the image along that dimension. If True, takes the min\_distance parameter as value. If zero or False, peaks are identified regardless of their distance from the border.
**num\_peaks**int, optional
Maximum number of peaks. When the number of peaks exceeds num\_peaks, return num\_peaks peaks based on highest peak intensity.
**footprint**ndarray of bools, optional
If provided, footprint == 1 represents the local region within which to search for peaks at every point in image.
**labels**ndarray of ints, optional
If provided, each unique region labels == value represents a unique region to search for peaks. Zero is reserved for background.
**num\_peaks\_per\_label**int, optional
Maximum number of peaks for each label.
**p\_norm**float
Which Minkowski p-norm to use. Should be in the range \[1, inf\]. A finite large p may cause a ValueError if overflow can occur. `inf` corresponds to the Chebyshev distance and 2 to the Euclidean distance.
Returns:
**output**ndarray
The coordinates of the peaks.
See also
[`skimage.feature.corner_peaks`](https://scikit-image.org/docs/stable/api/skimage.feature.html#skimage.feature.corner_peaks "(in skimage v0.25.2)")
Notes
The peak local maximum function returns the coordinates of local peaks (maxima) in an image. Internally, a maximum filter is used for finding local maxima. This operation dilates the original image. After comparison of the dilated and original images, this function returns the coordinates
Examples
\>>> import cupy as cp
\>>> img1 \= cp.zeros((7, 7))
\>>> img1\[3, 4\] \= 1
\>>> img1\[3, 2\] \= 1.5
\>>> img1
array(\[\[0. , 0. , 0. , 0. , 0. , 0. , 0. \],\
\[0. , 0. , 0. , 0. , 0. , 0. , 0. \],\
\[0. , 0. , 0. , 0. , 0. , 0. , 0. \],\
\[0. , 0. , 1.5, 0. , 1. , 0. , 0. \],\
\[0. , 0. , 0. , 0. , 0. , 0. , 0. \],\
\[0. , 0. , 0. , 0. , 0. , 0. , 0. \],\
\[0. , 0. , 0. , 0. , 0. , 0. , 0. \]\])
\>>> peak\_local\_max(img1, min\_distance\=1)
array(\[\[3, 2\],\
\[3, 4\]\])
\>>> peak\_local\_max(img1, min\_distance\=2)
array(\[\[3, 2\]\])
\>>> img2 \= cp.zeros((20, 20, 20))
\>>> img2\[10, 10, 10\] \= 1
\>>> img2\[15, 15, 15\] \= 1
\>>> peak\_idx \= peak\_local\_max(img2, exclude\_border\=0)
\>>> peak\_idx
array(\[\[10, 10, 10\],\
\[15, 15, 15\]\])
\>>> peak\_mask \= cp.zeros\_like(img2, dtype\=bool)
\>>> peak\_mask\[tuple(peak\_idx.T)\] \= True
\>>> np.argwhere(peak\_mask)
array(\[\[10, 10, 10\],\
\[15, 15, 15\]\])
cucim.skimage.feature.shape\_index(_image_, _sigma\=1_, _mode\='constant'_, _cval\=0_)[#](#cucim.skimage.feature.shape_index "Permalink to this definition")
Compute the shape index.
The shape index, as defined by Koenderink & van Doorn [\[1\]](#r7fa02a84f5a7-1)
, is a single valued measure of local curvature, assuming the image as a 3D plane with intensities representing heights.
It is derived from the eigenvalues of the Hessian, and its value ranges from -1 to 1 (and is undefined (=NaN) in _flat_ regions), with following ranges representing following shapes:
| | |
| --- | --- |Ranges of the shape index and corresponding shapes.[#](#id373 "Permalink to this table")
| Interval (s in …) | Shape |
| --- | --- |
| \[ -1, -7/8) | Spherical cup |\
| \[-7/8, -5/8) | Through |\
| \[-5/8, -3/8) | Rut |\
| \[-3/8, -1/8) | Saddle rut |\
| \[-1/8, +1/8) | Saddle |\
| \[+1/8, +3/8) | Saddle ridge |\
| \[+3/8, +5/8) | Ridge |\
| \[+5/8, +7/8) | Dome |\
| \[+7/8, +1\] | Spherical cap |\
\
Parameters:\
\
**image**(M, N) ndarray\
\
Input image.\
\
**sigma**float, optional\
\
Standard deviation used for the Gaussian kernel, which is used for smoothing the input data before Hessian eigen value calculation.\
\
**mode**{‘constant’, ‘reflect’, ‘wrap’, ‘nearest’, ‘mirror’}, optional\
\
How to handle values outside the image borders\
\
**cval**float, optional\
\
Used in conjunction with mode ‘constant’, the value outside the image boundaries.\
\
Returns:\
\
**s**ndarray\
\
Shape index\
\
References\
\
\[[1](#id111)\
\]\
\
Koenderink, J. J. & van Doorn, A. J., “Surface shape and curvature scales”, Image and Vision Computing, 1992, 10, 557-564. [DOI:10.1016/0262-8856(92)90076-F](https://doi.org/10.1016/0262-8856(92)90076-F)\
\
Examples\
\
\>>> from cucim.skimage.feature import shape\_index\
\>>> square \= cp.zeros((5, 5))\
\>>> square\[2, 2\] \= 4\
\>>> s \= shape\_index(square, sigma\=0.1)\
\>>> s\
array(\[\[ nan, nan, -0.5, nan, nan\],\
\[ nan, -0. , nan, -0. , nan\],\
\[-0.5, nan, -1. , nan, -0.5\],\
\[ nan, -0. , nan, -0. , nan\],\
\[ nan, nan, -0.5, nan, nan\]\])\
\
cucim.skimage.feature.structure\_tensor(_image_, _sigma\=1_, _mode\='constant'_, _cval\=0_, _order\='rc'_)[#](#cucim.skimage.feature.structure_tensor "Permalink to this definition")\
\
Compute structure tensor using sum of squared differences.\
\
The (2-dimensional) structure tensor A is defined as:\
\
A \= \[Arr Arc\]\
\[Arc Acc\]\
\
which is approximated by the weighted sum of squared differences in a local window around each pixel in the image. This formula can be extended to a larger number of dimensions (see [\[1\]](#rdb0ba267bece-1)\
).\
\
Parameters:\
\
**image**ndarray\
\
Input image.\
\
**sigma**float or array-like of float, optional\
\
Standard deviation used for the Gaussian kernel, which is used as a weighting function for the local summation of squared differences. If sigma is an iterable, its length must be equal to image.ndim and each element is used for the Gaussian kernel applied along its respective axis.\
\
**mode**{‘constant’, ‘reflect’, ‘wrap’, ‘nearest’, ‘mirror’}, optional\
\
How to handle values outside the image borders.\
\
**cval**float, optional\
\
Used in conjunction with mode ‘constant’, the value outside the image boundaries.\
\
**order**{‘rc’, ‘xy’}, optional\
\
NOTE: ‘xy’ is only an option for 2D images, higher dimensions must always use ‘rc’ order. This parameter allows for the use of reverse or forward order of the image axes in gradient computation. ‘rc’ indicates the use of the first axis initially (Arr, Arc, Acc), whilst ‘xy’ indicates the usage of the last axis initially (Axx, Axy, Ayy).\
\
Returns:\
\
**A\_elems**list of ndarray\
\
Upper-diagonal elements of the structure tensor for each pixel in the input image.\
\
See also\
\
[`structure_tensor_eigenvalues`](#cucim.skimage.feature.structure_tensor_eigenvalues "cucim.skimage.feature.structure_tensor_eigenvalues")\
\
References\
\
\[[1](#id113)\
\]\
\
[https://en.wikipedia.org/wiki/Structure\_tensor](https://en.wikipedia.org/wiki/Structure_tensor)\
\
Examples\
\
\>>> import cupy as cp\
\>>> from cucim.skimage.feature import structure\_tensor\
\>>> square \= cp.zeros((5, 5))\
\>>> square\[2, 2\] \= 1\
\>>> Arr, Arc, Acc \= structure\_tensor(square, sigma\=0.1, order\="rc")\
\>>> Acc\
array(\[\[0., 0., 0., 0., 0.\],\
\[0., 1., 0., 1., 0.\],\
\[0., 4., 0., 4., 0.\],\
\[0., 1., 0., 1., 0.\],\
\[0., 0., 0., 0., 0.\]\])\
\
cucim.skimage.feature.structure\_tensor\_eigenvalues(_A\_elems_)[#](#cucim.skimage.feature.structure_tensor_eigenvalues "Permalink to this definition")\
\
Compute eigenvalues of structure tensor.\
\
Parameters:\
\
**A\_elems**list of ndarray\
\
The upper-diagonal elements of the structure tensor, as returned by structure\_tensor.\
\
Returns:\
\
ndarray\
\
The eigenvalues of the structure tensor, in decreasing order. The eigenvalues are the leading dimension. That is, the coordinate \[i, j, k\] corresponds to the ith-largest eigenvalue at position (j, k).\
\
See also\
\
[`structure_tensor`](#cucim.skimage.feature.structure_tensor "cucim.skimage.feature.structure_tensor")\
\
Examples\
\
\>>> import cupy as cp\
\>>> from cucim.skimage.feature import structure\_tensor\
\>>> from cucim.skimage.feature import structure\_tensor\_eigenvalues\
\>>> square \= cp.zeros((5, 5))\
\>>> square\[2, 2\] \= 1\
\>>> A\_elems \= structure\_tensor(square, sigma\=0.1, order\='rc')\
\>>> structure\_tensor\_eigenvalues(A\_elems)\[0\]\
array(\[\[0., 0., 0., 0., 0.\],\
\[0., 2., 4., 2., 0.\],\
\[0., 4., 0., 4., 0.\],\
\[0., 2., 4., 2., 0.\],\
\[0., 0., 0., 0., 0.\]\])\
\
### filters[#](#module-cucim.skimage.filters "Permalink to this heading")\
\
Sharpening, edge finding, thresholding, etc.\
\
_class_ cucim.skimage.filters.LPIFilter2D(_impulse\_response_, _\*\*filter\_params_)[#](#cucim.skimage.filters.LPIFilter2D "Permalink to this definition")\
\
Linear Position-Invariant Filter (2-dimensional)\
\
Methods\
\
| | |\
| --- | --- |\
| `__call__`(data) | Apply the filter to the given data. |\
\
cucim.skimage.filters.apply\_hysteresis\_threshold(_image_, _low_, _high_)[#](#cucim.skimage.filters.apply_hysteresis_threshold "Permalink to this definition")\
\
Apply hysteresis thresholding to `image`.\
\
This algorithm finds regions where `image` is greater than `high` OR `image` is greater than `low` _and_ that region is connected to a region greater than `high`.\
\
Parameters:\
\
**image**array, shape (M,\[ N, …, P\])\
\
Grayscale input image.\
\
**low**float, or array of same shape as `image`\
\
Lower threshold.\
\
**high**float, or array of same shape as `image`\
\
Higher threshold.\
\
Returns:\
\
**thresholded**array of bool, same shape as `image`\
\
Array in which `True` indicates the locations where `image` was above the hysteresis threshold.\
\
References\
\
\[1\]\
\
J. Canny. A computational approach to edge detection. IEEE Transactions on Pattern Analysis and Machine Intelligence. 1986; vol. 8, pp.679-698. [DOI:10.1109/TPAMI.1986.4767851](https://doi.org/10.1109/TPAMI.1986.4767851)\
\
Examples\
\
\>>> import cupy as cp\
\>>> from cucim.skimage.filters import apply\_hysteresis\_threshold\
\>>> image \= cp.asarray(\[1, 2, 3, 2, 1, 2, 1, 3, 2\])\
\>>> apply\_hysteresis\_threshold(image, 1.5, 2.5).astype(int)\
array(\[0, 1, 1, 1, 0, 0, 0, 1, 1\])\
\
cucim.skimage.filters.butterworth(_image_, _cutoff\_frequency\_ratio\=0.005_, _high\_pass\=True_, _order\=2.0_, _channel\_axis\=None_, _\*_, _squared\_butterworth\=True_, _npad\=0_)[#](#cucim.skimage.filters.butterworth "Permalink to this definition")\
\
Apply a Butterworth filter to enhance high or low frequency features.\
\
This filter is defined in the Fourier domain.\
\
Parameters:\
\
**image**(M\[, N\[, …, P\]\]\[, C\]) ndarray\
\
Input image.\
\
**cutoff\_frequency\_ratio**float, optional\
\
Determines the position of the cut-off relative to the shape of the FFT. Receives a value between \[0, 0.5\].\
\
**high\_pass**bool, optional\
\
Whether to perform a high pass filter. If False, a low pass filter is performed.\
\
**order**float, optional\
\
Order of the filter which affects the slope near the cut-off. Higher order means steeper slope in frequency space.\
\
**channel\_axis**int, optional\
\
If there is a channel dimension, provide the index here. If None (default) then all axes are assumed to be spatial dimensions.\
\
**squared\_butterworth**bool, optional\
\
When True, the square of a Butterworth filter is used. See notes below for more details.\
\
**npad**int, optional\
\
Pad each edge of the image by npad pixels using numpy.pad’s `mode='edge'` extension.\
\
Returns:\
\
**result**ndarray\
\
The Butterworth-filtered image.\
\
Notes\
\
A band-pass filter can be achieved by combining a high-pass and low-pass filter. The user can increase npad if boundary artifacts are apparent.\
\
The “Butterworth filter” used in image processing textbooks (e.g. [\[1\]](#r049499a62648-1)\
, [\[2\]](#r049499a62648-2)\
) is often the square of the traditional Butterworth filters as described by [\[3\]](#r049499a62648-3)\
, [\[4\]](#r049499a62648-4)\
. The squared version will be used here if squared\_butterworth is set to `True`. The lowpass, squared Butterworth filter is given by the following expression for the lowpass case:\
\
\\\[H\_{low}(f) = \\frac{1}{1 + \\left(\\frac{f}{c f\_s}\\right)^{2n}}\\\]\
\
with the highpass case given by\
\
\\\[H\_{hi}(f) = 1 - H\_{low}(f)\\\]\
\
where \\(f=\\sqrt{\\sum\_{d=0}^{\\mathrm{ndim}} f\_{d}^{2}}\\) is the absolute value of the spatial frequency, \\(f\_s\\) is the sampling frequency, \\(c\\) the `cutoff_frequency_ratio`, and \\(n\\) is the filter order [\[1\]](#r049499a62648-1)\
. When `squared_butterworth=False`, the square root of the above expressions are used instead.\
\
Note that `cutoff_frequency_ratio` is defined in terms of the sampling frequency, \\(f\_s\\). The FFT spectrum covers the Nyquist range (\\(\[-f\_s/2, f\_s/2\]\\)) so `cutoff_frequency_ratio` should have a value between 0 and 0.5. The frequency response (gain) at the cutoff is 0.5 when `squared_butterworth` is true and \\(1/\\sqrt{2}\\) when it is false.\
\
References\
\
\[1\] ([1](#id116)\
,[2](#id120)\
)\
\
Russ, John C., et al. The Image Processing Handbook, 3rd. Ed. 1999, CRC Press, LLC.\
\
\[[2](#id117)\
\]\
\
Birchfield, Stan. Image Processing and Analysis. 2018. Cengage Learning.\
\
\[[3](#id118)\
\]\
\
Butterworth, Stephen. “On the theory of filter amplifiers.” Wireless Engineer 7.6 (1930): 536-541.\
\
\[[4](#id119)\
\]\
\
[https://en.wikipedia.org/wiki/Butterworth\_filter](https://en.wikipedia.org/wiki/Butterworth_filter)\
\
Examples\
\
Apply a high pass and low-pass Butterworth filter to a grayscale and color image respectively:\
\
\>>> import cupy as cp\
\>>> from skimage.data import camera, astronaut\
\>>> from cucim.skimage.filters import butterworth\
\>>> cam \= cp.asarray(camera())\
\>>> astro \= cp.asarray(astronaut())\
\>>> high\_pass \= butterworth(cam, 0.07, True, 8)\
\>>> low\_pass \= butterworth(astro, 0.01, False, 4, channel\_axis\=-1)\
\
cucim.skimage.filters.correlate\_sparse(_image_, _kernel_, _mode\='reflect'_)[#](#cucim.skimage.filters.correlate_sparse "Permalink to this definition")\
\
Compute valid cross-correlation of padded\_array and kernel.\
\
This function is _fast_ when kernel is large with many zeros.\
\
See `scipy.ndimage.correlate` for a description of cross-correlation.\
\
Parameters:\
\
**image**ndarray, dtype float, shape (M, N\[, …\], P)\
\
The input array. If mode is ‘valid’, this array should already be padded, as a margin of the same shape as kernel will be stripped off.\
\
**kernel**ndarray, dtype float shape (Q, R\[, …\], S)\
\
The kernel to be correlated. Must have the same number of dimensions as padded\_array. For high performance, it should be sparse (few nonzero entries).\
\
**mode**string, optional\
\
See scipy.ndimage.correlate for valid modes. Additionally, mode ‘valid’ is accepted, in which case no padding is applied and the result is the result for the smaller image for which the kernel is entirely inside the original data.\
\
Returns:\
\
**result**array of float, shape (M, N\[, …\], P)\
\
The result of cross-correlating image with kernel. If mode ‘valid’ is used, the resulting shape is (M-Q+1, N-R+1\[, …\], P-S+1).\
\
cucim.skimage.filters.difference\_of\_gaussians(_image_, _low\_sigma_, _high\_sigma\=None_, _\*_, _mode\='nearest'_, _cval\=0_, _channel\_axis\=None_, _truncate\=4.0_)[#](#cucim.skimage.filters.difference_of_gaussians "Permalink to this definition")\
\
Find features between `low_sigma` and `high_sigma` in size.\
\
This function uses the Difference of Gaussians method for applying band-pass filters to multi-dimensional arrays. The input array is blurred with two Gaussian kernels of differing sigmas to produce two intermediate, filtered images. The more-blurred image is then subtracted from the less-blurred image. The final output image will therefore have had high-frequency components attenuated by the smaller-sigma Gaussian, and low frequency components will have been removed due to their presence in the more-blurred intermediate.\
\
Parameters:\
\
**image**ndarray\
\
Input array to filter.\
\
**low\_sigma**scalar or sequence of scalars\
\
Standard deviation(s) for the Gaussian kernel with the smaller sigmas across all axes. The standard deviations are given for each axis as a sequence, or as a single number, in which case the single number is used as the standard deviation value for all axes.\
\
**high\_sigma**scalar or sequence of scalars, optional (default is None)\
\
Standard deviation(s) for the Gaussian kernel with the larger sigmas across all axes. The standard deviations are given for each axis as a sequence, or as a single number, in which case the single number is used as the standard deviation value for all axes. If None is given (default), sigmas for all axes are calculated as 1.6 \* low\_sigma.\
\
**mode**{‘reflect’, ‘constant’, ‘nearest’, ‘mirror’, ‘wrap’}, optional\
\
The `mode` parameter determines how the array borders are handled, where `cval` is the value when mode is equal to ‘constant’. Default is ‘nearest’.\
\
**cval**scalar, optional\
\
Value to fill past edges of input if `mode` is ‘constant’. Default is 0.0\
\
**channel\_axis**int or None, optional\
\
If None, the image is assumed to be a grayscale (single channel) image. Otherwise, this parameter indicates which axis of the array corresponds to channels.\
\
**truncate**float, optional (default is 4.0)\
\
Truncate the filter at this many standard deviations.\
\
Returns:\
\
**filtered\_image**ndarray\
\
the filtered array.\
\
See also\
\
`skimage.feature.blog_dog`\
\
Notes\
\
This function will subtract an array filtered with a Gaussian kernel with sigmas given by `high_sigma` from an array filtered with a Gaussian kernel with sigmas provided by `low_sigma`. The values for `high_sigma` must always be greater than or equal to the corresponding values in `low_sigma`, or a `ValueError` will be raised.\
\
When `high_sigma` is none, the values for `high_sigma` will be calculated as 1.6x the corresponding values in `low_sigma`. This ratio was originally proposed by Marr and Hildreth (1980) [\[1\]](#r74659d1d36f1-1)\
and is commonly used when approximating the inverted Laplacian of Gaussian, which is used in edge and blob detection.\
\
Input image is converted according to the conventions of `img_as_float`.\
\
Except for sigma values, all parameters are used for both filters.\
\
References\
\
\[[1](#id125)\
\]\
\
Marr, D. and Hildreth, E. Theory of Edge Detection. Proc. R. Soc. Lond. Series B 207, 187-217 (1980). [https://doi.org/10.1098/rspb.1980.0020](https://doi.org/10.1098/rspb.1980.0020)\
\
Examples\
\
Apply a simple Difference of Gaussians filter to a color image:\
\
\>>> from skimage.data import astronaut\
\>>> from cucim.skimage.filters import difference\_of\_gaussians\
\>>> astro \= cp.asarray(astronaut())\
\>>> filtered\_image \= difference\_of\_gaussians(astro, 2, 10,\
... channel\_axis\=-1)\
\
Apply a Laplacian of Gaussian filter as approximated by the Difference of Gaussians filter:\
\
\>>> filtered\_image \= difference\_of\_gaussians(astro, 2,\
... channel\_axis\=-1)\
\
Apply a Difference of Gaussians filter to a grayscale image using different sigma values for each axis:\
\
\>>> from skimage.data import camera\
\>>> cam \= cp.array(camera())\
\>>> filtered\_image \= difference\_of\_gaussians(cam, (2,5), (3,20))\
\
cucim.skimage.filters.farid(_image_, _mask\=None_, _\*_, _axis\=None_, _mode\='reflect'_, _cval\=0.0_)[#](#cucim.skimage.filters.farid "Permalink to this definition")\
\
Find the edge magnitude using the Farid transform.\
\
Parameters:\
\
**image**cp.ndarray\
\
The input image.\
\
**mask**cp.ndarray of bool, optional\
\
Clip the output image to this mask. (Values where mask=0 will be set to 0.)\
\
**axis**int or sequence of int, optional\
\
Compute the edge filter along this axis. If not provided, the edge magnitude is computed. This is defined as:\
\
farid\_mag \= cp.sqrt(sum(\[farid(image, axis\=i)\*\*2\
for i in range(image.ndim)\]) / image.ndim)\
\
The magnitude is also computed if axis is a sequence.\
\
**mode**str or sequence of str, optional\
\
The boundary mode for the convolution. See scipy.ndimage.convolve for a description of the modes. This can be either a single boundary mode or one boundary mode per axis.\
\
**cval**float, optional\
\
When mode is `'constant'`, this is the constant used in values outside the boundary of the image data.\
\
**Returns**\
\
**——-**\
\
**output**2-D array\
\
The Farid edge map.\
\
See also\
\
[`farid_h`](#cucim.skimage.filters.farid_h "cucim.skimage.filters.farid_h")\
, [`farid_v`](#cucim.skimage.filters.farid_v "cucim.skimage.filters.farid_v")\
\
horizontal and vertical edge detection.\
\
[`scharr`](#cucim.skimage.filters.scharr "cucim.skimage.filters.scharr")\
, [`sobel`](#cucim.skimage.filters.sobel "cucim.skimage.filters.sobel")\
, [`prewitt`](#cucim.skimage.filters.prewitt "cucim.skimage.filters.prewitt")\
, [`skimage.feature.canny`](https://scikit-image.org/docs/stable/api/skimage.feature.html#skimage.feature.canny "(in skimage v0.25.2)")\
\
Notes\
\
Take the square root of the sum of the squares of the horizontal and vertical derivatives to get a magnitude that is somewhat insensitive to direction. Similar to the Scharr operator, this operator is designed with a rotation invariance constraint.\
\
References\
\
\[1\]\
\
Farid, H. and Simoncelli, E. P., “Differentiation of discrete multidimensional signals”, IEEE Transactions on Image Processing 13(4): 496-508, 2004. [DOI:10.1109/TIP.2004.823819](https://doi.org/10.1109/TIP.2004.823819)\
\
\[2\]\
\
Wikipedia, “Farid and Simoncelli Derivatives.” Available at: <[https://en.wikipedia.org/wiki/Image\_derivatives#Farid\_and\_Simoncelli\_Derivatives](https://en.wikipedia.org/wiki/Image_derivatives#Farid_and_Simoncelli_Derivatives)\
\>\
\
Examples\
\
\>>> import cupy as cp\
\>>> from skimage import data\
\>>> camera \= cp.array(data.camera())\
\>>> from cucim.skimage import filters\
\>>> edges \= filters.farid(camera)\
\
cucim.skimage.filters.farid\_h(_image_, _\*_, _mask\=None_)[#](#cucim.skimage.filters.farid_h "Permalink to this definition")\
\
Find the horizontal edges of an image using the Farid transform.\
\
Parameters:\
\
**image**2-D array\
\
Image to process.\
\
**mask**2-D array, optional\
\
An optional mask to limit the application to a certain area. Note that pixels surrounding masked regions are also masked to prevent masked regions from affecting the result.\
\
Returns:\
\
**output**2-D array\
\
The Farid edge map.\
\
Notes\
\
The kernel was constructed using the 5-tap weights from \[1\].\
\
References\
\
\[1\]\
\
Farid, H. and Simoncelli, E. P., “Differentiation of discrete multidimensional signals”, IEEE Transactions on Image Processing 13(4): 496-508, 2004. [DOI:10.1109/TIP.2004.823819](https://doi.org/10.1109/TIP.2004.823819)\
\
\[2\]\
\
Farid, H. and Simoncelli, E. P. “Optimally rotation-equivariant directional derivative kernels”, In: 7th International Conference on Computer Analysis of Images and Patterns, Kiel, Germany. Sep, 1997.\
\
cucim.skimage.filters.farid\_v(_image_, _\*_, _mask\=None_)[#](#cucim.skimage.filters.farid_v "Permalink to this definition")\
\
Find the vertical edges of an image using the Farid transform.\
\
Parameters:\
\
**image**2-D array\
\
Image to process.\
\
**mask**2-D array, optional\
\
An optional mask to limit the application to a certain area. Note that pixels surrounding masked regions are also masked to prevent masked regions from affecting the result.\
\
Returns:\
\
**output**2-D array\
\
The Farid edge map.\
\
Notes\
\
The kernel was constructed using the 5-tap weights from \[1\].\
\
References\
\
\[1\]\
\
Farid, H. and Simoncelli, E. P., “Differentiation of discrete multidimensional signals”, IEEE Transactions on Image Processing 13(4): 496-508, 2004. [DOI:10.1109/TIP.2004.823819](https://doi.org/10.1109/TIP.2004.823819)\
\
cucim.skimage.filters.filter\_forward(_data_, _impulse\_response\=None_, _filter\_params\=None_, _predefined\_filter\=None_)[#](#cucim.skimage.filters.filter_forward "Permalink to this definition")\
\
Apply the given filter to data.\
\
Parameters:\
\
**data**(M, N) ndarray\
\
Input data.\
\
**impulse\_response**callable f(r, c, \*\*filter\_params)\
\
Impulse response of the filter. See LPIFilter2D.\_\_init\_\_.\
\
**filter\_params**dict, optional\
\
Additional keyword parameters to the impulse\_response function.\
\
Other Parameters:\
\
**predefined\_filter**LPIFilter2D\
\
If you need to apply the same filter multiple times over different images, construct the LPIFilter2D and specify it here.\
\
Examples\
\
Gaussian filter without normalization:\
\
\>>> def filt\_func(r, c, sigma\=1):\
... return cp.exp(\-(r\*\*2 + c\*\*2)/(2 \* sigma\*\*2))\
\>>>\
\>>> from skimage import data\
\>>> filtered \= filter\_forward(cp.array(data.coins()), filt\_func)\
\
cucim.skimage.filters.filter\_inverse(_data_, _impulse\_response\=None_, _filter\_params\=None_, _max\_gain\=2_, _predefined\_filter\=None_)[#](#cucim.skimage.filters.filter_inverse "Permalink to this definition")\
\
Apply the filter in reverse to the given data.\
\
Parameters:\
\
**data**(M, N) ndarray\
\
Input data.\
\
**impulse\_response**callable f(r, c, \*\*filter\_params)\
\
Impulse response of the filter. See [`LPIFilter2D`](#cucim.skimage.filters.LPIFilter2D "cucim.skimage.filters.LPIFilter2D")\
. This is a required argument unless a predifined\_filter is provided.\
\
**filter\_params**dict, optional\
\
Additional keyword parameters to the impulse\_response function.\
\
**max\_gain**float, optional\
\
Limit the filter gain. Often, the filter contains zeros, which would cause the inverse filter to have infinite gain. High gain causes amplification of artefacts, so a conservative limit is recommended.\
\
Other Parameters:\
\
**predefined\_filter**LPIFilter2D, optional\
\
If you need to apply the same filter multiple times over different images, construct the LPIFilter2D and specify it here.\
\
cucim.skimage.filters.frangi(_image_, _sigmas\=range(1, 10, 2)_, _scale\_range\=None_, _scale\_step\=None_, _alpha\=0.5_, _beta\=0.5_, _gamma\=None_, _black\_ridges\=True_, _mode\='reflect'_, _cval\=0_)[#](#cucim.skimage.filters.frangi "Permalink to this definition")\
\
Filter an image with the Frangi vesselness filter.\
\
This filter can be used to detect continuous ridges, e.g. vessels, wrinkles, rivers. It can be used to calculate the fraction of the whole image containing such objects.\
\
Defined only for 2-D and 3-D images. Calculates the eigenvalues of the Hessian to compute the similarity of an image region to vessels, according to the method described in [\[1\]](#ree817c6d0d46-1)\
.\
\
Parameters:\
\
**image**(M, N\[, P\]) ndarray\
\
Array with input image data.\
\
**sigmas**iterable of floats, optional\
\
Sigmas used as scales of filter, i.e., np.arange(scale\_range\[0\], scale\_range\[1\], scale\_step)\
\
**scale\_range**2-tuple of floats, optional\
\
The range of sigmas used.\
\
**scale\_step**float, optional\
\
Step size between sigmas.\
\
**alpha**float, optional\
\
Frangi correction constant that adjusts the filter’s sensitivity to deviation from a plate-like structure.\
\
**beta**float, optional\
\
Frangi correction constant that adjusts the filter’s sensitivity to deviation from a blob-like structure.\
\
**gamma**float, optional\
\
Frangi correction constant that adjusts the filter’s sensitivity to areas of high variance/texture/structure. The default, None, uses half of the maximum Hessian norm.\
\
**black\_ridges**boolean, optional\
\
When True (the default), the filter detects black ridges; when False, it detects white ridges.\
\
**mode**{‘constant’, ‘reflect’, ‘wrap’, ‘nearest’, ‘mirror’}, optional\
\
How to handle values outside the image borders.\
\
**cval**float, optional\
\
Used in conjunction with mode ‘constant’, the value outside the image boundaries.\
\
Returns:\
\
**out**(M, N\[, P\]) ndarray\
\
Filtered image (maximum of pixels across all scales).\
\
See also\
\
[`meijering`](#cucim.skimage.filters.meijering "cucim.skimage.filters.meijering")\
\
[`sato`](#cucim.skimage.filters.sato "cucim.skimage.filters.sato")\
\
[`hessian`](#cucim.skimage.filters.hessian "cucim.skimage.filters.hessian")\
\
Notes\
\
Earlier versions of this filter were implemented by Marc Schrijver, (November 2001), D. J. Kroon, University of Twente (May 2009) [\[2\]](#ree817c6d0d46-2)\
, and D. G. Ellis (January 2017) [\[3\]](#ree817c6d0d46-3)\
.\
\
References\
\
\[[1](#id132)\
\]\
\
Frangi, A. F., Niessen, W. J., Vincken, K. L., & Viergever, M. A. (1998,). Multiscale vessel enhancement filtering. In International Conference on Medical Image Computing and Computer-Assisted Intervention (pp. 130-137). Springer Berlin Heidelberg. [DOI:10.1007/BFb0056195](https://doi.org/10.1007/BFb0056195)\
\
\[[2](#id133)\
\]\
\
Kroon, D. J.: Hessian based Frangi vesselness filter.\
\
\[[3](#id134)\
\]\
\
Ellis, D. G.: [ellisdg/frangi3d](https://github.com/ellisdg/frangi3d/tree/master/frangi)\
\
cucim.skimage.filters.gabor(_image_, _frequency_, _theta\=0_, _bandwidth\=1_, _sigma\_x\=None_, _sigma\_y\=None_, _n\_stds\=3_, _offset\=0_, _mode\='reflect'_, _cval\=0_)[#](#cucim.skimage.filters.gabor "Permalink to this definition")\
\
Return real and imaginary responses to Gabor filter.\
\
The real and imaginary parts of the Gabor filter kernel are applied to the image and the response is returned as a pair of arrays.\
\
Gabor filter is a linear filter with a Gaussian kernel which is modulated by a sinusoidal plane wave. Frequency and orientation representations of the Gabor filter are similar to those of the human visual system. Gabor filter banks are commonly used in computer vision and image processing. They are especially suitable for edge detection and texture classification.\
\
Parameters:\
\
**image**2-D array\
\
Input image.\
\
**frequency**float\
\
Spatial frequency of the harmonic function. Specified in pixels.\
\
**theta**float, optional\
\
Orientation in radians. If 0, the harmonic is in the x-direction.\
\
**bandwidth**float, optional\
\
The bandwidth captured by the filter. For fixed bandwidth, `sigma_x` and `sigma_y` will decrease with increasing frequency. This value is ignored if `sigma_x` and `sigma_y` are set by the user.\
\
**sigma\_x, sigma\_y**float, optional\
\
Standard deviation in x- and y-directions. These directions apply to the kernel _before_ rotation. If theta = pi/2, then the kernel is rotated 90 degrees so that `sigma_x` controls the _vertical_ direction.\
\
**n\_stds**scalar, optional\
\
The linear size of the kernel is n\_stds (3 by default) standard deviations.\
\
**offset**float, optional\
\
Phase offset of harmonic function in radians.\
\
**mode**{‘constant’, ‘nearest’, ‘reflect’, ‘mirror’, ‘wrap’}, optional\
\
Mode used to convolve image with a kernel, passed to ndi.convolve\
\
**cval**scalar, optional\
\
Value to fill past edges of input if `mode` of convolution is ‘constant’. The parameter is passed to ndi.convolve.\
\
Returns:\
\
**real, imag**arrays\
\
Filtered images using the real and imaginary parts of the Gabor filter kernel. Images are of the same dimensions as the input one.\
\
References\
\
\[1\]\
\
[https://en.wikipedia.org/wiki/Gabor\_filter](https://en.wikipedia.org/wiki/Gabor_filter)\
\
\[2\]\
\
[https://web.archive.org/web/20180127125930/http://mplab.ucsd.edu/tutorials/gabor.pdf](https://web.archive.org/web/20180127125930/http://mplab.ucsd.edu/tutorials/gabor.pdf)\
\
Examples\
\
\>>> import cupy as cp\
\>>> from cucim.skimage.filters import gabor\
\>>> from skimage import data\
\>>> from matplotlib import pyplot as plt \
\
\>>> image \= cp.array(data.coins())\
\>>> \# detecting edges in a coin image\
\>>> filt\_real, filt\_imag \= gabor(image, frequency\=0.6)\
\>>> fig, ax \= plt.subplots() \
\>>> ax.imshow(cp.asnumpy(filt\_real)) \
\>>> plt.show() \
\
\>>> \# less sensitivity to finer details with the lower frequency kernel\
\>>> filt\_real, filt\_imag \= gabor(image, frequency\=0.1)\
\>>> fig, ax \= plt.subplots() \
\>>> ax.imshow(cp.asnumpy(filt\_real)) \
\>>> plt.show() \
\
cucim.skimage.filters.gabor\_kernel(_frequency_, _theta\=0_, _bandwidth\=1_, _sigma\_x\=None_, _sigma\_y\=None_, _n\_stds\=3_, _offset\=0_, _dtype\=None_, _\*_, _float\_dtype\=None_)[#](#cucim.skimage.filters.gabor_kernel "Permalink to this definition")\
\
Return complex 2D Gabor filter kernel.\
\
Gabor kernel is a Gaussian kernel modulated by a complex harmonic function. Harmonic function consists of an imaginary sine function and a real cosine function. Spatial frequency is inversely proportional to the wavelength of the harmonic and to the standard deviation of a Gaussian kernel. The bandwidth is also inversely proportional to the standard deviation.\
\
Parameters:\
\
**frequency**float\
\
Spatial frequency of the harmonic function. Specified in pixels.\
\
**theta**float, optional\
\
Orientation in radians. If 0, the harmonic is in the x-direction.\
\
**bandwidth**float, optional\
\
The bandwidth captured by the filter. For fixed bandwidth, `sigma_x` and `sigma_y` will decrease with increasing frequency. This value is ignored if `sigma_x` and `sigma_y` are set by the user.\
\
**sigma\_x, sigma\_y**float, optional\
\
Standard deviation in x- and y-directions. These directions apply to the kernel _before_ rotation. If theta = pi/2, then the kernel is rotated 90 degrees so that `sigma_x` controls the _vertical_ direction.\
\
**n\_stds**scalar, optional\
\
The linear size of the kernel is n\_stds (3 by default) standard deviations\
\
**offset**float, optional\
\
Phase offset of harmonic function in radians.\
\
**dtype**{np.complex64, np.complex128}\
\
Specifies if the filter is single or double precision complex.\
\
Returns:\
\
**g**complex array\
\
Complex filter kernel.\
\
References\
\
\[1\]\
\
[https://en.wikipedia.org/wiki/Gabor\_filter](https://en.wikipedia.org/wiki/Gabor_filter)\
\
\[2\]\
\
[https://web.archive.org/web/20180127125930/http://mplab.ucsd.edu/tutorials/gabor.pdf](https://web.archive.org/web/20180127125930/http://mplab.ucsd.edu/tutorials/gabor.pdf)\
\
Examples\
\
\>>> import cupy as cp\
\>>> from cucim.skimage.filters import gabor\_kernel\
\>>> from matplotlib import pyplot as plt \
\
\>>> gk \= gabor\_kernel(frequency\=0.2)\
\>>> fig, ax \= plt.subplots() \
\>>> ax.imshow(cp.asnumpy(gk.real)) \
\>>> plt.show() \
\
\>>> \# more ripples (equivalent to increasing the size of the\
\>>> \# Gaussian spread)\
\>>> gk \= gabor\_kernel(frequency\=0.2, bandwidth\=0.1)\
\>>> fig, ax \= plt.subplots() \
\>>> ax.imshow(cp.asnumpy(gk.real)) \
\>>> plt.show() \
\
cucim.skimage.filters.gaussian(_image_, _sigma\=1_, _mode\='nearest'_, _cval\=0_, _preserve\_range\=False_, _truncate\=4.0_, _\*_, _channel\_axis\=None_, _out\=None_)[#](#cucim.skimage.filters.gaussian "Permalink to this definition")\
\
Multi-dimensional Gaussian filter.\
\
Parameters:\
\
**image**ndarray\
\
Input image (grayscale or color) to filter.\
\
**sigma**scalar or sequence of scalars, optional\
\
Standard deviation for Gaussian kernel. The standard deviations of the Gaussian filter are given for each axis as a sequence, or as a single number, in which case it is equal for all axes.\
\
**mode**{‘reflect’, ‘constant’, ‘nearest’, ‘mirror’, ‘wrap’}, optional\
\
The `mode` parameter determines how the array borders are handled, where `cval` is the value when mode is equal to ‘constant’. Default is ‘nearest’.\
\
**cval**scalar, optional\
\
Value to fill past edges of input if `mode` is ‘constant’. Default is 0.0\
\
**preserve\_range**bool, optional\
\
Whether to keep the original range of values. Otherwise, the input image is converted according to the conventions of `img_as_float`. Also see [https://scikit-image.org/docs/dev/user\_guide/data\_types.html](https://scikit-image.org/docs/dev/user_guide/data_types.html)\
\
**truncate**float, optional\
\
Truncate the filter at this many standard deviations.\
\
**channel\_axis**int or None, optional\
\
If None, the image is assumed to be a grayscale (single channel) image. Otherwise, this parameter indicates which axis of the array corresponds to channels.\
\
New in version 24.02: channel\_axis was added in 24.02\`\
\
**out**ndarray, optional\
\
If given, the filtered image will be stored in this array. It must have a floating point data type.\
\
New in version 24.06: out was added in 24.06\`\
\
Returns:\
\
**filtered\_image**ndarray\
\
the filtered array\
\
Notes\
\
This function is a wrapper around `scipy.ndi.gaussian_filter()`.\
\
Integer arrays are converted to float.\
\
`out` should be of floating point data type since gaussian converts the input image to float. If out is not provided, another array will be allocated and returned as the result.\
\
The multi-dimensional filter is implemented as a sequence of one-dimensional convolution filters. The intermediate arrays are stored in the same data type as the output. Therefore, for output types with a limited precision, the results may be imprecise because intermediate results may be stored with insufficient precision.\
\
Examples\
\
\>>> import cupy as cp\
\>>> from cucim import skimage as ski\
\>>> a \= cp.zeros((3, 3))\
\>>> a\[1, 1\] \= 1\
\>>> a\
array(\[\[0., 0., 0.\],\
\[0., 1., 0.\],\
\[0., 0., 0.\]\])\
\>>> ski.filters.gaussian(a, sigma\=0.4) \# mild smoothing\
array(\[\[0.00163116, 0.03712502, 0.00163116\],\
\[0.03712502, 0.84496158, 0.03712502\],\
\[0.00163116, 0.03712502, 0.00163116\]\])\
\>>> ski.filters.gaussian(a, sigma\=1) \# more smoothing\
array(\[\[0.05855018, 0.09653293, 0.05855018\],\
\[0.09653293, 0.15915589, 0.09653293\],\
\[0.05855018, 0.09653293, 0.05855018\]\])\
\>>> \# Several modes are possible for handling boundaries\
\>>> ski.filters.gaussian(a, sigma\=1, mode\='reflect')\
array(\[\[0.08767308, 0.12075024, 0.08767308\],\
\[0.12075024, 0.16630671, 0.12075024\],\
\[0.08767308, 0.12075024, 0.08767308\]\])\
\>>> \# For RGB images, each is filtered separately\
\>>> from skimage.data import astronaut\
\>>> image \= cp.array(astronaut())\
\>>> filtered\_img \= ski.filters.gaussian(image, sigma\=1, channel\_axis\=-1)\
\
cucim.skimage.filters.hessian(_image_, _sigmas\=range(1, 10, 2)_, _scale\_range\=None_, _scale\_step\=None_, _alpha\=0.5_, _beta\=0.5_, _gamma\=15_, _black\_ridges\=True_, _mode\='reflect'_, _cval\=0_)[#](#cucim.skimage.filters.hessian "Permalink to this definition")\
\
Filter an image with the Hybrid Hessian filter.\
\
This filter can be used to detect continuous edges, e.g. vessels, wrinkles, rivers. It can be used to calculate the fraction of the whole image containing such objects.\
\
Defined only for 2-D and 3-D images. Almost equal to Frangi filter, but uses alternative method of smoothing. Refer to [\[1\]](#r664d4133c7b0-1)\
to find the differences between Frangi and Hessian filters.\
\
Parameters:\
\
**image**(M, N\[, P\]) ndarray\
\
Array with input image data.\
\
**sigmas**iterable of floats, optional\
\
Sigmas used as scales of filter, i.e., np.arange(scale\_range\[0\], scale\_range\[1\], scale\_step)\
\
**scale\_range**2-tuple of floats, optional\
\
The range of sigmas used.\
\
**scale\_step**float, optional\
\
Step size between sigmas.\
\
**beta**float, optional\
\
Frangi correction constant that adjusts the filter’s sensitivity to deviation from a blob-like structure.\
\
**gamma**float, optional\
\
Frangi correction constant that adjusts the filter’s sensitivity to areas of high variance/texture/structure.\
\
**black\_ridges**boolean, optional\
\
When True (the default), the filter detects black ridges; when False, it detects white ridges.\
\
**mode**{‘constant’, ‘reflect’, ‘wrap’, ‘nearest’, ‘mirror’}, optional\
\
How to handle values outside the image borders.\
\
**cval**float, optional\
\
Used in conjunction with mode ‘constant’, the value outside the image boundaries.\
\
Returns:\
\
**out**(M, N\[, P\]) ndarray\
\
Filtered image (maximum of pixels across all scales).\
\
See also\
\
[`meijering`](#cucim.skimage.filters.meijering "cucim.skimage.filters.meijering")\
\
[`sato`](#cucim.skimage.filters.sato "cucim.skimage.filters.sato")\
\
[`frangi`](#cucim.skimage.filters.frangi "cucim.skimage.filters.frangi")\
\
Notes\
\
Written by Marc Schrijver (November 2001) Re-Written by D. J. Kroon University of Twente (May 2009) [\[2\]](#r664d4133c7b0-2)\
\
References\
\
\[[1](#id142)\
\]\
\
Ng, C. C., Yap, M. H., Costen, N., & Li, B. (2014,). Automatic wrinkle detection using hybrid Hessian filter. In Asian Conference on Computer Vision (pp. 609-622). Springer International Publishing. [DOI:10.1007/978-3-319-16811-1\_40](https://doi.org/10.1007/978-3-319-16811-1_40)\
\
\[[2](#id143)\
\]\
\
Kroon, D. J.: Hessian based Frangi vesselness filter.\
\
cucim.skimage.filters.laplace(_image_, _ksize\=3_, _mask\=None_)[#](#cucim.skimage.filters.laplace "Permalink to this definition")\
\
Find the edges of an image using the Laplace operator.\
\
Parameters:\
\
**image**ndarray\
\
Image to process.\
\
**ksize**int, optional\
\
Define the size of the discrete Laplacian operator such that it will have a size of (ksize,) \* image.ndim.\
\
**mask**ndarray, optional\
\
An optional mask to limit the application to a certain area. Note that pixels surrounding masked regions are also masked to prevent masked regions from affecting the result.\
\
Returns:\
\
**output**ndarray\
\
The Laplace edge map.\
\
Notes\
\
The Laplacian operator is generated using the function skimage.restoration.uft.laplacian().\
\
cucim.skimage.filters.median(_image_, _footprint\=None_, _out\=None_, _mode\='nearest'_, _cval\=0.0_, _behavior\='ndimage'_, _\*_, _algorithm\='auto'_, _algorithm\_kwargs\={}_)[#](#cucim.skimage.filters.median "Permalink to this definition")\
\
Return local median of an image.\
\
Parameters:\
\
**image**array-like\
\
Input image.\
\
**footprint**ndarray, tuple of int, or None\
\
If `None`, `footprint` will be a N-D array with 3 elements for each dimension (e.g., vector, square, cube, etc.). If footprint is a tuple of integers, it will be an array of ones with the given shape. Otherwise, if `behavior=='rank'`, `footprint` is a 2-D array of 1’s and 0’s. If `behavior=='ndimage'`, `footprint` is a N-D array of 1’s and 0’s with the same number of dimension as `image`. Note that upstream scikit-image currently does not support supplying a tuple for footprint. It is added here to avoid overhead of generating a small weights array in cases where it is not needed.\
\
**out**ndarray, (same dtype as image), optional\
\
If None, a new array is allocated.\
\
**mode**{‘reflect’, ‘constant’, ‘nearest’, ‘mirror’,’‘wrap’}, optional\
\
The mode parameter determines how the array borders are handled, where `cval` is the value when mode is equal to ‘constant’. Default is ‘nearest’.\
\
New in version 0.15: `mode` is used when `behavior='ndimage'`.\
\
**cval**scalar, optional\
\
Value to fill past edges of input if mode is ‘constant’. Default is 0.0\
\
New in version 0.15: `cval` was added in 0.15 is used when `behavior='ndimage'`.\
\
**behavior**{‘ndimage’, ‘rank’}, optional\
\
Either to use the old behavior (i.e., < 0.15) or the new behavior. The old behavior will call the [`skimage.filters.rank.median()`](https://scikit-image.org/docs/stable/api/skimage.filters.rank.html#skimage.filters.rank.median "(in skimage v0.25.2)")\
. The new behavior will call the [`scipy.ndimage.median_filter()`](https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.median_filter.html#scipy.ndimage.median_filter "(in SciPy v1.15.2)")\
. Default is ‘ndimage’.\
\
New in version 0.15: `behavior` is introduced in 0.15\
\
Changed in version 0.16: Default `behavior` has been changed from ‘rank’ to ‘ndimage’\
\
Returns:\
\
**out**2-D array (same dtype as input image)\
\
Output image.\
\
Other Parameters:\
\
**algorithm**{‘auto’, ‘histogram’, ‘sorting’}\
\
Determines which algorithm is used to compute the median. The default of ‘auto’ will attempt to use a histogram-based algorithm for 2D images with 8 or 16-bit integer data types. Otherwise a sorting-based algorithm will be used. Note: this parameter is cuCIM-specific and does not exist in upstream scikit-image.\
\
**algorithm\_kwargs**dict\
\
Any additional algorithm-specific keywords. Currently can only be used to set the number of parallel partitions for the ‘histogram’ algorithm. (e.g. `algorithm_kwargs={'partitions': 256}`). Note: this parameter is cuCIM-specific and does not exist in upstream scikit-image.\
\
See also\
\
[`skimage.filters.rank.median`](https://scikit-image.org/docs/stable/api/skimage.filters.rank.html#skimage.filters.rank.median "(in skimage v0.25.2)")\
\
Rank-based implementation of the median filtering offering more flexibility with additional parameters but dedicated for unsigned integer images.\
\
Notes\
\
An efficient, histogram-based median filter as described in [\[1\]](#rbe7f7d88d1ca-1)\
is faster than the sorting based approach for larger kernel sizes (e.g. greater than 13x13 or so in 2D). It has near-constant run time regardless of the kernel size. The algorithm presented in [\[1\]](#rbe7f7d88d1ca-1)\
has been adapted to additional bit depths here. When algorithm=’auto’, the histogram-based algorithm will be chosen for integer-valued images with sufficiently large footprint size. Otherwise, the sorting-based approach is used.\
\
References\
\
\[1\] ([1](#id146)\
,[2](#id147)\
)\
\
O. Green, “Efficient Scalable Median Filtering Using Histogram-Based Operations,” in IEEE Transactions on Image Processing, vol. 27, no. 5, pp. 2217-2228, May 2018, [https://doi.org/10.1109/TIP.2017.2781375](https://doi.org/10.1109/TIP.2017.2781375)\
.\
\
Examples\
\
\>>> import cupy as cp\
\>>> from skimage import data\
\>>> from cucim.skimage.morphology import disk\
\>>> from cucim.skimage.filters import median\
\>>> img \= cp.array(data.camera())\
\>>> med \= median(img, disk(5))\
\
cucim.skimage.filters.meijering(_image_, _sigmas\=range(1, 10, 2)_, _alpha\=None_, _black\_ridges\=True_, _mode\='reflect'_, _cval\=0_)[#](#cucim.skimage.filters.meijering "Permalink to this definition")\
\
Filter an image with the Meijering neuriteness filter.\
\
This filter can be used to detect continuous ridges, e.g. neurites, wrinkles, rivers. It can be used to calculate the fraction of the whole image containing such objects.\
\
Calculates the eigenvalues of the Hessian to compute the similarity of an image region to neurites, according to the method described in [\[1\]](#r5ebf02c24e78-1)\
.\
\
Parameters:\
\
**image**(N, M\[, …\]) ndarray\
\
Array with input image data.\
\
**sigmas**iterable of floats, optional\
\
Sigmas used as scales of filter\
\
**alpha**float, optional\
\
Shaping filter constant, that selects maximally flat elongated features. The default, None, selects the optimal value -1/(ndim+1).\
\
**black\_ridges**boolean, optional\
\
When True (the default), the filter detects black ridges; when False, it detects white ridges.\
\
**mode**{‘constant’, ‘reflect’, ‘wrap’, ‘nearest’, ‘mirror’}, optional\
\
How to handle values outside the image borders.\
\
**cval**float, optional\
\
Used in conjunction with mode ‘constant’, the value outside the image boundaries.\
\
Returns:\
\
**out**(N, M\[, …, P\]) ndarray\
\
Filtered image (maximum of pixels across all scales).\
\
See also\
\
[`sato`](#cucim.skimage.filters.sato "cucim.skimage.filters.sato")\
\
[`frangi`](#cucim.skimage.filters.frangi "cucim.skimage.filters.frangi")\
\
[`hessian`](#cucim.skimage.filters.hessian "cucim.skimage.filters.hessian")\
\
References\
\
\[[1](#id149)\
\]\
\
Meijering, E., Jacob, M., Sarria, J. C., Steiner, P., Hirling, H., Unser, M. (2004). Design and validation of a tool for neurite tracing and analysis in fluorescence microscopy images. Cytometry Part A, 58(2), 167-176. [DOI:10.1002/cyto.a.20022](https://doi.org/10.1002/cyto.a.20022)\
\
cucim.skimage.filters.prewitt(_image_, _mask\=None_, _\*_, _axis\=None_, _mode\='reflect'_, _cval\=0.0_)[#](#cucim.skimage.filters.prewitt "Permalink to this definition")\
\
Find the edge magnitude using the Prewitt transform.\
\
Parameters:\
\
**image**array\
\
The input image.\
\
**mask**array of bool, optional\
\
Clip the output image to this mask. (Values where mask=0 will be set to 0.)\
\
**axis**int or sequence of int, optional\
\
Compute the edge filter along this axis. If not provided, the edge magnitude is computed. This is defined as:\
\
prw\_mag \= np.sqrt(sum(\[prewitt(image, axis\=i)\*\*2\
for i in range(image.ndim)\]) / image.ndim)\
\
The magnitude is also computed if axis is a sequence.\
\
**mode**str or sequence of str, optional\
\
The boundary mode for the convolution. See scipy.ndimage.convolve for a description of the modes. This can be either a single boundary mode or one boundary mode per axis.\
\
**cval**float, optional\
\
When mode is `'constant'`, this is the constant used in values outside the boundary of the image data.\
\
Returns:\
\
**output**array of float\
\
The Prewitt edge map.\
\
See also\
\
[`prewitt_h`](#cucim.skimage.filters.prewitt_h "cucim.skimage.filters.prewitt_h")\
, [`prewitt_v`](#cucim.skimage.filters.prewitt_v "cucim.skimage.filters.prewitt_v")\
\
horizontal and vertical edge detection.\
\
[`sobel`](#cucim.skimage.filters.sobel "cucim.skimage.filters.sobel")\
, [`scharr`](#cucim.skimage.filters.scharr "cucim.skimage.filters.scharr")\
, [`farid`](#cucim.skimage.filters.farid "cucim.skimage.filters.farid")\
, [`cucim.skimage.feature.canny`](#cucim.skimage.feature.canny "cucim.skimage.feature.canny")\
\
Notes\
\
The edge magnitude depends slightly on edge directions, since the approximation of the gradient operator by the Prewitt operator is not completely rotation invariant. For a better rotation invariance, the Scharr operator should be used. The Sobel operator has a better rotation invariance than the Prewitt operator, but a worse rotation invariance than the Scharr operator.\
\
Examples\
\
\>>> import cupy as cp\
\>>> from skimage import data\
\>>> from cucim.skimage import filters\
\>>> camera \= cp.array(data.camera())\
\>>> edges \= filters.prewitt(camera)\
\
cucim.skimage.filters.prewitt\_h(_image_, _mask\=None_)[#](#cucim.skimage.filters.prewitt_h "Permalink to this definition")\
\
Find the horizontal edges of an image using the Prewitt transform.\
\
Parameters:\
\
**image**2-D array\
\
Image to process.\
\
**mask**2-D array, optional\
\
An optional mask to limit the application to a certain area. Note that pixels surrounding masked regions are also masked to prevent masked regions from affecting the result.\
\
Returns:\
\
**output**2-D array\
\
The Prewitt edge map.\
\
Notes\
\
We use the following kernel:\
\
1/3 1/3 1/3\
0 0 0\
\-1/3 \-1/3 \-1/3\
\
cucim.skimage.filters.prewitt\_v(_image_, _mask\=None_)[#](#cucim.skimage.filters.prewitt_v "Permalink to this definition")\
\
Find the vertical edges of an image using the Prewitt transform.\
\
Parameters:\
\
**image**2-D array\
\
Image to process.\
\
**mask**2-D array, optional\
\
An optional mask to limit the application to a certain area. Note that pixels surrounding masked regions are also masked to prevent masked regions from affecting the result.\
\
Returns:\
\
**output**2-D array\
\
The Prewitt edge map.\
\
Notes\
\
We use the following kernel:\
\
1/3 0 \-1/3\
1/3 0 \-1/3\
1/3 0 \-1/3\
\
cucim.skimage.filters.rank\_order(_image_)[#](#cucim.skimage.filters.rank_order "Permalink to this definition")\
\
Return an image of the same shape where each pixel is the index of the pixel value in the ascending order of the unique values of `image`, aka the rank-order value.\
\
Parameters:\
\
**image**cp.ndarray\
\
Returns:\
\
**labels**cp.ndarray of unsigned integers, of shape image.shape\
\
New array where each pixel has the rank-order value of the corresponding pixel in `image`. Pixel values are between 0 and n - 1, where n is the number of distinct unique values in `image`. The dtype of this array will be determined by `cp.min_scalar_type(image.size)`.\
\
**original\_values**1-D cp.ndarray\
\
Unique original values of `image`. This will have the same dtype as `image`.\
\
Examples\
\
\>>> a \= cp.asarray(\[\[1, 4, 5\], \[4, 4, 1\], \[5, 1, 1\]\])\
\>>> a\
array(\[\[1, 4, 5\],\
\[4, 4, 1\],\
\[5, 1, 1\]\])\
\>>> rank\_order(a)\
(array(\[\[0, 1, 2\],\
\[1, 1, 0\],\
\[2, 0, 0\]\], dtype=uint8), array(\[1, 4, 5\]))\
\>>> b \= cp.asarray(\[\-1., 2.5, 3.1, 2.5\])\
\>>> rank\_order(b)\
(array(\[0, 1, 2, 1\], dtype=uint8), array(\[-1. , 2.5, 3.1\]))\
\
cucim.skimage.filters.roberts(_image_, _mask\=None_)[#](#cucim.skimage.filters.roberts "Permalink to this definition")\
\
Find the edge magnitude using Roberts’ cross operator.\
\
Parameters:\
\
**image**2-D array\
\
Image to process.\
\
**mask**2-D array, optional\
\
An optional mask to limit the application to a certain area. Note that pixels surrounding masked regions are also masked to prevent masked regions from affecting the result.\
\
Returns:\
\
**output**2-D array\
\
The Roberts’ Cross edge map.\
\
See also\
\
[`roberts_pos_diag`](#cucim.skimage.filters.roberts_pos_diag "cucim.skimage.filters.roberts_pos_diag")\
, [`roberts_neg_diag`](#cucim.skimage.filters.roberts_neg_diag "cucim.skimage.filters.roberts_neg_diag")\
\
diagonal edge detection.\
\
[`sobel`](#cucim.skimage.filters.sobel "cucim.skimage.filters.sobel")\
, [`scharr`](#cucim.skimage.filters.scharr "cucim.skimage.filters.scharr")\
, [`prewitt`](#cucim.skimage.filters.prewitt "cucim.skimage.filters.prewitt")\
, [`cucim.skimage.feature.canny`](#cucim.skimage.feature.canny "cucim.skimage.feature.canny")\
\
Examples\
\
\>>> import cupy as cp\
\>>> from skimage import data\
\>>> camera \= cp.array(data.camera())\
\>>> from cucim.skimage import filters\
\>>> edges \= filters.roberts(camera)\
\
cucim.skimage.filters.roberts\_neg\_diag(_image_, _mask\=None_)[#](#cucim.skimage.filters.roberts_neg_diag "Permalink to this definition")\
\
Find the cross edges of an image using the Roberts’ Cross operator.\
\
The kernel is applied to the input image to produce separate measurements of the gradient component one orientation.\
\
Parameters:\
\
**image**2-D array\
\
Image to process.\
\
**mask**2-D array, optional\
\
An optional mask to limit the application to a certain area. Note that pixels surrounding masked regions are also masked to prevent masked regions from affecting the result.\
\
Returns:\
\
**output**2-D array\
\
The Robert’s edge map.\
\
Notes\
\
We use the following kernel:\
\
0 1\
\-1 0\
\
cucim.skimage.filters.roberts\_pos\_diag(_image_, _mask\=None_)[#](#cucim.skimage.filters.roberts_pos_diag "Permalink to this definition")\
\
Find the cross edges of an image using Roberts’ cross operator.\
\
The kernel is applied to the input image to produce separate measurements of the gradient component one orientation.\
\
Parameters:\
\
**image**2-D array\
\
Image to process.\
\
**mask**2-D array, optional\
\
An optional mask to limit the application to a certain area. Note that pixels surrounding masked regions are also masked to prevent masked regions from affecting the result.\
\
Returns:\
\
**output**2-D array\
\
The Robert’s edge map.\
\
Notes\
\
We use the following kernel:\
\
1 0\
0 \-1\
\
cucim.skimage.filters.sato(_image_, _sigmas\=range(1, 10, 2)_, _black\_ridges\=True_, _mode\='reflect'_, _cval\=0_)[#](#cucim.skimage.filters.sato "Permalink to this definition")\
\
Filter an image with the Sato tubeness filter.\
\
This filter can be used to detect continuous ridges, e.g. tubes, wrinkles, rivers. It can be used to calculate the fraction of the whole image containing such objects.\
\
Defined only for 2-D and 3-D images. Calculates the eigenvalues of the Hessian to compute the similarity of an image region to tubes, according to the method described in [\[1\]](#r8b615273143c-1)\
.\
\
Parameters:\
\
**image**(M, N\[, P\]) ndarray\
\
Array with input image data.\
\
**sigmas**iterable of floats, optional\
\
Sigmas used as scales of filter.\
\
**black\_ridges**boolean, optional\
\
When True (the default), the filter detects black ridges; when False, it detects white ridges.\
\
**mode**{‘constant’, ‘reflect’, ‘wrap’, ‘nearest’, ‘mirror’}, optional\
\
How to handle values outside the image borders.\
\
**cval**float, optional\
\
Used in conjunction with mode ‘constant’, the value outside the image boundaries.\
\
Returns:\
\
**out**(M, N\[, P\]) ndarray\
\
Filtered image (maximum of pixels across all scales).\
\
See also\
\
[`meijering`](#cucim.skimage.filters.meijering "cucim.skimage.filters.meijering")\
\
[`frangi`](#cucim.skimage.filters.frangi "cucim.skimage.filters.frangi")\
\
[`hessian`](#cucim.skimage.filters.hessian "cucim.skimage.filters.hessian")\
\
References\
\
\[[1](#id151)\
\]\
\
Sato, Y., Nakajima, S., Shiraga, N., Atsumi, H., Yoshida, S., Koller, T., …, Kikinis, R. (1998). Three-dimensional multi-scale line filter for segmentation and visualization of curvilinear structures in medical images. Medical image analysis, 2(2), 143-168. [DOI:10.1016/S1361-8415(98)80009-1](https://doi.org/10.1016/S1361-8415(98)80009-1)\
\
cucim.skimage.filters.scharr(_image_, _mask\=None_, _\*_, _axis\=None_, _mode\='reflect'_, _cval\=0.0_)[#](#cucim.skimage.filters.scharr "Permalink to this definition")\
\
Find the edge magnitude using the Scharr transform.\
\
Parameters:\
\
**image**array\
\
The input image.\
\
**mask**array of bool, optional\
\
Clip the output image to this mask. (Values where mask=0 will be set to 0.)\
\
**axis**int or sequence of int, optional\
\
Compute the edge filter along this axis. If not provided, the edge magnitude is computed. This is defined as:\
\
sch\_mag \= np.sqrt(sum(\[scharr(image, axis\=i)\*\*2\
for i in range(image.ndim)\]) / image.ndim)\
\
The magnitude is also computed if axis is a sequence.\
\
**mode**str or sequence of str, optional\
\
The boundary mode for the convolution. See scipy.ndimage.convolve for a description of the modes. This can be either a single boundary mode or one boundary mode per axis.\
\
**cval**float, optional\
\
When mode is `'constant'`, this is the constant used in values outside the boundary of the image data.\
\
Returns:\
\
**output**array of float\
\
The Scharr edge map.\
\
See also\
\
[`scharr_h`](#cucim.skimage.filters.scharr_h "cucim.skimage.filters.scharr_h")\
, [`scharr_v`](#cucim.skimage.filters.scharr_v "cucim.skimage.filters.scharr_v")\
\
horizontal and vertical edge detection.\
\
[`sobel`](#cucim.skimage.filters.sobel "cucim.skimage.filters.sobel")\
, [`prewitt`](#cucim.skimage.filters.prewitt "cucim.skimage.filters.prewitt")\
, [`farid`](#cucim.skimage.filters.farid "cucim.skimage.filters.farid")\
, [`cucim.skimage.feature.canny`](#cucim.skimage.feature.canny "cucim.skimage.feature.canny")\
\
Notes\
\
The Scharr operator has a better rotation invariance than other edge filters such as the Sobel or the Prewitt operators.\
\
References\
\
\[1\]\
\
D. Kroon, 2009, Short Paper University Twente, Numerical Optimization of Kernel Based Image Derivatives.\
\
\[2\]\
\
[https://en.wikipedia.org/wiki/Sobel\_operator#Alternative\_operators](https://en.wikipedia.org/wiki/Sobel_operator#Alternative_operators)\
\
Examples\
\
\>>> import cupy as cp\
\>>> from skimage import data\
\>>> from cucim.skimage import filters\
\>>> camera \= cp.array(data.camera())\
\>>> edges \= filters.scharr(camera)\
\
cucim.skimage.filters.scharr\_h(_image_, _mask\=None_)[#](#cucim.skimage.filters.scharr_h "Permalink to this definition")\
\
Find the horizontal edges of an image using the Scharr transform.\
\
Parameters:\
\
**image**2-D array\
\
Image to process.\
\
**mask**2-D array, optional\
\
An optional mask to limit the application to a certain area. Note that pixels surrounding masked regions are also masked to prevent masked regions from affecting the result.\
\
Returns:\
\
**output**2-D array\
\
The Scharr edge map.\
\
Notes\
\
We use the following kernel:\
\
3 10 3\
0 0 0\
\-3 \-10 \-3\
\
References\
\
\[1\]\
\
D. Kroon, 2009, Short Paper University Twente, Numerical Optimization of Kernel Based Image Derivatives.\
\
cucim.skimage.filters.scharr\_v(_image_, _mask\=None_)[#](#cucim.skimage.filters.scharr_v "Permalink to this definition")\
\
Find the vertical edges of an image using the Scharr transform.\
\
Parameters:\
\
**image**2-D array\
\
Image to process\
\
**mask**2-D array, optional\
\
An optional mask to limit the application to a certain area. Note that pixels surrounding masked regions are also masked to prevent masked regions from affecting the result.\
\
Returns:\
\
**output**2-D array\
\
The Scharr edge map.\
\
Notes\
\
We use the following kernel:\
\
3 0 \-3\
10 0 \-10\
3 0 \-3\
\
References\
\
\[1\]\
\
D. Kroon, 2009, Short Paper University Twente, Numerical Optimization of Kernel Based Image Derivatives.\
\
cucim.skimage.filters.sobel(_image_, _mask\=None_, _\*_, _axis\=None_, _mode\='reflect'_, _cval\=0.0_)[#](#cucim.skimage.filters.sobel "Permalink to this definition")\
\
Find edges in an image using the Sobel filter.\
\
Parameters:\
\
**image**array\
\
The input image.\
\
**mask**array of bool, optional\
\
Clip the output image to this mask. (Values where mask=0 will be set to 0.)\
\
**axis**int or sequence of int, optional\
\
Compute the edge filter along this axis. If not provided, the edge magnitude is computed. This is defined as:\
\
sobel\_mag \= np.sqrt(sum(\[sobel(image, axis\=i)\*\*2\
for i in range(image.ndim)\]) / image.ndim)\
\
The magnitude is also computed if axis is a sequence.\
\
**mode**str or sequence of str, optional\
\
The boundary mode for the convolution. See scipy.ndimage.convolve for a description of the modes. This can be either a single boundary mode or one boundary mode per axis.\
\
**cval**float, optional\
\
When mode is `'constant'`, this is the constant used in values outside the boundary of the image data.\
\
Returns:\
\
**output**array of float\
\
The Sobel edge map.\
\
See also\
\
[`sobel_h`](#cucim.skimage.filters.sobel_h "cucim.skimage.filters.sobel_h")\
, [`sobel_v`](#cucim.skimage.filters.sobel_v "cucim.skimage.filters.sobel_v")\
\
horizontal and vertical edge detection.\
\
[`scharr`](#cucim.skimage.filters.scharr "cucim.skimage.filters.scharr")\
, [`prewitt`](#cucim.skimage.filters.prewitt "cucim.skimage.filters.prewitt")\
, [`farid`](#cucim.skimage.filters.farid "cucim.skimage.filters.farid")\
, [`cucim.skimage.feature.canny`](#cucim.skimage.feature.canny "cucim.skimage.feature.canny")\
\
References\
\
\[1\]\
\
D. Kroon, 2009, Short Paper University Twente, Numerical Optimization of Kernel Based Image Derivatives.\
\
\[2\]\
\
[https://en.wikipedia.org/wiki/Sobel\_operator](https://en.wikipedia.org/wiki/Sobel_operator)\
\
Examples\
\
\>>> import cupy as cp\
\>>> from skimage import data\
\>>> from cucim.skimage import filters\
\>>> camera \= cp.array(data.camera())\
\>>> edges \= filters.sobel(camera)\
\
cucim.skimage.filters.sobel\_h(_image_, _mask\=None_)[#](#cucim.skimage.filters.sobel_h "Permalink to this definition")\
\
Find the horizontal edges of an image using the Sobel transform.\
\
Parameters:\
\
**image**2-D array\
\
Image to process.\
\
**mask**2-D array, optional\
\
An optional mask to limit the application to a certain area. Note that pixels surrounding masked regions are also masked to prevent masked regions from affecting the result.\
\
Returns:\
\
**output**2-D array\
\
The Sobel edge map.\
\
Notes\
\
We use the following kernel:\
\
1 2 1\
0 0 0\
\-1 \-2 \-1\
\
cucim.skimage.filters.sobel\_v(_image_, _mask\=None_)[#](#cucim.skimage.filters.sobel_v "Permalink to this definition")\
\
Find the vertical edges of an image using the Sobel transform.\
\
Parameters:\
\
**image**2-D array\
\
Image to process.\
\
**mask**2-D array, optional\
\
An optional mask to limit the application to a certain area. Note that pixels surrounding masked regions are also masked to prevent masked regions from affecting the result.\
\
Returns:\
\
**output**2-D array\
\
The Sobel edge map.\
\
Notes\
\
We use the following kernel:\
\
1 0 \-1\
2 0 \-2\
1 0 \-1\
\
cucim.skimage.filters.threshold\_isodata(_image\=None_, _nbins\=256_, _return\_all\=False_, _\*_, _hist\=None_)[#](#cucim.skimage.filters.threshold_isodata "Permalink to this definition")\
\
Return threshold value(s) based on ISODATA method.\
\
Histogram-based threshold, known as Ridler-Calvard method or inter-means. Threshold values returned satisfy the following equality:\
\
threshold \= (image\[image <= threshold\].mean() +\
image\[image \> threshold\].mean()) / 2.0\
\
That is, returned thresholds are intensities that separate the image into two groups of pixels, where the threshold intensity is midway between the mean intensities of these groups.\
\
For integer images, the above equality holds to within one; for floating- point images, the equality holds to within the histogram bin-width.\
\
Either image or hist must be provided. In case hist is given, the actual histogram of the image is ignored.\
\
Parameters:\
\
**image**(M, N\[, …\]) ndarray\
\
Grayscale input image.\
\
**nbins**int, optional\
\
Number of bins used to calculate histogram. This value is ignored for integer arrays.\
\
**return\_all**bool, optional\
\
If False (default), return only the lowest threshold that satisfies the above equality. If True, return all valid thresholds.\
\
**hist**array, or 2-tuple of arrays, optional\
\
Histogram to determine the threshold from and a corresponding array of bin center intensities. Alternatively, only the histogram can be passed.\
\
Returns:\
\
**threshold**float or int or array\
\
Threshold value(s).\
\
References\
\
\[1\]\
\
Ridler, TW & Calvard, S (1978), “Picture thresholding using an iterative selection method” IEEE Transactions on Systems, Man and Cybernetics 8: 630-632, [DOI:10.1109/TSMC.1978.4310039](https://doi.org/10.1109/TSMC.1978.4310039)\
\
\[2\]\
\
Sezgin M. and Sankur B. (2004) “Survey over Image Thresholding Techniques and Quantitative Performance Evaluation” Journal of Electronic Imaging, 13(1): 146-165, [http://www.busim.ee.boun.edu.tr/~sankur/SankurFolder/Threshold\_survey.pdf](http://www.busim.ee.boun.edu.tr/~sankur/SankurFolder/Threshold_survey.pdf)\
[DOI:10.1117/1.1631315](https://doi.org/10.1117/1.1631315)\
\
\[3\]\
\
ImageJ AutoThresholder code, [http://fiji.sc/wiki/index.php/Auto\_Threshold](http://fiji.sc/wiki/index.php/Auto_Threshold)\
\
Examples\
\
\>>> from skimage.data import coins\
\>>> image \= cp.array(coins())\
\>>> thresh \= threshold\_isodata(image)\
\>>> binary \= image \> thresh\
\
cucim.skimage.filters.threshold\_li(_image_, _\*_, _tolerance\=None_, _initial\_guess\=None_, _iter\_callback\=None_)[#](#cucim.skimage.filters.threshold_li "Permalink to this definition")\
\
Compute threshold value by Li’s iterative Minimum Cross Entropy method.\
\
Parameters:\
\
**image**(M, N\[, …\]) ndarray\
\
Grayscale input image.\
\
**tolerance**float, optional\
\
Finish the computation when the change in the threshold in an iteration is less than this value. By default, this is half the smallest difference between intensity values in `image`.\
\
**initial\_guess**float or Callable\[\[array\[float\]\], float\], optional\
\
Li’s iterative method uses gradient descent to find the optimal threshold. If the image intensity histogram contains more than two modes (peaks), the gradient descent could get stuck in a local optimum. An initial guess for the iteration can help the algorithm find the globally-optimal threshold. A float value defines a specific start point, while a callable should take in an array of image intensities and return a float value. Example valid callables include `numpy.mean` (default), `lambda arr: numpy.quantile(arr, 0.95)`, or even [`skimage.filters.threshold_otsu()`](https://scikit-image.org/docs/stable/api/skimage.filters.html#skimage.filters.threshold_otsu "(in skimage v0.25.2)")\
.\
\
**iter\_callback**Callable\[\[float\], Any\], optional\
\
A function that will be called on the threshold at every iteration of the algorithm.\
\
Returns:\
\
**threshold**float\
\
Upper threshold value. All pixels with an intensity higher than this value are assumed to be foreground.\
\
References\
\
\[1\]\
\
Li C.H. and Lee C.K. (1993) “Minimum Cross Entropy Thresholding” Pattern Recognition, 26(4): 617-625 [DOI:10.1016/0031-3203(93)90115-D](https://doi.org/10.1016/0031-3203(93)90115-D)\
\
\[2\]\
\
Li C.H. and Tam P.K.S. (1998) “An Iterative Algorithm for Minimum Cross Entropy Thresholding” Pattern Recognition Letters, 18(8): 771-776 [DOI:10.1016/S0167-8655(98)00057-9](https://doi.org/10.1016/S0167-8655(98)00057-9)\
\
\[3\]\
\
Sezgin M. and Sankur B. (2004) “Survey over Image Thresholding Techniques and Quantitative Performance Evaluation” Journal of Electronic Imaging, 13(1): 146-165 [DOI:10.1117/1.1631315](https://doi.org/10.1117/1.1631315)\
\
\[4\]\
\
ImageJ AutoThresholder code, [http://fiji.sc/wiki/index.php/Auto\_Threshold](http://fiji.sc/wiki/index.php/Auto_Threshold)\
\
Examples\
\
\>>> from skimage.data import camera\
\>>> image \= cp.array(camera())\
\>>> thresh \= threshold\_li(image)\
\>>> binary \= image \> thresh\
\
cucim.skimage.filters.threshold\_local(_image_, _block\_size\=3_, _method\='gaussian'_, _offset\=0_, _mode\='reflect'_, _param\=None_, _cval\=0_)[#](#cucim.skimage.filters.threshold_local "Permalink to this definition")\
\
Compute a threshold mask image based on local pixel neighborhood.\
\
Also known as adaptive or dynamic thresholding. The threshold value is the weighted mean for the local neighborhood of a pixel subtracted by a constant. Alternatively the threshold can be determined dynamically by a given function, using the ‘generic’ method.\
\
Parameters:\
\
**image**(M, N\[, …\]) ndarray\
\
Grayscale input image.\
\
**block\_size**int or sequence of int\
\
Odd size of pixel neighborhood which is used to calculate the threshold value (e.g. 3, 5, 7, …, 21, …).\
\
**method**{‘generic’, ‘gaussian’, ‘mean’, ‘median’}, optional\
\
Method used to determine adaptive threshold for local neighborhood in weighted mean image.\
\
* ‘generic’: use custom function (see `param` parameter)\
\
* ‘gaussian’: apply gaussian filter (see `param` parameter for custom sigma value)\
\
* ‘mean’: apply arithmetic mean filter\
\
* ‘median’: apply median rank filter\
\
\
By default, the ‘gaussian’ method is used.\
\
**offset**float, optional\
\
Constant subtracted from weighted mean of neighborhood to calculate the local threshold value. Default offset is 0.\
\
**mode**{‘reflect’, ‘constant’, ‘nearest’, ‘mirror’, ‘wrap’}, optional\
\
The mode parameter determines how the array borders are handled, where cval is the value when mode is equal to ‘constant’. Default is ‘reflect’.\
\
**param**{int, function}, optional\
\
Either specify sigma for ‘gaussian’ method or function object for ‘generic’ method. This functions takes the flat array of local neighborhood as a single argument and returns the calculated threshold for the centre pixel.\
\
**cval**float, optional\
\
Value to fill past edges of input if mode is ‘constant’.\
\
Returns:\
\
**threshold**(M, N\[, …\]) ndarray\
\
Threshold image. All pixels in the input image higher than the corresponding pixel in the threshold image are considered foreground.\
\
References\
\
\[1\]\
\
Gonzalez, R. C. and Wood, R. E. “Digital Image Processing (2nd Edition).” Prentice-Hall Inc., 2002: 600–612. ISBN: 0-201-18075-8\
\
Examples\
\
\>>> import cupy as cp\
\>>> from skimage.data import camera\
\>>> image \= cp.array(camera()\[:50, :50\])\
\>>> binary\_image1 \= image \> threshold\_local(image, 15, 'mean')\
\
cucim.skimage.filters.threshold\_mean(_image_)[#](#cucim.skimage.filters.threshold_mean "Permalink to this definition")\
\
Return threshold value based on the mean of grayscale values.\
\
Parameters:\
\
**image**(M, N\[, …\]) ndarray\
\
Grayscale input image.\
\
Returns:\
\
**threshold**float\
\
Upper threshold value. All pixels with an intensity higher than this value are assumed to be foreground.\
\
References\
\
\[1\]\
\
C. A. Glasbey, “An analysis of histogram-based thresholding algorithms,” CVGIP: Graphical Models and Image Processing, vol. 55, pp. 532-537, 1993. [DOI:10.1006/cgip.1993.1040](https://doi.org/10.1006/cgip.1993.1040)\
\
Examples\
\
\>>> from skimage.data import camera\
\>>> image \= cp.array(camera())\
\>>> thresh \= threshold\_mean(image)\
\>>> binary \= image \> thresh\
\
cucim.skimage.filters.threshold\_minimum(_image\=None_, _nbins\=256_, _max\_num\_iter\=10000_, _\*_, _hist\=None_)[#](#cucim.skimage.filters.threshold_minimum "Permalink to this definition")\
\
Return threshold value based on minimum method.\
\
The histogram of the input `image` is computed if not provided and smoothed until there are only two maxima. Then the minimum in between is the threshold value.\
\
Either image or hist must be provided. In case hist is given, the actual histogram of the image is ignored.\
\
Parameters:\
\
**image**(M, N\[, …\]) ndarray, optional\
\
Grayscale input image.\
\
**nbins**int, optional\
\
Number of bins used to calculate histogram. This value is ignored for integer arrays.\
\
**max\_num\_iter**int, optional\
\
Maximum number of iterations to smooth the histogram.\
\
**hist**array, or 2-tuple of arrays, optional\
\
Histogram to determine the threshold from and a corresponding array of bin center intensities. Alternatively, only the histogram can be passed.\
\
Returns:\
\
**threshold**float\
\
Upper threshold value. All pixels with an intensity higher than this value are assumed to be foreground.\
\
Raises:\
\
RuntimeError\
\
If unable to find two local maxima in the histogram or if the smoothing takes more than 1e4 iterations.\
\
References\
\
\[1\]\
\
C. A. Glasbey, “An analysis of histogram-based thresholding algorithms,” CVGIP: Graphical Models and Image Processing, vol. 55, pp. 532-537, 1993.\
\
\[2\]\
\
Prewitt, JMS & Mendelsohn, ML (1966), “The analysis of cell images”, Annals of the New York Academy of Sciences 128: 1035-1053 [DOI:10.1111/j.1749-6632.1965.tb11715.x](https://doi.org/10.1111/j.1749-6632.1965.tb11715.x)\
\
Examples\
\
\>>> from skimage.data import camera\
\>>> image \= cp.array(camera())\
\>>> thresh \= threshold\_minimum(image)\
\>>> binary \= image \> thresh\
\
cucim.skimage.filters.threshold\_multiotsu(_image\=None_, _classes\=3_, _nbins\=256_, _\*_, _hist\=None_)[#](#cucim.skimage.filters.threshold_multiotsu "Permalink to this definition")\
\
Generate classes\-1 threshold values to divide gray levels in image, following Otsu’s method for multiple classes.\
\
The threshold values are chosen to maximize the total sum of pairwise variances between the thresholded graylevel classes. See Notes and [\[1\]](#r67a1a24cb955-1)\
for more details.\
\
Either image or hist must be provided. If hist is provided, the actual histogram of the image is ignored.\
\
Parameters:\
\
**image**(M, N\[, …\]) ndarray, optional\
\
Grayscale input image.\
\
**classes**int, optional\
\
Number of classes to be thresholded, i.e. the number of resulting regions.\
\
**nbins**int, optional\
\
Number of bins used to calculate the histogram. This value is ignored for integer arrays.\
\
**hist**array, or 2-tuple of arrays, optional\
\
Histogram from which to determine the threshold, and optionally a corresponding array of bin center intensities. If no hist provided, this function will compute it from the image (see notes).\
\
Returns:\
\
**thresh**array\
\
Array containing the threshold values for the desired classes.\
\
Raises:\
\
ValueError\
\
If `image` contains less grayscale value then the desired number of classes.\
\
Notes\
\
This implementation relies on a Cython function whose complexity is \\(O\\left(\\frac{Ch^{C-1}}{(C-1)!}\\right)\\), where \\(h\\) is the number of histogram bins and \\(C\\) is the number of classes desired.\
\
If no hist is given, this function will make use of skimage.exposure.histogram, which behaves differently than np.histogram. While both allowed, use the former for consistent behaviour.\
\
The input image must be grayscale.\
\
References\
\
\[[1](#id170)\
\]\
\
Liao, P-S., Chen, T-S. and Chung, P-C., “A fast algorithm for multilevel thresholding”, Journal of Information Science and Engineering 17 (5): 713-727, 2001. Available at: <[https://ftp.iis.sinica.edu.tw/JISE/2001/200109\_01.pdf](https://ftp.iis.sinica.edu.tw/JISE/2001/200109_01.pdf)\
\> [DOI:10.6688/JISE.2001.17.5.1](https://doi.org/10.6688/JISE.2001.17.5.1)\
\
\[2\]\
\
Tosa, Y., “Multi-Otsu Threshold”, a java plugin for ImageJ. Available at: <[http://imagej.net/plugins/download/Multi\_OtsuThreshold.java](http://imagej.net/plugins/download/Multi_OtsuThreshold.java)\
\>\
\
Examples\
\
\>>> import cupy as cp\
\>>> from cucim.skimage.color import label2rgb\
\>>> from skimage import data\
\>>> image \= cp.asarray(data.camera())\
\>>> thresholds \= threshold\_multiotsu(image)\
\>>> regions \= cp.digitize(image, bins\=thresholds)\
\>>> regions\_colorized \= label2rgb(regions)\
\
cucim.skimage.filters.threshold\_niblack(_image_, _window\_size\=15_, _k\=0.2_)[#](#cucim.skimage.filters.threshold_niblack "Permalink to this definition")\
\
Applies Niblack local threshold to an array.\
\
A threshold T is calculated for every pixel in the image using the following formula:\
\
T \= m(x,y) \- k \* s(x,y)\
\
where m(x,y) and s(x,y) are the mean and standard deviation of pixel (x,y) neighborhood defined by a rectangular window with size w times w centered around the pixel. k is a configurable parameter that weights the effect of standard deviation.\
\
Parameters:\
\
**image**(M, N\[, …\]) ndarray\
\
Grayscale input image.\
\
**window\_size**int, or iterable of int, optional\
\
Window size specified as a single odd integer (3, 5, 7, …), or an iterable of length `image.ndim` containing only odd integers (e.g. `(1, 5, 5)`).\
\
**k**float, optional\
\
Value of parameter k in threshold formula.\
\
Returns:\
\
**threshold**(M, N) ndarray\
\
Threshold mask. All pixels with an intensity higher than this value are assumed to be foreground.\
\
Notes\
\
This algorithm is originally designed for text recognition.\
\
The Bradley threshold is a particular case of the Niblack one, being equivalent to\
\
\>>> from skimage import data\
\>>> image \= cp.array(data.page())\
\>>> q \= 1\
\>>> threshold\_image \= threshold\_niblack(image, k\=0) \* q\
\
for some value `q`. By default, Bradley and Roth use `q=1`.\
\
References\
\
\[1\]\
\
W. Niblack, An introduction to Digital Image Processing, Prentice-Hall, 1986.\
\
\[2\]\
\
D. Bradley and G. Roth, “Adaptive thresholding using Integral Image”, Journal of Graphics Tools 12(2), pp. 13-21, 2007. [DOI:10.1080/2151237X.2007.10129236](https://doi.org/10.1080/2151237X.2007.10129236)\
\
Examples\
\
\>>> from skimage import data\
\>>> image \= cp.array(data.page())\
\>>> threshold\_image \= threshold\_niblack(image, window\_size\=7, k\=0.1)\
\
cucim.skimage.filters.threshold\_otsu(_image\=None_, _nbins\=256_, _\*_, _hist\=None_)[#](#cucim.skimage.filters.threshold_otsu "Permalink to this definition")\
\
Return threshold value based on Otsu’s method.\
\
Either image or hist must be provided. If hist is provided, the actual histogram of the image is ignored.\
\
Parameters:\
\
**image**(M, N\[, …\]) ndarray, optional\
\
Grayscale input image.\
\
**nbins**int, optional\
\
Number of bins used to calculate histogram. This value is ignored for integer arrays.\
\
**hist**array, or 2-tuple of arrays, optional\
\
Histogram from which to determine the threshold, and optionally a corresponding array of bin center intensities. If no hist provided, this function will compute it from the image.\
\
Returns:\
\
**threshold**float\
\
Upper threshold value. All pixels with an intensity higher than this value are assumed to be foreground.\
\
Notes\
\
The input image must be grayscale.\
\
References\
\
\[1\]\
\
Wikipedia, [https://en.wikipedia.org/wiki/Otsu’s\_Method](https://en.wikipedia.org/wiki/Otsu's_Method)\
\
Examples\
\
\>>> from skimage.data import camera\
\>>> image \= cp.array(camera())\
\>>> thresh \= threshold\_otsu(image)\
\>>> binary \= image <= thresh\
\
cucim.skimage.filters.threshold\_sauvola(_image_, _window\_size\=15_, _k\=0.2_, _r\=None_)[#](#cucim.skimage.filters.threshold_sauvola "Permalink to this definition")\
\
Applies Sauvola local threshold to an array. Sauvola is a modification of Niblack technique.\
\
In the original method a threshold T is calculated for every pixel in the image using the following formula:\
\
T \= m(x,y) \* (1 + k \* ((s(x,y) / R) \- 1))\
\
where m(x,y) and s(x,y) are the mean and standard deviation of pixel (x,y) neighborhood defined by a rectangular window with size w times w centered around the pixel. k is a configurable parameter that weights the effect of standard deviation. R is the maximum standard deviation of a grayscale image.\
\
Parameters:\
\
**image**(M, N\[, …\]) ndarray\
\
Grayscale input image.\
\
**window\_size**int, or iterable of int, optional\
\
Window size specified as a single odd integer (3, 5, 7, …), or an iterable of length `image.ndim` containing only odd integers (e.g. `(1, 5, 5)`).\
\
**k**float, optional\
\
Value of the positive parameter k.\
\
**r**float, optional\
\
Value of R, the dynamic range of standard deviation. If None, set to the half of the image dtype range.\
\
Returns:\
\
**threshold**(M, N) ndarray\
\
Threshold mask. All pixels with an intensity higher than this value are assumed to be foreground.\
\
Notes\
\
This algorithm is originally designed for text recognition.\
\
References\
\
\[1\]\
\
J. Sauvola and M. Pietikainen, “Adaptive document image binarization,” Pattern Recognition 33(2), pp. 225-236, 2000. [DOI:10.1016/S0031-3203(99)00055-2](https://doi.org/10.1016/S0031-3203(99)00055-2)\
\
Examples\
\
\>>> from skimage import data\
\>>> image \= cp.array(data.page())\
\>>> t\_sauvola \= threshold\_sauvola(image, window\_size\=15, k\=0.2)\
\>>> binary\_image \= image \> t\_sauvola\
\
cucim.skimage.filters.threshold\_triangle(_image_, _nbins\=256_)[#](#cucim.skimage.filters.threshold_triangle "Permalink to this definition")\
\
Return threshold value based on the triangle algorithm.\
\
Parameters:\
\
**image**(M, N\[, …\]) ndarray\
\
Grayscale input image.\
\
**nbins**int, optional\
\
Number of bins used to calculate histogram. This value is ignored for integer arrays.\
\
Returns:\
\
**threshold**float\
\
Upper threshold value. All pixels with an intensity higher than this value are assumed to be foreground.\
\
References\
\
\[1\]\
\
Zack, G. W., Rogers, W. E. and Latt, S. A., 1977, Automatic Measurement of Sister Chromatid Exchange Frequency, Journal of Histochemistry and Cytochemistry 25 (7), pp. 741-753 [DOI:10.1177/25.7.70454](https://doi.org/10.1177/25.7.70454)\
\
\[2\]\
\
ImageJ AutoThresholder code, [http://fiji.sc/wiki/index.php/Auto\_Threshold](http://fiji.sc/wiki/index.php/Auto_Threshold)\
\
Examples\
\
\>>> import cupy as cp\
\>>> from cucim.skimage.filters import threshold\_triangle\
\>>> from skimage.data import camera\
\>>> image \= cp.array(camera())\
\>>> thresh \= threshold\_triangle(image)\
\>>> binary \= image \> thresh\
\
cucim.skimage.filters.threshold\_yen(_image\=None_, _nbins\=256_, _\*_, _hist\=None_)[#](#cucim.skimage.filters.threshold_yen "Permalink to this definition")\
\
Return threshold value based on Yen’s method. Either image or hist must be provided. In case hist is given, the actual histogram of the image is ignored.\
\
Parameters:\
\
**image**(M, N\[, …\]) ndarray\
\
Grayscale input image.\
\
**nbins**int, optional\
\
Number of bins used to calculate histogram. This value is ignored for integer arrays.\
\
**hist**array, or 2-tuple of arrays, optional\
\
Histogram from which to determine the threshold, and optionally a corresponding array of bin center intensities. An alternative use of this function is to pass it only hist.\
\
Returns:\
\
**threshold**float\
\
Upper threshold value. All pixels with an intensity higher than this value are assumed to be foreground.\
\
References\
\
\[1\]\
\
Yen J.C., Chang F.J., and Chang S. (1995) “A New Criterion for Automatic Multilevel Thresholding” IEEE Trans. on Image Processing, 4(3): 370-378. [DOI:10.1109/83.366472](https://doi.org/10.1109/83.366472)\
\
\[2\]\
\
Sezgin M. and Sankur B. (2004) “Survey over Image Thresholding Techniques and Quantitative Performance Evaluation” Journal of Electronic Imaging, 13(1): 146-165, [DOI:10.1117/1.1631315](https://doi.org/10.1117/1.1631315)\
[http://www.busim.ee.boun.edu.tr/~sankur/SankurFolder/Threshold\_survey.pdf](http://www.busim.ee.boun.edu.tr/~sankur/SankurFolder/Threshold_survey.pdf)\
\
\[3\]\
\
ImageJ AutoThresholder code, [http://fiji.sc/wiki/index.php/Auto\_Threshold](http://fiji.sc/wiki/index.php/Auto_Threshold)\
\
Examples\
\
\>>> from skimage.data import camera\
\>>> image \= cp.array(camera())\
\>>> thresh \= threshold\_yen(image)\
\>>> binary \= image <= thresh\
\
cucim.skimage.filters.try\_all\_threshold(_image_, _figsize\=(8, 5)_, _verbose\=True_)[#](#cucim.skimage.filters.try_all_threshold "Permalink to this definition")\
\
Returns a figure comparing the outputs of different thresholding methods.\
\
Parameters:\
\
**image**(M, N) ndarray\
\
Input image.\
\
**figsize**tuple, optional\
\
Figure size (in inches).\
\
**verbose**bool, optional\
\
Print function name for each method.\
\
Returns:\
\
**fig, ax**tuple\
\
Matplotlib figure and axes.\
\
Notes\
\
The following algorithms are used:\
\
* isodata\
\
* li\
\
* mean\
\
* minimum\
\
* otsu\
\
* triangle\
\
* yen\
\
\
Examples\
\
\>>> from skimage.data import text\
\>>> text\_img \= cp.array(text())\
\>>> fig, ax \= try\_all\_threshold(text\_img, figsize\=(10, 6), verbose\=False)\
\
cucim.skimage.filters.unsharp\_mask(_image_, _radius\=1.0_, _amount\=1.0_, _preserve\_range\=False_, _\*_, _channel\_axis\=None_)[#](#cucim.skimage.filters.unsharp_mask "Permalink to this definition")\
\
Unsharp masking filter.\
\
The sharp details are identified as the difference between the original image and its blurred version. These details are then scaled, and added back to the original image.\
\
Parameters:\
\
**image**(M\[, …\]\[, C\]) ndarray\
\
Input image.\
\
**radius**scalar or sequence of scalars, optional\
\
If a scalar is given, then its value is used for all dimensions. If sequence is given, then there must be exactly one radius for each dimension except the last dimension for multichannel images. Note that 0 radius means no blurring, and negative values are not allowed.\
\
**amount**scalar, optional\
\
The details will be amplified with this factor. The factor could be 0 or negative. Typically, it is a small positive number, e.g. 1.0.\
\
**preserve\_range**bool, optional\
\
Whether to keep the original range of values. Otherwise, the input image is converted according to the conventions of `img_as_float`. Also see [https://scikit-image.org/docs/dev/user\_guide/data\_types.html](https://scikit-image.org/docs/dev/user_guide/data_types.html)\
\
**channel\_axis**int or None, optional\
\
If None, the image is assumed to be a grayscale (single channel) image. Otherwise, this parameter indicates which axis of the array corresponds to channels.\
\
Returns:\
\
**output**(M\[, …\]\[, C\]) ndarray of float\
\
Image with unsharp mask applied.\
\
Notes\
\
Unsharp masking is an image sharpening technique. It is a linear image operation, and numerically stable, unlike deconvolution which is an ill-posed problem. Because of this stability, it is often preferred over deconvolution.\
\
The main idea is as follows: sharp details are identified as the difference between the original image and its blurred version. These details are added back to the original image after a scaling step:\
\
> enhanced image = original + amount \* (original - blurred)\
\
When applying this filter to several color layers independently, color bleeding may occur. More visually pleasing result can be achieved by processing only the brightness/lightness/intensity channel in a suitable color space such as HSV, HSL, YUV, or YCbCr.\
\
Unsharp masking is described in most introductory digital image processing books. This implementation is based on [\[1\]](#r82e4adc9e646-1)\
.\
\
References\
\
\[[1](#id182)\
\]\
\
Maria Petrou, Costas Petrou “Image Processing: The Fundamentals”, (2010), ed ii., page 357, ISBN 13: 9781119994398 [DOI:10.1002/9781119994398](https://doi.org/10.1002/9781119994398)\
\
\[2\]\
\
Wikipedia. Unsharp masking [https://en.wikipedia.org/wiki/Unsharp\_masking](https://en.wikipedia.org/wiki/Unsharp_masking)\
\
Examples\
\
\>>> import cupy as cp\
\>>> array \= cp.ones(shape\=(5,5), dtype\=cp.uint8)\*100\
\>>> array\[2,2\] \= 120\
\>>> array\
array(\[\[100, 100, 100, 100, 100\],\
\[100, 100, 100, 100, 100\],\
\[100, 100, 120, 100, 100\],\
\[100, 100, 100, 100, 100\],\
\[100, 100, 100, 100, 100\]\], dtype=uint8)\
\>>> cp.around(unsharp\_mask(array, radius\=0.5, amount\=2),2)\
array(\[\[0.39, 0.39, 0.39, 0.39, 0.39\],\
\[0.39, 0.39, 0.38, 0.39, 0.39\],\
\[0.39, 0.38, 0.53, 0.38, 0.39\],\
\[0.39, 0.39, 0.38, 0.39, 0.39\],\
\[0.39, 0.39, 0.39, 0.39, 0.39\]\])\
\
\>>> array \= cp.ones(shape\=(5,5), dtype\=cp.int8)\*100\
\>>> array\[2,2\] \= 127\
\>>> cp.around(unsharp\_mask(array, radius\=0.5, amount\=2),2)\
array(\[\[0.79, 0.79, 0.79, 0.79, 0.79\],\
\[0.79, 0.78, 0.75, 0.78, 0.79\],\
\[0.79, 0.75, 1. , 0.75, 0.79\],\
\[0.79, 0.78, 0.75, 0.78, 0.79\],\
\[0.79, 0.79, 0.79, 0.79, 0.79\]\])\
\
\>>> cp.around(unsharp\_mask(array, radius\=0.5, amount\=2,\
... preserve\_range\=True),\
... 2)\
array(\[\[100. , 100. , 99.99, 100. , 100. \],\
\[100. , 99.39, 95.48, 99.39, 100. \],\
\[ 99.99, 95.48, 147.59, 95.48, 99.99\],\
\[100. , 99.39, 95.48, 99.39, 100. \],\
\[100. , 100. , 99.99, 100. , 100. \]\])\
\
cucim.skimage.filters.wiener(_data_, _impulse\_response\=None_, _filter\_params\=None_, _K\=0.25_, _predefined\_filter\=None_)[#](#cucim.skimage.filters.wiener "Permalink to this definition")\
\
Minimum Mean Square Error (Wiener) inverse filter.\
\
Parameters:\
\
**data**(M, N) ndarray\
\
Input data.\
\
**K**float or (M, N) ndarray\
\
Ratio between power spectrum of noise and undegraded image.\
\
**impulse\_response**callable f(r, c, \*\*filter\_params)\
\
Impulse response of the filter. See LPIFilter2D.\_\_init\_\_.\
\
**filter\_params**dict, optional\
\
Additional keyword parameters to the impulse\_response function.\
\
Other Parameters:\
\
**predefined\_filter**LPIFilter2D\
\
If you need to apply the same filter multiple times over different images, construct the LPIFilter2D and specify it here.\
\
cucim.skimage.filters.window(_window\_type_, _shape_, _warp\_kwargs\=None_)[#](#cucim.skimage.filters.window "Permalink to this definition")\
\
Return an n-dimensional window of a given size and dimensionality.\
\
Parameters:\
\
**window\_type**string, float, or tuple\
\
The type of window to be created. Any window type supported by `scipy.signal.get_window` is allowed here. See notes below for a current list, or the SciPy documentation for the version of SciPy on your machine.\
\
**shape**tuple of int or int\
\
The shape of the window along each axis. If an integer is provided, a 1D window is generated.\
\
**warp\_kwargs**dict\
\
Keyword arguments passed to skimage.transform.warp (e.g., `warp_kwargs={'order':3}` to change interpolation method).\
\
Returns:\
\
**nd\_window**ndarray\
\
A window of the specified `shape`. `dtype` is `np.float64`.\
\
Notes\
\
This function is based on `scipy.signal.get_window` and thus can access all of the window types available to that function (e.g., `"hann"`, `"boxcar"`). Note that certain window types require parameters that have to be supplied with the window name as a tuple (e.g., `("tukey", 0.8)`). If only a float is supplied, it is interpreted as the beta parameter of the Kaiser window.\
\
See [https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.windows.get\_window.html](https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.windows.get_window.html)\
for more details.\
\
Note that this function generates a double precision array of the specified `shape` and can thus generate very large arrays that consume a large amount of available memory.\
\
The approach taken here to create nD windows is to first calculate the Euclidean distance from the center of the intended nD window to each position in the array. That distance is used to sample, with interpolation, from a 1D window returned from `scipy.signal.get_window`. The method of interpolation can be changed with the `order` keyword argument passed to skimage.transform.warp.\
\
Some coordinates in the output window will be outside of the original signal; these will be filled in with zeros.\
\
Window types: - boxcar - triang - blackman - hamming - hann - bartlett - flattop - parzen - bohman - blackmanharris - nuttall - barthann - kaiser (needs beta) - gaussian (needs standard deviation) - general\_gaussian (needs power, width) - slepian (needs width) - dpss (needs normalized half-bandwidth) - chebwin (needs attenuation) - exponential (needs decay scale) - tukey (needs taper fraction)\
\
References\
\
\[1\]\
\
Two-dimensional window design, Wikipedia, [https://en.wikipedia.org/wiki/Two\_dimensional\_window\_design](https://en.wikipedia.org/wiki/Two_dimensional_window_design)\
\
Examples\
\
Return a Hann window with shape (512, 512):\
\
\>>> from cucim.skimage.filters import window\
\>>> w \= window('hann', (512, 512))\
\
Return a Kaiser window with beta parameter of 16 and shape (256, 256, 35):\
\
\>>> w \= window(16, (256, 256, 35))\
\
Return a Tukey window with an alpha parameter of 0.8 and shape (100, 300):\
\
\>>> w \= window(('tukey', 0.8), (100, 300))\
\
### measure[#](#module-cucim.skimage.measure "Permalink to this heading")\
\
Measurement of image properties, e.g., region properties, moments.\
\
cucim.skimage.measure.approximate\_polygon(_coords_, _tolerance_)[#](#cucim.skimage.measure.approximate_polygon "Permalink to this definition")\
\
Approximate a polygonal chain with the specified tolerance.\
\
It is based on the Douglas-Peucker algorithm.\
\
Note that the approximated polygon is always within the convex hull of the original polygon.\
\
Parameters:\
\
**coords**(K, 2) array\
\
Coordinate array.\
\
**tolerance**float\
\
Maximum distance from original points of polygon to approximated polygonal chain. If tolerance is 0, the original coordinate array is returned.\
\
Returns:\
\
**coords**(L, 2) array\
\
Approximated polygonal chain where M <= N.\
\
References\
\
\[1\]\
\
[https://en.wikipedia.org/wiki/Ramer-Douglas-Peucker\_algorithm](https://en.wikipedia.org/wiki/Ramer-Douglas-Peucker_algorithm)\
\
cucim.skimage.measure.block\_reduce(_image_, _block\_size=2_, _func=_, _cval=0_, _func\_kwargs=None_)[#](#cucim.skimage.measure.block_reduce "Permalink to this definition")\
\
Downsample image by applying function func to local blocks.\
\
This function is useful for max and mean pooling, for example.\
\
Parameters:\
\
**image**(M\[, …\]) ndarray\
\
N-dimensional input image.\
\
**block\_size**array\_like or int\
\
Array containing down-sampling integer factor along each axis. Default block\_size is 2.\
\
**func**callable\
\
Function object which is used to calculate the return value for each local block. This function must implement an `axis` parameter. Primary functions are `numpy.sum`, `numpy.min`, `numpy.max`, `numpy.mean` and `numpy.median`. See also func\_kwargs.\
\
**cval**float\
\
Constant padding value if image is not perfectly divisible by the block size.\
\
**func\_kwargs**dict\
\
Keyword arguments passed to func. Notably useful for passing dtype argument to `np.mean`. Takes dictionary of inputs, e.g.: `func_kwargs={'dtype': np.float16})`.\
\
Returns:\
\
**image**ndarray\
\
Down-sampled image with same number of dimensions as input image.\
\
Examples\
\
\>>> import cupy as cp\
\>>> from cucim.skimage.measure import block\_reduce\
\>>> image \= cp.arange(3\*3\*4).reshape(3, 3, 4)\
\>>> image \
array(\[\[\[ 0, 1, 2, 3\],\
\[ 4, 5, 6, 7\],\
\[ 8, 9, 10, 11\]\],\
\[\[12, 13, 14, 15\],\
\[16, 17, 18, 19\],\
\[20, 21, 22, 23\]\],\
\[\[24, 25, 26, 27\],\
\[28, 29, 30, 31\],\
\[32, 33, 34, 35\]\]\])\
\>>> block\_reduce(image, block\_size\=(3, 3, 1), func\=cp.mean)\
array(\[\[\[16., 17., 18., 19.\]\]\])\
\>>> image\_max1 \= block\_reduce(image, block\_size\=(1, 3, 4), func\=cp.max)\
\>>> image\_max1 \
array(\[\[\[11\]\],\
\[\[23\]\],\
\[\[35\]\]\])\
\>>> image\_max2 \= block\_reduce(image, block\_size\=(3, 1, 4), func\=cp.max)\
\>>> image\_max2 \
array(\[\[\[27\],\
\[31\],\
\[35\]\]\])\
\
cucim.skimage.measure.blur\_effect(_image_, _h\_size=11_, _channel\_axis=None_, _reduce\_func=_)[#](#cucim.skimage.measure.blur_effect "Permalink to this definition")\
\
Compute a metric that indicates the strength of blur in an image (0 for no blur, 1 for maximal blur).\
\
Parameters:\
\
**image**ndarray\
\
RGB or grayscale nD image. The input image is converted to grayscale before computing the blur metric.\
\
**h\_size**int, optional\
\
Size of the re-blurring filter.\
\
**channel\_axis**int or None, optional\
\
If None, the image is assumed to be grayscale (single-channel). Otherwise, this parameter indicates which axis of the array corresponds to color channels.\
\
**reduce\_func**callable, optional\
\
Function used to calculate the aggregation of blur metrics along all axes. If set to None, the entire list is returned, where the i-th element is the blur metric along the i-th axis. This function should be a host function that operates on standard python floats.\
\
Returns:\
\
**blur**float (0 to 1) or list of floats\
\
Blur metric: by default, the maximum of blur metrics along all axes.\
\
Notes\
\
h\_size must keep the same value in order to compare results between images. Most of the time, the default size (11) is enough. This means that the metric can clearly discriminate blur up to an average 11x11 filter; if blur is higher, the metric still gives good results but its values tend towards an asymptote.\
\
References\
\
\[1\]\
\
Frederique Crete, Thierry Dolmiere, Patricia Ladret, and Marina Nicolas “The blur effect: perception and estimation with a new no-reference perceptual blur metric” Proc. SPIE 6492, Human Vision and Electronic Imaging XII, 64920I (2007) [https://hal.archives-ouvertes.fr/hal-00232709](https://hal.archives-ouvertes.fr/hal-00232709)\
[DOI:10.1117/12.702790](https://doi.org/10.1117/12.702790)\
\
cucim.skimage.measure.centroid(_image_, _\*_, _spacing\=None_)[#](#cucim.skimage.measure.centroid "Permalink to this definition")\
\
Return the (weighted) centroid of an image.\
\
Parameters:\
\
**image**array\
\
The input image.\
\
**spacing: tuple of float, shape (ndim,)**\
\
The pixel spacing along each axis of the image.\
\
Returns:\
\
**center**tuple of float, length `image.ndim`\
\
The centroid of the (nonzero) pixels in `image`.\
\
Examples\
\
\>>> import cupy as cp\
\>>> from cucim.skimage.measure import centroid\
\>>> image \= cp.zeros((20, 20), dtype\=cp.float64)\
\>>> image\[13:17, 13:17\] \= 0.5\
\>>> image\[10:12, 10:12\] \= 1\
\>>> centroid(image)\
array(\[13.16666667, 13.16666667\])\
\
cucim.skimage.measure.euler\_number(_image_, _connectivity\=None_)[#](#cucim.skimage.measure.euler_number "Permalink to this definition")\
\
Calculate the Euler characteristic in binary image.\
\
For 2D objects, the Euler number is the number of objects minus the number of holes. For 3D objects, the Euler number is obtained as the number of objects plus the number of holes, minus the number of tunnels, or loops.\
\
Parameters:\
\
**image: (M, N\[, P\]) ndarray**\
\
Input image. If image is not binary, all values greater than zero are considered as the object.\
\
**connectivity**int, optional\
\
Maximum number of orthogonal hops to consider a pixel/voxel as a neighbor. Accepted values are ranging from 1 to input.ndim. If `None`, a full connectivity of `input.ndim` is used. 4 or 8 neighborhoods are defined for 2D images (connectivity 1 and 2, respectively). 6 or 26 neighborhoods are defined for 3D images, (connectivity 1 and 3, respectively). Connectivity 2 is not defined.\
\
Returns:\
\
**euler\_number**int\
\
Euler characteristic of the set of all objects in the image.\
\
Notes\
\
The Euler characteristic is an integer number that describes the topology of the set of all objects in the input image. If object is 4-connected, then background is 8-connected, and conversely.\
\
The computation of the Euler characteristic is based on an integral geometry formula in discretized space. In practice, a neighborhood configuration is constructed, and a LUT is applied for each configuration. The coefficients used are the ones of Ohser et al.\
\
It can be useful to compute the Euler characteristic for several connectivities. A large relative difference between results for different connectivities suggests that the image resolution (with respect to the size of objects and holes) is too low.\
\
References\
\
\[1\]\
\
S. Rivollier. Analyse d’image geometrique et morphometrique par diagrammes de forme et voisinages adaptatifs generaux. PhD thesis, 2010. Ecole Nationale Superieure des Mines de Saint-Etienne. [https://tel.archives-ouvertes.fr/tel-00560838](https://tel.archives-ouvertes.fr/tel-00560838)\
\
\[2\]\
\
Ohser J., Nagel W., Schladitz K. (2002) The Euler Number of Discretized Sets - On the Choice of Adjacency in Homogeneous Lattices. In: Mecke K., Stoyan D. (eds) Morphology of Condensed Matter. Lecture Notes in Physics, vol 600. Springer, Berlin, Heidelberg.\
\
Examples\
\
\>>> import cupy as cp\
\>>> SAMPLE \= cp.zeros((100,100,100))\
\>>> SAMPLE\[40:60, 40:60, 40:60\] \= 1\
\>>> euler\_number(SAMPLE) \
1...\
\>>> SAMPLE\[45:55,45:55,45:55\] \= 0;\
\>>> euler\_number(SAMPLE) \
2...\
\>>> SAMPLE \= cp.array(\[\[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0\],\
... \[0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0\],\
... \[0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0\],\
... \[0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0\],\
... \[0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0\],\
... \[0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0\],\
... \[0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0\],\
... \[1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0\],\
... \[0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1\],\
... \[0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1\]\])\
\>>> euler\_number(SAMPLE) \# doctest:\
array(0)\
\>>> euler\_number(SAMPLE, connectivity\=1) \# doctest:\
array(2)\
\
cucim.skimage.measure.inertia\_tensor(_image_, _mu\=None_, _\*_, _spacing\=None_)[#](#cucim.skimage.measure.inertia_tensor "Permalink to this definition")\
\
Compute the inertia tensor of the input image.\
\
Parameters:\
\
**image**array\
\
The input image.\
\
**mu**array, optional\
\
The pre-computed central moments of `image`. The inertia tensor computation requires the central moments of the image. If an application requires both the central moments and the inertia tensor (for example, skimage.measure.regionprops), then it is more efficient to pre-compute them and pass them to the inertia tensor call.\
\
**spacing**tuple of float, shape (ndim,), optional\
\
The pixel spacing along each axis of the image.\
\
Returns:\
\
**T**array, shape `(image.ndim, image.ndim)`\
\
The inertia tensor of the input image. \\(T\_{i, j}\\) contains the covariance of image intensity along axes \\(i\\) and \\(j\\).\
\
References\
\
\[1\]\
\
[https://en.wikipedia.org/wiki/Moment\_of\_inertia#Inertia\_tensor](https://en.wikipedia.org/wiki/Moment_of_inertia#Inertia_tensor)\
\
\[2\]\
\
Bernd Jähne. Spatio-Temporal Image Processing: Theory and Scientific Applications. (Chapter 8: Tensor Methods) Springer, 1993.\
\
cucim.skimage.measure.inertia\_tensor\_eigvals(_image_, _mu\=None_, _T\=None_, _\*_, _spacing\=None_)[#](#cucim.skimage.measure.inertia_tensor_eigvals "Permalink to this definition")\
\
Compute the eigenvalues of the inertia tensor of the image.\
\
The inertia tensor measures covariance of the image intensity along the image axes. (See inertia\_tensor.) The relative magnitude of the eigenvalues of the tensor is thus a measure of the elongation of a (bright) object in the image.\
\
Parameters:\
\
**image**array\
\
The input image.\
\
**mu**array, optional\
\
The pre-computed central moments of `image`.\
\
**T**array, shape `(image.ndim, image.ndim)`\
\
The pre-computed inertia tensor. If `T` is given, `mu` and `image` are ignored.\
\
**spacing**tuple of float, shape (ndim,), optional\
\
The pixel spacing along each axis of the image.\
\
Returns:\
\
**eigvals**list of float, length `image.ndim`\
\
The eigenvalues of the inertia tensor of `image`, in descending order.\
\
Notes\
\
Computing the eigenvalues requires the inertia tensor of the input image. This is much faster if the central moments (`mu`) are provided, or, alternatively, one can provide the inertia tensor (`T`) directly.\
\
cucim.skimage.measure.intersection\_coeff(_image0\_mask_, _image1\_mask_, _mask\=None_)[#](#cucim.skimage.measure.intersection_coeff "Permalink to this definition")\
\
Fraction of a channel’s segmented binary mask that overlaps with a second channel’s segmented binary mask.\
\
Parameters:\
\
**image0\_mask**(M, N) ndarray of dtype bool\
\
Image mask of channel A.\
\
**image1\_mask**(M, N) ndarray of dtype bool\
\
Image mask of channel B. Must have same dimensions as image0\_mask.\
\
**mask**(M, N) ndarray of dtype bool, optional\
\
Only image0\_mask and image1\_mask pixels within this region of interest mask are included in the calculation. Must have same dimensions as image0\_mask.\
\
Returns:\
\
Intersection coefficient, float\
\
Fraction of image0\_mask that overlaps with image1\_mask.\
\
cucim.skimage.measure.label(_label\_image_, _background\=None_, _return\_num\=False_, _connectivity\=None_)[#](#cucim.skimage.measure.label "Permalink to this definition")\
\
Label connected regions of an integer array.\
\
Two pixels are connected when they are neighbors and have the same value. In 2D, they can be neighbors either in a 1- or 2-connected sense. The value refers to the maximum number of orthogonal hops to consider a pixel/voxel a neighbor:\
\
1\-connectivity 2\-connectivity diagonal connection close\-up\
\
\[ \] \[ \] \[ \] \[ \] \[ \]\
| \\ | / | <- hop 2\
\[ \]\--\[x\]\--\[ \] \[ \]\--\[x\]\--\[ \] \[x\]\--\[ \]\
| / | \\ hop 1\
\[ \] \[ \] \[ \] \[ \]\
\
Parameters:\
\
**label\_image**ndarray of dtype int\
\
Image to label.\
\
**background**int, optional\
\
Consider all pixels with this value as background pixels, and label them as 0. By default, 0-valued pixels are considered as background pixels.\
\
**return\_num**bool, optional\
\
Whether to return the number of assigned labels.\
\
**connectivity**int, optional\
\
Maximum number of orthogonal hops to consider a pixel/voxel as a neighbor. Accepted values are ranging from 1 to input.ndim. If `None`, a full connectivity of `input.ndim` is used.\
\
Returns:\
\
**labels**ndarray of dtype int\
\
Labeled array, where all connected regions are assigned the same integer value.\
\
**num**int, optional\
\
Number of labels, which equals the maximum label index and is only returned if return\_num is True.\
\
See also\
\
[`cucim.skimage.measure.regionprops`](#cucim.skimage.measure.regionprops "cucim.skimage.measure.regionprops")\
\
[`cucim.skimage.measure.regionprops_table`](#cucim.skimage.measure.regionprops_table "cucim.skimage.measure.regionprops_table")\
\
Notes\
\
Currently the cucim implementation of this function always uses 32-bit integers for the label array. This is done for performance. In the future 64-bit integer support may also be added for better skimage compatibility.\
\
References\
\
\[1\]\
\
Christophe Fiorio and Jens Gustedt, “Two linear time Union-Find strategies for image processing”, Theoretical Computer Science 154 (1996), pp. 165-181.\
\
\[2\]\
\
Kensheng Wu, Ekow Otoo and Arie Shoshani, “Optimizing connected component labeling algorithms”, Paper LBNL-56864, 2005, Lawrence Berkeley National Laboratory (University of California), [http://repositories.cdlib.org/lbnl/LBNL-56864](http://repositories.cdlib.org/lbnl/LBNL-56864)\
\
Examples\
\
\>>> import cupy as cp\
\>>> x \= cp.eye(3).astype(int)\
\>>> print(x)\
\[\[1 0 0\]\
\[0 1 0\]\
\[0 0 1\]\]\
\>>> print(label(x, connectivity\=1))\
\[\[1 0 0\]\
\[0 2 0\]\
\[0 0 3\]\]\
\>>> print(label(x, connectivity\=2))\
\[\[1 0 0\]\
\[0 1 0\]\
\[0 0 1\]\]\
\>>> print(label(x, background\=-1))\
\[\[1 2 2\]\
\[2 1 2\]\
\[2 2 1\]\]\
\>>> x \= cp.asarray(\[\[1, 0, 0\],\
... \[1, 1, 5\],\
... \[0, 0, 0\]\])\
\>>> print(label(x))\
\[\[1 0 0\]\
\[1 1 2\]\
\[0 0 0\]\]\
\
cucim.skimage.measure.manders\_coloc\_coeff(_image0_, _image1\_mask_, _mask\=None_)[#](#cucim.skimage.measure.manders_coloc_coeff "Permalink to this definition")\
\
Manders’ colocalization coefficient between two channels.\
\
Parameters:\
\
**image0**(M, N) ndarray\
\
Image of channel A. All pixel values should be non-negative.\
\
**image1\_mask**(M, N) ndarray of dtype bool\
\
Binary mask with segmented regions of interest in channel B. Must have same dimensions as image0.\
\
**mask**(M, N) ndarray of dtype bool, optional\
\
Only image0 pixel values within this region of interest mask are included in the calculation. Must have same dimensions as image0.\
\
Returns:\
\
**mcc**float\
\
Manders’ colocalization coefficient.\
\
Notes\
\
Manders’ Colocalization Coefficient (MCC) is the fraction of total intensity of a certain channel (channel A) that is within the segmented region of a second channel (channel B) [\[1\]](#r68fa832cfb27-1)\
. It ranges from 0 for no colocalisation to 1 for complete colocalization. It is also referred to as M1 and M2.\
\
MCC is commonly used to measure the colocalization of a particular protein in a subceullar compartment. Typically a segmentation mask for channel B is generated by setting a threshold that the pixel values must be above to be included in the MCC calculation. In this implementation, the channel B mask is provided as the argument image1\_mask, allowing the exact segmentation method to be decided by the user beforehand.\
\
The implemented equation is:\
\
\\\[r = \\frac{\\sum A\_{i,coloc}}{\\sum A\_i}\\\]\
\
where\
\
\\(A\_i\\) is the value of the \\(i^{th}\\) pixel in image0 \\(A\_{i,coloc} = A\_i\\) if \\(Bmask\_i > 0\\) \\(Bmask\_i\\) is the value of the \\(i^{th}\\) pixel in mask\
\
MCC is sensitive to noise, with diffuse signal in the first channel inflating its value. Images should be processed to remove out of focus and background light before the MCC is calculated [\[2\]](#r68fa832cfb27-2)\
.\
\
References\
\
\[[1](#id194)\
\]\
\
Manders, E.M.M., Verbeek, F.J. and Aten, J.A. (1993), Measurement of co-localization of objects in dual-colour confocal images. Journal of Microscopy, 169: 375-382. [https://doi.org/10.1111/j.1365-2818.1993.tb03313.x](https://doi.org/10.1111/j.1365-2818.1993.tb03313.x)\
[https://imagej.net/media/manders.pdf](https://imagej.net/media/manders.pdf)\
\
\[[2](#id195)\
\]\
\
Dunn, K. W., Kamocka, M. M., & McDonald, J. H. (2011). A practical guide to evaluating colocalization in biological microscopy. American journal of physiology. Cell physiology, 300(4), C723–C742. [https://doi.org/10.1152/ajpcell.00462.2010](https://doi.org/10.1152/ajpcell.00462.2010)\
\
cucim.skimage.measure.manders\_overlap\_coeff(_image0_, _image1_, _mask\=None_)[#](#cucim.skimage.measure.manders_overlap_coeff "Permalink to this definition")\
\
Manders’ overlap coefficient\
\
Parameters:\
\
**image0**(M, N) ndarray\
\
Image of channel A. All pixel values should be non-negative.\
\
**image1**(M, N) ndarray\
\
Image of channel B. All pixel values should be non-negative. Must have same dimensions as image0\
\
**mask**(M, N) ndarray of dtype bool, optional\
\
Only image0 and image1 pixel values within this region of interest mask are included in the calculation. Must have same dimensions as image0.\
\
Returns:\
\
moc: float\
\
Manders’ Overlap Coefficient of pixel intensities between the two images.\
\
Notes\
\
Manders’ Overlap Coefficient (MOC) is given by the equation [\[1\]](#rb497c6126263-1)\
:\
\
\\\[r = \\frac{\\sum A\_i B\_i}{\\sqrt{\\sum A\_i^2 \\sum B\_i^2}}\\\]\
\
where\
\
\\(A\_i\\) is the value of the \\(i^{th}\\) pixel in image0 \\(B\_i\\) is the value of the \\(i^{th}\\) pixel in image1\
\
It ranges between 0 for no colocalization and 1 for complete colocalization of all pixels.\
\
MOC does not take into account pixel intensities, just the fraction of pixels that have positive values for both channels\[Rb497c6126263-2\]\_ [\[3\]](#rb497c6126263-3)\
. Its usefulness has been criticized as it changes in response to differences in both co-occurence and correlation and so a particular MOC value could indicate a wide range of colocalization patterns [\[4\]](#rb497c6126263-4)\
[\[5\]](#rb497c6126263-5)\
.\
\
References\
\
\[[1](#id198)\
\]\
\
Manders, E.M.M., Verbeek, F.J. and Aten, J.A. (1993), Measurement of co-localization of objects in dual-colour confocal images. Journal of Microscopy, 169: 375-382. [https://doi.org/10.1111/j.1365-2818.1993.tb03313.x](https://doi.org/10.1111/j.1365-2818.1993.tb03313.x)\
[https://imagej.net/media/manders.pdf](https://imagej.net/media/manders.pdf)\
\
\[2\]\
\
Dunn, K. W., Kamocka, M. M., & McDonald, J. H. (2011). A practical guide to evaluating colocalization in biological microscopy. American journal of physiology. Cell physiology, 300(4), C723–C742. [https://doi.org/10.1152/ajpcell.00462.2010](https://doi.org/10.1152/ajpcell.00462.2010)\
\
\[[3](#id199)\
\]\
\
Bolte, S. and Cordelières, F.P. (2006), A guided tour into subcellular colocalization analysis in light microscopy. Journal of Microscopy, 224: 213-232. [https://doi.org/10.1111/j.1365-2818.2006.01](https://doi.org/10.1111/j.1365-2818.2006.01)\
\
\[[4](#id200)\
\]\
\
Adler J, Parmryd I. (2010), Quantifying colocalization by correlation: the Pearson correlation coefficient is superior to the Mander’s overlap coefficient. Cytometry A. Aug;77(8):733-42.https://doi.org/10.1002/cyto.a.20896\
\
\[[5](#id201)\
\]\
\
Adler, J, Parmryd, I. Quantifying colocalization: The case for discarding the Manders overlap coefficient. Cytometry. 2021; 99: 910– 920. [https://doi.org/10.1002/cyto.a.24336](https://doi.org/10.1002/cyto.a.24336)\
\
cucim.skimage.measure.moments(_image_, _order\=3_, _\*_, _spacing\=None_)[#](#cucim.skimage.measure.moments "Permalink to this definition")\
\
Calculate all raw image moments up to a certain order.\
\
The following properties can be calculated from raw image moments:\
\
* Area as: `M[0, 0]`.\
\
* Centroid as: {`M[1, 0] / M[0, 0]`, `M[0, 1] / M[0, 0]`}.\
\
\
Note that raw moments are neither translation, scale nor rotation invariant.\
\
Parameters:\
\
**image**(N\[, …\]) double or uint8 array\
\
Rasterized shape as image.\
\
**order**int, optional\
\
Maximum order of moments. Default is 3.\
\
**spacing: tuple of float, shape (ndim,)**\
\
The pixel spacing along each axis of the image.\
\
Returns:\
\
**m**(`order + 1`, `order + 1`) array\
\
Raw image moments.\
\
References\
\
\[1\]\
\
Wilhelm Burger, Mark Burge. Principles of Digital Image Processing: Core Algorithms. Springer-Verlag, London, 2009.\
\
\[2\]\
\
B. Jähne. Digital Image Processing. Springer-Verlag, Berlin-Heidelberg, 6. edition, 2005.\
\
\[3\]\
\
T. H. Reiss. Recognizing Planar Objects Using Invariant Image Features, from Lecture notes in computer science, p. 676. Springer, Berlin, 1993.\
\
\[4\]\
\
[https://en.wikipedia.org/wiki/Image\_moment](https://en.wikipedia.org/wiki/Image_moment)\
\
Examples\
\
\>>> import cupy as cp\
\>>> from cucim.skimage.measure import moments\
\>>> image \= cp.zeros((20, 20), dtype\=cp.float64)\
\>>> image\[13:17, 13:17\] \= 1\
\>>> M \= moments(image)\
\>>> centroid \= (M\[1, 0\] / M\[0, 0\], M\[0, 1\] / M\[0, 0\])\
\>>> centroid\
(array(14.5), array(14.5))\
\
cucim.skimage.measure.moments\_central(_image_, _center\=None_, _order\=3_, _\*_, _spacing\=None_, _\*\*kwargs_)[#](#cucim.skimage.measure.moments_central "Permalink to this definition")\
\
Calculate all central image moments up to a certain order.\
\
The center coordinates (cr, cc) can be calculated from the raw moments as: {`M[1, 0] / M[0, 0]`, `M[0, 1] / M[0, 0]`}.\
\
Note that central moments are translation invariant but not scale and rotation invariant.\
\
Parameters:\
\
**image**(N\[, …\]) double or uint8 array\
\
Rasterized shape as image.\
\
**center**tuple of float, optional\
\
Coordinates of the image centroid. This will be computed if it is not provided.\
\
**order**int, optional\
\
The maximum order of moments computed.\
\
**spacing: tuple of float, shape (ndim,)**\
\
The pixel spacing along each axis of the image.\
\
Returns:\
\
**mu**(`order + 1`, `order + 1`) array\
\
Central image moments.\
\
References\
\
\[1\]\
\
Wilhelm Burger, Mark Burge. Principles of Digital Image Processing: Core Algorithms. Springer-Verlag, London, 2009.\
\
\[2\]\
\
B. Jähne. Digital Image Processing. Springer-Verlag, Berlin-Heidelberg, 6. edition, 2005.\
\
\[3\]\
\
T. H. Reiss. Recognizing Planar Objects Using Invariant Image Features, from Lecture notes in computer science, p. 676. Springer, Berlin, 1993.\
\
\[4\]\
\
[https://en.wikipedia.org/wiki/Image\_moment](https://en.wikipedia.org/wiki/Image_moment)\
\
Examples\
\
\>>> import cupy as cp\
\>>> from cucim.skimage.measure import moments, moments\_central\
\>>> image \= cp.zeros((20, 20), dtype\=cp.float64)\
\>>> image\[13:17, 13:17\] \= 1\
\>>> M \= moments(image)\
\>>> centroid \= (M\[1, 0\] / M\[0, 0\], M\[0, 1\] / M\[0, 0\])\
\>>> moments\_central(image, centroid)\
array(\[\[16., 0., 20., 0.\],\
\[ 0., 0., 0., 0.\],\
\[20., 0., 25., 0.\],\
\[ 0., 0., 0., 0.\]\])\
\
cucim.skimage.measure.moments\_coords(_coords_, _order\=3_)[#](#cucim.skimage.measure.moments_coords "Permalink to this definition")\
\
Calculate all raw image moments up to a certain order.\
\
The following properties can be calculated from raw image moments:\
\
* Area as: `M[0, 0]`.\
\
* Centroid as: {`M[1, 0] / M[0, 0]`, `M[0, 1] / M[0, 0]`}.\
\
\
Note that raw moments are neither translation, scale, nor rotation invariant.\
\
Parameters:\
\
**coords**(N, D) double or uint8 array\
\
Array of N points that describe an image of D dimensionality in Cartesian space.\
\
**order**int, optional\
\
Maximum order of moments. Default is 3.\
\
Returns:\
\
**M**(`order + 1`, `order + 1`, …) array\
\
Raw image moments. (D dimensions)\
\
References\
\
\[1\]\
\
Johannes Kilian. Simple Image Analysis By Moments. Durham University, version 0.2, Durham, 2001.\
\
Examples\
\
\>>> import cupy as cp\
\>>> from cucim.skimage.measure import moments\_coords\
\>>> coords \= cp.array(\[\[row, col\]\
... for row in range(13, 17)\
... for col in range(14, 18)\], dtype\=cp.float64)\
\>>> M \= moments\_coords(coords)\
\>>> centroid \= (M\[1, 0\] / M\[0, 0\], M\[0, 1\] / M\[0, 0\])\
\>>> centroid\
(array(14.5), array(15.5))\
\
cucim.skimage.measure.moments\_coords\_central(_coords_, _center\=None_, _order\=3_)[#](#cucim.skimage.measure.moments_coords_central "Permalink to this definition")\
\
Calculate all central image moments up to a certain order.\
\
The following properties can be calculated from raw image moments:\
\
* Area as: `M[0, 0]`.\
\
* Centroid as: {`M[1, 0] / M[0, 0]`, `M[0, 1] / M[0, 0]`}.\
\
\
Note that raw moments are neither translation, scale nor rotation invariant.\
\
Parameters:\
\
**coords**(N, D) double or uint8 array\
\
Array of N points that describe an image of D dimensionality in Cartesian space. A tuple of coordinates as returned by `cp.nonzero` is also accepted as input.\
\
**center**tuple of float, optional\
\
Coordinates of the image centroid. This will be computed if it is not provided.\
\
**order**int, optional\
\
Maximum order of moments. Default is 3.\
\
Returns:\
\
**Mc**(`order + 1`, `order + 1`, …) array\
\
Central image moments. (D dimensions)\
\
References\
\
\[1\]\
\
Johannes Kilian. Simple Image Analysis By Moments. Durham University, version 0.2, Durham, 2001.\
\
Examples\
\
\>>> import cupy as cp\
\>>> from cucim.skimage.measure import moments\_coords\_central\
\>>> coords \= cp.array(\[\[row, col\]\
... for row in range(13, 17)\
... for col in range(14, 18)\])\
\>>> moments\_coords\_central(coords)\
array(\[\[16., 0., 20., 0.\],\
\[ 0., 0., 0., 0.\],\
\[20., 0., 25., 0.\],\
\[ 0., 0., 0., 0.\]\])\
\
As seen above, for symmetric objects, odd-order moments (columns 1 and 3, rows 1 and 3) are zero when centered on the centroid, or center of mass, of the object (the default). If we break the symmetry by adding a new point, this no longer holds:\
\
\>>> coords2 \= cp.concatenate((coords, cp.array(\[\[17, 17\]\])), axis\=0)\
\>>> cp.around(moments\_coords\_central(coords2),\
... decimals\=2) \
array(\[\[17. , 0. , 22.12, -2.49\],\
\[ 0. , 3.53, 1.73, 7.4 \],\
\[25.88, 6.02, 36.63, 8.83\],\
\[ 4.15, 19.17, 14.8 , 39.6 \]\])\
\
Image moments and central image moments are equivalent (by definition) when the center is (0, 0):\
\
\>>> cp.allclose(moments\_coords(coords),\
... moments\_coords\_central(coords, (0, 0)))\
array(True)\
\
cucim.skimage.measure.moments\_hu(_nu_)[#](#cucim.skimage.measure.moments_hu "Permalink to this definition")\
\
Calculate Hu’s set of image moments (2D-only).\
\
Note that this set of moments is proved to be translation, scale and rotation invariant.\
\
Parameters:\
\
**nu**(M, M) array\
\
Normalized central image moments, where M must be >= 4.\
\
Returns:\
\
**nu**(7,) array\
\
Hu’s set of image moments.\
\
Notes\
\
Due to the small array sizes, this function will be faster on the CPU. Consider transferring `nu` to the host and running `skimage.measure.moments_hu` if the moments are not needed on the device.\
\
References\
\
\[1\]\
\
M. K. Hu, “Visual Pattern Recognition by Moment Invariants”, IRE Trans. Info. Theory, vol. IT-8, pp. 179-187, 1962\
\
\[2\]\
\
Wilhelm Burger, Mark Burge. Principles of Digital Image Processing: Core Algorithms. Springer-Verlag, London, 2009.\
\
\[3\]\
\
B. Jähne. Digital Image Processing. Springer-Verlag, Berlin-Heidelberg, 6. edition, 2005.\
\
\[4\]\
\
T. H. Reiss. Recognizing Planar Objects Using Invariant Image Features, from Lecture notes in computer science, p. 676. Springer, Berlin, 1993.\
\
\[5\]\
\
[https://en.wikipedia.org/wiki/Image\_moment](https://en.wikipedia.org/wiki/Image_moment)\
\
Examples\
\
\>>> import cupy as cp\
\>>> from cucim.skimage.measure import (moments\_central, moments\_hu,\
... moments\_normalized)\
\>>> image \= cp.zeros((20, 20), dtype\=np.float64)\
\>>> image\[13:17, 13:17\] \= 0.5\
\>>> image\[10:12, 10:12\] \= 1\
\>>> mu \= moments\_central(image)\
\>>> nu \= moments\_normalized(mu)\
\>>> moments\_hu(nu)\
array(\[7.45370370e-01, 3.51165981e-01, 1.04049179e-01, 4.06442107e-02,\
2.64312299e-03, 2.40854582e-02, 6.50521303e-19\])\
\
cucim.skimage.measure.moments\_normalized(_mu_, _order\=3_, _spacing\=None_)[#](#cucim.skimage.measure.moments_normalized "Permalink to this definition")\
\
Calculate all normalized central image moments up to a certain order.\
\
Note that normalized central moments are translation and scale invariant but not rotation invariant.\
\
Parameters:\
\
**mu**(M\[, …\], M) array\
\
Central image moments, where M must be greater than or equal to `order`.\
\
**order**int, optional\
\
Maximum order of moments. Default is 3.\
\
**spacing: tuple of float, shape (ndim,)**\
\
The pixel spacing along each axis of the image.\
\
Returns:\
\
**nu**(`order + 1``[, ...], ``order + 1`) array\
\
Normalized central image moments.\
\
Notes\
\
Differs from the scikit-image implementation in that any moments greater than the requested order will be set to `nan`.\
\
References\
\
\[1\]\
\
Wilhelm Burger, Mark Burge. Principles of Digital Image Processing: Core Algorithms. Springer-Verlag, London, 2009.\
\
\[2\]\
\
B. Jähne. Digital Image Processing. Springer-Verlag, Berlin-Heidelberg, 6. edition, 2005.\
\
\[3\]\
\
T. H. Reiss. Recognizing Planar Objects Using Invariant Image Features, from Lecture notes in computer science, p. 676. Springer, Berlin, 1993.\
\
\[4\]\
\
[https://en.wikipedia.org/wiki/Image\_moment](https://en.wikipedia.org/wiki/Image_moment)\
\
Examples\
\
\>>> import cupy as cp\
\>>> from cucim.skimage.measure import (moments, moments\_central,\
... moments\_normalized)\
\>>> image \= cp.zeros((20, 20), dtype\=cp.float64)\
\>>> image\[13:17, 13:17\] \= 1\
\>>> m \= moments(image)\
\>>> centroid \= (m\[0, 1\] / m\[0, 0\], m\[1, 0\] / m\[0, 0\])\
\>>> mu \= moments\_central(image, centroid)\
\>>> moments\_normalized(mu)\
array(\[\[ nan, nan, 0.078125 , 0. \],\
\[ nan, 0. , 0. , 0. \],\
\[0.078125 , 0. , 0.00610352, 0. \],\
\[0. , 0. , 0. , 0. \]\])\
\
cucim.skimage.measure.pearson\_corr\_coeff(_image0_, _image1_, _mask\=None_)[#](#cucim.skimage.measure.pearson_corr_coeff "Permalink to this definition")\
\
Calculate Pearson’s Correlation Coefficient between pixel intensities in channels.\
\
Parameters:\
\
**image0**(M, N) ndarray\
\
Image of channel A.\
\
**image1**(M, N) ndarray\
\
Image of channel 2 to be correlated with channel B. Must have same dimensions as image0.\
\
**mask**(M, N) ndarray of dtype bool, optional\
\
Only image0 and image1 pixels within this region of interest mask are included in the calculation. Must have same dimensions as image0.\
\
Returns:\
\
**pcc**float\
\
Pearson’s correlation coefficient of the pixel intensities between the two images, within the mask if provided.\
\
**p-value**float\
\
Two-tailed p-value.\
\
Notes\
\
Pearson’s Correlation Coefficient (PCC) measures the linear correlation between the pixel intensities of the two images. Its value ranges from -1 for perfect linear anti-correlation to +1 for perfect linear correlation. The calculation of the p-value assumes that the intensities of pixels in each input image are normally distributed.\
\
Scipy’s implementation of Pearson’s correlation coefficient is used. Please refer to it for further information and caveats [\[1\]](#rbf59d2a1d417-1)\
.\
\
\\\[r = \\frac{\\sum (A\_i - m\_A\_i) (B\_i - m\_B\_i)} {\\sqrt{\\sum (A\_i - m\_A\_i)^2 \\sum (B\_i - m\_B\_i)^2}}\\\]\
\
where\
\
\\(A\_i\\) is the value of the \\(i^{th}\\) pixel in image0 \\(B\_i\\) is the value of the \\(i^{th}\\) pixel in image1, \\(m\_A\_i\\) is the mean of the pixel values in image0 \\(m\_B\_i\\) is the mean of the pixel values in image1\
\
A low PCC value does not necessarily mean that there is no correlation between the two channel intensities, just that there is no linear correlation. You may wish to plot the pixel intensities of each of the two channels in a 2D scatterplot and use Spearman’s rank correlation if a non-linear correlation is visually identified [\[2\]](#rbf59d2a1d417-2)\
. Also consider if you are interested in correlation or co-occurence, in which case a method involving segmentation masks (e.g. MCC or intersection coefficient) may be more suitable [\[3\]](#rbf59d2a1d417-3)\
[\[4\]](#rbf59d2a1d417-4)\
.\
\
Providing the mask of only relevant sections of the image (e.g., cells, or particular cellular compartments) and removing noise is important as the PCC is sensitive to these measures [\[3\]](#rbf59d2a1d417-3)\
[\[4\]](#rbf59d2a1d417-4)\
.\
\
References\
\
\[[1](#id226)\
\]\
\
[https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.pearsonr.html](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.pearsonr.html)\
\
\[[2](#id227)\
\]\
\
[https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.spearmanr.html](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.spearmanr.html)\
\
\[3\] ([1](#id228)\
,[2](#id230)\
)\
\
Dunn, K. W., Kamocka, M. M., & McDonald, J. H. (2011). A practical guide to evaluating colocalization in biological microscopy. American journal of physiology. Cell physiology, 300(4), C723–C742. [https://doi.org/10.1152/ajpcell.00462.2010](https://doi.org/10.1152/ajpcell.00462.2010)\
\
\[4\] ([1](#id229)\
,[2](#id231)\
)\
\
Bolte, S. and Cordelières, F.P. (2006), A guided tour into subcellular colocalization analysis in light microscopy. Journal of Microscopy, 224: 213-232. [https://doi.org/10.1111/j.1365-2818.2006.01706.x](https://doi.org/10.1111/j.1365-2818.2006.01706.x)\
\
cucim.skimage.measure.perimeter(_image_, _neighborhood\=4_)[#](#cucim.skimage.measure.perimeter "Permalink to this definition")\
\
Calculate total perimeter of all objects in binary image.\
\
Parameters:\
\
**image**(M, N) ndarray\
\
Binary input image.\
\
**neighborhood**4 or 8, optional\
\
Neighborhood connectivity for border pixel determination. It is used to compute the contour. A higher neighborhood widens the border on which the perimeter is computed.\
\
Returns:\
\
**perimeter**float\
\
Total perimeter of all objects in binary image.\
\
References\
\
\[1\]\
\
K. Benkrid, D. Crookes. Design and FPGA Implementation of a Perimeter Estimator. The Queen’s University of Belfast. [http://www.cs.qub.ac.uk/~d.crookes/webpubs/papers/perimeter.doc](http://www.cs.qub.ac.uk/~d.crookes/webpubs/papers/perimeter.doc)\
\
Examples\
\
\>>> import cupy as cp\
\>>> from skimage import data\
\>>> from cucim.skimage import util\
\>>> from cucim.skimage.measure import label\
\>>> \# coins image (binary)\
\>>> img\_coins \= cp.array(data.coins() \> 110)\
\>>> \# total perimeter of all objects in the image\
\>>> perimeter(img\_coins, neighborhood\=4) \
array(7796.86799644)\
\>>> perimeter(img\_coins, neighborhood\=8) \
array(8806.26807333)\
\
cucim.skimage.measure.perimeter\_crofton(_image_, _directions\=4_)[#](#cucim.skimage.measure.perimeter_crofton "Permalink to this definition")\
\
Calculate total Crofton perimeter of all objects in binary image.\
\
Parameters:\
\
**image**(M, N) ndarray\
\
Input image. If image is not binary, all values greater than zero are considered as the object.\
\
**directions**2 or 4, optional\
\
Number of directions used to approximate the Crofton perimeter. By default, 4 is used: it should be more accurate than 2. Computation time is the same in both cases.\
\
Returns:\
\
**perimeter**float\
\
Total perimeter of all objects in binary image.\
\
Notes\
\
This measure is based on Crofton formula \[1\], which is a measure from integral geometry. It is defined for general curve length evaluation via a double integral along all directions. In a discrete space, 2 or 4 directions give a quite good approximation, 4 being more accurate than 2 for more complex shapes.\
\
Similar to [`perimeter()`](#cucim.skimage.measure.perimeter "cucim.skimage.measure.perimeter")\
, this function returns an approximation of the perimeter in continuous space.\
\
References\
\
\[1\]\
\
[https://en.wikipedia.org/wiki/Crofton\_formula](https://en.wikipedia.org/wiki/Crofton_formula)\
\
\[2\]\
\
S. Rivollier. Analyse d’image geometrique et morphometrique par diagrammes de forme et voisinages adaptatifs generaux. PhD thesis, 2010. Ecole Nationale Superieure des Mines de Saint-Etienne. [https://tel.archives-ouvertes.fr/tel-00560838](https://tel.archives-ouvertes.fr/tel-00560838)\
\
Examples\
\
\>>> import cupy as cp\
\>>> from cucim.skimage import util\
\>>> from skimage import data\
\>>> from skimage.measure import label\
\>>> \# coins image (binary)\
\>>> img\_coins \= cp.array(data.coins() \> 110)\
\>>> \# total perimeter of all objects in the image\
\>>> perimeter\_crofton(img\_coins, directions\=2) \
array(8144.57895443)\
\>>> perimeter\_crofton(img\_coins, directions\=4) \
array(7837.07740694)\
\
cucim.skimage.measure.profile\_line(_image_, _src_, _dst_, _linewidth=1_, _order=None_, _mode='reflect'_, _cval=0.0_, _\*_, _reduce\_func=_)[#](#cucim.skimage.measure.profile_line "Permalink to this definition")\
\
Return the intensity profile of an image measured along a scan line.\
\
Parameters:\
\
**image**ndarray, shape (M, N\[, C\])\
\
The image, either grayscale (2D array) or multichannel (3D array, where the final axis contains the channel information).\
\
**src**array\_like, shape (2,)\
\
The coordinates of the start point of the scan line.\
\
**dst**array\_like, shape (2,)\
\
The coordinates of the end point of the scan line. The destination point is _included_ in the profile, in contrast to standard numpy indexing.\
\
**linewidth**int, optional\
\
Width of the scan, perpendicular to the line\
\
**order**int in {0, 1, 2, 3, 4, 5}, optional\
\
The order of the spline interpolation, default is 0 if image.dtype is bool and 1 otherwise. The order has to be in the range 0-5. See skimage.transform.warp for detail.\
\
**mode**{‘constant’, ‘nearest’, ‘reflect’, ‘mirror’, ‘wrap’}, optional\
\
How to compute any values falling outside of the image.\
\
**cval**float, optional\
\
If mode is ‘constant’, what constant value to use outside the image.\
\
**reduce\_func**callable, optional\
\
Function used to calculate the aggregation of pixel values perpendicular to the profile\_line direction when linewidth > 1. If set to None the unreduced array will be returned.\
\
Returns:\
\
**return\_value**array\
\
The intensity profile along the scan line. The length of the profile is the ceil of the computed length of the scan line.\
\
Examples\
\
\>>> import cupy as cp\
\>>> x \= cp.asarray(\[\[1, 1, 1, 2, 2, 2\]\])\
\>>> img \= cp.vstack(\[cp.zeros\_like(x), x, x, x, cp.zeros\_like(x)\])\
\>>> img\
array(\[\[0, 0, 0, 0, 0, 0\],\
\[1, 1, 1, 2, 2, 2\],\
\[1, 1, 1, 2, 2, 2\],\
\[1, 1, 1, 2, 2, 2\],\
\[0, 0, 0, 0, 0, 0\]\])\
\>>> profile\_line(img, (2, 1), (2, 4))\
array(\[1., 1., 2., 2.\])\
\>>> profile\_line(img, (1, 0), (1, 6), cval\=4)\
array(\[1., 1., 1., 2., 2., 2., 2.\])\
\
The destination point is included in the profile, in contrast to standard numpy indexing. For example:\
\
\>>> profile\_line(img, (1, 0), (1, 6)) \# The final point is out of bounds\
array(\[1., 1., 1., 2., 2., 2., 2.\])\
\>>> profile\_line(img, (1, 0), (1, 5)) \# This accesses the full first row\
array(\[1., 1., 1., 2., 2., 2.\])\
\
For different reduce\_func inputs:\
\
\>>> profile\_line(img, (1, 0), (1, 3), linewidth\=3, reduce\_func\=cp.mean)\
array(\[0.66666667, 0.66666667, 0.66666667, 1.33333333\])\
\>>> profile\_line(img, (1, 0), (1, 3), linewidth\=3, reduce\_func\=cp.max)\
array(\[1, 1, 1, 2\])\
\>>> profile\_line(img, (1, 0), (1, 3), linewidth\=3, reduce\_func\=cp.sum)\
array(\[2, 2, 2, 4\])\
\
The unreduced array will be returned when reduce\_func is None or when reduce\_func acts on each pixel value individually.\
\
\>>> profile\_line(img, (1, 2), (4, 2), linewidth\=3, order\=0,\
... reduce\_func\=None)\
array(\[\[1, 1, 2\],\
\[1, 1, 2\],\
\[1, 1, 2\],\
\[0, 0, 0\]\])\
\>>> profile\_line(img, (1, 0), (1, 3), linewidth\=3, reduce\_func\=cp.sqrt)\
array(\[\[1. , 1. , 0. \],\
\[1. , 1. , 0. \],\
\[1. , 1. , 0. \],\
\[1.41421356, 1.41421356, 0. \]\])\
\
cucim.skimage.measure.regionprops(_label\_image_, _intensity\_image\=None_, _cache\=True_, _\*_, _extra\_properties\=None_, _spacing\=None_)[#](#cucim.skimage.measure.regionprops "Permalink to this definition")\
\
Measure properties of labeled image regions.\
\
Parameters:\
\
**label\_image**(M, N\[, P\]) ndarray\
\
Labeled input image. Labels with value 0 are ignored.\
\
Changed in version 0.14.1: Previously, `label_image` was processed by `numpy.squeeze` and so any number of singleton dimensions was allowed. This resulted in inconsistent handling of images with singleton dimensions. To recover the old behaviour, use `regionprops(np.squeeze(label_image), ...)`.\
\
**intensity\_image**(M, N\[, P\]\[, C\]) ndarray, optional\
\
Intensity (i.e., input) image with same size as labeled image, plus optionally an extra dimension for multichannel data. Currently, this extra channel dimension, if present, must be the last axis. Default is None.\
\
Changed in version 0.18.0: The ability to provide an extra dimension for channels was added.\
\
**cache**bool, optional\
\
Determine whether to cache calculated properties. The computation is much faster for cached properties, whereas the memory consumption increases.\
\
**extra\_properties**Iterable of callables\
\
Add extra property computation functions that are not included with skimage. The name of the property is derived from the function name, the dtype is inferred by calling the function on a small sample. If the name of an extra property clashes with the name of an existing property the extra property will not be visible and a UserWarning is issued. A property computation function must take a region mask as its first argument. If the property requires an intensity image, it must accept the intensity image as the second argument.\
\
**spacing: tuple of float, shape (ndim,)**\
\
The pixel spacing along each axis of the image.\
\
Returns:\
\
**properties**list of RegionProperties\
\
Each item describes one labeled region, and can be accessed using the attributes listed below.\
\
See also\
\
[`label`](#cucim.skimage.measure.label "cucim.skimage.measure.label")\
\
Notes\
\
The following properties can be accessed as attributes or keys:\
\
**num\_pixels**int\
\
Number of foreground pixels.\
\
**area**float\
\
Area of the region i.e. number of pixels of the region scaled by pixel-area.\
\
**area\_bbox**float\
\
Area of the bounding box i.e. number of pixels of bounding box scaled by pixel-area.\
\
**area\_convex**float\
\
Are of the convex hull image, which is the smallest convex polygon that encloses the region.\
\
**area\_filled**float\
\
Area of the region with all the holes filled in.\
\
**axis\_major\_length**float\
\
The length of the major axis of the ellipse that has the same normalized second central moments as the region.\
\
**axis\_minor\_length**float\
\
The length of the minor axis of the ellipse that has the same normalized second central moments as the region.\
\
**bbox**tuple\
\
Bounding box `(min_row, min_col, max_row, max_col)`. Pixels belonging to the bounding box are in the half-open interval `[min_row; max_row)` and `[min_col; max_col)`.\
\
**centroid**array\
\
Centroid coordinate tuple `(row, col)`.\
\
**centroid\_local**array\
\
Centroid coordinate tuple `(row, col)`, relative to region bounding box.\
\
**centroid\_weighted**array\
\
Centroid coordinate tuple `(row, col)` weighted with intensity image.\
\
**centroid\_weighted\_local**array\
\
Centroid coordinate tuple `(row, col)`, relative to region bounding box, weighted with intensity image.\
\
**coords\_scaled**(K, 2) ndarray\
\
Coordinate list `(row, col)` of the region scaled by `spacing`.\
\
**coords**(K, 2) ndarray\
\
Coordinate list `(row, col)` of the region.\
\
**eccentricity**float\
\
Eccentricity of the ellipse that has the same second-moments as the region. The eccentricity is the ratio of the focal distance (distance between focal points) over the major axis length. The value is in the interval \[0, 1). When it is 0, the ellipse becomes a circle.\
\
**equivalent\_diameter\_area**float\
\
The diameter of a circle with the same area as the region.\
\
**euler\_number**int\
\
Euler characteristic of the set of non-zero pixels. Computed as number of connected components subtracted by number of holes (input.ndim connectivity). In 3D, number of connected components plus number of holes subtracted by number of tunnels.\
\
**extent**float\
\
Ratio of pixels in the region to pixels in the total bounding box. Computed as `area / (rows * cols)`\
\
**feret\_diameter\_max**float\
\
Maximum Feret’s diameter computed as the longest distance between points around a region’s convex hull contour as determined by `find_contours`. [\[5\]](#r357b1e388f3a-5)\
\
**image**(H, J) ndarray\
\
Sliced binary region image which has the same size as bounding box.\
\
**image\_convex**(H, J) ndarray\
\
Binary convex hull image which has the same size as bounding box.\
\
**image\_filled**(H, J) ndarray\
\
Binary region image with filled holes which has the same size as bounding box.\
\
**image\_intensity**ndarray\
\
Image inside region bounding box.\
\
**inertia\_tensor**ndarray\
\
Inertia tensor of the region for the rotation around its mass.\
\
**inertia\_tensor\_eigvals**tuple\
\
The eigenvalues of the inertia tensor in decreasing order.\
\
**intensity\_max**float\
\
Value with the greatest intensity in the region.\
\
**intensity\_mean**float\
\
Value with the mean intensity in the region.\
\
**intensity\_min**float\
\
Value with the least intensity in the region.\
\
**intensity\_std**float\
\
Standard deviation of the intensity in the region.\
\
**label**int\
\
The label in the labeled input image.\
\
**moments**(3, 3) ndarray\
\
Spatial moments up to 3rd order:\
\
m\_ij \= sum{ array(row, col) \* row^i \* col^j }\
\
where the sum is over the row, col coordinates of the region.\
\
**moments\_central**(3, 3) ndarray\
\
Central moments (translation invariant) up to 3rd order:\
\
mu\_ij \= sum{ array(row, col) \* (row \- row\_c)^i \* (col \- col\_c)^j }\
\
where the sum is over the row, col coordinates of the region, and row\_c and col\_c are the coordinates of the region’s centroid.\
\
**moments\_hu**tuple\
\
Hu moments (translation, scale and rotation invariant).\
\
**moments\_normalized**(3, 3) ndarray\
\
Normalized moments (translation and scale invariant) up to 3rd order:\
\
nu\_ij \= mu\_ij / m\_00^\[(i+j)/2 + 1\]\
\
where m\_00 is the zeroth spatial moment.\
\
**moments\_weighted**(3, 3) ndarray\
\
Spatial moments of intensity image up to 3rd order:\
\
wm\_ij \= sum{ array(row, col) \* row^i \* col^j }\
\
where the sum is over the row, col coordinates of the region.\
\
**moments\_weighted\_central**(3, 3) ndarray\
\
Central moments (translation invariant) of intensity image up to 3rd order:\
\
wmu\_ij \= sum{ array(row, col) \* (row \- row\_c)^i \* (col \- col\_c)^j }\
\
where the sum is over the row, col coordinates of the region, and row\_c and col\_c are the coordinates of the region’s weighted centroid.\
\
**moments\_weighted\_hu**tuple\
\
Hu moments (translation, scale and rotation invariant) of intensity image.\
\
**moments\_weighted\_normalized**(3, 3) ndarray\
\
Normalized moments (translation and scale invariant) of intensity image up to 3rd order:\
\
wnu\_ij \= wmu\_ij / wm\_00^\[(i+j)/2 + 1\]\
\
where `wm_00` is the zeroth spatial moment (intensity-weighted area).\
\
**orientation**float\
\
Angle between the 0th axis (rows) and the major axis of the ellipse that has the same second moments as the region, ranging from \-pi/2 to pi/2 counter-clockwise.\
\
**perimeter**float\
\
Perimeter of object which approximates the contour as a line through the centers of border pixels using a 4-connectivity.\
\
**perimeter\_crofton**float\
\
Perimeter of object approximated by the Crofton formula in 4 directions.\
\
**slice**tuple of slices\
\
A slice to extract the object from the source image.\
\
**solidity**float\
\
Ratio of pixels in the region to pixels of the convex hull image.\
\
Each region also supports iteration, so that you can do:\
\
for prop in region:\
print(prop, region\[prop\])\
\
References\
\
\[1\]\
\
Wilhelm Burger, Mark Burge. Principles of Digital Image Processing: Core Algorithms. Springer-Verlag, London, 2009.\
\
\[2\]\
\
B. Jähne. Digital Image Processing. Springer-Verlag, Berlin-Heidelberg, 6. edition, 2005.\
\
\[3\]\
\
T. H. Reiss. Recognizing Planar Objects Using Invariant Image Features, from Lecture notes in computer science, p. 676. Springer, Berlin, 1993.\
\
\[4\]\
\
[https://en.wikipedia.org/wiki/Image\_moment](https://en.wikipedia.org/wiki/Image_moment)\
\
\[[5](#id239)\
\]\
\
W. Pabst, E. Gregorová. Characterization of particles and particle systems, pp. 27-28. ICT Prague, 2007. [https://old.vscht.cz/sil/keramika/Characterization\_of\_particles/CPPS%20\_English%20version\_.pdf](https://old.vscht.cz/sil/keramika/Characterization_of_particles/CPPS%20_English%20version_.pdf)\
\
Examples\
\
\>>> from skimage import data, util\
\>>> from cucim.skimage.measure import label, regionprops\
\>>> img \= cp.asarray(util.img\_as\_ubyte(data.coins()) \> 110)\
\>>> label\_img \= label(img, connectivity\=img.ndim)\
\>>> props \= regionprops(label\_img)\
\>>> \# centroid of first labeled object\
\>>> props\[0\].centroid\
(22.72987986048314, 81.91228523446583)\
\>>> \# centroid of first labeled object\
\>>> props\[0\]\['centroid'\]\
(22.72987986048314, 81.91228523446583)\
\
Add custom measurements by passing functions as `extra_properties`\
\
\>>> from skimage import data, util\
\>>> from cucim.skimage.measure import label, regionprops\
\>>> import numpy as np\
\>>> img \= cp.asarray(util.img\_as\_ubyte(data.coins()) \> 110)\
\>>> label\_img \= label(img, connectivity\=img.ndim)\
\>>> def pixelcount(regionmask):\
... return np.sum(regionmask)\
\>>> props \= regionprops(label\_img, extra\_properties\=(pixelcount,))\
\>>> props\[0\].pixelcount\
array(7741)\
\>>> props\[1\]\['pixelcount'\]\
array(42)\
\
cucim.skimage.measure.regionprops\_table(_label\_image_, _intensity\_image\=None_, _properties\=('label', 'bbox')_, _\*_, _cache\=True_, _separator\='-'_, _extra\_properties\=None_, _spacing\=None_)[#](#cucim.skimage.measure.regionprops_table "Permalink to this definition")\
\
Compute image properties and return them as a pandas-compatible table.\
\
The table is a dictionary mapping column names to value arrays. See Notes section below for details.\
\
New in version 0.16.\
\
Parameters:\
\
**label\_image**(M, N\[, P\]) ndarray\
\
Labeled input image. Labels with value 0 are ignored.\
\
**intensity\_image**(M, N\[, P\]\[, C\]) ndarray, optional\
\
Intensity (i.e., input) image with same size as labeled image, plus optionally an extra dimension for multichannel data. The channel dimension, if present, must be the last axis. Default is None.\
\
Changed in version 0.18.0: The ability to provide an extra dimension for channels was added.\
\
**properties**tuple or list of str, optional\
\
Properties that will be included in the resulting dictionary For a list of available properties, please see [`regionprops()`](#cucim.skimage.measure.regionprops "cucim.skimage.measure.regionprops")\
. Users should remember to add “label” to keep track of region identities.\
\
**cache**bool, optional\
\
Determine whether to cache calculated properties. The computation is much faster for cached properties, whereas the memory consumption increases.\
\
**separator**str, optional\
\
For non-scalar properties not listed in OBJECT\_COLUMNS, each element will appear in its own column, with the index of that element separated from the property name by this separator. For example, the inertia tensor of a 2D region will appear in four columns: `inertia_tensor-0-0`, `inertia_tensor-0-1`, `inertia_tensor-1-0`, and `inertia_tensor-1-1` (where the separator is `-`).\
\
Object columns are those that cannot be split in this way because the number of columns would change depending on the object. For example, `image` and `coords`.\
\
**extra\_properties**Iterable of callables\
\
Add extra property computation functions that are not included with skimage. The name of the property is derived from the function name, the dtype is inferred by calling the function on a small sample. If the name of an extra property clashes with the name of an existing property the extra property will not be visible and a UserWarning is issued. A property computation function must take a region mask as its first argument. If the property requires an intensity image, it must accept the intensity image as the second argument.\
\
**spacing: tuple of float, shape (ndim,)**\
\
The pixel spacing along each axis of the image.\
\
Returns:\
\
**out\_dict**dict\
\
Dictionary mapping property names to an array of values of that property, one value per region. This dictionary can be used as input to pandas `DataFrame` to map property names to columns in the frame and regions to rows. If the image has no regions, the arrays will have length 0, but the correct type.\
\
Notes\
\
Each column contains either a scalar property, an object property, or an element in a multidimensional array.\
\
Properties with scalar values for each region, such as “eccentricity”, will appear as a float or int array with that property name as key.\
\
Multidimensional properties _of fixed size_ for a given image dimension, such as “centroid” (every centroid will have three elements in a 3D image, no matter the region size), will be split into that many columns, with the name {property\_name}{separator}{element\_num} (for 1D properties), {property\_name}{separator}{elem\_num0}{separator}{elem\_num1} (for 2D properties), and so on.\
\
For multidimensional properties that don’t have a fixed size, such as “image” (the image of a region varies in size depending on the region size), an object array will be used, with the corresponding property name as the key.\
\
Examples\
\
\>>> from skimage import data, util, measure\
\>>> image \= data.coins()\
\>>> label\_image \= measure.label(image \> 110, connectivity\=image.ndim)\
\>>> props \= measure.regionprops\_table(label\_image, image,\
... properties\=\['label', 'inertia\_tensor',\
... 'inertia\_tensor\_eigvals'\])\
\>>> props \
{'label': array(\[ 1, 2, ...\]), ...\
'inertia\_tensor-0-0': array(\[ 4.012...e+03, 8.51..., ...\]), ...\
...,\
'inertia\_tensor\_eigvals-1': array(\[ 2.67...e+02, 2.83..., ...\])}\
\
The resulting dictionary can be directly passed to pandas, if installed, to obtain a clean DataFrame:\
\
\>>> import pandas as pd \
\>>> data \= pd.DataFrame(props) \
\>>> data.head() \
label inertia\_tensor-0-0 ... inertia\_tensor\_eigvals-1\
0 1 4012.909888 ... 267.065503\
1 2 8.514739 ... 2.834806\
2 3 0.666667 ... 0.000000\
3 4 0.000000 ... 0.000000\
4 5 0.222222 ... 0.111111\
\
\[5 rows x 7 columns\]\
\
If we want to measure a feature that does not come as a built-in property, we can define custom functions and pass them as `extra_properties`. For example, we can create a custom function that measures the intensity quartiles in a region:\
\
\>>> from skimage import data, util, measure\
\>>> import numpy as np\
\>>> def quartiles(regionmask, intensity):\
... return np.percentile(intensity\[regionmask\], q\=(25, 50, 75))\
\>>>\
\>>> image \= data.coins()\
\>>> label\_image \= measure.label(image \> 110, connectivity\=image.ndim)\
\>>> props \= measure.regionprops\_table(label\_image, intensity\_image\=image,\
... properties\=('label',),\
... extra\_properties\=(quartiles,))\
\>>> import pandas as pd \
\>>> pd.DataFrame(props).head() \
label quartiles-0 quartiles-1 quartiles-2\
0 1 117.00 123.0 130.0\
1 2 111.25 112.0 114.0\
2 3 111.00 111.0 111.0\
3 4 111.00 111.5 112.5\
4 5 112.50 113.0 114.0\
\
cucim.skimage.measure.shannon\_entropy(_image_, _base\=2_)[#](#cucim.skimage.measure.shannon_entropy "Permalink to this definition")\
\
Calculate the Shannon entropy of an image.\
\
The Shannon entropy is defined as S = -sum(pk \* log(pk)), where pk are frequency/probability of pixels of value k.\
\
Parameters:\
\
**image**(M, N) ndarray\
\
Grayscale input image.\
\
**base**float, optional\
\
The logarithmic base to use.\
\
Returns:\
\
**entropy**0-dimensional float cupy.ndarray\
\
Notes\
\
The returned value is measured in bits or shannon (Sh) for base=2, natural unit (nat) for base=np.e and hartley (Hart) for base=10.\
\
References\
\
\[1\]\
\
[https://en.wikipedia.org/wiki/Entropy\_(information\_theory](https://en.wikipedia.org/wiki/Entropy_(information_theory)\
) <[https://en.wikipedia.org/wiki/Entropy\_(information\_theory)](https://en.wikipedia.org/wiki/Entropy_(information_theory))\
\>\`\_\
\
\[2\]\
\
[https://en.wiktionary.org/wiki/Shannon\_entropy](https://en.wiktionary.org/wiki/Shannon_entropy)\
\
Examples\
\
\>>> import cupy as cp\
\>>> from skimage import data\
\>>> from cucim.skimage.measure import shannon\_entropy\
\>>> shannon\_entropy(cp.array(data.camera()))\
array(7.23169501)\
\
cucim.skimage.measure.subdivide\_polygon(_coords_, _degree\=2_, _preserve\_ends\=False_)[#](#cucim.skimage.measure.subdivide_polygon "Permalink to this definition")\
\
Subdivision of polygonal curves using B-Splines.\
\
Note that the resulting curve is always within the convex hull of the original polygon. Circular polygons stay closed after subdivision.\
\
Parameters:\
\
**coords**(K, 2) array\
\
Coordinate array.\
\
**degree**{1, 2, 3, 4, 5, 6, 7}, optional\
\
Degree of B-Spline. Default is 2.\
\
**preserve\_ends**bool, optional\
\
Preserve first and last coordinate of non-circular polygon. Default is False.\
\
Returns:\
\
**coords**(L, 2) array\
\
Subdivided coordinate array.\
\
References\
\
\[1\]\
\
[http://mrl.nyu.edu/publications/subdiv-course2000/coursenotes00.pdf](http://mrl.nyu.edu/publications/subdiv-course2000/coursenotes00.pdf)\
\
### metrics[#](#module-cucim.skimage.metrics "Permalink to this heading")\
\
Metrics corresponding to images, e.g., distance metrics, similarity, etc.\
\
cucim.skimage.metrics.adapted\_rand\_error(_image\_true\=None_, _image\_test\=None_, _\*_, _table\=None_, _ignore\_labels\=(0,)_, _alpha\=0.5_)[#](#cucim.skimage.metrics.adapted_rand_error "Permalink to this definition")\
\
Compute Adapted Rand error as defined by the SNEMI3D contest. [\[1\]](#rcdd78a98f6a6-1)\
\
Parameters:\
\
**image\_true**cp.ndarray of int\
\
Ground-truth label image, same shape as im\_test.\
\
**image\_test**cp.ndarray of int\
\
Test image.\
\
**table**cupyx.scipy.sparse array in csr format, optional\
\
A contingency table built with skimage.evaluate.contingency\_table. If None, it will be computed on the fly.\
\
**ignore\_labels**sequence of int, optional\
\
Labels to ignore. Any part of the true image labeled with any of these values will not be counted in the score.\
\
**alpha**float, optional\
\
Relative weight given to precision and recall in the adapted Rand error calculation.\
\
Returns:\
\
**are**float\
\
The adapted Rand error.\
\
**prec**float\
\
The adapted Rand precision: this is the number of pairs of pixels that have the same label in the test label image _and_ in the true image, divided by the number in the test image.\
\
**rec**float\
\
The adapted Rand recall: this is the number of pairs of pixels that have the same label in the test label image _and_ in the true image, divided by the number in the true image.\
\
Notes\
\
Pixels with label 0 in the true segmentation are ignored in the score.\
\
The adapted Rand error is calculated as follows:\
\
\\(1 - \\frac{\\sum\_{ij} p\_{ij}^{2}}{\\alpha \\sum\_{k} s\_{k}^{2} + (1-\\alpha)\\sum\_{k} t\_{k}^{2}}\\), where \\(p\_{ij}\\) is the probability that a pixel has the same label in the test image _and_ in the true image, \\(t\_{k}\\) is the probability that a pixel has label \\(k\\) in the true image, and \\(s\_{k}\\) is the probability that a pixel has label \\(k\\) in the test image.\
\
Default behavior is to weight precision and recall equally in the adapted Rand error calculation. When alpha = 0, adapted Rand error = recall. When alpha = 1, adapted Rand error = precision.\
\
References\
\
\[[1](#id248)\
\]\
\
Arganda-Carreras I, Turaga SC, Berger DR, et al. (2015) Crowdsourcing the creation of image segmentation algorithms for connectomics. Front. Neuroanat. 9:142. [DOI:10.3389/fnana.2015.00142](https://doi.org/10.3389/fnana.2015.00142)\
\
cucim.skimage.metrics.contingency\_table(_im\_true_, _im\_test_, _\*_, _ignore\_labels\=None_, _normalize\=False_, _sparse\_type\='matrix'_)[#](#cucim.skimage.metrics.contingency_table "Permalink to this definition")\
\
Return the contingency table for all regions in matched segmentations.\
\
Parameters:\
\
**im\_true**ndarray of int\
\
Ground-truth label image, same shape as im\_test.\
\
**im\_test**ndarray of int\
\
Test image.\
\
**ignore\_labels**sequence of int, optional\
\
Labels to ignore. Any part of the true image labeled with any of these values will not be counted in the score.\
\
**normalize**bool\
\
Determines if the contingency table is normalized by pixel count.\
\
**sparse\_type**{“matrix”}, optional\
\
scikit-image supports both “matrix” and “array” for this argument. CuPy does not yet have csr\_array support, so only “matrix” (cupy.scipy.sparse.csr\_matrix) is supported by cuCIM.\
\
Returns:\
\
**cont**scipy.sparse.csr\_matrix\
\
A contingency table. cont\[i, j\] will equal the number of voxels labeled i in im\_true and j in im\_test.\
\
cucim.skimage.metrics.mean\_squared\_error(_image0_, _image1_)[#](#cucim.skimage.metrics.mean_squared_error "Permalink to this definition")\
\
Compute the mean-squared error between two images.\
\
Parameters:\
\
**image0, image1**ndarray\
\
Images. Any dimensionality, must have same shape.\
\
Returns:\
\
**mse**float\
\
The mean-squared error (MSE) metric.\
\
Notes\
\
Changed in version 0.16: This function was renamed from `skimage.measure.compare_mse` to `skimage.metrics.mean_squared_error`.\
\
cucim.skimage.metrics.normalized\_mutual\_information(_image0_, _image1_, _\*_, _bins\=100_)[#](#cucim.skimage.metrics.normalized_mutual_information "Permalink to this definition")\
\
Compute the normalized mutual information (NMI).\
\
The normalized mutual information of \\(A\\) and \\(B\\) is given by:\
\
.. math::\
\
> Y(A, B) = frac{H(A) + H(B)}{H(A, B)}\
\
where \\(H(X) := - \\sum\_{x \\in X}{x \\log x}\\) is the entropy.\
\
It was proposed to be useful in registering images by Colin Studholme and colleagues [\[1\]](#r988d52405a80-1)\
. It ranges from 1 (perfectly uncorrelated image values) to 2 (perfectly correlated image values, whether positively or negatively).\
\
Parameters:\
\
**image0, image1**ndarray\
\
Images to be compared. The two input images must have the same number of dimensions.\
\
**bins**int or sequence of int, optional\
\
The number of bins along each axis of the joint histogram.\
\
Returns:\
\
**nmi**float\
\
The normalized mutual information between the two arrays, computed at the granularity given by `bins`. Higher NMI implies more similar input images.\
\
Raises:\
\
ValueError\
\
If the images don’t have the same number of dimensions.\
\
Notes\
\
If the two input images are not the same shape, the smaller image is padded with zeros.\
\
References\
\
\[[1](#id250)\
\]\
\
C. Studholme, D.L.G. Hill, & D.J. Hawkes (1999). An overlap invariant entropy measure of 3D medical image alignment. Pattern Recognition 32(1):71-86 [DOI:10.1016/S0031-3203(98)00091-0](https://doi.org/10.1016/S0031-3203(98)00091-0)\
\
cucim.skimage.metrics.normalized\_root\_mse(_image\_true_, _image\_test_, _\*_, _normalization\='euclidean'_)[#](#cucim.skimage.metrics.normalized_root_mse "Permalink to this definition")\
\
Compute the normalized root mean-squared error (NRMSE) between two images.\
\
Parameters:\
\
**image\_true**ndarray\
\
Ground-truth image, same shape as im\_test.\
\
**image\_test**ndarray\
\
Test image.\
\
**normalization**{‘euclidean’, ‘min-max’, ‘mean’}, optional\
\
Controls the normalization method to use in the denominator of the NRMSE. There is no standard method of normalization across the literature [\[1\]](#r9462348ca58d-1)\
. The methods available here are as follows:\
\
* ‘euclidean’ : normalize by the averaged Euclidean norm of `im_true`:\
\
NRMSE \= RMSE \* sqrt(N) / || im\_true ||\
\
where || . || denotes the Frobenius norm and `N = im_true.size`. This result is equivalent to:\
\
NRMSE \= || im\_true \- im\_test || / || im\_true ||.\
\
* ‘min-max’ : normalize by the intensity range of `im_true`.\
\
* ‘mean’ : normalize by the mean of `im_true`\
\
\
Returns:\
\
**nrmse**float\
\
The NRMSE metric.\
\
Notes\
\
Changed in version 0.16: This function was renamed from `skimage.measure.compare_nrmse` to `skimage.metrics.normalized_root_mse`.\
\
References\
\
\[[1](#id252)\
\]\
\
[https://en.wikipedia.org/wiki/Root-mean-square\_deviation](https://en.wikipedia.org/wiki/Root-mean-square_deviation)\
\
cucim.skimage.metrics.peak\_signal\_noise\_ratio(_image\_true_, _image\_test_, _\*_, _data\_range\=None_)[#](#cucim.skimage.metrics.peak_signal_noise_ratio "Permalink to this definition")\
\
Compute the peak signal to noise ratio (PSNR) for an image.\
\
Parameters:\
\
**image\_true**ndarray\
\
Ground-truth image, same shape as im\_test.\
\
**image\_test**ndarray\
\
Test image.\
\
**data\_range**int, optional\
\
The data range of the input image (distance between minimum and maximum possible values). By default, this is estimated from the image data-type.\
\
Returns:\
\
**psnr**float\
\
The PSNR metric.\
\
Notes\
\
Changed in version 0.16: This function was renamed from `skimage.measure.compare_psnr` to `skimage.metrics.peak_signal_noise_ratio`.\
\
References\
\
\[1\]\
\
[https://en.wikipedia.org/wiki/Peak\_signal-to-noise\_ratio](https://en.wikipedia.org/wiki/Peak_signal-to-noise_ratio)\
\
cucim.skimage.metrics.structural\_similarity(_im1_, _im2_, _\*_, _win\_size\=None_, _gradient\=False_, _data\_range\=None_, _channel\_axis\=None_, _gaussian\_weights\=False_, _full\=False_, _\*\*kwargs_)[#](#cucim.skimage.metrics.structural_similarity "Permalink to this definition")\
\
Compute the mean structural similarity index between two images. Please pay attention to the data\_range parameter with floating-point images.\
\
Parameters:\
\
**im1, im2**ndarray\
\
Images. Any dimensionality with same shape.\
\
**win\_size**int or None, optional\
\
The side-length of the sliding window used in comparison. Must be an odd value. If gaussian\_weights is True, this is ignored and the window size will depend on sigma.\
\
**gradient**bool, optional\
\
If True, also return the gradient with respect to im2.\
\
**data\_range**float, optional\
\
The data range of the input image (difference between maximum and minimum possible values). By default, this is estimated from the image data type. This estimate may be wrong for floating-point image data. Therefore it is recommended to always pass this scalar value explicitly (see note below).\
\
**channel\_axis**int or None, optional\
\
If None, the image is assumed to be a grayscale (single channel) image. Otherwise, this parameter indicates which axis of the array corresponds to channels.\
\
**gaussian\_weights**bool, optional\
\
If True, each patch has its mean and variance spatially weighted by a normalized Gaussian kernel of width sigma=1.5.\
\
**full**bool, optional\
\
If True, also return the full structural similarity image.\
\
Returns:\
\
**mssim**float\
\
The mean structural similarity index over the image.\
\
**grad**ndarray\
\
The gradient of the structural similarity between im1 and im2 [\[2\]](#rb94e0698d256-2)\
. This is only returned if gradient is set to True.\
\
**S**ndarray\
\
The full SSIM image. This is only returned if full is set to True.\
\
Other Parameters:\
\
**use\_sample\_covariance**bool\
\
If True, normalize covariances by N-1 rather than, N where N is the number of pixels within the sliding window.\
\
**K1**float\
\
Algorithm parameter, K1 (small constant, see [\[1\]](#rb94e0698d256-1)\
).\
\
**K2**float\
\
Algorithm parameter, K2 (small constant, see [\[1\]](#rb94e0698d256-1)\
).\
\
**sigma**float\
\
Standard deviation for the Gaussian when gaussian\_weights is True.\
\
Notes\
\
If data\_range is not specified, the range is automatically guessed based on the image data type. However for floating-point image data, this estimate yields a result double the value of the desired range, as the dtype\_range in skimage.util.dtype.py has defined intervals from -1 to +1. This yields an estimate of 2, instead of 1, which is most often required when working with image data (as negative light intensities are nonsensical). In case of working with YCbCr-like color data, note that these ranges are different per channel (Cb and Cr have double the range of Y), so one cannot calculate a channel-averaged SSIM with a single call to this function, as identical ranges are assumed for each channel.\
\
To match the implementation of Wang et al. [\[1\]](#rb94e0698d256-1)\
, set gaussian\_weights to True, sigma to 1.5, use\_sample\_covariance to False, and specify the data\_range argument.\
\
Changed in version 0.16: This function was renamed from `skimage.measure.compare_ssim` to `skimage.metrics.structural_similarity`.\
\
References\
\
\[1\] ([1](#id256)\
,[2](#id257)\
,[3](#id258)\
)\
\
Wang, Z., Bovik, A. C., Sheikh, H. R., & Simoncelli, E. P. (2004). Image quality assessment: From error visibility to structural similarity. IEEE Transactions on Image Processing, 13, 600-612. [https://ece.uwaterloo.ca/~z70wang/publications/ssim.pdf](https://ece.uwaterloo.ca/~z70wang/publications/ssim.pdf)\
, [DOI:10.1109/TIP.2003.819861](https://doi.org/10.1109/TIP.2003.819861)\
\
\[[2](#id255)\
\]\
\
Avanaki, A. N. (2009). Exact global histogram specification optimized for structural similarity. Optical Review, 16, 613-621. [arXiv:0901.0065](https://arxiv.org/abs/0901.0065)\
[DOI:10.1007/s10043-009-0119-z](https://doi.org/10.1007/s10043-009-0119-z)\
\
cucim.skimage.metrics.variation\_of\_information(_image0\=None_, _image1\=None_, _\*_, _table\=None_, _ignore\_labels\=()_)[#](#cucim.skimage.metrics.variation_of_information "Permalink to this definition")\
\
Return symmetric conditional entropies associated with the VI. [\[1\]](#r1dff00e1e61d-1)\
\
The variation of information is defined as VI(X,Y) = H(X|Y) + H(Y|X). If X is the ground-truth segmentation, then H(X|Y) can be interpreted as the amount of under-segmentation and H(X|Y) as the amount of over-segmentation. In other words, a perfect over-segmentation will have H(X|Y)=0 and a perfect under-segmentation will have H(Y|X)=0.\
\
Parameters:\
\
**image0, image1**cp.ndarray of int\
\
Label images / segmentations, must have same shape.\
\
**table**cupyx.scipy.sparse array in csr format, optional\
\
A contingency table built with skimage.evaluate.contingency\_table. If None, it will be computed with skimage.evaluate.contingency\_table. If given, the entropies will be computed from this table and any images will be ignored.\
\
**ignore\_labels**sequence of int, optional\
\
Labels to ignore. Any part of the true image labeled with any of these values will not be counted in the score.\
\
Returns:\
\
**vi**cp.ndarray of float, shape (2,)\
\
The conditional entropies of image1|image0 and image0|image1.\
\
References\
\
\[[1](#id261)\
\]\
\
Marina Meilă (2007), Comparing clusterings—an information based distance, Journal of Multivariate Analysis, Volume 98, Issue 5, Pages 873-895, ISSN 0047-259X, [DOI:10.1016/j.jmva.2006.11.013](https://doi.org/10.1016/j.jmva.2006.11.013)\
.\
\
### morphology[#](#id263 "Permalink to this heading")\
\
Morphological algorithms, e.g., closing, opening, skeletonization.\
\
cucim.skimage.morphology.ball(_radius_, _dtype=_, _\*_, _strict\_radius=True_, _decomposition=None_)[#](#cucim.skimage.morphology.ball "Permalink to this definition")\
\
Generates a ball-shaped footprint.\
\
This is the 3D equivalent of a disk. A pixel is within the neighborhood if the Euclidean distance between it and the origin is no greater than radius.\
\
Parameters:\
\
**radius**float\
\
The radius of the ball-shaped footprint.\
\
Returns:\
\
**footprint**cupy.ndarray\
\
The footprint where elements of the neighborhood are 1 and 0 otherwise.\
\
Other Parameters:\
\
**dtype**data-type, optional\
\
The data type of the footprint.\
\
**strict\_radius**bool, optional\
\
If False, extend the radius by 0.5. This allows the circle to expand further within a cube that remains of size `2 * radius + 1` along each axis. This parameter is ignored if decomposition is not None.\
\
**decomposition**{None, ‘sequence’}, optional\
\
If None, a single array is returned. For ‘sequence’, a tuple of smaller footprints is returned. Applying this series of smaller footprints will given a result equivalent to a single, larger footprint, but with better computational performance. For ball footprints, the sequence decomposition is not exactly equivalent to decomposition=None. See Notes for more details.\
\
Notes\
\
The disk produced by the decomposition=’sequence’ mode is not identical to that with decomposition=None. Here we extend the approach taken in [\[1\]](#rd994c2171c55-1)\
for disks to the 3D case, using 3-dimensional extensions of the “square”, “diamond” and “t-shaped” elements from that publication. All of these elementary elements have size `(3,) * ndim`. We numerically computed the number of repetitions of each element that gives the closest match to the ball computed with kwargs `strict_radius=False, decomposition=None`.\
\
Empirically, the equivalent composite footprint to the sequence decomposition approaches a rhombicuboctahedron (26-faces [\[2\]](#rd994c2171c55-2)\
).\
\
References\
\
\[[1](#id264)\
\]\
\
Park, H and Chin R.T. Decomposition of structuring elements for optimal implementation of morphological operations. In Proceedings: 1997 IEEE Workshop on Nonlinear Signal and Image Processing, London, UK. [https://www.iwaenc.org/proceedings/1997/nsip97/pdf/scan/ns970226.pdf](https://www.iwaenc.org/proceedings/1997/nsip97/pdf/scan/ns970226.pdf)\
\
\[[2](#id265)\
\]\
\
[https://en.wikipedia.org/wiki/Rhombicuboctahedron](https://en.wikipedia.org/wiki/Rhombicuboctahedron)\
\
cucim.skimage.morphology.binary\_closing(_image_, _footprint\=None_, _out\=None_, _\*_, _mode\='ignore'_)[#](#cucim.skimage.morphology.binary_closing "Permalink to this definition")\
\
Return fast binary morphological closing of an image.\
\
This function returns the same result as grayscale closing but performs faster for binary images.\
\
The morphological closing on an image is defined as a dilation followed by an erosion. Closing can remove small dark spots (i.e. “pepper”) and connect small bright cracks. This tends to “close” up (dark) gaps between (bright) features.\
\
Parameters:\
\
**image**ndarray\
\
Binary input image.\
\
**footprint**ndarray or tuple, optional\
\
The neighborhood expressed as a 2-D array of 1’s and 0’s. If None, use a cross-shaped footprint (connectivity=1). The footprint can also be provided as a sequence of smaller footprints as described in the notes below.\
\
**out**ndarray of bool, optional\
\
The array to store the result of the morphology. If None, is passed, a new array will be allocated.\
\
**mode**str, optional\
\
The mode parameter determines how the array borders are handled. Valid modes are: ‘max’, ‘min’, ‘ignore’. If ‘ignore’, pixels outside the image domain are assumed to be True for the erosion and False for the dilation, which causes them to not influence the result. Default is ‘ignore’.\
\
New in version 24.06: mode was added in 24.06.\
\
Returns:\
\
**closing**ndarray of bool\
\
The result of the morphological closing.\
\
Notes\
\
The footprint can also be a provided as a sequence of 2-tuples where the first element of each 2-tuple is a footprint ndarray and the second element is an integer describing the number of times it should be iterated. For example `footprint=[(cp.ones((9, 1)), 1), (cp.ones((1, 9)), 1)]` would apply a 9x1 footprint followed by a 1x9 footprint resulting in a net effect that is the same as `footprint=cp.ones((9, 9))`, but with lower computational cost. Most of the builtin footprints such as [`skimage.morphology.disk()`](https://scikit-image.org/docs/stable/api/skimage.morphology.html#skimage.morphology.disk "(in skimage v0.25.2)")\
provide an option to automatically generate a footprint sequence of this type.\
\
cucim.skimage.morphology.binary\_dilation(_image_, _footprint\=None_, _out\=None_, _\*_, _mode\='ignore'_)[#](#cucim.skimage.morphology.binary_dilation "Permalink to this definition")\
\
Return fast binary morphological dilation of an image.\
\
This function returns the same result as grayscale dilation but performs faster for binary images.\
\
Morphological dilation sets a pixel at `(i,j)` to the maximum over all pixels in the neighborhood centered at `(i,j)`. Dilation enlarges bright regions and shrinks dark regions.\
\
Parameters:\
\
**image**ndarray\
\
Binary input image.\
\
**footprint**ndarray or tuple, optional\
\
The neighborhood expressed as a 2-D array of 1’s and 0’s. If None, use a cross-shaped footprint (connectivity=1). The footprint can also be provided as a sequence of smaller footprints as described in the notes below.\
\
**out**ndarray of bool, optional\
\
The array to store the result of the morphology. If None is passed, a new array will be allocated.\
\
**mode**str, optional\
\
The mode parameter determines how the array borders are handled. Valid modes are: ‘max’, ‘min’, ‘ignore’. If ‘min’ or ‘ignore’, pixels outside the image domain are assumed to be False, which causes them to not influence the result. Default is ‘ignore’.\
\
New in version 24.06: mode was added in 24.06.\
\
Returns:\
\
**dilated**ndarray of bool or uint\
\
The result of the morphological dilation with values in `[False, True]`.\
\
Notes\
\
The footprint can also be a provided as a sequence of 2-tuples where the first element of each 2-tuple is a footprint ndarray and the second element is an integer describing the number of times it should be iterated. For example `footprint=[(cp.ones((9, 1)), 1), (cp.ones((1, 9)), 1)]` would apply a 9x1 footprint followed by a 1x9 footprint resulting in a net effect that is the same as `footprint=cp.ones((9, 9))`, but with lower computational cost. Most of the builtin footprints such as [`skimage.morphology.disk()`](https://scikit-image.org/docs/stable/api/skimage.morphology.html#skimage.morphology.disk "(in skimage v0.25.2)")\
provide an option to automatically generate a footprint sequence of this type.\
\
For non-symmetric footprints, [`skimage.morphology.binary_dilation()`](https://scikit-image.org/docs/stable/api/skimage.morphology.html#skimage.morphology.binary_dilation "(in skimage v0.25.2)")\
and [`skimage.morphology.dilation()`](https://scikit-image.org/docs/stable/api/skimage.morphology.html#skimage.morphology.dilation "(in skimage v0.25.2)")\
produce an output that differs: binary\_dilation mirrors the footprint, whereas dilation does not.\
\
cucim.skimage.morphology.binary\_erosion(_image_, _footprint\=None_, _out\=None_, _\*_, _mode\='ignore'_)[#](#cucim.skimage.morphology.binary_erosion "Permalink to this definition")\
\
Return fast binary morphological erosion of an image.\
\
This function returns the same result as grayscale erosion but performs faster for binary images.\
\
Morphological erosion sets a pixel at `(i,j)` to the minimum over all pixels in the neighborhood centered at `(i,j)`. Erosion shrinks bright regions and enlarges dark regions.\
\
Parameters:\
\
**image**ndarray\
\
Binary input image.\
\
**footprint**ndarray or tuple, optional\
\
The neighborhood expressed as a 2-D array of 1’s and 0’s. If None, use a cross-shaped footprint (connectivity=1). The footprint can also be provided as a sequence of smaller footprints as described in the notes below.\
\
**out**ndarray of bool, optional\
\
The array to store the result of the morphology. If None is passed, a new array will be allocated.\
\
**mode**str, optional\
\
The mode parameter determines how the array borders are handled. Valid modes are: ‘max’, ‘min’, ‘ignore’. If ‘max’ or ‘ignore’, pixels outside the image domain are assumed to be True, which causes them to not influence the result. Default is ‘ignore’.\
\
New in version 24.06: mode was added in 24.06.\
\
Returns:\
\
**eroded**ndarray of bool or uint\
\
The result of the morphological erosion taking values in `[False, True]`.\
\
Notes\
\
The footprint can also be a provided as a sequence of 2-tuples where the first element of each 2-tuple is a footprint ndarray and the second element is an integer describing the number of times it should be iterated. For example `footprint=[(cp.ones((9, 1)), 1), (cp.ones((1, 9)), 1)]` would apply a 9x1 footprint followed by a 1x9 footprint resulting in a net effect that is the same as `footprint=cp.ones((9, 9))`, but with lower computational cost. Most of the builtin footprints such as [`skimage.morphology.disk()`](https://scikit-image.org/docs/stable/api/skimage.morphology.html#skimage.morphology.disk "(in skimage v0.25.2)")\
provide an option to automatically generate a footprint sequence of this type.\
\
For even-sized footprints, [`skimage.morphology.erosion()`](https://scikit-image.org/docs/stable/api/skimage.morphology.html#skimage.morphology.erosion "(in skimage v0.25.2)")\
and this function produce an output that differs: one is shifted by one pixel compared to the other.\
\
cucim.skimage.morphology.binary\_opening(_image_, _footprint\=None_, _out\=None_, _\*_, _mode\='ignore'_)[#](#cucim.skimage.morphology.binary_opening "Permalink to this definition")\
\
Return fast binary morphological opening of an image.\
\
This function returns the same result as grayscale opening but performs faster for binary images.\
\
The morphological opening on an image is defined as an erosion followed by a dilation. Opening can remove small bright spots (i.e. “salt”) and connect small dark cracks. This tends to “open” up (dark) gaps between (bright) features.\
\
Parameters:\
\
**image**ndarray\
\
Binary input image.\
\
**footprint**ndarray or tuple, optional\
\
The neighborhood expressed as a 2-D array of 1’s and 0’s. If None, use a cross-shaped footprint (connectivity=1). The footprint can also be provided as a sequence of smaller footprints as described in the notes below.\
\
**out**ndarray of bool, optional\
\
The array to store the result of the morphology. If None is passed, a new array will be allocated.\
\
**mode**str, optional\
\
The mode parameter determines how the array borders are handled. Valid modes are: ‘max’, ‘min’, ‘ignore’. If ‘ignore’, pixels outside the image domain are assumed to be True for the erosion and False for the dilation, which causes them to not influence the result. Default is ‘ignore’.\
\
New in version 24.06: mode was added in 24.06\
\
Returns:\
\
**opening**ndarray of bool\
\
The result of the morphological opening.\
\
Notes\
\
The footprint can also be a provided as a sequence of 2-tuples where the first element of each 2-tuple is a footprint ndarray and the second element is an integer describing the number of times it should be iterated. For example `footprint=[(cp.ones((9, 1)), 1), (cp.ones((1, 9)), 1)]` would apply a 9x1 footprint followed by a 1x9 footprint resulting in a net effect that is the same as `footprint=cp.ones((9, 9))`, but with lower computational cost. Most of the builtin footprints such as [`skimage.morphology.disk()`](https://scikit-image.org/docs/stable/api/skimage.morphology.html#skimage.morphology.disk "(in skimage v0.25.2)")\
provide an option to automatically generate a footprint sequence of this type.\
\
cucim.skimage.morphology.black\_tophat(_image_, _footprint\=None_, _out\=None_, _\*_, _mode\='reflect'_, _cval\=0.0_)[#](#cucim.skimage.morphology.black_tophat "Permalink to this definition")\
\
Return black top hat of an image.\
\
The black top hat of an image is defined as its morphological closing minus the original image. This operation returns the dark spots of the image that are smaller than the footprint. Note that dark spots in the original image are bright spots after the black top hat.\
\
Parameters:\
\
**image**cupy.ndarray\
\
Image array.\
\
**footprint**cupy.ndarray, optional\
\
The neighborhood expressed as a 2-D array of 1’s and 0’s. If None, use a cross-shaped footprint (connectivity=1). The footprint can also be provided as a sequence of smaller footprints as described in the notes below.\
\
**out**cupy.ndarray, optional\
\
The array to store the result of the morphology. If None is passed, a new array will be allocated.\
\
**mode**str, optional\
\
The mode parameter determines how the array borders are handled. Valid modes are: ‘reflect’, ‘constant’, ‘nearest’, ‘mirror’, ‘wrap’, ‘max’, ‘min’, or ‘ignore’. If ‘max’ or ‘ignore’, pixels outside the image domain are assumed to be the maximum for the image’s dtype, which causes them to not influence the result. Default is ‘reflect’.\
\
**cval**scalar, optional\
\
Value to fill past edges of input if mode is ‘constant’. Default is 0.0.\
\
New in version 24.06: mode and cval were added in 24.06.\
\
Returns:\
\
**out**cupy.ndarray, same shape and type as image\
\
The result of the morphological black top hat.\
\
See also\
\
[`white_tophat`](#cucim.skimage.morphology.white_tophat "cucim.skimage.morphology.white_tophat")\
\
Notes\
\
The footprint can also be a provided as a sequence of 2-tuples where the first element of each 2-tuple is a footprint ndarray and the second element is an integer describing the number of times it should be iterated. For example `footprint=[(cp.ones((9, 1)), 1), (cp.ones((1, 9)), 1)]` would apply a 9x1 footprint followed by a 1x9 footprint resulting in a net effect that is the same as `footprint=cp.ones((9, 9))`, but with lower computational cost. Most of the builtin footprints such as [`skimage.morphology.disk()`](https://scikit-image.org/docs/stable/api/skimage.morphology.html#skimage.morphology.disk "(in skimage v0.25.2)")\
provide an option to automatically generate a footprint sequence of this type.\
\
References\
\
\[1\]\
\
[https://en.wikipedia.org/wiki/Top-hat\_transform](https://en.wikipedia.org/wiki/Top-hat_transform)\
\
Examples\
\
\>>> \# Change dark peak to bright peak and subtract background\
\>>> import cupy as cp\
\>>> from cucim.skimage.morphology import footprint\_rectangle\
\>>> dark\_on\_grey \= cp.asarray(\[\[7, 6, 6, 6, 7\],\
... \[6, 5, 4, 5, 6\],\
... \[6, 4, 0, 4, 6\],\
... \[6, 5, 4, 5, 6\],\
... \[7, 6, 6, 6, 7\]\], dtype\=cp.uint8)\
\>>> black\_tophat(dark\_on\_grey, footprint\_rectangle((3, 3)))\
array(\[\[0, 0, 0, 0, 0\],\
\[0, 0, 1, 0, 0\],\
\[0, 1, 5, 1, 0\],\
\[0, 0, 1, 0, 0\],\
\[0, 0, 0, 0, 0\]\], dtype=uint8)\
\
cucim.skimage.morphology.closing(_image_, _footprint\=None_, _out\=None_, _\*_, _mode\='reflect'_, _cval\=0.0_)[#](#cucim.skimage.morphology.closing "Permalink to this definition")\
\
Return grayscale morphological closing of an image.\
\
The morphological closing of an image is defined as a dilation followed by an erosion. Closing can remove small dark spots (i.e. “pepper”) and connect small bright cracks. This tends to “close” up (dark) gaps between (bright) features.\
\
Parameters:\
\
**image**cupy.ndarray\
\
Image array.\
\
**footprint**cupy.ndarray, optional\
\
The neighborhood expressed as a 2-D array of 1’s and 0’s. If None, use a cross-shaped footprint (connectivity=1). The footprint can also be provided as a sequence of smaller footprints as described in the notes below.\
\
**out**cupy.ndarray, optional\
\
The array to store the result of the morphology. If None, a new array will be allocated.\
\
**mode**str, optional\
\
The mode parameter determines how the array borders are handled. Valid modes are: ‘reflect’, ‘constant’, ‘nearest’, ‘mirror’, ‘wrap’, ‘max’, ‘min’, or ‘ignore’. If ‘max’ or ‘ignore’, pixels outside the image domain are assumed to be the maximum for the image’s dtype, which causes them to not influence the result. Default is ‘reflect’.\
\
**cval**scalar, optional\
\
Value to fill past edges of input if mode is ‘constant’. Default is 0.0.\
\
New in version 24.06: mode and cval were added in 24.06.\
\
Returns:\
\
**closing**cupy.ndarray, same shape and type as image\
\
The result of the morphological closing.\
\
Notes\
\
The footprint can also be a provided as a sequence of 2-tuples where the first element of each 2-tuple is a footprint ndarray and the second element is an integer describing the number of times it should be iterated. For example `footprint=[(cp.ones((9, 1)), 1), (cp.ones((1, 9)), 1)]` would apply a 9x1 footprint followed by a 1x9 footprint resulting in a net effect that is the same as `footprint=cp.ones((9, 9))`, but with lower computational cost. Most of the builtin footprints such as [`skimage.morphology.disk()`](https://scikit-image.org/docs/stable/api/skimage.morphology.html#skimage.morphology.disk "(in skimage v0.25.2)")\
provide an option to automatically generate a footprint sequence of this type.\
\
Examples\
\
\>>> \# Close a gap between two bright lines\
\>>> import cupy as cp\
\>>> from cucim.skimage.morphology import footprint\_rectangle\
\>>> broken\_line \= cp.asarray(\[\[0, 0, 0, 0, 0\],\
... \[0, 0, 0, 0, 0\],\
... \[1, 1, 0, 1, 1\],\
... \[0, 0, 0, 0, 0\],\
... \[0, 0, 0, 0, 0\]\], dtype\=cp.uint8)\
\>>> closing(broken\_line, footprint\_rectangle((3, 3)))\
array(\[\[0, 0, 0, 0, 0\],\
\[0, 0, 0, 0, 0\],\
\[1, 1, 1, 1, 1\],\
\[0, 0, 0, 0, 0\],\
\[0, 0, 0, 0, 0\]\], dtype=uint8)\
\
cucim.skimage.morphology.diamond(_radius_, _dtype=_, _\*_, _decomposition=None_)[#](#cucim.skimage.morphology.diamond "Permalink to this definition")\
\
Generates a flat, diamond-shaped footprint.\
\
A pixel is part of the neighborhood (i.e. labeled 1) if the city block/Manhattan distance between it and the center of the neighborhood is no greater than radius.\
\
Parameters:\
\
**radius**int\
\
The radius of the diamond-shaped footprint.\
\
Returns:\
\
**footprint**cupy.ndarray\
\
The footprint where elements of the neighborhood are 1 and 0 otherwise. When decomposition is None, this is just a numpy.ndarray. Otherwise, this will be a tuple whose length is equal to the number of unique structuring elements to apply (see Notes for more detail)\
\
Other Parameters:\
\
**dtype**data-type, optional\
\
The data type of the footprint.\
\
**decomposition**{None, ‘sequence’}, optional\
\
If None, a single array is returned. For ‘sequence’, a tuple of smaller footprints is returned. Applying this series of smaller footprints will given an identical result to a single, larger footprint, but with better computational performance. See Notes for more details.\
\
Notes\
\
When decomposition is not None, each element of the footprint tuple is a 2-tuple of the form `(ndarray, num_iter)` that specifies a footprint array and the number of iterations it is to be applied.\
\
For either binary or grayscale morphology, using `decomposition='sequence'` was observed to have a performance benefit, with the magnitude of the benefit increasing with increasing footprint size.\
\
cucim.skimage.morphology.dilation(_image_, _footprint=None_, _out=None_, _shift\_x=_, _shift\_y=_, _\*_, _mode='reflect'_, _cval=0.0_)[#](#cucim.skimage.morphology.dilation "Permalink to this definition")\
\
Return grayscale morphological dilation of an image.\
\
Morphological dilation sets the value of a pixel to the maximum over all pixel values within a local neighborhood centered about it. The values where the footprint is 1 define this neighborhood. Dilation enlarges bright regions and shrinks dark regions.\
\
Parameters:\
\
**image**cupy.ndarray\
\
Image array.\
\
**footprint**cupy.ndarray, optional\
\
The neighborhood expressed as a 2-D array of 1’s and 0’s. If None, use a cross-shaped footprint (connectivity=1). The footprint can also be provided as a sequence of smaller footprints as described in the notes below.\
\
**out**cupy.ndarray, optional\
\
The array to store the result of the morphology. If None is passed, a new array will be allocated.\
\
**mode**str, optional\
\
The mode parameter determines how the array borders are handled. Valid modes are: ‘reflect’, ‘constant’, ‘nearest’, ‘mirror’, ‘wrap’, ‘max’, ‘min’, or ‘ignore’. If ‘max’ or ‘ignore’, pixels outside the image domain are assumed to be the maximum for the image’s dtype, which causes them to not influence the result. Default is ‘reflect’.\
\
**cval**scalar, optional\
\
Value to fill past edges of input if mode is ‘constant’. Default is 0.0.\
\
New in version 24.06: mode and cval were added in 24.06.\
\
Returns:\
\
**dilated**cupy.ndarray, same shape and type as image\
\
The result of the morphological dilation.\
\
Other Parameters:\
\
**shift\_x, shift\_y**DEPRECATED\
\
Deprecated since version 24.06.\
\
Notes\
\
For `uint8` (and `uint16` up to a certain bit-depth) data, the lower algorithm complexity makes the [`skimage.filters.rank.maximum()`](https://scikit-image.org/docs/stable/api/skimage.filters.rank.html#skimage.filters.rank.maximum "(in skimage v0.25.2)")\
function more efficient for larger images and footprints.\
\
The footprint can also be a provided as a sequence of 2-tuples where the first element of each 2-tuple is a footprint ndarray and the second element is an integer describing the number of times it should be iterated. For example `footprint=[(cp.ones((9, 1)), 1), (cp.ones((1, 9)), 1)]` would apply a 9x1 footprint followed by a 1x9 footprint resulting in a net effect that is the same as `footprint=cp.ones((9, 9))`, but with lower computational cost. Most of the builtin footprints such as [`skimage.morphology.disk()`](https://scikit-image.org/docs/stable/api/skimage.morphology.html#skimage.morphology.disk "(in skimage v0.25.2)")\
provide an option to automatically generate a footprint sequence of this type.\
\
For non-symmetric footprints, [`skimage.morphology.binary_dilation()`](https://scikit-image.org/docs/stable/api/skimage.morphology.html#skimage.morphology.binary_dilation "(in skimage v0.25.2)")\
and [`skimage.morphology.dilation()`](https://scikit-image.org/docs/stable/api/skimage.morphology.html#skimage.morphology.dilation "(in skimage v0.25.2)")\
produce an output that differs: binary\_dilation mirrors the footprint, whereas dilation does not.\
\
Examples\
\
\>>> \# Dilation enlarges bright regions\
\>>> import cupy as cp\
\>>> from cucim.skimage.morphology import footprint\_rectangle\
\>>> bright\_pixel \= cp.asarray(\[\[0, 0, 0, 0, 0\],\
... \[0, 0, 0, 0, 0\],\
... \[0, 0, 1, 0, 0\],\
... \[0, 0, 0, 0, 0\],\
... \[0, 0, 0, 0, 0\]\], dtype\=cp.uint8)\
\>>> dilation(bright\_pixel, footprint\_rectangle((3, 3)))\
array(\[\[0, 0, 0, 0, 0\],\
\[0, 1, 1, 1, 0\],\
\[0, 1, 1, 1, 0\],\
\[0, 1, 1, 1, 0\],\
\[0, 0, 0, 0, 0\]\], dtype=uint8)\
\
cucim.skimage.morphology.disk(_radius_, _dtype=_, _\*_, _strict\_radius=True_, _decomposition=None_)[#](#cucim.skimage.morphology.disk "Permalink to this definition")\
\
Generates a flat, disk-shaped footprint.\
\
A pixel is within the neighborhood if the Euclidean distance between it and the origin is no greater than radius (This is only approximately True, when decomposition == ‘sequence’).\
\
Parameters:\
\
**radius**int\
\
The radius of the disk-shaped footprint.\
\
Returns:\
\
**footprint**cupy.ndarray\
\
The footprint where elements of the neighborhood are 1 and 0 otherwise.\
\
Other Parameters:\
\
**dtype**data-type, optional\
\
The data type of the footprint.\
\
**strict\_radius**bool, optional\
\
If False, extend the radius by 0.5. This allows the circle to expand further within a cube that remains of size `2 * radius + 1` along each axis. This parameter is ignored if decomposition is not None.\
\
**decomposition**{None, ‘sequence’, ‘crosses’}, optional\
\
If None, a single array is returned. For ‘sequence’, a tuple of smaller footprints is returned. Applying this series of smaller footprints will given a result equivalent to a single, larger footprint, but with better computational performance. For disk footprints, the ‘sequence’ or ‘crosses’ decompositions are not always exactly equivalent to `decomposition=None`. See Notes for more details.\
\
Notes\
\
When decomposition is not None, each element of the footprint tuple is a 2-tuple of the form `(ndarray, num_iter)` that specifies a footprint array and the number of iterations it is to be applied.\
\
The disk produced by the `decomposition='sequence'` mode may not be identical to that with `decomposition=None`. A disk footprint can be approximated by applying a series of smaller footprints of extent 3 along each axis. Specific solutions for this are given in [\[1\]](#r24440ba9a49a-1)\
for the case of 2D disks with radius 2 through 10. Here, we numerically computed the number of repetitions of each element that gives the closest match to the disk computed with kwargs `strict_radius=False, decomposition=None`.\
\
Empirically, the series decomposition at large radius approaches a hexadecagon (a 16-sided polygon [\[2\]](#r24440ba9a49a-2)\
). In [\[3\]](#r24440ba9a49a-3)\
, the authors demonstrate that a hexadecagon is the closest approximation to a disk that can be achieved for decomposition with footprints of shape (3, 3).\
\
The disk produced by the `decomposition='crosses'` is often but not always identical to that with `decomposition=None`. It tends to give a closer approximation than `decomposition='sequence'`, at a performance that is fairly comparable. The individual cross-shaped elements are not limited to extent (3, 3) in size. Unlike the ‘seqeuence’ decomposition, the ‘crosses’ decomposition can also accurately approximate the shape of disks with `strict_radius=True`. The method is based on an adaption of algorithm 1 given in [\[4\]](#r24440ba9a49a-4)\
.\
\
References\
\
\[[1](#id269)\
\]\
\
Park, H and Chin R.T. Decomposition of structuring elements for optimal implementation of morphological operations. In Proceedings: 1997 IEEE Workshop on Nonlinear Signal and Image Processing, London, UK. [https://www.iwaenc.org/proceedings/1997/nsip97/pdf/scan/ns970226.pdf](https://www.iwaenc.org/proceedings/1997/nsip97/pdf/scan/ns970226.pdf)\
\
\[[2](#id270)\
\]\
\
[https://en.wikipedia.org/wiki/Hexadecagon](https://en.wikipedia.org/wiki/Hexadecagon)\
\
\[[3](#id271)\
\]\
\
Vanrell, M and Vitrià, J. Optimal 3 × 3 decomposable disks for morphological transformations. Image and Vision Computing, Vol. 15, Issue 11, 1997. [DOI:10.1016/S0262-8856(97)00026-7](https://doi.org/10.1016/S0262-8856(97)00026-7)\
\
\[[4](#id272)\
\]\
\
Li, D. and Ritter, G.X. Decomposition of Separable and Symmetric Convex Templates. Proc. SPIE 1350, Image Algebra and Morphological Image Processing, (1 November 1990). [DOI:10.1117/12.23608](https://doi.org/10.1117/12.23608)\
\
cucim.skimage.morphology.erosion(_image_, _footprint=None_, _out=None_, _shift\_x=_, _shift\_y=_, _\*_, _mode='reflect'_, _cval=0.0_)[#](#cucim.skimage.morphology.erosion "Permalink to this definition")\
\
Return grayscale morphological erosion of an image.\
\
Morphological erosion sets a pixel at (i,j) to the minimum over all pixels in the neighborhood centered at (i,j). Erosion shrinks bright regions and enlarges dark regions.\
\
Parameters:\
\
**image**cupy.ndarray\
\
Image array.\
\
**footprint**cupy.ndarray, optional\
\
The neighborhood expressed as a 2-D array of 1’s and 0’s. If None, use a cross-shaped footprint (connectivity=1). The footprint can also be provided as a sequence of smaller footprints as described in the notes below.\
\
**out**cupy.ndarray, optional\
\
The array to store the result of the morphology. If None is passed, a new array will be allocated.\
\
**mode**str, optional\
\
The mode parameter determines how the array borders are handled. Valid modes are: ‘reflect’, ‘constant’, ‘nearest’, ‘mirror’, ‘wrap’, ‘max’, ‘min’, or ‘ignore’. If ‘max’ or ‘ignore’, pixels outside the image domain are assumed to be the maximum for the image’s dtype, which causes them to not influence the result. Default is ‘reflect’.\
\
**cval**scalar, optional\
\
Value to fill past edges of input if mode is ‘constant’. Default is 0.0.\
\
New in version 24.06: mode and cval were added in 24.06.\
\
Returns:\
\
**eroded**cupy.ndarray, same shape as image\
\
The result of the morphological erosion.\
\
Other Parameters:\
\
**shift\_x, shift\_y**DEPRECATED\
\
Deprecated since version 24.06.\
\
Notes\
\
For `uint8` (and `uint16` up to a certain bit-depth) data, the lower algorithm complexity makes the [`skimage.filters.rank.minimum()`](https://scikit-image.org/docs/stable/api/skimage.filters.rank.html#skimage.filters.rank.minimum "(in skimage v0.25.2)")\
function more efficient for larger images and footprints.\
\
The footprint can also be a provided as a sequence of 2-tuples where the first element of each 2-tuple is a footprint ndarray and the second element is an integer describing the number of times it should be iterated. For example `footprint=[(cp.ones((9, 1)), 1), (cp.ones((1, 9)), 1)]` would apply a 9x1 footprint followed by a 1x9 footprint resulting in a net effect that is the same as `footprint=cp.ones((9, 9))`, but with lower computational cost. Most of the builtin footprints such as [`skimage.morphology.disk()`](https://scikit-image.org/docs/stable/api/skimage.morphology.html#skimage.morphology.disk "(in skimage v0.25.2)")\
provide an option to automatically generate a footprint sequence of this type.\
\
For even-sized footprints, [`skimage.morphology.binary_erosion()`](https://scikit-image.org/docs/stable/api/skimage.morphology.html#skimage.morphology.binary_erosion "(in skimage v0.25.2)")\
and this function produce an output that differs: one is shifted by one pixel compared to the other.\
\
Examples\
\
\>>> \# Erosion shrinks bright regions\
\>>> import cupy as cp\
\>>> from cucim.skimage.morphology import footprint\_rectangle\
\>>> bright\_square \= cp.asarray(\[\[0, 0, 0, 0, 0\],\
... \[0, 1, 1, 1, 0\],\
... \[0, 1, 1, 1, 0\],\
... \[0, 1, 1, 1, 0\],\
... \[0, 0, 0, 0, 0\]\], dtype\=cp.uint8)\
\>>> erosion(bright\_square, footprint\_rectangle((3, 3)))\
array(\[\[0, 0, 0, 0, 0\],\
\[0, 0, 0, 0, 0\],\
\[0, 0, 1, 0, 0\],\
\[0, 0, 0, 0, 0\],\
\[0, 0, 0, 0, 0\]\], dtype=uint8)\
\
cucim.skimage.morphology.footprint\_from\_sequence(_footprints_)[#](#cucim.skimage.morphology.footprint_from_sequence "Permalink to this definition")\
\
Convert a footprint sequence into an equivalent ndarray.\
\
Parameters:\
\
**footprints**tuple of 2-tuples\
\
A sequence of footprint tuples where the first element of each tuple is an array corresponding to a footprint and the second element is the number of times it is to be applied. Currently, all footprints should have odd size.\
\
Returns:\
\
**footprint**ndarray\
\
An single array equivalent to applying the sequence of `footprints`.\
\
cucim.skimage.morphology.footprint\_rectangle(_shape_, _\*_, _dtype=_, _decomposition=None_)[#](#cucim.skimage.morphology.footprint_rectangle "Permalink to this definition")\
\
Generate a rectangular or hyper-rectangular footprint.\
\
Generates, depending on the length and dimensions requested with shape, a square, rectangle, cube, cuboid, or even higher-dimensional versions of these shapes.\
\
Parameters:\
\
**shape**tuple\[int, …\]\
\
The length of the footprint in each dimension. The length of the sequence determines the number of dimensions of the footprint.\
\
**dtype**data-type, optional\
\
The data type of the footprint.\
\
**decomposition**{None, ‘separable’, ‘sequence’}, optional\
\
If None, a single array is returned. For ‘sequence’, a tuple of smaller footprints is returned. Applying this series of smaller footprints will give an identical result to a single, larger footprint, but often with better computational performance. See Notes for more details. With ‘separable’, this function uses separable 1D footprints for each axis. Whether ‘sequence’ or ‘separable’ is computationally faster may be architecture-dependent.\
\
Returns:\
\
**footprint**array or tuple\[tuple\[ndarray, int\], …\]\
\
A footprint consisting only of ones, i.e. every pixel belongs to the neighborhood. When decomposition is None, this is just an array. Otherwise, this will be a tuple whose length is equal to the number of unique structuring elements to apply (see Examples for more detail).\
\
Examples\
\
\>>> import cucim.skimage as ski\
\>>> ski.morphology.footprint\_rectangle((3, 5))\
array(\[\[1, 1, 1, 1, 1\],\
\[1, 1, 1, 1, 1\],\
\[1, 1, 1, 1, 1\]\], dtype=uint8)\
\
Decomposition will return multiple footprints that combine into a simple footprint of the requested shape.\
\
\>>> ski.morphology.footprint\_rectangle((9, 9), decomposition\="sequence")\
((array(\[\[1, 1, 1\],\
\[1, 1, 1\],\
\[1, 1, 1\]\], dtype=uint8),\
4),)\
\
“sequence” makes sure that the decomposition only returns 1D footprints.\
\
\>>> ski.morphology.footprint\_rectangle((3, 5), decomposition\="separable")\
((array(\[\[1\],\
\[1\],\
\[1\]\], dtype=uint8),\
1),\
(array(\[\[1, 1, 1, 1, 1\]\], dtype=uint8), 1))\
\
Generate a 5-dimensional hypercube with 3 samples in each dimension\
\
\>>> ski.morphology.footprint\_rectangle((3,) \* 5).shape\
(3, 3, 3, 3, 3)\
\
cucim.skimage.morphology.isotropic\_closing(_image_, _radius_, _out\=None_, _spacing\=None_)[#](#cucim.skimage.morphology.isotropic_closing "Permalink to this definition")\
\
Return binary morphological closing of an image.\
\
This function returns the same result as binary [`skimage.morphology.binary_closing()`](https://scikit-image.org/docs/stable/api/skimage.morphology.html#skimage.morphology.binary_closing "(in skimage v0.25.2)")\
but performs faster for large circular structuring elements. This works by thresholding the exact Euclidean distance map [\[1\]](#rf7a1262585f2-1)\
, [\[2\]](#rf7a1262585f2-2)\
. The implementation is based on: func:cucim.core.operations.morphology.distance\_transform\_edt.\
\
Parameters:\
\
**image**ndarray\
\
Binary input image.\
\
**radius**float\
\
The radius with which the regions should be closed.\
\
**out**ndarray of bool, optional\
\
The array to store the result of the morphology. If None, is passed, a new array will be allocated.\
\
**spacing**float, or sequence of float, optional\
\
Spacing of elements along each dimension. If a sequence, must be of length equal to the input’s dimension (number of axes). If a single number, this value is used for all axes. If not specified, a grid spacing of unity is implied.\
\
Returns:\
\
**closed**ndarray of bool\
\
The result of the morphological closing.\
\
Notes\
\
Empirically, on an RTX A6000 GPU, it was observed that `isotropic_closing` is faster than `binary_closing` with `decomposition=None` at radius 12 in 2D and radius 3 in 3D. It becomes faster than `binary_erosion` with `decomposition="sequence"` at radius 14 in 2D and radius 5 in 3D. In practice, the exact point at which these isotropic functions become faster than their binary counterparts will also be dependent on image shape and content.\
\
References\
\
\[[1](#id277)\
\]\
\
Cuisenaire, O. and Macq, B., “Fast Euclidean morphological operators using local distance transformation by propagation, and applications,” Image Processing And Its Applications, 1999. Seventh International Conference on (Conf. Publ. No. 465), 1999, pp. 856-860 vol.2. [DOI:10.1049/cp:19990446](https://doi.org/10.1049/cp:19990446)\
\
\[[2](#id278)\
\]\
\
Ingemar Ragnemalm, Fast erosion and dilation by contour processing and thresholding of distance maps, Pattern Recognition Letters, Volume 13, Issue 3, 1992, Pages 161-166. [DOI:10.1016/0167-8655(92)90055-5](https://doi.org/10.1016/0167-8655(92)90055-5)\
\
cucim.skimage.morphology.isotropic\_dilation(_image_, _radius_, _out\=None_, _spacing\=None_)[#](#cucim.skimage.morphology.isotropic_dilation "Permalink to this definition")\
\
Return binary morphological dilation of an image.\
\
This function returns the same result as [`skimage.morphology.binary_dilation()`](https://scikit-image.org/docs/stable/api/skimage.morphology.html#skimage.morphology.binary_dilation "(in skimage v0.25.2)")\
but performs faster for large circular structuring elements. This works by applying a threshold to the exact Euclidean distance map of the inverted image [\[1\]](#re99c914bb6cb-1)\
, [\[2\]](#re99c914bb6cb-2)\
. The implementation is based on: func:cucim.core.operations.morphology.distance\_transform\_edt.\
\
Parameters:\
\
**image**ndarray\
\
Binary input image.\
\
**radius**float\
\
The radius by which regions should be dilated.\
\
**out**ndarray of bool, optional\
\
The array to store the result of the morphology. If None is passed, a new array will be allocated.\
\
**spacing**float, or sequence of float, optional\
\
Spacing of elements along each dimension. If a sequence, must be of length equal to the input’s dimension (number of axes). If a single number, this value is used for all axes. If not specified, a grid spacing of unity is implied.\
\
Returns:\
\
**dilated**ndarray of bool\
\
The result of the morphological dilation with values in `[False, True]`.\
\
Notes\
\
Empirically, on an RTX A6000 GPU, it was observed that `isotropic_dilation` is faster than `binary_dilation` with `decomposition=None` at radius 12 in 2D and radius 3 in 3D. It becomes faster than `binary_dilation` with `decomposition="sequence"` at radius 14 in 2D and radius 5 in 3D. In practice, the exact point at which these isotropic functions become faster than their binary counterparts will also be dependent on image shape and content.\
\
References\
\
\[[1](#id281)\
\]\
\
Cuisenaire, O. and Macq, B., “Fast Euclidean morphological operators using local distance transformation by propagation, and applications,” Image Processing And Its Applications, 1999. Seventh International Conference on (Conf. Publ. No. 465), 1999, pp. 856-860 vol.2. [DOI:10.1049/cp:19990446](https://doi.org/10.1049/cp:19990446)\
\
\[[2](#id282)\
\]\
\
Ingemar Ragnemalm, Fast erosion and dilation by contour processing and thresholding of distance maps, Pattern Recognition Letters, Volume 13, Issue 3, 1992, Pages 161-166. [DOI:10.1016/0167-8655(92)90055-5](https://doi.org/10.1016/0167-8655(92)90055-5)\
\
cucim.skimage.morphology.isotropic\_erosion(_image_, _radius_, _out\=None_, _spacing\=None_)[#](#cucim.skimage.morphology.isotropic_erosion "Permalink to this definition")\
\
Return binary morphological erosion of an image.\
\
This function returns the same result as [`skimage.morphology.binary_erosion()`](https://scikit-image.org/docs/stable/api/skimage.morphology.html#skimage.morphology.binary_erosion "(in skimage v0.25.2)")\
but performs faster for large circular structuring elements. This works by applying a threshold to the exact Euclidean distance map of the image [\[1\]](#rfafca02defc4-1)\
, [\[2\]](#rfafca02defc4-2)\
. The implementation is based on: func:cucim.core.operations.morphology.distance\_transform\_edt.\
\
Parameters:\
\
**image**ndarray\
\
Binary input image.\
\
**radius**float\
\
The radius by which regions should be eroded.\
\
**out**ndarray of bool, optional\
\
The array to store the result of the morphology. If None, a new array will be allocated.\
\
**spacing**float, or sequence of float, optional\
\
Spacing of elements along each dimension. If a sequence, must be of length equal to the input’s dimension (number of axes). If a single number, this value is used for all axes. If not specified, a grid spacing of unity is implied.\
\
Returns:\
\
**eroded**ndarray of bool\
\
The result of the morphological erosion taking values in `[False, True]`.\
\
Notes\
\
Empirically, on an RTX A6000 GPU, it was observed that `isotropic_erosion` is faster than `binary_erosion` with `decomposition=None` at radius 12 in 2D and radius 3 in 3D. It becomes faster than `binary_erosion` with `decomposition="sequence"` at radius 14 in 2D and radius 5 in 3D. In practice, the exact point at which these isotropic functions become faster than their binary counterparts will also be dependent on image shape and content.\
\
References\
\
\[[1](#id285)\
\]\
\
Cuisenaire, O. and Macq, B., “Fast Euclidean morphological operators using local distance transformation by propagation, and applications,” Image Processing And Its Applications, 1999. Seventh International Conference on (Conf. Publ. No. 465), 1999, pp. 856-860 vol.2. [DOI:10.1049/cp:19990446](https://doi.org/10.1049/cp:19990446)\
\
\[[2](#id286)\
\]\
\
Ingemar Ragnemalm, Fast erosion and dilation by contour processing and thresholding of distance maps, Pattern Recognition Letters, Volume 13, Issue 3, 1992, Pages 161-166. [DOI:10.1016/0167-8655(92)90055-5](https://doi.org/10.1016/0167-8655(92)90055-5)\
\
cucim.skimage.morphology.isotropic\_opening(_image_, _radius_, _out\=None_, _spacing\=None_)[#](#cucim.skimage.morphology.isotropic_opening "Permalink to this definition")\
\
Return binary morphological opening of an image.\
\
This function returns the same result as [`skimage.morphology.binary_opening()`](https://scikit-image.org/docs/stable/api/skimage.morphology.html#skimage.morphology.binary_opening "(in skimage v0.25.2)")\
but performs faster for large circular structuring elements. This works by thresholding the exact Euclidean distance map [\[1\]](#ra33c1fbc8804-1)\
, [\[2\]](#ra33c1fbc8804-2)\
. The implementation is based on: func:cucim.core.operations.morphology.distance\_transform\_edt.\
\
Parameters:\
\
**image**ndarray\
\
Binary input image.\
\
**radius**float\
\
The radius with which the regions should be opened.\
\
**out**ndarray of bool, optional\
\
The array to store the result of the morphology. If None is passed, a new array will be allocated.\
\
**spacing**float, or sequence of float, optional\
\
Spacing of elements along each dimension. If a sequence, must be of length equal to the input’s dimension (number of axes). If a single number, this value is used for all axes. If not specified, a grid spacing of unity is implied.\
\
Returns:\
\
**opened**ndarray of bool\
\
The result of the morphological opening.\
\
Notes\
\
Empirically, on an RTX A6000 GPU, it was observed that `isotropic_opening` is faster than `binary_opening` with `decomposition=None` at radius 12 in 2D and radius 3 in 3D. It becomes faster than `binary_erosion` with `decomposition="sequence"` at radius 14 in 2D and radius 5 in 3D. In practice, the exact point at which these isotropic functions become faster than their binary counterparts will also be dependent on image shape and content.\
\
References\
\
\[[1](#id289)\
\]\
\
Cuisenaire, O. and Macq, B., “Fast Euclidean morphological operators using local distance transformation by propagation, and applications,” Image Processing And Its Applications, 1999. Seventh International Conference on (Conf. Publ. No. 465), 1999, pp. 856-860 vol.2. [DOI:10.1049/cp:19990446](https://doi.org/10.1049/cp:19990446)\
\
\[[2](#id290)\
\]\
\
Ingemar Ragnemalm, Fast erosion and dilation by contour processing and thresholding of distance maps, Pattern Recognition Letters, Volume 13, Issue 3, 1992, Pages 161-166. [DOI:10.1016/0167-8655(92)90055-5](https://doi.org/10.1016/0167-8655(92)90055-5)\
\
cucim.skimage.morphology.medial\_axis(_image_, _mask\=None_, _return\_distance\=False_, _\*_, _rng\=None_)[#](#cucim.skimage.morphology.medial_axis "Permalink to this definition")\
\
Compute the medial axis transform of a binary image.\
\
Parameters:\
\
**image**binary ndarray, shape (M, N)\
\
The image of the shape to skeletonize. If this input isn’t already a binary image, it gets converted into one: In this case, zero values are considered background (False), nonzero values are considered foreground (True).\
\
**mask**binary ndarray, shape (M, N), optional\
\
If a mask is given, only those elements in image with a true value in mask are used for computing the medial axis.\
\
**return\_distance**bool, optional\
\
If true, the distance transform is returned as well as the skeleton.\
\
**rng**{numpy.random.Generator, int}, optional\
\
Pseudo-random number generator. By default, a PCG64 generator is used (see [`numpy.random.default_rng()`](https://numpy.org/doc/stable/reference/random/generator.html#numpy.random.default_rng "(in NumPy v2.2)")\
). If rng is an int, it is used to seed the generator.\
\
The PRNG determines the order in which pixels are processed for tiebreaking.\
\
Note: Due to a missing permute method on CuPy’s random Generator class, only a numpy.random.Generator is currently supported.\
\
Returns:\
\
**out**ndarray of bools\
\
Medial axis transform of the image\
\
**dist**ndarray of ints, optional\
\
Distance transform of the image (only returned if return\_distance is True)\
\
See also\
\
`skeletonize`, [`thin`](#cucim.skimage.morphology.thin "cucim.skimage.morphology.thin")\
\
Notes\
\
This algorithm computes the medial axis transform of an image as the ridges of its distance transform.\
\
The different steps of the algorithm are as follows\
\
* A lookup table is used, that assigns 0 or 1 to each configuration of the 3x3 binary square, whether the central pixel should be removed or kept. We want a point to be removed if it has more than one neighbor and if removing it does not change the number of connected components.\
\
* The distance transform to the background is computed, as well as the cornerness of the pixel.\
\
* The foreground (value of 1) points are ordered by the distance transform, then the cornerness.\
\
* A cython function is called to reduce the image to its skeleton. It processes pixels in the order determined at the previous step, and removes or maintains a pixel according to the lookup table. Because of the ordering, it is possible to process all pixels in only one pass.\
\
\
Examples\
\
\>>> square \= np.zeros((7, 7), dtype\=bool)\
\>>> square\[1:\-1, 2:\-2\] \= 1\
\>>> square.view(cp.uint8)\
array(\[\[0, 0, 0, 0, 0, 0, 0\],\
\[0, 0, 1, 1, 1, 0, 0\],\
\[0, 0, 1, 1, 1, 0, 0\],\
\[0, 0, 1, 1, 1, 0, 0\],\
\[0, 0, 1, 1, 1, 0, 0\],\
\[0, 0, 1, 1, 1, 0, 0\],\
\[0, 0, 0, 0, 0, 0, 0\]\], dtype=uint8)\
\>>> medial\_axis(square).view(cp.uint8)\
array(\[\[0, 0, 0, 0, 0, 0, 0\],\
\[0, 0, 1, 0, 1, 0, 0\],\
\[0, 0, 0, 1, 0, 0, 0\],\
\[0, 0, 0, 1, 0, 0, 0\],\
\[0, 0, 0, 1, 0, 0, 0\],\
\[0, 0, 1, 0, 1, 0, 0\],\
\[0, 0, 0, 0, 0, 0, 0\]\], dtype=uint8)\
\
cucim.skimage.morphology.octagon(_m_, _n_, _dtype=_, _\*_, _decomposition=None_)[#](#cucim.skimage.morphology.octagon "Permalink to this definition")\
\
Generates an octagon shaped footprint.\
\
For a given size of (m) horizontal and vertical sides and a given (n) height or width of slanted sides octagon is generated. The slanted sides are 45 or 135 degrees to the horizontal axis and hence the widths and heights are equal. The overall size of the footprint along a single axis will be `m + 2 * n`.\
\
Parameters:\
\
**m**int\
\
The size of the horizontal and vertical sides.\
\
**n**int\
\
The height or width of the slanted sides.\
\
Returns:\
\
**footprint**cupy.ndarray\
\
The footprint where elements of the neighborhood are 1 and 0 otherwise. When decomposition is None, this is just a numpy.ndarray. Otherwise, this will be a tuple whose length is equal to the number of unique structuring elements to apply (see Notes for more detail)\
\
Other Parameters:\
\
**dtype**data-type, optional\
\
The data type of the footprint.\
\
**decomposition**{None, ‘sequence’}, optional\
\
If None, a single array is returned. For ‘sequence’, a tuple of smaller footprints is returned. Applying this series of smaller footprints will given an identical result to a single, larger footprint, but with better computational performance. See Notes for more details.\
\
Notes\
\
When decomposition is not None, each element of the footprint tuple is a 2-tuple of the form `(ndarray, num_iter)` that specifies a footprint array and the number of iterations it is to be applied.\
\
For either binary or grayscale morphology, using `decomposition='sequence'` was observed to have a performance benefit, with the magnitude of the benefit increasing with increasing footprint size.\
\
cucim.skimage.morphology.octahedron(_radius_, _dtype=_, _\*_, _decomposition=None_)[#](#cucim.skimage.morphology.octahedron "Permalink to this definition")\
\
Generates a octahedron-shaped footprint.\
\
This is the 3D equivalent of a diamond. A pixel is part of the neighborhood (i.e. labeled 1) if the city block/Manhattan distance between it and the center of the neighborhood is no greater than radius.\
\
Parameters:\
\
**radius**int\
\
The radius of the octahedron-shaped footprint.\
\
Returns:\
\
**footprint**cupy.ndarray\
\
The footprint where elements of the neighborhood are 1 and 0 otherwise. When decomposition is None, this is just a numpy.ndarray. Otherwise, this will be a tuple whose length is equal to the number of unique structuring elements to apply (see Notes for more detail)\
\
Other Parameters:\
\
**dtype**data-type, optional\
\
The data type of the footprint.\
\
**decomposition**{None, ‘sequence’}, optional\
\
If None, a single array is returned. For ‘sequence’, a tuple of smaller footprints is returned. Applying this series of smaller footprints will given an identical result to a single, larger footprint, but with better computational performance. See Notes for more details.\
\
Notes\
\
When decomposition is not None, each element of the footprint tuple is a 2-tuple of the form `(ndarray, num_iter)` that specifies a footprint array and the number of iterations it is to be applied.\
\
For either binary or grayscale morphology, using `decomposition='sequence'` was observed to have a performance benefit, with the magnitude of the benefit increasing with increasing footprint size.\
\
cucim.skimage.morphology.opening(_image_, _footprint\=None_, _out\=None_, _\*_, _mode\='reflect'_, _cval\=0.0_)[#](#cucim.skimage.morphology.opening "Permalink to this definition")\
\
Return grayscale morphological opening of an image.\
\
The morphological opening of an image is defined as an erosion followed by a dilation. Opening can remove small bright spots (i.e. “salt”) and connect small dark cracks. This tends to “open” up (dark) gaps between (bright) features.\
\
Parameters:\
\
**image**cupy.ndarray\
\
Image array.\
\
**footprint**cupy.ndarray, optional\
\
The neighborhood expressed as a 2-D array of 1’s and 0’s. If None, use a cross-shaped footprint (connectivity=1). The footprint can also be provided as a sequence of smaller footprints as described in the notes below.\
\
**out**cupy.ndarray, optional\
\
The array to store the result of the morphology. If None is passed, a new array will be allocated.\
\
**mode**str, optional\
\
The mode parameter determines how the array borders are handled. Valid modes are: ‘reflect’, ‘constant’, ‘nearest’, ‘mirror’, ‘wrap’, ‘max’, ‘min’, or ‘ignore’. If ‘max’ or ‘ignore’, pixels outside the image domain are assumed to be the maximum for the image’s dtype, which causes them to not influence the result. Default is ‘reflect’.\
\
**cval**scalar, optional\
\
Value to fill past edges of input if mode is ‘constant’. Default is 0.0.\
\
New in version 24.06: mode and cval were added in 24.06.\
\
Returns:\
\
**opening**cupy.ndarray, same shape and type as image\
\
The result of the morphological opening.\
\
Notes\
\
The footprint can also be a provided as a sequence of 2-tuples where the first element of each 2-tuple is a footprint ndarray and the second element is an integer describing the number of times it should be iterated. For example `footprint=[(cp.ones((9, 1)), 1), (cp.ones((1, 9)), 1)]` would apply a 9x1 footprint followed by a 1x9 footprint resulting in a net effect that is the same as `footprint=cp.ones((9, 9))`, but with lower computational cost. Most of the builtin footprints such as [`skimage.morphology.disk()`](https://scikit-image.org/docs/stable/api/skimage.morphology.html#skimage.morphology.disk "(in skimage v0.25.2)")\
provide an option to automatically generate a footprint sequence of this type.\
\
Examples\
\
\>>> \# Open up gap between two bright regions (but also shrink regions)\
\>>> import cupy as cp\
\>>> from cucim.skimage.morphology import footprint\_rectangle\
\>>> bad\_connection \= cp.asarray(\[\[1, 0, 0, 0, 1\],\
... \[1, 1, 0, 1, 1\],\
... \[1, 1, 1, 1, 1\],\
... \[1, 1, 0, 1, 1\],\
... \[1, 0, 0, 0, 1\]\], dtype\=cp.uint8)\
\>>> opening(bad\_connection, footprint\_rectangle((3, 3)))\
array(\[\[0, 0, 0, 0, 0\],\
\[1, 1, 0, 1, 1\],\
\[1, 1, 0, 1, 1\],\
\[1, 1, 0, 1, 1\],\
\[0, 0, 0, 0, 0\]\], dtype=uint8)\
\
cucim.skimage.morphology.reconstruction(_seed_, _mask_, _method\='dilation'_, _footprint\=None_, _offset\=None_)[#](#cucim.skimage.morphology.reconstruction "Permalink to this definition")\
\
Perform a morphological reconstruction of an image.\
\
Morphological reconstruction by dilation is similar to basic morphological dilation: high-intensity values will replace nearby low-intensity values. The basic dilation operator, however, uses a footprint to determine how far a value in the input image can spread. In contrast, reconstruction uses two images: a “seed” image, which specifies the values that spread, and a “mask” image, which gives the maximum allowed value at each pixel. The mask image, like the footprint, limits the spread of high-intensity values. Reconstruction by erosion is simply the inverse: low-intensity values spread from the seed image and are limited by the mask image, which represents the minimum allowed value.\
\
Alternatively, you can think of reconstruction as a way to isolate the connected regions of an image. For dilation, reconstruction connects regions marked by local maxima in the seed image: neighboring pixels less-than-or-equal-to those seeds are connected to the seeded region. Local maxima with values larger than the seed image will get truncated to the seed value.\
\
Parameters:\
\
**seed**ndarray\
\
The seed image (a.k.a. marker image), which specifies the values that are dilated or eroded.\
\
**mask**ndarray\
\
The maximum (dilation) / minimum (erosion) allowed value at each pixel.\
\
**method**{‘dilation’|’erosion’}, optional\
\
Perform reconstruction by dilation or erosion. In dilation (or erosion), the seed image is dilated (or eroded) until limited by the mask image. For dilation, each seed value must be less than or equal to the corresponding mask value; for erosion, the reverse is true. Default is ‘dilation’.\
\
**footprint**ndarray, optional\
\
The neighborhood expressed as an n-D array of 1’s and 0’s. Default is the n-D square of radius equal to 1 (i.e. a 3x3 square for 2D images, a 3x3x3 cube for 3D images, etc.)\
\
**offset**ndarray, optional\
\
The coordinates of the center of the footprint. Default is located on the geometrical center of the footprint, in that case footprint dimensions must be odd.\
\
Returns:\
\
**reconstructed**ndarray\
\
The result of morphological reconstruction.\
\
Notes\
\
The algorithm is taken from [\[1\]](#r790032433545-1)\
. Applications for grayscale reconstruction are discussed in [\[2\]](#r790032433545-2)\
and [\[3\]](#r790032433545-3)\
.\
\
References\
\
\[[1](#id293)\
\]\
\
Robinson, “Efficient morphological reconstruction: a downhill filter”, Pattern Recognition Letters 25 (2004) 1759-1767.\
\
\[[2](#id294)\
\]\
\
Vincent, L., “Morphological Grayscale Reconstruction in Image Analysis: Applications and Efficient Algorithms”, IEEE Transactions on Image Processing (1993)\
\
\[[3](#id295)\
\]\
\
Soille, P., “Morphological Image Analysis: Principles and Applications”, Chapter 6, 2nd edition (2003), ISBN 3540429883.\
\
Examples\
\
\>>> import cupy as cp\
\>>> from cucim.skimage.morphology import reconstruction\
\
First, we create a sinusoidal mask image with peaks at middle and ends.\
\
\>>> x \= cp.linspace(0, 4 \* np.pi)\
\>>> y\_mask \= cp.cos(x)\
\
Then, we create a seed image initialized to the minimum mask value (for reconstruction by dilation, min-intensity values don’t spread) and add “seeds” to the left and right peak, but at a fraction of peak value (1).\
\
\>>> y\_seed \= y\_mask.min() \* cp.ones\_like(x)\
\>>> y\_seed\[0\] \= 0.5\
\>>> y\_seed\[\-1\] \= 0\
\>>> y\_rec \= reconstruction(y\_seed, y\_mask)\
\
The reconstructed image (or curve, in this case) is exactly the same as the mask image, except that the peaks are truncated to 0.5 and 0. The middle peak disappears completely: Since there were no seed values in this peak region, its reconstructed value is truncated to the surrounding value (-1).\
\
As a more practical example, we try to extract the bright features of an image by subtracting a background image created by reconstruction.\
\
\>>> y, x \= cp.mgrid\[:20:0.5, :20:0.5\]\
\>>> bumps \= cp.sin(x) + cp.sin(y)\
\
To create the background image, set the mask image to the original image, and the seed image to the original image with an intensity offset, h.\
\
\>>> h \= 0.3\
\>>> seed \= bumps \- h\
\>>> background \= reconstruction(seed, bumps)\
\
The resulting reconstructed image looks exactly like the original image, but with the peaks of the bumps cut off. Subtracting this reconstructed image from the original image leaves just the peaks of the bumps\
\
\>>> hdome \= bumps \- background\
\
This operation is known as the h-dome of the image and leaves features of height h in the subtracted image.\
\
cucim.skimage.morphology.remove\_small\_holes(_ar_, _area\_threshold\=64_, _connectivity\=1_, _\*_, _out\=None_)[#](#cucim.skimage.morphology.remove_small_holes "Permalink to this definition")\
\
Remove contiguous holes smaller than the specified size.\
\
Parameters:\
\
**ar**ndarray (arbitrary shape, int or bool type)\
\
The array containing the connected components of interest.\
\
**area\_threshold**int, optional (default: 64)\
\
The maximum area, in pixels, of a contiguous hole that will be filled. Replaces min\_size.\
\
**connectivity**int, {1, 2, …, ar.ndim}, optional (default: 1)\
\
The connectivity defining the neighborhood of a pixel.\
\
**out**ndarray\
\
Array of the same shape as ar and bool dtype, into which the output is placed. By default, a new array is created.\
\
Returns:\
\
**out**ndarray, same shape and type as input ar\
\
The input array with small holes within connected components removed.\
\
Raises:\
\
TypeError\
\
If the input array is of an invalid type, such as float or string.\
\
ValueError\
\
If the input array contains negative values.\
\
Notes\
\
If the array type is int, it is assumed that it contains already-labeled objects. The labels are not kept in the output image (this function always outputs a bool image). It is suggested that labeling is completed after using this function.\
\
Examples\
\
\>>> import cupy as cp\
\>>> from cucim.skimage import morphology\
\>>> a \= cp.array(\[\[1, 1, 1, 1, 1, 0\],\
... \[1, 1, 1, 0, 1, 0\],\
... \[1, 0, 0, 1, 1, 0\],\
... \[1, 1, 1, 1, 1, 0\]\], bool)\
\>>> b \= morphology.remove\_small\_holes(a, 2)\
\>>> b\
array(\[\[ True, True, True, True, True, False\],\
\[ True, True, True, True, True, False\],\
\[ True, False, False, True, True, False\],\
\[ True, True, True, True, True, False\]\])\
\>>> c \= morphology.remove\_small\_holes(a, 2, connectivity\=2)\
\>>> c\
array(\[\[ True, True, True, True, True, False\],\
\[ True, True, True, False, True, False\],\
\[ True, False, False, True, True, False\],\
\[ True, True, True, True, True, False\]\])\
\>>> d \= morphology.remove\_small\_holes(a, 2, out\=a)\
\>>> d is a\
True\
\
cucim.skimage.morphology.remove\_small\_objects(_ar_, _min\_size\=64_, _connectivity\=1_, _\*_, _out\=None_)[#](#cucim.skimage.morphology.remove_small_objects "Permalink to this definition")\
\
Remove objects smaller than the specified size.\
\
Expects ar to be an array with labeled objects, and removes objects smaller than min\_size. If ar is bool, the image is first labeled. This leads to potentially different behavior for bool and 0-and-1 arrays.\
\
Parameters:\
\
**ar**ndarray (arbitrary shape, int or bool type)\
\
The array containing the objects of interest. If the array type is int, the ints must be non-negative.\
\
**min\_size**int, optional (default: 64)\
\
The smallest allowable object size.\
\
**connectivity**int, {1, 2, …, ar.ndim}, optional (default: 1)\
\
The connectivity defining the neighborhood of a pixel. Used during labelling if ar is bool.\
\
**out**ndarray\
\
Array of the same shape as ar, into which the output is placed. By default, a new array is created.\
\
Returns:\
\
**out**ndarray, same shape and type as input ar\
\
The input array with small connected components removed.\
\
Raises:\
\
TypeError\
\
If the input array is of an invalid type, such as float or string.\
\
ValueError\
\
If the input array contains negative values.\
\
Examples\
\
\>>> import cupy as cp\
\>>> from cucim.skimage import morphology\
\>>> a \= cp.array(\[\[0, 0, 0, 1, 0\],\
... \[1, 1, 1, 0, 0\],\
... \[1, 1, 1, 0, 1\]\], bool)\
\>>> b \= morphology.remove\_small\_objects(a, 6)\
\>>> b\
array(\[\[False, False, False, False, False\],\
\[ True, True, True, False, False\],\
\[ True, True, True, False, False\]\])\
\>>> c \= morphology.remove\_small\_objects(a, 7, connectivity\=2)\
\>>> c\
array(\[\[False, False, False, True, False\],\
\[ True, True, True, False, False\],\
\[ True, True, True, False, False\]\])\
\>>> d \= morphology.remove\_small\_objects(a, 6, out\=a)\
\>>> d is a\
True\
\
cucim.skimage.morphology.star(_a_, _dtype=_)[#](#cucim.skimage.morphology.star "Permalink to this definition")\
\
Generates a star shaped footprint.\
\
Start has 8 vertices and is an overlap of square of size 2\*a + 1 with its 45 degree rotated version. The slanted sides are 45 or 135 degrees to the horizontal axis.\
\
Parameters:\
\
**a**int\
\
Parameter deciding the size of the star structural element. The side of the square array returned is 2\*a + 1 + 2\*floor(a / 2).\
\
Returns:\
\
**footprint**cupy.ndarray\
\
The footprint where elements of the neighborhood are 1 and 0 otherwise.\
\
Other Parameters:\
\
**dtype**data-type, optional\
\
The data type of the footprint.\
\
cucim.skimage.morphology.thin(_image_, _max\_num\_iter\=None_)[#](#cucim.skimage.morphology.thin "Permalink to this definition")\
\
Perform morphological thinning of a binary image.\
\
Parameters:\
\
**image**binary (M, N) ndarray\
\
The image to thin. If this input isn’t already a binary image, it gets converted into one: In this case, zero values are considered background (False), nonzero values are considered foreground (True).\
\
**max\_num\_iter**int, number of iterations, optional\
\
Regardless of the value of this parameter, the thinned image is returned immediately if an iteration produces no change. If this parameter is specified it thus sets an upper bound on the number of iterations performed.\
\
Returns:\
\
**out**ndarray of bool\
\
Thinned image.\
\
See also\
\
[`medial_axis`](#cucim.skimage.morphology.medial_axis "cucim.skimage.morphology.medial_axis")\
\
Notes\
\
This algorithm [\[1\]](#r455cf7e5f861-1)\
works by making multiple passes over the image, removing pixels matching a set of criteria designed to thin connected regions while preserving eight-connected components and 2 x 2 squares [\[2\]](#r455cf7e5f861-2)\
. In each of the two sub-iterations the algorithm correlates the intermediate skeleton image with a neighborhood mask, then looks up each neighborhood in a lookup table indicating whether the central pixel should be deleted in that sub-iteration.\
\
References\
\
\[[1](#id299)\
\]\
\
Z. Guo and R. W. Hall, “Parallel thinning with two-subiteration algorithms,” Comm. ACM, vol. 32, no. 3, pp. 359-373, 1989. [DOI:10.1145/62065.62074](https://doi.org/10.1145/62065.62074)\
\
\[[2](#id300)\
\]\
\
Lam, L., Seong-Whan Lee, and Ching Y. Suen, “Thinning Methodologies-A Comprehensive Survey,” IEEE Transactions on Pattern Analysis and Machine Intelligence, Vol 14, No. 9, p. 879, 1992. [DOI:10.1109/34.161346](https://doi.org/10.1109/34.161346)\
\
Examples\
\
\>>> square \= np.zeros((7, 7), dtype\=bool)\
\>>> square\[1:\-1, 2:\-2\] \= 1\
\>>> square\[0, 1\] \= 1\
\>>> square.view(cp.uint8)\
array(\[\[0, 1, 0, 0, 0, 0, 0\],\
\[0, 0, 1, 1, 1, 0, 0\],\
\[0, 0, 1, 1, 1, 0, 0\],\
\[0, 0, 1, 1, 1, 0, 0\],\
\[0, 0, 1, 1, 1, 0, 0\],\
\[0, 0, 1, 1, 1, 0, 0\],\
\[0, 0, 0, 0, 0, 0, 0\]\], dtype=uint8)\
\>>> skel \= thin(square)\
\>>> skel.view(np.uint8)\
array(\[\[0, 1, 0, 0, 0, 0, 0\],\
\[0, 0, 1, 0, 0, 0, 0\],\
\[0, 0, 0, 1, 0, 0, 0\],\
\[0, 0, 0, 1, 0, 0, 0\],\
\[0, 0, 0, 1, 0, 0, 0\],\
\[0, 0, 0, 0, 0, 0, 0\],\
\[0, 0, 0, 0, 0, 0, 0\]\], dtype=uint8)\
\
cucim.skimage.morphology.white\_tophat(_image_, _footprint\=None_, _out\=None_, _\*_, _mode\='reflect'_, _cval\=0.0_)[#](#cucim.skimage.morphology.white_tophat "Permalink to this definition")\
\
Return white top hat of an image.\
\
The white top hat of an image is defined as the image minus its morphological opening. This operation returns the bright spots of the image that are smaller than the footprint.\
\
Parameters:\
\
**image**cupy.ndarray\
\
Image array.\
\
**footprint**cupy.ndarray, optional\
\
The neighborhood expressed as a 2-D array of 1’s and 0’s. If None, use a cross-shaped footprint (connectivity=1). The footprint can also be provided as a sequence of smaller footprints as described in the notes below.\
\
**out**cupy.ndarray, optional\
\
The array to store the result of the morphology. If None is passed, a new array will be allocated.\
\
**mode**str, optional\
\
The mode parameter determines how the array borders are handled. Valid modes are: ‘reflect’, ‘constant’, ‘nearest’, ‘mirror’, ‘wrap’, ‘max’, ‘min’, or ‘ignore’. If ‘max’ or ‘ignore’, pixels outside the image domain are assumed to be the maximum for the image’s dtype, which causes them to not influence the result. Default is ‘reflect’.\
\
**cval**scalar, optional\
\
Value to fill past edges of input if mode is ‘constant’. Default is 0.0.\
\
New in version 24.06: mode and cval were added in 24.06.\
\
Returns:\
\
**out**cupy.ndarray, same shape and type as image\
\
The result of the morphological white top hat.\
\
See also\
\
[`black_tophat`](#cucim.skimage.morphology.black_tophat "cucim.skimage.morphology.black_tophat")\
\
Notes\
\
The footprint can also be a provided as a sequence of 2-tuples where the first element of each 2-tuple is a footprint ndarray and the second element is an integer describing the number of times it should be iterated. For example `footprint=[(cp.ones((9, 1)), 1), (cp.ones((1, 9)), 1)]` would apply a 9x1 footprint followed by a 1x9 footprint resulting in a net effect that is the same as `footprint=cp.ones((9, 9))`, but with lower computational cost. Most of the builtin footprints such as [`skimage.morphology.disk()`](https://scikit-image.org/docs/stable/api/skimage.morphology.html#skimage.morphology.disk "(in skimage v0.25.2)")\
provide an option to automatically generate a footprint sequence of this type.\
\
References\
\
\[1\]\
\
[https://en.wikipedia.org/wiki/Top-hat\_transform](https://en.wikipedia.org/wiki/Top-hat_transform)\
\
Examples\
\
\>>> \# Subtract grey background from bright peak\
\>>> import cupy as cp\
\>>> from cucim.skimage.morphology import footprint\_rectangle\
\>>> bright\_on\_grey \= cp.asarray(\[\[2, 3, 3, 3, 2\],\
... \[3, 4, 5, 4, 3\],\
... \[3, 5, 9, 5, 3\],\
... \[3, 4, 5, 4, 3\],\
... \[2, 3, 3, 3, 2\]\], dtype\=cp.uint8)\
\>>> white\_tophat(bright\_on\_grey, footprint\_rectangle((3, 3)))\
array(\[\[0, 0, 0, 0, 0\],\
\[0, 0, 1, 0, 0\],\
\[0, 1, 5, 1, 0\],\
\[0, 0, 1, 0, 0\],\
\[0, 0, 0, 0, 0\]\], dtype=uint8)\
\
### registration[#](#module-cucim.skimage.registration "Permalink to this heading")\
\
Image registration algorithms, e.g., optical flow or phase cross correlation.\
\
cucim.skimage.registration.optical\_flow\_ilk(_reference\_image_, _moving\_image_, _\*_, _radius=7_, _num\_warp=10_, _gaussian=False_, _prefilter=False_, _dtype=_)[#](#cucim.skimage.registration.optical_flow_ilk "Permalink to this definition")\
\
Coarse to fine optical flow estimator.\
\
The iterative Lucas-Kanade (iLK) solver is applied at each level of the image pyramid. iLK [\[1\]](#r8a901ce569ca-1)\
is a fast and robust alternative to TVL1 algorithm although less accurate for rendering flat surfaces and object boundaries (see [\[2\]](#r8a901ce569ca-2)\
).\
\
Parameters:\
\
**reference\_image**ndarray, shape (M, N\[, P\[, …\]\])\
\
The first grayscale image of the sequence.\
\
**moving\_image**ndarray, shape (M, N\[, P\[, …\]\])\
\
The second grayscale image of the sequence.\
\
**radius**int, optional\
\
Radius of the window considered around each pixel.\
\
**num\_warp**int, optional\
\
Number of times moving\_image is warped.\
\
**gaussian**bool, optional\
\
If True, a Gaussian kernel is used for the local integration. Otherwise, a uniform kernel is used.\
\
**prefilter**bool, optional\
\
Whether to prefilter the estimated optical flow before each image warp. When True, a median filter with window size 3 along each axis is applied. This helps to remove potential outliers.\
\
**dtype**dtype, optional\
\
Output data type: must be floating point. Single precision provides good results and saves memory usage and computation time compared to double precision.\
\
Returns:\
\
**flow**ndarray, shape (reference\_image.ndim, M, N\[, P\[, …\]\])\
\
The estimated optical flow components for each axis.\
\
Notes\
\
* The implemented algorithm is described in **Table2** of [\[1\]](#r8a901ce569ca-1)\
.\
\
* Color images are not supported.\
\
\
References\
\
\[1\] ([1](#id304)\
,[2](#id306)\
)\
\
Le Besnerais, G., & Champagnat, F. (2005, September). Dense optical flow by iterative local window registration. In IEEE International Conference on Image Processing 2005 (Vol. 1, pp. I-137). IEEE. [DOI:10.1109/ICIP.2005.1529706](https://doi.org/10.1109/ICIP.2005.1529706)\
\
\[[2](#id305)\
\]\
\
Plyer, A., Le Besnerais, G., & Champagnat, F. (2016). Massively parallel Lucas Kanade optical flow for real-time video processing applications. Journal of Real-Time Image Processing, 11(4), 713-730. [DOI:10.1007/s11554-014-0423-0](https://doi.org/10.1007/s11554-014-0423-0)\
\
Examples\
\
\>>> import cupy as cp\
\>>> from skimage.data import stereo\_motorcycle\
\>>> from cucim.skimage.color import rgb2gray\
\>>> from cucim.skimage.registration import optical\_flow\_ilk\
\>>> reference\_image, moving\_image, disp \= map(cp.array, stereo\_motorcycle())\
\>>> \# --- Convert the images to gray level: color is not supported.\
\>>> reference\_image \= rgb2gray(reference\_image)\
\>>> moving\_image \= rgb2gray(moving\_image)\
\>>> flow \= optical\_flow\_ilk(moving\_image, reference\_image)\
\
cucim.skimage.registration.optical\_flow\_tvl1(_reference\_image_, _moving\_image_, _\*_, _attachment=15_, _tightness=0.3_, _num\_warp=5_, _num\_iter=10_, _tol=0.0001_, _prefilter=False_, _dtype=_)[#](#cucim.skimage.registration.optical_flow_tvl1 "Permalink to this definition")\
\
Coarse to fine optical flow estimator.\
\
The TV-L1 solver is applied at each level of the image pyramid. TV-L1 is a popular algorithm for optical flow estimation introduced by Zack et al. [\[1\]](#rfeed16b8dc8b-1)\
, improved in [\[2\]](#rfeed16b8dc8b-2)\
and detailed in [\[3\]](#rfeed16b8dc8b-3)\
.\
\
Parameters:\
\
**reference\_image**ndarray, shape (M, N\[, P\[, …\]\])\
\
The first grayscale image of the sequence.\
\
**moving\_image**ndarray, shape (M, N\[, P\[, …\]\])\
\
The second grayscale image of the sequence.\
\
**attachment**float, optional\
\
Attachment parameter (\\(\\lambda\\) in [\[1\]](#rfeed16b8dc8b-1)\
). The smaller this parameter is, the smoother the returned result will be.\
\
**tightness**float, optional\
\
Tightness parameter (\\(\\theta\\) in [\[1\]](#rfeed16b8dc8b-1)\
). It should have a small value in order to maintain attachment and regularization parts in correspondence.\
\
**num\_warp**int, optional\
\
Number of times moving\_image is warped.\
\
**num\_iter**int, optional\
\
Number of fixed point iteration.\
\
**tol**float, optional\
\
Tolerance used as stopping criterion based on the L² distance between two consecutive values of (u, v).\
\
**prefilter**bool, optional\
\
Whether to prefilter the estimated optical flow before each image warp. When True, a median filter with window size 3 along each axis is applied. This helps to remove potential outliers.\
\
**dtype**dtype, optional\
\
Output data type: must be floating point. Single precision provides good results and saves memory usage and computation time compared to double precision.\
\
Returns:\
\
**flow**ndarray, shape (image0.ndim, M, N\[, P\[, …\]\])\
\
The estimated optical flow components for each axis.\
\
Notes\
\
Color images are not supported.\
\
References\
\
\[1\] ([1](#id309)\
,[2](#id312)\
,[3](#id313)\
)\
\
Zach, C., Pock, T., & Bischof, H. (2007, September). A duality based approach for realtime TV-L 1 optical flow. In Joint pattern recognition symposium (pp. 214-223). Springer, Berlin, Heidelberg. [DOI:10.1007/978-3-540-74936-3\_22](https://doi.org/10.1007/978-3-540-74936-3_22)\
\
\[[2](#id310)\
\]\
\
Wedel, A., Pock, T., Zach, C., Bischof, H., & Cremers, D. (2009). An improved algorithm for TV-L 1 optical flow. In Statistical and geometrical approaches to visual motion analysis (pp. 23-45). Springer, Berlin, Heidelberg. [DOI:10.1007/978-3-642-03061-1\_2](https://doi.org/10.1007/978-3-642-03061-1_2)\
\
\[[3](#id311)\
\]\
\
Pérez, J. S., Meinhardt-Llopis, E., & Facciolo, G. (2013). TV-L1 optical flow estimation. Image Processing On Line, 2013, 137-150. [DOI:10.5201/ipol.2013.26](https://doi.org/10.5201/ipol.2013.26)\
\
Examples\
\
\>>> import cupy as cp\
\>>> from cucim.skimage.color import rgb2gray\
\>>> from skimage.data import stereo\_motorcycle\
\>>> from cucim.skimage.registration import optical\_flow\_tvl1\
\>>> image0, image1, disp \= \[cp.array(a) for a in stereo\_motorcycle()\]\
\>>> \# --- Convert the images to gray level: color is not supported.\
\>>> image0 \= rgb2gray(image0)\
\>>> image1 \= rgb2gray(image1)\
\>>> flow \= optical\_flow\_tvl1(image1, image0)\
\
cucim.skimage.registration.phase\_cross\_correlation(_reference\_image_, _moving\_image_, _\*_, _upsample\_factor\=1_, _space\='real'_, _disambiguate\=False_, _reference\_mask\=None_, _moving\_mask\=None_, _overlap\_ratio\=0.3_, _normalization\='phase'_)[#](#cucim.skimage.registration.phase_cross_correlation "Permalink to this definition")\
\
Efficient subpixel image translation registration by cross-correlation.\
\
This code gives the same precision as the FFT upsampled cross-correlation in a fraction of the computation time and with reduced memory requirements. It obtains an initial estimate of the cross-correlation peak by an FFT and then refines the shift estimation by upsampling the DFT only in a small neighborhood of that estimate by means of a matrix-multiply DFT [\[1\]](#r2c60f15ff436-1)\
.\
\
Parameters:\
\
**reference\_image**array\
\
Reference image.\
\
**moving\_image**array\
\
Image to register. Must be same dimensionality as `reference_image`.\
\
**upsample\_factor**int, optional\
\
Upsampling factor. Images will be registered to within `1 / upsample_factor` of a pixel. For example `upsample_factor == 20` means the images will be registered within 1/20th of a pixel. Default is 1 (no upsampling). Not used if any of `reference_mask` or `moving_mask` is not None.\
\
**space**string, one of “real” or “fourier”, optional\
\
Defines how the algorithm interprets input data. “real” means data will be FFT’d to compute the correlation, while “fourier” data will bypass FFT of input data. Case insensitive. Not used if any of `reference_mask` or `moving_mask` is not None.\
\
**disambiguate**bool\
\
The shift returned by this function is only accurate _modulo_ the image shape, due to the periodic nature of the Fourier transform. If this parameter is set to `True`, the _real_ space cross-correlation is computed for each possible shift, and the shift with the highest cross-correlation within the overlapping area is returned.\
\
**reference\_mask**ndarray\
\
Boolean mask for `reference_image`. The mask should evaluate to `True` (or 1) on valid pixels. `reference_mask` should have the same shape as `reference_image`.\
\
**moving\_mask**ndarray or None, optional\
\
Boolean mask for `moving_image`. The mask should evaluate to `True` (or 1) on valid pixels. `moving_mask` should have the same shape as `moving_image`. If `None`, `reference_mask` will be used.\
\
**overlap\_ratio**float, optional\
\
Minimum allowed overlap ratio between images. The correlation for translations corresponding with an overlap ratio lower than this threshold will be ignored. A lower overlap\_ratio leads to smaller maximum translation, while a higher overlap\_ratio leads to greater robustness against spurious matches due to small overlap between masked images. Used only if one of `reference_mask` or `moving_mask` is None.\
\
**normalization**{“phase”, None}\
\
The type of normalization to apply to the cross-correlation. This parameter is unused when masks (reference\_mask and moving\_mask) are supplied.\
\
Returns:\
\
**shift**tuple\
\
Shift vector (in pixels) required to register `moving_image` with `reference_image`. Axis ordering is consistent with the axis order of the input array.\
\
**error**float\
\
Translation invariant normalized RMS error between `reference_image` and `moving_image`. For masked cross-correlation this error is not available and NaN is returned.\
\
**phasediff**float\
\
Global phase difference between the two images (should be zero if images are non-negative). For masked cross-correlation this phase difference is not available and NaN is returned.\
\
Notes\
\
The use of cross-correlation to estimate image translation has a long history dating back to at least [\[2\]](#r2c60f15ff436-2)\
. The “phase correlation” method (selected by `normalization="phase"`) was first proposed in [\[3\]](#r2c60f15ff436-3)\
. Publications [\[1\]](#r2c60f15ff436-1)\
and [\[2\]](#r2c60f15ff436-2)\
use an unnormalized cross-correlation (`normalization=None`). Which form of normalization is better is application-dependent. For example, the phase correlation method works well in registering images under different illumination, but is not very robust to noise. In a high noise scenario, the unnormalized method may be preferable.\
\
When masks are provided, a masked normalized cross-correlation algorithm is used [\[5\]](#r2c60f15ff436-5)\
, [\[6\]](#r2c60f15ff436-6)\
.\
\
References\
\
\[1\] ([1](#id317)\
,[2](#id320)\
)\
\
Manuel Guizar-Sicairos, Samuel T. Thurman, and James R. Fienup, “Efficient subpixel image registration algorithms,” Optics Letters 33, 156-158 (2008). [DOI:10.1364/OL.33.000156](https://doi.org/10.1364/OL.33.000156)\
\
\[2\] ([1](#id318)\
,[2](#id321)\
)\
\
P. Anuta, Spatial registration of multispectral and multitemporal digital imagery using fast Fourier transform techniques, IEEE Trans. Geosci. Electron., vol. 8, no. 4, pp. 353–368, Oct. 1970. [DOI:10.1109/TGE.1970.271435](https://doi.org/10.1109/TGE.1970.271435)\
.\
\
\[[3](#id319)\
\]\
\
C. D. Kuglin D. C. Hines. The phase correlation image alignment method, Proceeding of IEEE International Conference on Cybernetics and Society, pp. 163-165, New York, NY, USA, 1975, pp. 163–165.\
\
\[4\]\
\
James R. Fienup, “Invariant error metrics for image reconstruction” Optics Letters 36, 8352-8357 (1997). [DOI:10.1364/AO.36.008352](https://doi.org/10.1364/AO.36.008352)\
\
\[[5](#id322)\
\]\
\
Dirk Padfield. Masked Object Registration in the Fourier Domain. IEEE Transactions on Image Processing, vol. 21(5), pp. 2706-2718 (2012). [DOI:10.1109/TIP.2011.2181402](https://doi.org/10.1109/TIP.2011.2181402)\
\
\[[6](#id323)\
\]\
\
D. Padfield. “Masked FFT registration”. In Proc. Computer Vision and Pattern Recognition, pp. 2918-2925 (2010). [DOI:10.1109/CVPR.2010.5540032](https://doi.org/10.1109/CVPR.2010.5540032)\
\
### restoration[#](#module-cucim.skimage.restoration "Permalink to this heading")\
\
Restoration algorithms, e.g., deconvolution algorithms, denoising, etc.\
\
cucim.skimage.restoration.calibrate\_denoiser(_image_, _denoise\_function_, _denoise\_parameters_, _\*_, _stride\=4_, _approximate\_loss\=True_, _extra\_output\=False_)[#](#cucim.skimage.restoration.calibrate_denoiser "Permalink to this definition")\
\
Calibrate a denoising function and return optimal J-invariant version.\
\
The returned function is partially evaluated with optimal parameter values set for denoising the input image.\
\
Parameters:\
\
**image**ndarray\
\
Input data to be denoised (converted using img\_as\_float).\
\
**denoise\_function**function\
\
Denoising function to be calibrated.\
\
**denoise\_parameters**dict of list\
\
Ranges of parameters for denoise\_function to be calibrated over.\
\
**stride**int, optional\
\
Stride used in masking procedure that converts denoise\_function to J-invariance.\
\
**approximate\_loss**bool, optional\
\
Whether to approximate the self-supervised loss used to evaluate the denoiser by only computing it on one masked version of the image. If False, the runtime will be a factor of stride\*\*image.ndim longer.\
\
**extra\_output**bool, optional\
\
If True, return parameters and losses in addition to the calibrated denoising function\
\
Returns:\
\
**best\_denoise\_function**function\
\
The optimal J-invariant version of denoise\_function.\
\
If extra\_output is True, the following tuple is also returned:\
\
**(parameters\_tested, losses)**tuple (list of dict, list of int)\
\
List of parameters tested for denoise\_function, as a dictionary of kwargs Self-supervised loss for each set of parameters in parameters\_tested.\
\
Notes\
\
The calibration procedure uses a self-supervised mean-square-error loss to evaluate the performance of J-invariant versions of denoise\_function. The minimizer of the self-supervised loss is also the minimizer of the ground-truth loss (i.e., the true MSE error) \[1\]. The returned function can be used on the original noisy image, or other images with similar characteristics.\
\
Increasing the stride increases the performance of best\_denoise\_function\
\
at the expense of increasing its runtime. It has no effect on the runtime of the calibration.\
\
References\
\
\[1\]\
\
J. Batson & L. Royer. Noise2Self: Blind Denoising by Self-Supervision, International Conference on Machine Learning, p. 524-533 (2019).\
\
Examples\
\
\>>> import cupy as cp\
\>>> from cucim.skimage import color\
\>>> from skimage import data\
\>>> from cucim.skimage.restoration import (denoise\_tv\_chambolle,\
... calibrate\_denoiser)\
\>>> img \= color.rgb2gray(cp.array(data.astronaut()\[:50, :50\]))\
\>>> noisy \= img + 0.5 \* img.std() \* cp.random.randn(\*img.shape)\
\>>> parameters \= {'weight': cp.arange(0.01, 0.3, 0.02)}\
\>>> denoising\_function \= calibrate\_denoiser(noisy, denoise\_tv\_chambolle,\
... denoise\_parameters\=parameters)\
\>>> denoised\_img \= denoising\_function(img)\
\
cucim.skimage.restoration.denoise\_invariant(_image_, _denoise\_function_, _\*_, _stride\=4_, _masks\=None_, _denoiser\_kwargs\=None_)[#](#cucim.skimage.restoration.denoise_invariant "Permalink to this definition")\
\
Apply a J-invariant version of denoise\_function.\
\
Parameters:\
\
**image**ndarray (M\[, N\[, …\]\]\[, C\]) of ints, uints or floats\
\
Input data to be denoised. image can be of any numeric type, but it is cast into a ndarray of floats (using img\_as\_float) for the computation of the denoised image.\
\
**denoise\_function**function\
\
Original denoising function.\
\
**stride**int, optional\
\
Stride used in masking procedure that converts denoise\_function to J-invariance.\
\
**masks**list of ndarray, optional\
\
Set of masks to use for computing J-invariant output. If None, a full set of masks covering the image will be used.\
\
**denoiser\_kwargs:**\
\
Keyword arguments passed to denoise\_function.\
\
Returns:\
\
**output**ndarray\
\
Denoised image, of same shape as image.\
\
Notes\
\
A denoising function is J-invariant if the prediction it makes for each pixel does not depend on the value of that pixel in the original image. The prediction for each pixel may instead use all the relevant information contained in the rest of the image, which is typically quite significant. Any function can be converted into a J-invariant one using a simple masking procedure, as described in \[1\].\
\
The pixel-wise error of a J-invariant denoiser is uncorrelated to the noise, so long as the noise in each pixel is independent. Consequently, the average difference between the denoised image and the oisy image, the _self-supervised loss_, is the same as the difference between the denoised image and the original clean image, the _ground-truth loss_ (up to a constant).\
\
This means that the best J-invariant denoiser for a given image can be found using the noisy data alone, by selecting the denoiser minimizing the self- supervised loss.\
\
References\
\
\[1\]\
\
J. Batson & L. Royer. Noise2Self: Blind Denoising by Self-Supervision, International Conference on Machine Learning, p. 524-533 (2019).\
\
Examples\
\
\>>> import cucim.skimage\
\>>> import cupy as cp\
\>>> import skimage\
\>>> from cucim.skimage.restoration import denoise\_invariant, denoise\_tv\_chambolle\
\>>> image \= cucim.skimage.util.img\_as\_float(cp.asarray(skimage.data.chelsea()))\
\>>> noisy \= cucim.skimage.util.random\_noise(image, var\=0.2 \*\* 2)\
\>>> denoised \= denoise\_invariant(noisy, denoise\_function\=denoise\_tv\_chambolle)\
\
cucim.skimage.restoration.denoise\_tv\_chambolle(_image_, _weight\=0.1_, _eps\=0.0002_, _max\_num\_iter\=200_, _\*_, _channel\_axis\=None_)[#](#cucim.skimage.restoration.denoise_tv_chambolle "Permalink to this definition")\
\
Perform total variation denoising in nD.\
\
Given \\(f\\), a noisy image (input data), total variation denoising (also known as total variation regularization) aims to find an image \\(u\\) with less total variation than \\(f\\), under the constraint that \\(u\\) remain similar to \\(f\\). This can be expressed by the Rudin–Osher–Fatemi (ROF) minimization problem:\
\
\\\[\\min\_{u} \\sum\_{i=0}^{N-1} \\left( \\left| \\nabla{u\_i} \\right| + \\frac{\\lambda}{2}(f\_i - u\_i)^2 \\right)\\\]\
\
where \\(\\lambda\\) is a positive parameter. The first term of this cost function is the total variation; the second term represents data fidelity. As \\(\\lambda \\to 0\\), the total variation term dominates, forcing the solution to have smaller total variation, at the expense of looking less like the input data.\
\
This code is an implementation of the algorithm proposed by Chambolle in [\[1\]](#rd494debfd106-1)\
to solve the ROF problem.\
\
Parameters:\
\
**image**ndarray\
\
Input image to be denoised. If its dtype is not float, it gets converted with [`img_as_float()`](#cucim.skimage.util.img_as_float "cucim.skimage.util.img_as_float")\
.\
\
**weight**float, optional\
\
Denoising weight. It is equal to \\(\\frac{1}{\\lambda}\\). Therefore, the greater the weight, the more denoising (at the expense of fidelity to image).\
\
**eps**float, optional\
\
Tolerance \\(\\varepsilon > 0\\) for the stop criterion (compares to absolute value of relative difference of the cost function \\(E\\)): The algorithm stops when \\(|E\_{n-1} - E\_n| < \\varepsilon \* E\_0\\).\
\
**max\_num\_iter**int, optional\
\
Maximal number of iterations used for the optimization.\
\
**channel\_axis**int or None, optional\
\
If `None`, the image is assumed to be grayscale (single-channel). Otherwise, this parameter indicates which axis of the array corresponds to channels.\
\
New in version 0.19: `channel_axis` was added in 0.19.\
\
Returns:\
\
**u**ndarray\
\
Denoised image.\
\
See also\
\
`denoise_tv_bregman`\
\
Perform total variation denoising using split-Bregman optimization.\
\
Notes\
\
Make sure to set the channel\_axis parameter appropriately for color images.\
\
The principle of total variation denoising is explained in [\[2\]](#rd494debfd106-2)\
. It is about minimizing the total variation of an image, which can be roughly described as the integral of the norm of the image gradient. Total variation denoising tends to produce cartoon-like images, that is, piecewise-constant images.\
\
References\
\
\[[1](#id332)\
\]\
\
A. Chambolle, An algorithm for total variation minimization and applications, Journal of Mathematical Imaging and Vision, Springer, 2004, 20, 89-97.\
\
\[[2](#id333)\
\]\
\
[https://en.wikipedia.org/wiki/Total\_variation\_denoising](https://en.wikipedia.org/wiki/Total_variation_denoising)\
\
Examples\
\
2D example on astronaut image:\
\
\>>> import cupy as cp\
\>>> from cucim.skimage import color\
\>>> from skimage import data\
\>>> img \= color.rgb2gray(cp.array(data.astronaut()\[:50, :50\]))\
\>>> img += 0.5 \* img.std() \* cp.random.randn(\*img.shape)\
\>>> denoised\_img \= denoise\_tv\_chambolle(img, weight\=60)\
\
3D example on synthetic data:\
\
\>>> x, y, z \= cp.ogrid\[0:20, 0:20, 0:20\]\
\>>> mask \= (x \- 22)\*\*2 + (y \- 20)\*\*2 + (z \- 17)\*\*2 < 8\*\*2\
\>>> mask \= mask.astype(float)\
\>>> mask += 0.2\*cp.random.randn(\*mask.shape)\
\>>> res \= denoise\_tv\_chambolle(mask, weight\=100)\
\
cucim.skimage.restoration.richardson\_lucy(_image_, _psf_, _num\_iter\=50_, _clip\=True_, _filter\_epsilon\=None_)[#](#cucim.skimage.restoration.richardson_lucy "Permalink to this definition")\
\
Richardson-Lucy deconvolution.\
\
Parameters:\
\
**image**(\[P, \]M, N) ndarray\
\
Input degraded image (can be n-dimensional). If you keep the default clip=True parameter, you may want to normalize the image so that its values fall in the \[-1, 1\] interval to avoid information loss.\
\
**psf**ndarray\
\
The point spread function.\
\
**num\_iter**int, optional\
\
Number of iterations. This parameter plays the role of regularisation.\
\
**clip**boolean, optional\
\
True by default. If true, pixel value of the result above 1 or under -1 are thresholded for skimage pipeline compatibility.\
\
**filter\_epsilon: float, optional**\
\
Value below which intermediate results become 0 to avoid division by small numbers.\
\
Returns:\
\
**im\_deconv**ndarray\
\
The deconvolved image.\
\
References\
\
\[1\]\
\
[https://en.wikipedia.org/wiki/Richardson%E2%80%93Lucy\_deconvolution](https://en.wikipedia.org/wiki/Richardson%E2%80%93Lucy_deconvolution)\
\
Examples\
\
\>>> import cupy as cp\
\>>> from cucim.skimage import img\_as\_float, restoration\
\>>> from skimage import data\
\>>> camera \= cp.asarray(img\_as\_float(cp.array(data.camera())))\
\>>> from cupyx.scipy.signal import convolve2d\
\>>> psf \= cp.ones((5, 5)) / 25\
\>>> camera \= convolve2d(camera, psf, 'same')\
\>>> camera += 0.1 \* camera.std() \* cp.random.standard\_normal(camera.shape)\
\>>> deconvolved \= restoration.richardson\_lucy(camera, psf, 5)\
\
cucim.skimage.restoration.unsupervised\_wiener(_image_, _psf_, _reg\=None_, _user\_params\=None_, _is\_real\=True_, _clip\=True_, _\*_, _rng\=None_)[#](#cucim.skimage.restoration.unsupervised_wiener "Permalink to this definition")\
\
Unsupervised Wiener-Hunt deconvolution.\
\
Return the deconvolution with a Wiener-Hunt approach, where the hyperparameters are automatically estimated. The algorithm is a stochastic iterative process (Gibbs sampler) described in the reference below. See also `wiener` function.\
\
Parameters:\
\
**image**(M, N) ndarray\
\
The input degraded image.\
\
**psf**ndarray\
\
The impulse response (input image’s space) or the transfer function (Fourier space). Both are accepted. The transfer function is automatically recognized as being complex (`cupy.iscomplexobj(psf)`).\
\
**reg**ndarray, optional\
\
The regularisation operator. The Laplacian by default. It can be an impulse response or a transfer function, as for the psf.\
\
**user\_params**dict, optional\
\
Dictionary of parameters for the Gibbs sampler. See below.\
\
**clip**boolean, optional\
\
True by default. If true, pixel values of the result above 1 or under -1 are thresholded for skimage pipeline compatibility.\
\
**rng**{cupy.random.Generator, int}, optional\
\
Pseudo-random number generator. By default, a PCG64 generator is used (see [`cupy.random.default_rng()`](https://docs.cupy.dev/en/stable/reference/generated/cupy.random.default_rng.html#cupy.random.default_rng "(in CuPy v13.4.0)")\
). If rng is an int, it is used to seed the generator.\
\
Returns:\
\
**x\_postmean**(M, N) ndarray\
\
The deconvolved image (the posterior mean).\
\
**chains**dict\
\
The keys `noise` and `prior` contain the chain list of noise and prior precision respectively.\
\
Other Parameters:\
\
**The keys of \`\`user\_params\`\` are:**\
\
**threshold**float\
\
The stopping criterion: the norm of the difference between to successive approximated solution (empirical mean of object samples, see Notes section). 1e-4 by default.\
\
**burnin**int\
\
The number of sample to ignore to start computation of the mean. 15 by default.\
\
**min\_num\_iter**int\
\
The minimum number of iterations. 30 by default.\
\
**max\_num\_iter**int\
\
The maximum number of iterations if `threshold` is not satisfied. 200 by default.\
\
**callback**callable (None by default)\
\
A user provided callable to which is passed, if the function exists, the current image sample for whatever purpose. The user can store the sample, or compute other moments than the mean. It has no influence on the algorithm execution and is only for inspection.\
\
Notes\
\
The estimated image is design as the posterior mean of a probability law (from a Bayesian analysis). The mean is defined as a sum over all the possible images weighted by their respective probability. Given the size of the problem, the exact sum is not tractable. This algorithm use of MCMC to draw image under the posterior law. The practical idea is to only draw highly probable images since they have the biggest contribution to the mean. At the opposite, the less probable images are drawn less often since their contribution is low. Finally, the empirical mean of these samples give us an estimation of the mean, and an exact computation with an infinite sample set.\
\
References\
\
\[1\]\
\
François Orieux, Jean-François Giovannelli, and Thomas Rodet, “Bayesian estimation of regularization and point spread function parameters for Wiener-Hunt deconvolution”, J. Opt. Soc. Am. A 27, 1593-1607 (2010)\
\
[https://www.osapublishing.org/josaa/abstract.cfm?URI=josaa-27-7-1593](https://www.osapublishing.org/josaa/abstract.cfm?URI=josaa-27-7-1593)\
\
[https://hal.archives-ouvertes.fr/hal-00674508](https://hal.archives-ouvertes.fr/hal-00674508)\
\
Examples\
\
\>>> import cupy as cp\
\>>> import cupyx.scipy.ndimage as ndi\
\>>> from cucim.skimage import color, restoration\
\>>> from skimage import data\
\>>> img \= color.rgb2gray(cp.array(data.astronaut()))\
\>>> psf \= cp.ones((5, 5)) / 25\
\>>> img \= ndi.uniform\_filter(img, size\=psf.shape)\
\>>> rng \= cp.random.default\_rng()\
\>>> img += 0.1 \* img.std() \* rng.standard\_normal(img.shape)\
\>>> deconvolved\_img \= restoration.unsupervised\_wiener(img, psf)\
\
cucim.skimage.restoration.wiener(_image_, _psf_, _balance_, _reg\=None_, _is\_real\=True_, _clip\=True_)[#](#cucim.skimage.restoration.wiener "Permalink to this definition")\
\
Wiener-Hunt deconvolution\
\
Return the deconvolution with a Wiener-Hunt approach (i.e. with Fourier diagonalisation).\
\
Parameters:\
\
**image**cp.ndarray\
\
Input degraded image (can be n-dimensional).\
\
**psf**ndarray\
\
Point Spread Function. This is assumed to be the impulse response (input image space) if the data-type is real, or the transfer function (Fourier space) if the data-type is complex. There is no constraints on the shape of the impulse response. The transfer function must be of shape (N1, N2, …, ND) if is\_real is True, (N1, N2, …, ND // 2 + 1) otherwise (see cp.fft.rfftn).\
\
**balance**float\
\
The regularisation parameter value that tunes the balance between the data adequacy that improve frequency restoration and the prior adequacy that reduce frequency restoration (to avoid noise artifacts).\
\
**reg**ndarray, optional\
\
The regularisation operator. The Laplacian by default. It can be an impulse response or a transfer function, as for the psf. Shape constraint is the same as for the psf parameter.\
\
**is\_real**boolean, optional\
\
True by default. Specify if `psf` and `reg` are provided with hermitian hypothesis, that is only half of the frequency plane is provided (due to the redundancy of Fourier transform of real signal). It’s apply only if `psf` and/or `reg` are provided as transfer function. For the hermitian property see `uft` module or `cupy.fft.rfftn`.\
\
**clip**boolean, optional\
\
True by default. If True, pixel values of the result above 1 or under -1 are thresholded for skimage pipeline compatibility.\
\
Returns:\
\
**im\_deconv**(M, N) ndarray\
\
The deconvolved image.\
\
Notes\
\
This function applies the Wiener filter to a noisy and degraded image by an impulse response (or PSF). If the data model is\
\
\\\[y = Hx + n\\\]\
\
where \\(n\\) is noise, \\(H\\) the PSF and \\(x\\) the unknown original image, the Wiener filter is\
\
\\\[\\hat x = F^\\dagger \\left( |\\Lambda\_H|^2 + \\lambda |\\Lambda\_D|^2 \\right)^{-1} \\Lambda\_H^\\dagger F y\\\]\
\
where \\(F\\) and \\(F^\\dagger\\) are the Fourier and inverse Fourier transforms respectively, \\(\\Lambda\_H\\) the transfer function (or the Fourier transform of the PSF, see \[Hunt\] below) and \\(\\Lambda\_D\\) the filter to penalize the restored image frequencies (Laplacian by default, that is penalization of high frequency). The parameter \\(\\lambda\\) tunes the balance between the data (that tends to increase high frequency, even those coming from noise), and the regularization.\
\
These methods are then specific to a prior model. Consequently, the application or the true image nature must correspond to the prior model. By default, the prior model (Laplacian) introduce image smoothness or pixel correlation. It can also be interpreted as high-frequency penalization to compensate the instability of the solution with respect to the data (sometimes called noise amplification or “explosive” solution).\
\
Finally, the use of Fourier space implies a circulant property of \\(H\\), see [\[2\]](#r33534ae55690-2)\
.\
\
References\
\
\[1\]\
\
François Orieux, Jean-François Giovannelli, and Thomas Rodet, “Bayesian estimation of regularization and point spread function parameters for Wiener-Hunt deconvolution”, J. Opt. Soc. Am. A 27, 1593-1607 (2010)\
\
[https://www.osapublishing.org/josaa/abstract.cfm?URI=josaa-27-7-1593](https://www.osapublishing.org/josaa/abstract.cfm?URI=josaa-27-7-1593)\
\
[https://hal.archives-ouvertes.fr/hal-00674508](https://hal.archives-ouvertes.fr/hal-00674508)\
\
\[[2](#id338)\
\]\
\
B. R. Hunt “A matrix theory proof of the discrete convolution theorem”, IEEE Trans. on Audio and Electroacoustics, vol. au-19, no. 4, pp. 285-288, dec. 1971\
\
Examples\
\
\>>> import cupy as cp\
\>>> import cupyx.scipy.ndimage as ndi\
\>>> from cucim.skimage import color, restoration\
\>>> from skimage import data\
\>>> img \= color.rgb2gray(cp.array(data.astronaut()))\
\>>> psf \= cp.ones((5, 5)) / 25\
\>>> img \= ndi.uniform\_filter(img, size\=psf.shape)\
\>>> img += 0.1 \* img.std() \* cp.random.standard\_normal(img.shape)\
\>>> deconvolved\_img \= restoration.wiener(img, psf, 0.1)\
\
### segmentation[#](#module-cucim.skimage.segmentation "Permalink to this heading")\
\
Algorithms to partition images into meaningful regions or boundaries.\
\
cucim.skimage.segmentation.chan\_vese(_image_, _mu\=0.25_, _lambda1\=1.0_, _lambda2\=1.0_, _tol\=0.001_, _max\_num\_iter\=500_, _dt\=0.5_, _init\_level\_set\='checkerboard'_, _extended\_output\=False_)[#](#cucim.skimage.segmentation.chan_vese "Permalink to this definition")\
\
Chan-Vese segmentation algorithm.\
\
Active contour model by evolving a level set. Can be used to segment objects without clearly defined boundaries.\
\
Parameters:\
\
**image**(M, N) ndarray\
\
Grayscale image to be segmented.\
\
**mu**float, optional\
\
‘edge length’ weight parameter. Higher mu values will produce a ‘round’ edge, while values closer to zero will detect smaller objects.\
\
**lambda1**float, optional\
\
‘difference from average’ weight parameter for the output region with value ‘True’. If it is lower than lambda2, this region will have a larger range of values than the other.\
\
**lambda2**float, optional\
\
‘difference from average’ weight parameter for the output region with value ‘False’. If it is lower than lambda1, this region will have a larger range of values than the other.\
\
**tol**float, positive, optional\
\
Level set variation tolerance between iterations. If the L2 norm difference between the level sets of successive iterations normalized by the area of the image is below this value, the algorithm will assume that the solution was reached.\
\
**max\_num\_iter**uint, optional\
\
Maximum number of iterations allowed before the algorithm interrupts itself.\
\
**dt**float, optional\
\
A multiplication factor applied at calculations for each step, serves to accelerate the algorithm. While higher values may speed up the algorithm, they may also lead to convergence problems.\
\
**init\_level\_set**str or (M, N) ndarray, optional\
\
Defines the starting level set used by the algorithm. If a string is inputted, a level set that matches the image size will automatically be generated. Alternatively, it is possible to define a custom level set, which should be an array of float values, with the same shape as ‘image’. Accepted string values are as follows.\
\
‘checkerboard’\
\
the starting level set is defined as sin(x/5\*pi)\*sin(y/5\*pi), where x and y are pixel coordinates. This level set has fast convergence, but may fail to detect implicit edges.\
\
‘disk’\
\
the starting level set is defined as the opposite of the distance from the center of the image minus half of the minimum value between image width and image height. This is somewhat slower, but is more likely to properly detect implicit edges.\
\
‘small disk’\
\
the starting level set is defined as the opposite of the distance from the center of the image minus a quarter of the minimum value between image width and image height.\
\
**extended\_output**bool, optional\
\
If set to True, the return value will be a tuple containing the three return values (see below). If set to False which is the default value, only the ‘segmentation’ array will be returned.\
\
Returns:\
\
**segmentation**(M, N) ndarray, bool\
\
Segmentation produced by the algorithm.\
\
**phi**(M, N) ndarray of floats\
\
Final level set computed by the algorithm.\
\
**energies**list of floats\
\
Shows the evolution of the ‘energy’ for each step of the algorithm. This should allow to check whether the algorithm converged.\
\
Notes\
\
The Chan-Vese Algorithm is designed to segment objects without clearly defined boundaries. This algorithm is based on level sets that are evolved iteratively to minimize an energy, which is defined by weighted values corresponding to the sum of differences intensity from the average value outside the segmented region, the sum of differences from the average value inside the segmented region, and a term which is dependent on the length of the boundary of the segmented region.\
\
This algorithm was first proposed by Tony Chan and Luminita Vese, in a publication entitled “An Active Contour Model Without Edges” [\[1\]](#rbdce7887ce89-1)\
.\
\
This implementation of the algorithm is somewhat simplified in the sense that the area factor ‘nu’ described in the original paper is not implemented, and is only suitable for grayscale images.\
\
Typical values for lambda1 and lambda2 are 1. If the ‘background’ is very different from the segmented object in terms of distribution (for example, a uniform black image with figures of varying intensity), then these values should be different from each other.\
\
Typical values for mu are between 0 and 1, though higher values can be used when dealing with shapes with very ill-defined contours.\
\
The ‘energy’ which this algorithm tries to minimize is defined as the sum of the differences from the average within the region squared and weighed by the ‘lambda’ factors to which is added the length of the contour multiplied by the ‘mu’ factor.\
\
Supports 2D grayscale images only, and does not implement the area term described in the original article.\
\
References\
\
\[[1](#id341)\
\]\
\
An Active Contour Model without Edges, Tony Chan and Luminita Vese, Scale-Space Theories in Computer Vision, 1999, [DOI:10.1007/3-540-48236-9\_13](https://doi.org/10.1007/3-540-48236-9_13)\
\
\[2\]\
\
Chan-Vese Segmentation, Pascal Getreuer Image Processing On Line, 2 (2012), pp. 214-224, [DOI:10.5201/ipol.2012.g-cv](https://doi.org/10.5201/ipol.2012.g-cv)\
\
\[3\]\
\
The Chan-Vese Algorithm - Project Report, Rami Cohen, 2011 [arXiv:1107.2782](https://arxiv.org/abs/1107.2782)\
\
cucim.skimage.segmentation.checkerboard\_level\_set(_image\_shape_, _square\_size\=5_)[#](#cucim.skimage.segmentation.checkerboard_level_set "Permalink to this definition")\
\
Create a checkerboard level set with binary values.\
\
Parameters:\
\
**image\_shape**tuple of positive integers\
\
Shape of the image.\
\
**square\_size**int, optional\
\
Size of the squares of the checkerboard. It defaults to 5.\
\
Returns:\
\
**out**array with shape image\_shape\
\
Binary level set of the checkerboard.\
\
See also\
\
[`disk_level_set`](#cucim.skimage.segmentation.disk_level_set "cucim.skimage.segmentation.disk_level_set")\
\
cucim.skimage.segmentation.clear\_border(_labels_, _buffer\_size\=0_, _bgval\=0_, _mask\=None_, _\*_, _out\=None_)[#](#cucim.skimage.segmentation.clear_border "Permalink to this definition")\
\
Clear objects connected to the label image border.\
\
Parameters:\
\
**labels**(M\[, N\[, …, P\]\]) array of int or bool\
\
Imaging data labels.\
\
**buffer\_size**int, optional\
\
The width of the border examined. By default, only objects that touch the outside of the image are removed.\
\
**bgval**float or int, optional\
\
Cleared objects are set to this value.\
\
**mask**ndarray of bool, same shape as image, optional.\
\
Image data mask. Objects in labels image overlapping with False pixels of mask will be removed. If defined, the argument buffer\_size will be ignored.\
\
**out**ndarray\
\
Array of the same shape as labels, into which the output is placed. By default, a new array is created.\
\
Returns:\
\
**out**(M\[, N\[, …, P\]\]) array\
\
Imaging data labels with cleared borders\
\
Examples\
\
\>>> import cupy as cp\
\>>> from cucim.skimage.segmentation import clear\_border\
\>>> labels \= cp.array(\[\[0, 0, 0, 0, 0, 0, 0, 1, 0\],\
... \[1, 1, 0, 0, 1, 0, 0, 1, 0\],\
... \[1, 1, 0, 1, 0, 1, 0, 0, 0\],\
... \[0, 0, 0, 1, 1, 1, 1, 0, 0\],\
... \[0, 1, 1, 1, 1, 1, 1, 1, 0\],\
... \[0, 0, 0, 0, 0, 0, 0, 0, 0\]\])\
\>>> clear\_border(labels)\
array(\[\[0, 0, 0, 0, 0, 0, 0, 0, 0\],\
\[0, 0, 0, 0, 1, 0, 0, 0, 0\],\
\[0, 0, 0, 1, 0, 1, 0, 0, 0\],\
\[0, 0, 0, 1, 1, 1, 1, 0, 0\],\
\[0, 1, 1, 1, 1, 1, 1, 1, 0\],\
\[0, 0, 0, 0, 0, 0, 0, 0, 0\]\])\
\>>> mask \= cp.array(\[\[0, 0, 1, 1, 1, 1, 1, 1, 1\],\
... \[0, 0, 1, 1, 1, 1, 1, 1, 1\],\
... \[1, 1, 1, 1, 1, 1, 1, 1, 1\],\
... \[1, 1, 1, 1, 1, 1, 1, 1, 1\],\
... \[1, 1, 1, 1, 1, 1, 1, 1, 1\],\
... \[1, 1, 1, 1, 1, 1, 1, 1, 1\]\]).astype(bool)\
\>>> clear\_border(labels, mask\=mask)\
array(\[\[0, 0, 0, 0, 0, 0, 0, 1, 0\],\
\[0, 0, 0, 0, 1, 0, 0, 1, 0\],\
\[0, 0, 0, 1, 0, 1, 0, 0, 0\],\
\[0, 0, 0, 1, 1, 1, 1, 0, 0\],\
\[0, 1, 1, 1, 1, 1, 1, 1, 0\],\
\[0, 0, 0, 0, 0, 0, 0, 0, 0\]\])\
\
cucim.skimage.segmentation.disk\_level\_set(_image\_shape_, _\*_, _center\=None_, _radius\=None_)[#](#cucim.skimage.segmentation.disk_level_set "Permalink to this definition")\
\
Create a disk level set with binary values.\
\
Parameters:\
\
**image\_shape**tuple of positive integers\
\
Shape of the image\
\
**center**tuple of positive integers, optional\
\
Coordinates of the center of the disk given in (row, column). If not given, it defaults to the center of the image.\
\
**radius**float, optional\
\
Radius of the disk. If not given, it is set to the 75% of the smallest image dimension.\
\
Returns:\
\
**out**array with shape image\_shape\
\
Binary level set of the disk with the given radius and center.\
\
See also\
\
[`checkerboard_level_set`](#cucim.skimage.segmentation.checkerboard_level_set "cucim.skimage.segmentation.checkerboard_level_set")\
\
cucim.skimage.segmentation.expand\_labels(_label\_image_, _distance\=1_, _spacing\=1_)[#](#cucim.skimage.segmentation.expand_labels "Permalink to this definition")\
\
Expand labels in label image by `distance` pixels without overlapping.\
\
Given a label image, `expand_labels` grows label regions (connected outwards by up to `distance` units without overflowing into neighboring regions. More specifically, each background pixel that is within Euclidean distance of <= `distance` pixels of a connected component is assigned the label of that connected component. The spacing parameter can be used to specify the spacing rate of the distance transform used to calculate the Euclidean distance for anisotropic images where multiple connected components are within `distance` pixels of a background pixel, the label value of the closest connected component will be assigned (see Notes for the case of multiple labels at equal distance).\
\
Parameters:\
\
**label\_image**ndarray of dtype int\
\
label image\
\
**distance**float\
\
Euclidean distance in pixels by which to grow the labels. Default is one.\
\
**spacing**float, or sequence of float, optional\
\
Spacing of elements along each dimension. If a sequence, must be of length equal to the input rank; if a single number, this is used for all axes. If not specified, a grid spacing of unity is implied.\
\
Returns:\
\
**enlarged\_labels**ndarray of dtype int\
\
Labeled array, where all connected regions have been enlarged\
\
See also\
\
[`cucim.skimage.measure.label()`](#cucim.skimage.measure.label "cucim.skimage.measure.label")\
, [`cucim.skimage.morphology.dilation()`](#cucim.skimage.morphology.dilation "cucim.skimage.morphology.dilation")\
\
Notes\
\
Where labels are spaced more than `distance` pixels are apart, this is equivalent to a morphological dilation with a disc or hyperball of radius `distance`. However, in contrast to a morphological dilation, `expand_labels` will not expand a label region into a neighboring region.\
\
This implementation of `expand_labels` is derived from CellProfiler [\[1\]](#r3a8edbdeb58f-1)\
, where it is known as module “IdentifySecondaryObjects (Distance-N)” [\[2\]](#r3a8edbdeb58f-2)\
.\
\
There is an important edge case when a pixel has the same distance to multiple regions, as it is not defined which region expands into that space. Here, the exact behavior depends on the upstream implementation of `scipy.ndimage.distance_transform_edt`.\
\
References\
\
\[[1](#id345)\
\]\
\
[https://cellprofiler.org](https://cellprofiler.org)\
\
\[[2](#id346)\
\]\
\
[CellProfiler/CellProfiler](https://github.com/CellProfiler/CellProfiler/blob/082930ea95add7b72243a4fa3d39ae5145995e9c/cellprofiler/modules/identifysecondaryobjects.py#L559)\
\
Examples\
\
\>>> labels \= np.array(\[0, 1, 0, 0, 0, 0, 2\])\
\>>> expand\_labels(labels, distance\=1)\
array(\[1, 1, 1, 0, 0, 2, 2\])\
\
Labels will not overwrite each other:\
\
\>>> expand\_labels(labels, distance\=3)\
array(\[1, 1, 1, 1, 2, 2, 2\])\
\
In case of ties, behavior is undefined, but currently resolves to the label closest to `(0,) * ndim` in lexicographical order.\
\
\>>> labels\_tied \= np.array(\[0, 1, 0, 2, 0\])\
\>>> expand\_labels(labels\_tied, 1)\
array(\[1, 1, 1, 2, 2\])\
\>>> labels2d \= np.array(\
... \[\[0, 1, 0, 0\],\
... \[2, 0, 0, 0\],\
... \[0, 3, 0, 0\]\]\
... )\
\>>> expand\_labels(labels2d, 1)\
array(\[\[2, 1, 1, 0\],\
\[2, 2, 0, 0\],\
\[2, 3, 3, 0\]\])\
\>>> expand\_labels(labels2d, 1, spacing\=\[1, 0.5\])\
array(\[\[1, 1, 1, 1\],\
\[2, 2, 2, 0\],\
\[3, 3, 3, 3\]\])\
\
cucim.skimage.segmentation.find\_boundaries(_label\_img_, _connectivity\=1_, _mode\='thick'_, _background\=0_)[#](#cucim.skimage.segmentation.find_boundaries "Permalink to this definition")\
\
Return bool array where boundaries between labeled regions are True.\
\
Parameters:\
\
**label\_img**array of int or bool\
\
An array in which different regions are labeled with either different integers or boolean values.\
\
**connectivity**int in {1, …, label\_img.ndim}, optional\
\
A pixel is considered a boundary pixel if any of its neighbors has a different label. connectivity controls which pixels are considered neighbors. A connectivity of 1 (default) means pixels sharing an edge (in 2D) or a face (in 3D) will be considered neighbors. A connectivity of label\_img.ndim means pixels sharing a corner will be considered neighbors.\
\
**mode**string in {‘thick’, ‘inner’, ‘outer’, ‘subpixel’}\
\
How to mark the boundaries:\
\
* thick: any pixel not completely surrounded by pixels of the same label (defined by connectivity) is marked as a boundary. This results in boundaries that are 2 pixels thick.\
\
* inner: outline the pixels _just inside_ of objects, leaving background pixels untouched.\
\
* outer: outline pixels in the background around object boundaries. When two objects touch, their boundary is also marked.\
\
* subpixel: return a doubled image, with pixels _between_ the original pixels marked as boundary where appropriate.\
\
\
**background**int, optional\
\
For modes ‘inner’ and ‘outer’, a definition of a background label is required. See mode for descriptions of these two.\
\
Returns:\
\
**boundaries**array of bool, same shape as label\_img\
\
A bool image where `True` represents a boundary pixel. For mode equal to ‘subpixel’, `boundaries.shape[i]` is equal to `2 * label_img.shape[i] - 1` for all `i` (a pixel is inserted in between all other pairs of pixels).\
\
Examples\
\
\>>> labels \= cp.array(\[\[0, 0, 0, 0, 0, 0, 0, 0, 0, 0\],\
... \[0, 0, 0, 0, 0, 0, 0, 0, 0, 0\],\
... \[0, 0, 0, 0, 0, 5, 5, 5, 0, 0\],\
... \[0, 0, 1, 1, 1, 5, 5, 5, 0, 0\],\
... \[0, 0, 1, 1, 1, 5, 5, 5, 0, 0\],\
... \[0, 0, 1, 1, 1, 5, 5, 5, 0, 0\],\
... \[0, 0, 0, 0, 0, 5, 5, 5, 0, 0\],\
... \[0, 0, 0, 0, 0, 0, 0, 0, 0, 0\],\
... \[0, 0, 0, 0, 0, 0, 0, 0, 0, 0\]\], dtype\=cp.uint8)\
\>>> find\_boundaries(labels, mode\='thick').astype(cp.uint8)\
array(\[\[0, 0, 0, 0, 0, 0, 0, 0, 0, 0\],\
\[0, 0, 0, 0, 0, 1, 1, 1, 0, 0\],\
\[0, 0, 1, 1, 1, 1, 1, 1, 1, 0\],\
\[0, 1, 1, 1, 1, 1, 0, 1, 1, 0\],\
\[0, 1, 1, 0, 1, 1, 0, 1, 1, 0\],\
\[0, 1, 1, 1, 1, 1, 0, 1, 1, 0\],\
\[0, 0, 1, 1, 1, 1, 1, 1, 1, 0\],\
\[0, 0, 0, 0, 0, 1, 1, 1, 0, 0\],\
\[0, 0, 0, 0, 0, 0, 0, 0, 0, 0\]\], dtype=uint8)\
\>>> find\_boundaries(labels, mode\='inner').astype(cp.uint8)\
array(\[\[0, 0, 0, 0, 0, 0, 0, 0, 0, 0\],\
\[0, 0, 0, 0, 0, 0, 0, 0, 0, 0\],\
\[0, 0, 0, 0, 0, 1, 1, 1, 0, 0\],\
\[0, 0, 1, 1, 1, 1, 0, 1, 0, 0\],\
\[0, 0, 1, 0, 1, 1, 0, 1, 0, 0\],\
\[0, 0, 1, 1, 1, 1, 0, 1, 0, 0\],\
\[0, 0, 0, 0, 0, 1, 1, 1, 0, 0\],\
\[0, 0, 0, 0, 0, 0, 0, 0, 0, 0\],\
\[0, 0, 0, 0, 0, 0, 0, 0, 0, 0\]\], dtype=uint8)\
\>>> find\_boundaries(labels, mode\='outer').astype(cp.uint8)\
array(\[\[0, 0, 0, 0, 0, 0, 0, 0, 0, 0\],\
\[0, 0, 0, 0, 0, 1, 1, 1, 0, 0\],\
\[0, 0, 1, 1, 1, 1, 0, 0, 1, 0\],\
\[0, 1, 0, 0, 1, 1, 0, 0, 1, 0\],\
\[0, 1, 0, 0, 1, 1, 0, 0, 1, 0\],\
\[0, 1, 0, 0, 1, 1, 0, 0, 1, 0\],\
\[0, 0, 1, 1, 1, 1, 0, 0, 1, 0\],\
\[0, 0, 0, 0, 0, 1, 1, 1, 0, 0\],\
\[0, 0, 0, 0, 0, 0, 0, 0, 0, 0\]\], dtype=uint8)\
\>>> labels\_small \= labels\[::2, ::3\]\
\>>> labels\_small\
array(\[\[0, 0, 0, 0\],\
\[0, 0, 5, 0\],\
\[0, 1, 5, 0\],\
\[0, 0, 5, 0\],\
\[0, 0, 0, 0\]\], dtype=uint8)\
\>>> find\_boundaries(labels\_small, mode\='subpixel').astype(cp.uint8)\
array(\[\[0, 0, 0, 0, 0, 0, 0\],\
\[0, 0, 0, 1, 1, 1, 0\],\
\[0, 0, 0, 1, 0, 1, 0\],\
\[0, 1, 1, 1, 0, 1, 0\],\
\[0, 1, 0, 1, 0, 1, 0\],\
\[0, 1, 1, 1, 0, 1, 0\],\
\[0, 0, 0, 1, 0, 1, 0\],\
\[0, 0, 0, 1, 1, 1, 0\],\
\[0, 0, 0, 0, 0, 0, 0\]\], dtype=uint8)\
\>>> bool\_image \= cp.array(\[\[False, False, False, False, False\],\
... \[False, False, False, False, False\],\
... \[False, False, True, True, True\],\
... \[False, False, True, True, True\],\
... \[False, False, True, True, True\]\],\
... dtype\=bool)\
\>>> find\_boundaries(bool\_image)\
array(\[\[False, False, False, False, False\],\
\[False, False, True, True, True\],\
\[False, True, True, True, True\],\
\[False, True, True, False, False\],\
\[False, True, True, False, False\]\])\
\
cucim.skimage.segmentation.inverse\_gaussian\_gradient(_image_, _alpha\=100.0_, _sigma\=5.0_)[#](#cucim.skimage.segmentation.inverse_gaussian_gradient "Permalink to this definition")\
\
Inverse of gradient magnitude.\
\
Compute the magnitude of the gradients in the image and then inverts the result in the range \[0, 1\]. Flat areas are assigned values close to 1, while areas close to borders are assigned values close to 0.\
\
This function or a similar one defined by the user should be applied over the image as a preprocessing step before calling morphological\_geodesic\_active\_contour.\
\
Parameters:\
\
**image**(M, N) or (L, M, N) array\
\
Grayscale image or volume.\
\
**alpha**float, optional\
\
Controls the steepness of the inversion. A larger value will make the transition between the flat areas and border areas steeper in the resulting array.\
\
**sigma**float, optional\
\
Standard deviation of the Gaussian filter applied over the image.\
\
Returns:\
\
**gimage**(M, N) or (L, M, N) array\
\
Preprocessed image (or volume) suitable for morphological\_geodesic\_active\_contour.\
\
cucim.skimage.segmentation.join\_segmentations(_s1_, _s2_, _return\_mapping: [bool](https://docs.python.org/3/library/functions.html#bool "(in Python v3.13)")\
\= False_)[#](#cucim.skimage.segmentation.join_segmentations "Permalink to this definition")\
\
Return the join of the two input segmentations.\
\
The join J of S1 and S2 is defined as the segmentation in which two voxels are in the same segment if and only if they are in the same segment in _both_ S1 and S2.\
\
Parameters:\
\
**s1, s2**numpy arrays\
\
s1 and s2 are label fields of the same shape.\
\
**return\_mapping**bool, optional\
\
If true, return mappings for joined segmentation labels to the original labels.\
\
Returns:\
\
**j**numpy array\
\
The join segmentation of s1 and s2.\
\
**map\_j\_to\_s1**ArrayMap, optional\
\
Mapping from labels of the joined segmentation j to labels of s1.\
\
**map\_j\_to\_s2**ArrayMap, optional\
\
Mapping from labels of the joined segmentation j to labels of s2.\
\
Examples\
\
\>>> import cupy as cp\
\>>> from cucim.skimage.segmentation import join\_segmentations\
\>>> s1 \= cp.array(\[\[0, 0, 1, 1\],\
... \[0, 2, 1, 1\],\
... \[2, 2, 2, 1\]\])\
\>>> s2 \= cp.array(\[\[0, 1, 1, 0\],\
... \[0, 1, 1, 0\],\
... \[0, 1, 1, 1\]\])\
\>>> join\_segmentations(s1, s2)\
array(\[\[0, 1, 3, 2\],\
\[0, 5, 3, 2\],\
\[4, 5, 5, 3\]\])\
\
cucim.skimage.segmentation.mark\_boundaries(_image_, _label\_img_, _color\=(1, 1, 0)_, _outline\_color\=None_, _mode\='outer'_, _background\_label\=0_, _\*_, _order\=3_)[#](#cucim.skimage.segmentation.mark_boundaries "Permalink to this definition")\
\
Return image with boundaries between labeled regions highlighted.\
\
Parameters:\
\
**image**(M, N\[, 3\]) array\
\
Grayscale or RGB image.\
\
**label\_img**(M, N) array of int\
\
Label array where regions are marked by different integer values.\
\
**color**length-3 sequence, optional\
\
RGB color of boundaries in the output image.\
\
**outline\_color**length-3 sequence, optional\
\
RGB color surrounding boundaries in the output image. If None, no outline is drawn.\
\
**mode**string in {‘thick’, ‘inner’, ‘outer’, ‘subpixel’}, optional\
\
The mode for finding boundaries.\
\
**background\_label**int, optional\
\
Which label to consider background (this is only useful for modes `inner` and `outer`).\
\
Returns:\
\
**marked**(M, N, 3) array of float\
\
An image in which the boundaries between labels are superimposed on the original image.\
\
See also\
\
[`find_boundaries`](#cucim.skimage.segmentation.find_boundaries "cucim.skimage.segmentation.find_boundaries")\
\
cucim.skimage.segmentation.morphological\_chan\_vese(_image_, _num\_iter_, _init\_level\_set='checkerboard'_, _smoothing=1_, _lambda1=1_, _lambda2=1_, _iter\_callback=>_)[#](#cucim.skimage.segmentation.morphological_chan_vese "Permalink to this definition")\
\
Morphological Active Contours without Edges (MorphACWE)\
\
Active contours without edges implemented with morphological operators. It can be used to segment objects in images and volumes without well defined borders. It is required that the inside of the object looks different on average than the outside (i.e., the inner area of the object should be darker or lighter than the outer area on average).\
\
Parameters:\
\
**image**(M, N) or (L, M, N) array\
\
Grayscale image or volume to be segmented.\
\
**num\_iter**uint\
\
Number of num\_iter to run\
\
**init\_level\_set**str, (M, N) array, or (L, M, N) array\
\
Initial level set. If an array is given, it will be binarized and used as the initial level set. If a string is given, it defines the method to generate a reasonable initial level set with the shape of the image. Accepted values are ‘checkerboard’ and ‘disk’. See the documentation of checkerboard\_level\_set and disk\_level\_set respectively for details about how these level sets are created.\
\
**smoothing**uint, optional\
\
Number of times the smoothing operator is applied per iteration. Reasonable values are around 1-4. Larger values lead to smoother segmentations.\
\
**lambda1**float, optional\
\
Weight parameter for the outer region. If lambda1 is larger than lambda2, the outer region will contain a larger range of values than the inner region.\
\
**lambda2**float, optional\
\
Weight parameter for the inner region. If lambda2 is larger than lambda1, the inner region will contain a larger range of values than the outer region.\
\
**iter\_callback**function, optional\
\
If given, this function is called once per iteration with the current level set as the only argument. This is useful for debugging or for plotting intermediate results during the evolution.\
\
Returns:\
\
**out**(M, N) or (L, M, N) array\
\
Final segmentation (i.e., the final level set)\
\
See also\
\
[`disk_level_set`](#cucim.skimage.segmentation.disk_level_set "cucim.skimage.segmentation.disk_level_set")\
, [`checkerboard_level_set`](#cucim.skimage.segmentation.checkerboard_level_set "cucim.skimage.segmentation.checkerboard_level_set")\
\
Notes\
\
This is a version of the Chan-Vese algorithm that uses morphological operators instead of solving a partial differential equation (PDE) for the evolution of the contour. The set of morphological operators used in this algorithm are proved to be infinitesimally equivalent to the Chan-Vese PDE (see [\[1\]](#r2416b93d33b0-1)\
). However, morphological operators are do not suffer from the numerical stability issues typically found in PDEs (it is not necessary to find the right time step for the evolution), and are computationally faster.\
\
The algorithm and its theoretical derivation are described in [\[1\]](#r2416b93d33b0-1)\
.\
\
References\
\
\[1\] ([1](#id349)\
,[2](#id350)\
)\
\
A Morphological Approach to Curvature-based Evolution of Curves and Surfaces, Pablo Márquez-Neila, Luis Baumela, Luis Álvarez. In IEEE Transactions on Pattern Analysis and Machine Intelligence (PAMI), 2014, [DOI:10.1109/TPAMI.2013.106](https://doi.org/10.1109/TPAMI.2013.106)\
\
cucim.skimage.segmentation.morphological\_geodesic\_active\_contour(_gimage_, _num\_iter_, _init\_level\_set='disk'_, _smoothing=1_, _threshold='auto'_, _balloon=0_, _iter\_callback=>_)[#](#cucim.skimage.segmentation.morphological_geodesic_active_contour "Permalink to this definition")\
\
Morphological Geodesic Active Contours (MorphGAC).\
\
Geodesic active contours implemented with morphological operators. It can be used to segment objects with visible but noisy, cluttered, broken borders.\
\
Parameters:\
\
**gimage**(M, N) or (L, M, N) array\
\
Preprocessed image or volume to be segmented. This is very rarely the original image. Instead, this is usually a preprocessed version of the original image that enhances and highlights the borders (or other structures) of the object to segment. [`morphological_geodesic_active_contour()`](#cucim.skimage.segmentation.morphological_geodesic_active_contour "cucim.skimage.segmentation.morphological_geodesic_active_contour")\
will try to stop the contour evolution in areas where gimage is small. See [`inverse_gaussian_gradient()`](#cucim.skimage.segmentation.inverse_gaussian_gradient "cucim.skimage.segmentation.inverse_gaussian_gradient")\
as an example function to perform this preprocessing. Note that the quality of [`morphological_geodesic_active_contour()`](#cucim.skimage.segmentation.morphological_geodesic_active_contour "cucim.skimage.segmentation.morphological_geodesic_active_contour")\
might greatly depend on this preprocessing.\
\
**num\_iter**uint\
\
Number of num\_iter to run.\
\
**init\_level\_set**str, (M, N) array, or (L, M, N) array\
\
Initial level set. If an array is given, it will be binarized and used as the initial level set. If a string is given, it defines the method to generate a reasonable initial level set with the shape of the image. Accepted values are ‘checkerboard’ and ‘disk’. See the documentation of checkerboard\_level\_set and disk\_level\_set respectively for details about how these level sets are created.\
\
**smoothing**uint, optional\
\
Number of times the smoothing operator is applied per iteration. Reasonable values are around 1-4. Larger values lead to smoother segmentations.\
\
**threshold**float, optional\
\
Areas of the image with a value smaller than this threshold will be considered borders. The evolution of the contour will stop in these areas.\
\
**balloon**float, optional\
\
Balloon force to guide the contour in non-informative areas of the image, i.e., areas where the gradient of the image is too small to push the contour towards a border. A negative value will shrink the contour, while a positive value will expand the contour in these areas. Setting this to zero will disable the balloon force.\
\
**iter\_callback**function, optional\
\
If given, this function is called once per iteration with the current level set as the only argument. This is useful for debugging or for plotting intermediate results during the evolution.\
\
Returns:\
\
**out**(M, N) or (L, M, N) array\
\
Final segmentation (i.e., the final level set)\
\
See also\
\
[`inverse_gaussian_gradient`](#cucim.skimage.segmentation.inverse_gaussian_gradient "cucim.skimage.segmentation.inverse_gaussian_gradient")\
, [`disk_level_set`](#cucim.skimage.segmentation.disk_level_set "cucim.skimage.segmentation.disk_level_set")\
, [`checkerboard_level_set`](#cucim.skimage.segmentation.checkerboard_level_set "cucim.skimage.segmentation.checkerboard_level_set")\
\
Notes\
\
This is a version of the Geodesic Active Contours (GAC) algorithm that uses morphological operators instead of solving partial differential equations (PDEs) for the evolution of the contour. The set of morphological operators used in this algorithm are proved to be infinitesimally equivalent to the GAC PDEs (see [\[1\]](#ra07eed798308-1)\
). However, morphological operators are do not suffer from the numerical stability issues typically found in PDEs (e.g., it is not necessary to find the right time step for the evolution), and are computationally faster.\
\
The algorithm and its theoretical derivation are described in [\[1\]](#ra07eed798308-1)\
.\
\
References\
\
\[1\] ([1](#id352)\
,[2](#id353)\
)\
\
A Morphological Approach to Curvature-based Evolution of Curves and Surfaces, Pablo Márquez-Neila, Luis Baumela, Luis Álvarez. In IEEE Transactions on Pattern Analysis and Machine Intelligence (PAMI), 2014, [DOI:10.1109/TPAMI.2013.106](https://doi.org/10.1109/TPAMI.2013.106)\
\
cucim.skimage.segmentation.random\_walker(_data_, _labels_, _beta\=130_, _mode\='cg\_j'_, _tol\=0.001_, _copy\=True_, _return\_full\_prob\=False_, _spacing\=None_, _\*_, _prob\_tol\=0.001_, _channel\_axis\=None_)[#](#cucim.skimage.segmentation.random_walker "Permalink to this definition")\
\
Random walker algorithm for segmentation from markers.\
\
Random walker algorithm is implemented for gray-level or multichannel images.\
\
Parameters:\
\
**data**(M, N\[, P\]\[, C\]) ndarray\
\
Image to be segmented in phases. Gray-level data can be two- or three-dimensional; multichannel data can be three- or four- dimensional with channel\_axis specifying the dimension containing channels. Data spacing is assumed isotropic unless the spacing keyword argument is used.\
\
**labels**(M, N\[, P\]) array of ints\
\
Array of seed markers labeled with different positive integers for different phases. Zero-labeled pixels are unlabeled pixels. Negative labels correspond to inactive pixels that are not taken into account (they are removed from the graph). If labels are not consecutive integers, the labels array will be transformed so that labels are consecutive. In the multichannel case, labels should have the same shape as a single channel of data, i.e. without the final dimension denoting channels.\
\
**beta**float, optional\
\
Penalization coefficient for the random walker motion (the greater beta, the more difficult the diffusion).\
\
**mode**string, available options {‘cg’, ‘cg\_j’, ‘cg\_mg’, ‘bf’}\
\
Mode for solving the linear system in the random walker algorithm.\
\
* ‘bf’ (brute force): an LU factorization of the Laplacian is computed. This is fast for small images (<1024x1024), but very slow and memory-intensive for large images (e.g., 3-D volumes).\
\
* ‘cg’ (conjugate gradient): the linear system is solved iteratively using the Conjugate Gradient method from scipy.sparse.linalg. This is less memory-consuming than the brute force method for large images, but it is quite slow.\
\
* ‘cg\_j’ (conjugate gradient with Jacobi preconditionner): the Jacobi preconditionner is applied during the Conjugate gradient method iterations. This may accelerate the convergence of the ‘cg’ method.\
\
* ‘cg\_mg’ (conjugate gradient with multigrid preconditioner): a preconditioner is computed using a multigrid solver, then the solution is computed with the Conjugate Gradient method. This mode requires that the pyamg module is installed.\
\
\
**tol**float, optional\
\
Tolerance to achieve when solving the linear system using the conjugate gradient based modes (‘cg’, ‘cg\_j’ and ‘cg\_mg’).\
\
**copy**bool, optional\
\
If copy is False, the labels array will be overwritten with the result of the segmentation. Use copy=False if you want to save on memory.\
\
**return\_full\_prob**bool, optional\
\
If True, the probability that a pixel belongs to each of the labels will be returned, instead of only the most likely label.\
\
**spacing**iterable of floats, optional\
\
Spacing between voxels in each spatial dimension. If None, then the spacing between pixels/voxels in each dimension is assumed 1.\
\
**prob\_tol**float, optional\
\
Tolerance on the resulting probability to be in the interval \[0, 1\]. If the tolerance is not satisfied, a warning is displayed.\
\
**channel\_axis**int or None, optional\
\
If None, the image is assumed to be a grayscale (single channel) image. Otherwise, this parameter indicates which axis of the array corresponds to channels.\
\
Returns:\
\
**output**ndarray\
\
* If return\_full\_prob is False, array of ints of same shape and data type as labels, in which each pixel has been labeled according to the marker that reached the pixel first by anisotropic diffusion.\
\
* If return\_full\_prob is True, array of floats of shape (nlabels, labels.shape). output\[label\_nb, i, j\] is the probability that label label\_nb reaches the pixel (i, j) first.\
\
\
Notes\
\
Multichannel inputs are scaled with all channel data combined. Ensure all channels are separately normalized prior to running this algorithm.\
\
The spacing argument is specifically for anisotropic datasets, where data points are spaced differently in one or more spatial dimensions. Anisotropic data is commonly encountered in medical imaging.\
\
The algorithm was first proposed in [\[1\]](#rbeca6ade2f68-1)\
.\
\
The algorithm solves the diffusion equation at infinite times for sources placed on markers of each phase in turn. A pixel is labeled with the phase that has the greatest probability to diffuse first to the pixel.\
\
The diffusion equation is solved by minimizing x.T L x for each phase, where L is the Laplacian of the weighted graph of the image, and x is the probability that a marker of the given phase arrives first at a pixel by diffusion (x=1 on markers of the phase, x=0 on the other markers, and the other coefficients are looked for). Each pixel is attributed the label for which it has a maximal value of x. The Laplacian L of the image is defined as:\
\
> * L\_ii = d\_i, the number of neighbors of pixel i (the degree of i)\
> \
> * L\_ij = -w\_ij if i and j are adjacent pixels\
> \
\
The weight w\_ij is a decreasing function of the norm of the local gradient. This ensures that diffusion is easier between pixels of similar values.\
\
When the Laplacian is decomposed into blocks of marked and unmarked pixels:\
\
L \= M B.T\
B A\
\
with first indices corresponding to marked pixels, and then to unmarked pixels, minimizing x.T L x for one phase amount to solving:\
\
A x \= \- B x\_m\
\
where x\_m = 1 on markers of the given phase, and 0 on other markers. This linear system is solved in the algorithm using a direct method for small images, and an iterative method for larger images.\
\
References\
\
\[[1](#id355)\
\]\
\
Leo Grady, Random walks for image segmentation, IEEE Trans Pattern Anal Mach Intell. 2006 Nov;28(11):1768-83. [DOI:10.1109/TPAMI.2006.233](https://doi.org/10.1109/TPAMI.2006.233)\
.\
\
Examples\
\
\>>> import cupy as cp\
\>>> cp.random.seed(0)\
\>>> a \= cp.zeros((10, 10)) + 0.2 \* cp.random.rand(10, 10)\
\>>> a\[5:8, 5:8\] += 1\
\>>> b \= cp.zeros\_like(a, dtype\=cp.int32)\
\>>> b\[3, 3\] \= 1 \# Marker for first phase\
\>>> b\[6, 6\] \= 2 \# Marker for second phase\
\>>> random\_walker(a, b)\
array(\[\[1, 1, 1, 1, 1, 1, 1, 1, 1, 1\],\
\[1, 1, 1, 1, 1, 1, 1, 1, 1, 1\],\
\[1, 1, 1, 1, 1, 1, 1, 1, 1, 1\],\
\[1, 1, 1, 1, 1, 1, 1, 1, 1, 1\],\
\[1, 1, 1, 1, 1, 1, 1, 1, 1, 1\],\
\[1, 1, 1, 1, 1, 2, 2, 2, 1, 1\],\
\[1, 1, 1, 1, 1, 2, 2, 2, 1, 1\],\
\[1, 1, 1, 1, 1, 2, 2, 2, 1, 1\],\
\[1, 1, 1, 1, 1, 1, 1, 1, 1, 1\],\
\[1, 1, 1, 1, 1, 1, 1, 1, 1, 1\]\], dtype=int32)\
\
cucim.skimage.segmentation.relabel\_sequential(_label\_field_, _offset\=1_)[#](#cucim.skimage.segmentation.relabel_sequential "Permalink to this definition")\
\
Relabel arbitrary labels to {offset, … offset + number\_of\_labels}.\
\
This function also returns the forward map (mapping the original labels to the reduced labels) and the inverse map (mapping the reduced labels back to the original ones).\
\
Parameters:\
\
**label\_field**numpy array of int, arbitrary shape\
\
An array of labels, which must be non-negative integers.\
\
**offset**int, optional\
\
The return labels will start at offset, which should be strictly positive.\
\
Returns:\
\
**relabeled**numpy array of int, same shape as label\_field\
\
The input label field with labels mapped to {offset, …, number\_of\_labels + offset - 1}. The data type will be the same as label\_field, except when offset + number\_of\_labels causes overflow of the current data type.\
\
**forward\_map**ArrayMap\
\
The map from the original label space to the returned label space. Can be used to re-apply the same mapping. See examples for usage. The output data type will be the same as relabeled.\
\
**inverse\_map**ArrayMap\
\
The map from the new label space to the original space. This can be used to reconstruct the original label field from the relabeled one. The output data type will be the same as label\_field.\
\
Notes\
\
The label 0 is assumed to denote the background and is never remapped.\
\
The forward map can be extremely big for some inputs, since its length is given by the maximum of the label field. However, in most situations, `label_field.max()` is much smaller than `label_field.size`, and in these cases the forward map is guaranteed to be smaller than either the input or output images.\
\
Examples\
\
\>>> import cupy as cp\
\>>> from cucim.skimage.segmentation import relabel\_sequential\
\>>> label\_field \= cp.array(\[1, 1, 5, 5, 8, 99, 42\])\
\>>> relab, fw, inv \= relabel\_sequential(label\_field)\
\>>> relab\
array(\[1, 1, 2, 2, 3, 5, 4\])\
\>>> print(fw)\
ArrayMap:\
1 → 1\
5 → 2\
8 → 3\
42 → 4\
99 → 5\
\>>> cp.array(fw)\
array(\[0, 1, 0, 0, 0, 2, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0,\
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5\])\
\>>> cp.array(inv)\
array(\[ 0, 1, 5, 8, 42, 99\])\
\>>> (fw\[label\_field\] \== relab).all()\
array(True)\
\>>> (inv\[relab\] \== label\_field).all()\
array(True)\
\>>> relab, fw, inv \= relabel\_sequential(label\_field, offset\=5)\
\>>> relab\
array(\[5, 5, 6, 6, 7, 9, 8\])\
\
### transform[#](#module-cucim.skimage.transform "Permalink to this heading")\
\
Geometric and other transformations, e.g., rotations, warp, etc.\
\
_class_ cucim.skimage.transform.AffineTransform(_matrix=None_, _scale=None_, _rotation=None_, _shear=None_, _translation=None_, _\*_, _dimensionality=2_, _xp=_)[#](#cucim.skimage.transform.AffineTransform "Permalink to this definition")\
\
Affine transformation.\
\
Has the following form:\
\
X \= a0 \* x + a1 \* y + a2\
\= sx \* x \* \[cos(rotation) + tan(shear\_y) \* sin(rotation)\]\
\- sy \* y \* \[tan(shear\_x) \* cos(rotation) + sin(rotation)\]\
+ translation\_x\
\
Y \= b0 \* x + b1 \* y + b2\
\= sx \* x \* \[sin(rotation) \- tan(shear\_y) \* cos(rotation)\]\
\- sy \* y \* \[tan(shear\_x) \* sin(rotation) \- cos(rotation)\]\
+ translation\_y\
\
where `sx` and `sy` are scale factors in the x and y directions.\
\
This is equivalent to applying the operations in the following order:\
\
1. Scale\
\
2. Shear\
\
3. Rotate\
\
4. Translate\
\
\
The homogeneous transformation matrix is:\
\
\[\[a0 a1 a2\]\
\[b0 b1 b2\]\
\[0 0 1\]\]\
\
In 2D, the transformation parameters can be given as the homogeneous transformation matrix, above, or as the implicit parameters, scale, rotation, shear, and translation in x (a2) and y (b2). For 3D and higher, only the matrix form is allowed.\
\
In narrower transforms, such as the Euclidean (only rotation and translation) or Similarity (rotation, translation, and a global scale factor) transforms, it is possible to specify 3D transforms using implicit parameters also.\
\
Parameters:\
\
**matrix**(D+1, D+1) ndarray, optional\
\
Homogeneous transformation matrix. If this matrix is provided, it is an error to provide any of scale, rotation, shear, or translation.\
\
**scale**{s as float or (sx, sy) as ndarray, list or tuple}, optional\
\
Scale factor(s). If a single value, it will be assigned to both sx and sy. Only available for 2D.\
\
New in version 0.17: Added support for supplying a single scalar value.\
\
**rotation**float, optional\
\
Rotation angle, clockwise, as radians. Only available for 2D.\
\
**shear**float or 2-tuple of float, optional\
\
The x and y shear angles, clockwise, by which these axes are rotated around the origin \[2\]. If a single value is given, take that to be the x shear angle, with the y angle remaining 0. Only available in 2D.\
\
**translation**(tx, ty) as ndarray, list or tuple, optional\
\
Translation parameters. Only available for 2D.\
\
**dimensionality**int, optional\
\
The dimensionality of the transform. This is not used if any other parameters are provided.\
\
Raises:\
\
ValueError\
\
If both `matrix` and any of the other parameters are provided.\
\
References\
\
\[1\]\
\
Wikipedia, “Affine transformation”, [https://en.wikipedia.org/wiki/Affine\_transformation#Image\_transformation](https://en.wikipedia.org/wiki/Affine_transformation#Image_transformation)\
\
\[2\]\
\
Wikipedia, “Shear mapping”, [https://en.wikipedia.org/wiki/Shear\_mapping](https://en.wikipedia.org/wiki/Shear_mapping)\
\
Examples\
\
\>>> import cupy as cp\
\>>> from cucim.skimage import transform\
\>>> from skimage import data\
\>>> img \= cp.array(data.astronaut())\
\
Define source and destination points:\
\
\>>> src \= cp.array(\[\[150, 150\],\
... \[250, 100\],\
... \[150, 200\]\])\
\>>> dst \= cp.array(\[\[200, 200\],\
... \[300, 150\],\
... \[150, 400\]\])\
\
Estimate the transformation matrix:\
\
\>>> tform \= transform.AffineTransform()\
\>>> tform.estimate(src, dst)\
True\
\
Apply the transformation:\
\
\>>> warped \= transform.warp(img, inverse\_map\=tform.inverse)\
\
Attributes:\
\
**params**(D+1, D+1) ndarray\
\
Homogeneous transformation matrix.\
\
_property_ rotation[#](#cucim.skimage.transform.AffineTransform.rotation "Permalink to this definition")\
\
_property_ scale[#](#cucim.skimage.transform.AffineTransform.scale "Permalink to this definition")\
\
_property_ shear[#](#cucim.skimage.transform.AffineTransform.shear "Permalink to this definition")\
\
_property_ translation[#](#cucim.skimage.transform.AffineTransform.translation "Permalink to this definition")\
\
_class_ cucim.skimage.transform.EssentialMatrixTransform(_rotation=None_, _translation=None_, _matrix=None_, _\*_, _dimensionality=2_, _xp=_)[#](#cucim.skimage.transform.EssentialMatrixTransform "Permalink to this definition")\
\
Essential matrix transformation.\
\
The essential matrix relates corresponding points between a pair of calibrated images. The matrix transforms normalized, homogeneous image points in one image to epipolar lines in the other image.\
\
The essential matrix is only defined for a pair of moving images capturing a non-planar scene. In the case of pure rotation or planar scenes, the homography describes the geometric relation between two images (ProjectiveTransform). If the intrinsic calibration of the images is unknown, the fundamental matrix describes the projective relation between the two images (FundamentalMatrixTransform).\
\
Parameters:\
\
**rotation**(3, 3) ndarray, optional\
\
Rotation matrix of the relative camera motion.\
\
**translation**(3, 1) ndarray, optional\
\
Translation vector of the relative camera motion. The vector must have unit length.\
\
**matrix**(3, 3) ndarray, optional\
\
Essential matrix.\
\
References\
\
\[1\]\
\
Hartley, Richard, and Andrew Zisserman. Multiple view geometry in computer vision. Cambridge university press, 2003.\
\
Examples\
\
\>>> import cupy as cp\
\>>> from cucim.skimage import transform\
\>>>\
\>>> tform\_matrix \= transform.EssentialMatrixTransform(\
... rotation\=cp.eye(3), translation\=cp.array(\[0, 0, 1\])\
... )\
\>>> tform\_matrix.params\
array(\[\[ 0., -1., 0.\],\
\[ 1., 0., 0.\],\
\[ 0., 0., 0.\]\])\
\>>> src \= cp.array(\[\[ 1.839035, 1.924743\],\
... \[ 0.543582, 0.375221\],\
... \[ 0.47324 , 0.142522\],\
... \[ 0.96491 , 0.598376\],\
... \[ 0.102388, 0.140092\],\
... \[15.994343, 9.622164\],\
... \[ 0.285901, 0.430055\],\
... \[ 0.09115 , 0.254594\]\])\
\>>> dst \= cp.array(\[\[1.002114, 1.129644\],\
... \[1.521742, 1.846002\],\
... \[1.084332, 0.275134\],\
... \[0.293328, 0.588992\],\
... \[0.839509, 0.08729 \],\
... \[1.779735, 1.116857\],\
... \[0.878616, 0.602447\],\
... \[0.642616, 1.028681\]\])\
\>>> tform\_matrix.estimate(src, dst)\
True\
\>>> tform\_matrix.residuals(src, dst)\
array(\[0.42455187, 0.01460448, 0.13847034, 0.12140951, 0.27759346,\
0.32453118, 0.00210776, 0.26512283\])\
\
Attributes:\
\
**params**(3, 3) ndarray\
\
Essential matrix.\
\
Methods\
\
| | |\
| --- | --- |\
| [`estimate`](#cucim.skimage.transform.EssentialMatrixTransform.estimate "cucim.skimage.transform.EssentialMatrixTransform.estimate")
(src, dst) | Estimate essential matrix using 8-point algorithm. |\
\
estimate(_src_, _dst_)[#](#cucim.skimage.transform.EssentialMatrixTransform.estimate "Permalink to this definition")\
\
Estimate essential matrix using 8-point algorithm.\
\
The 8-point algorithm requires at least 8 corresponding point pairs for a well-conditioned solution, otherwise the over-determined solution is estimated.\
\
Parameters:\
\
**src**(N, 2) ndarray\
\
Source coordinates.\
\
**dst**(N, 2) ndarray\
\
Destination coordinates.\
\
Returns:\
\
**success**bool\
\
True, if model estimation succeeds.\
\
_class_ cucim.skimage.transform.EuclideanTransform(_matrix=None_, _rotation=None_, _translation=None_, _\*_, _dimensionality=2_, _xp=_)[#](#cucim.skimage.transform.EuclideanTransform "Permalink to this definition")\
\
Euclidean transformation, also known as a rigid transform.\
\
Has the following form:\
\
X \= a0 \* x \- b0 \* y + a1 \=\
\= x \* cos(rotation) \- y \* sin(rotation) + a1\
\
Y \= b0 \* x + a0 \* y + b1 \=\
\= x \* sin(rotation) + y \* cos(rotation) + b1\
\
where the homogeneous transformation matrix is:\
\
\[\[a0 \-b0 a1\]\
\[b0 a0 b1\]\
\[0 0 1\]\]\
\
The Euclidean transformation is a rigid transformation with rotation and translation parameters. The similarity transformation extends the Euclidean transformation with a single scaling factor.\
\
In 2D and 3D, the transformation parameters may be provided either via matrix, the homogeneous transformation matrix, above, or via the implicit parameters rotation and/or translation (where a1 is the translation along x, b1 along y, etc.). Beyond 3D, if the transformation is only a translation, you may use the implicit parameter translation; otherwise, you must use matrix.\
\
Parameters:\
\
**matrix**(D+1, D+1) ndarray, optional\
\
Homogeneous transformation matrix.\
\
**rotation**float or sequence of float, optional\
\
Rotation angle, clockwise, as radians. If given as a vector, it is interpreted as Euler rotation angles [\[1\]](#ra85de9f51a41-1)\
. Only 2D (single rotation) and 3D (Euler rotations) values are supported. For higher dimensions, you must provide or estimate the transformation matrix.\
\
**translation**(x, y\[, z, …\]) sequence of float, length D, optional\
\
Translation parameters for each axis.\
\
**dimensionality**int, optional\
\
The dimensionality of the transform.\
\
References\
\
\[[1](#id360)\
\]\
\
[https://en.wikipedia.org/wiki/Rotation\_matrix#In\_three\_dimensions](https://en.wikipedia.org/wiki/Rotation_matrix#In_three_dimensions)\
\
Attributes:\
\
**params**(D+1, D+1) ndarray\
\
Homogeneous transformation matrix.\
\
Methods\
\
| | |\
| --- | --- |\
| [`estimate`](#cucim.skimage.transform.EuclideanTransform.estimate "cucim.skimage.transform.EuclideanTransform.estimate")
(src, dst) | Estimate the transformation from a set of corresponding points. |\
\
estimate(_src_, _dst_)[#](#cucim.skimage.transform.EuclideanTransform.estimate "Permalink to this definition")\
\
Estimate the transformation from a set of corresponding points.\
\
You can determine the over-, well- and under-determined parameters with the total least-squares method.\
\
Number of source and destination coordinates must match.\
\
Parameters:\
\
**src**(N, D) ndarray\
\
Source coordinates.\
\
**dst**(N, D) ndarray\
\
Destination coordinates.\
\
Returns:\
\
**success**bool\
\
True, if model estimation succeeds.\
\
_property_ rotation[#](#cucim.skimage.transform.EuclideanTransform.rotation "Permalink to this definition")\
\
_property_ translation[#](#cucim.skimage.transform.EuclideanTransform.translation "Permalink to this definition")\
\
_class_ cucim.skimage.transform.FundamentalMatrixTransform(_matrix=None_, _\*_, _dimensionality=2_, _xp=_)[#](#cucim.skimage.transform.FundamentalMatrixTransform "Permalink to this definition")\
\
Fundamental matrix transformation.\
\
The fundamental matrix relates corresponding points between a pair of uncalibrated images. The matrix transforms homogeneous image points in one image to epipolar lines in the other image.\
\
The fundamental matrix is only defined for a pair of moving images. In the case of pure rotation or planar scenes, the homography describes the geometric relation between two images (ProjectiveTransform). If the intrinsic calibration of the images is known, the essential matrix describes the metric relation between the two images (EssentialMatrixTransform).\
\
Parameters:\
\
**matrix**(3, 3) ndarray, optional\
\
Fundamental matrix.\
\
References\
\
\[1\]\
\
Hartley, Richard, and Andrew Zisserman. Multiple view geometry in computer vision. Cambridge university press, 2003.\
\
Examples\
\
\>>> import numpy as np\
\>>> import cucim.skimage as ski\
\>>> tform\_matrix \= ski.transform.FundamentalMatrixTransform()\
\
Define source and destination points:\
\
\>>> src \= np.array(\[1.839035, 1.924743,\
... 0.543582, 0.375221,\
... 0.473240, 0.142522,\
... 0.964910, 0.598376,\
... 0.102388, 0.140092,\
... 15.994343, 9.622164,\
... 0.285901, 0.430055,\
... 0.091150, 0.254594\]).reshape(\-1, 2)\
\>>> dst \= np.array(\[1.002114, 1.129644,\
... 1.521742, 1.846002,\
... 1.084332, 0.275134,\
... 0.293328, 0.588992,\
... 0.839509, 0.087290,\
... 1.779735, 1.116857,\
... 0.878616, 0.602447,\
... 0.642616, 1.028681\]).reshape(\-1, 2)\
\
Estimate the transformation matrix:\
\
\>>> tform\_matrix.estimate(src, dst)\
True\
\>>> tform\_matrix.params\
array(\[\[-0.21785884, 0.41928191, -0.03430748\],\
\[-0.07179414, 0.04516432, 0.02160726\],\
\[ 0.24806211, -0.42947814, 0.02210191\]\])\
\
Compute the Sampson distance:\
\
\>>> tform\_matrix.residuals(src, dst)\
array(\[0.0053886 , 0.00526101, 0.08689701, 0.01850534, 0.09418259,\
0.00185967, 0.06160489, 0.02655136\])\
\
Apply inverse transformation:\
\
\>>> tform\_matrix.inverse(dst)\
array(\[\[-0.0513591 , 0.04170974, 0.01213043\],\
\[-0.21599496, 0.29193419, 0.00978184\],\
\[-0.0079222 , 0.03758889, -0.00915389\],\
\[ 0.14187184, -0.27988959, 0.02476507\],\
\[ 0.05890075, -0.07354481, -0.00481342\],\
\[-0.21985267, 0.36717464, -0.01482408\],\
\[ 0.01339569, -0.03388123, 0.00497605\],\
\[ 0.03420927, -0.1135812 , 0.02228236\]\])\
\
Attributes:\
\
**params**(3, 3) ndarray\
\
Fundamental matrix.\
\
Methods\
\
| | |\
| --- | --- |\
| `__call__`(coords) | Apply forward transformation. |\
| [`estimate`](#cucim.skimage.transform.FundamentalMatrixTransform.estimate "cucim.skimage.transform.FundamentalMatrixTransform.estimate")
(src, dst) | Estimate fundamental matrix using 8-point algorithm. |\
| [`inverse`](#cucim.skimage.transform.FundamentalMatrixTransform.inverse "cucim.skimage.transform.FundamentalMatrixTransform.inverse")
(coords) | Apply inverse transformation. |\
| [`residuals`](#cucim.skimage.transform.FundamentalMatrixTransform.residuals "cucim.skimage.transform.FundamentalMatrixTransform.residuals")
(src, dst) | Compute the Sampson distance. |\
\
estimate(_src_, _dst_)[#](#cucim.skimage.transform.FundamentalMatrixTransform.estimate "Permalink to this definition")\
\
Estimate fundamental matrix using 8-point algorithm.\
\
The 8-point algorithm requires at least 8 corresponding point pairs for a well-conditioned solution, otherwise the over-determined solution is estimated.\
\
Parameters:\
\
**src**(N, 2) ndarray\
\
Source coordinates.\
\
**dst**(N, 2) ndarray\
\
Destination coordinates.\
\
Returns:\
\
**success**bool\
\
True, if model estimation succeeds.\
\
inverse(_coords_)[#](#cucim.skimage.transform.FundamentalMatrixTransform.inverse "Permalink to this definition")\
\
Apply inverse transformation.\
\
Parameters:\
\
**coords**(N, 2) ndarray\
\
Destination coordinates.\
\
Returns:\
\
**coords**(N, 3) ndarray\
\
Epipolar lines in the source image.\
\
residuals(_src_, _dst_)[#](#cucim.skimage.transform.FundamentalMatrixTransform.residuals "Permalink to this definition")\
\
Compute the Sampson distance.\
\
The Sampson distance is the first approximation to the geometric error.\
\
Parameters:\
\
**src**(N, 2) ndarray\
\
Source coordinates.\
\
**dst**(N, 2) ndarray\
\
Destination coordinates.\
\
Returns:\
\
**residuals**(N,) ndarray\
\
Sampson distance.\
\
_class_ cucim.skimage.transform.PiecewiseAffineTransform[#](#cucim.skimage.transform.PiecewiseAffineTransform "Permalink to this definition")\
\
Piecewise affine transformation.\
\
Control points are used to define the mapping. The transform is based on a Delaunay triangulation of the points to form a mesh. Each triangle is used to find a local affine transform.\
\
Attributes:\
\
**affines**list of AffineTransform objects\
\
Affine transformations for each triangle in the mesh.\
\
**inverse\_affines**list of AffineTransform objects\
\
Inverse affine transformations for each triangle in the mesh.\
\
Methods\
\
| | |\
| --- | --- |\
| `__call__`(coords) | Apply forward transformation. |\
| [`estimate`](#cucim.skimage.transform.PiecewiseAffineTransform.estimate "cucim.skimage.transform.PiecewiseAffineTransform.estimate")
(src, dst) | Estimate the transformation from a set of corresponding points. |\
| [`inverse`](#cucim.skimage.transform.PiecewiseAffineTransform.inverse "cucim.skimage.transform.PiecewiseAffineTransform.inverse")
(coords) | Apply inverse transformation. |\
\
estimate(_src_, _dst_)[#](#cucim.skimage.transform.PiecewiseAffineTransform.estimate "Permalink to this definition")\
\
Estimate the transformation from a set of corresponding points.\
\
Number of source and destination coordinates must match.\
\
Parameters:\
\
**src**(N, D) ndarray\
\
Source coordinates.\
\
**dst**(N, D) ndarray\
\
Destination coordinates.\
\
Returns:\
\
**success**bool\
\
True, if all pieces of the model are successfully estimated.\
\
inverse(_coords_)[#](#cucim.skimage.transform.PiecewiseAffineTransform.inverse "Permalink to this definition")\
\
Apply inverse transformation.\
\
Coordinates outside of the mesh will be set to \- 1.\
\
Parameters:\
\
**coords**(N, D) ndarray\
\
Source coordinates.\
\
Returns:\
\
**coords**(N, D) ndarray\
\
Transformed coordinates.\
\
_class_ cucim.skimage.transform.PolynomialTransform(_params=None_, _\*_, _dimensionality=2_, _xp=_)[#](#cucim.skimage.transform.PolynomialTransform "Permalink to this definition")\
\
2D polynomial transformation.\
\
Has the following form:\
\
X \= sum\[j\=0:order\]( sum\[i\=0:j\]( a\_ji \* x\*\*(j \- i) \* y\*\*i ))\
Y \= sum\[j\=0:order\]( sum\[i\=0:j\]( b\_ji \* x\*\*(j \- i) \* y\*\*i ))\
\
Parameters:\
\
**params**(2, N) ndarray, optional\
\
Polynomial coefficients where N \* 2 = (order + 1) \* (order + 2). So, a\_ji is defined in params\[0, :\] and b\_ji in params\[1, :\].\
\
Attributes:\
\
**params**(2, N) ndarray\
\
Polynomial coefficients where N \* 2 = (order + 1) \* (order + 2). So, a\_ji is defined in params\[0, :\] and b\_ji in params\[1, :\].\
\
Methods\
\
| | |\
| --- | --- |\
| `__call__`(coords) | Apply forward transformation. |\
| [`estimate`](#cucim.skimage.transform.PolynomialTransform.estimate "cucim.skimage.transform.PolynomialTransform.estimate")
(src, dst\[, order, weights\]) | Estimate the transformation from a set of corresponding points. |\
| [`inverse`](#cucim.skimage.transform.PolynomialTransform.inverse "cucim.skimage.transform.PolynomialTransform.inverse")
(coords) | Apply inverse transformation. |\
\
estimate(_src_, _dst_, _order\=2_, _weights\=None_)[#](#cucim.skimage.transform.PolynomialTransform.estimate "Permalink to this definition")\
\
Estimate the transformation from a set of corresponding points.\
\
You can determine the over-, well- and under-determined parameters with the total least-squares method.\
\
Number of source and destination coordinates must match.\
\
The transformation is defined as:\
\
X \= sum\[j\=0:order\]( sum\[i\=0:j\]( a\_ji \* x\*\*(j \- i) \* y\*\*i ))\
Y \= sum\[j\=0:order\]( sum\[i\=0:j\]( b\_ji \* x\*\*(j \- i) \* y\*\*i ))\
\
These equations can be transformed to the following form:\
\
0 \= sum\[j\=0:order\]( sum\[i\=0:j\]( a\_ji \* x\*\*(j \- i) \* y\*\*i )) \- X\
0 \= sum\[j\=0:order\]( sum\[i\=0:j\]( b\_ji \* x\*\*(j \- i) \* y\*\*i )) \- Y\
\
which exist for each set of corresponding points, so we have a set of N \* 2 equations. The coefficients appear linearly so we can write A x = 0, where:\
\
A \= \[\[1 x y x\*\*2 x\*y y\*\*2 ... 0 ... 0 \-X\]\
\[0 ... 0 1 x y x\*\*2 x\*y y\*\*2 \-Y\]\
...\
...\
\]\
x.T \= \[a00 a10 a11 a20 a21 a22 ... ann\
b00 b10 b11 b20 b21 b22 ... bnn c3\]\
\
In case of total least-squares the solution of this homogeneous system of equations is the right singular vector of A which corresponds to the smallest singular value normed by the coefficient c3.\
\
Weights can be applied to each pair of corresponding points to indicate, particularly in an overdetermined system, if point pairs have higher or lower confidence or uncertainties associated with them. From the matrix treatment of least squares problems, these weight values are normalised, square-rooted, then built into a diagonal matrix, by which A is multiplied.\
\
Parameters:\
\
**src**(N, 2) ndarray\
\
Source coordinates.\
\
**dst**(N, 2) ndarray\
\
Destination coordinates.\
\
**order**int, optional\
\
Polynomial order (number of coefficients is order + 1).\
\
**weights**(N,) ndarray, optional\
\
Relative weight values for each pair of points.\
\
Returns:\
\
**success**bool\
\
True, if model estimation succeeds.\
\
inverse(_coords_)[#](#cucim.skimage.transform.PolynomialTransform.inverse "Permalink to this definition")\
\
Apply inverse transformation.\
\
Parameters:\
\
**coords**(N, 2) ndarray\
\
Destination coordinates.\
\
Returns:\
\
**coords**(N, 2) ndarray\
\
Source coordinates.\
\
_class_ cucim.skimage.transform.ProjectiveTransform(_matrix=None_, _\*_, _dimensionality=2_, _xp=_)[#](#cucim.skimage.transform.ProjectiveTransform "Permalink to this definition")\
\
Projective transformation.\
\
Apply a projective transformation (homography) on coordinates.\
\
For each homogeneous coordinate \\(\\mathbf{x} = \[x, y, 1\]^T\\), its target position is calculated by multiplying with the given matrix, \\(H\\), to give \\(H \\mathbf{x}\\):\
\
\[\[a0 a1 a2\]\
\[b0 b1 b2\]\
\[c0 c1 1 \]\].\
\
E.g., to rotate by theta degrees clockwise, the matrix should be:\
\
\[\[cos(theta) \-sin(theta) 0\]\
\[sin(theta) cos(theta) 0\]\
\[0 0 1\]\]\
\
or, to translate x by 10 and y by 20:\
\
\[\[1 0 10\]\
\[0 1 20\]\
\[0 0 1 \]\].\
\
Parameters:\
\
**matrix**(D+1, D+1) ndarray, optional\
\
Homogeneous transformation matrix.\
\
**dimensionality**int, optional\
\
The number of dimensions of the transform. This is ignored if `matrix` is not None.\
\
Attributes:\
\
**params**(D+1, D+1) ndarray\
\
Homogeneous transformation matrix.\
\
Methods\
\
| | |\
| --- | --- |\
| `__call__`(coords) | Apply forward transformation. |\
| [`estimate`](#cucim.skimage.transform.ProjectiveTransform.estimate "cucim.skimage.transform.ProjectiveTransform.estimate")
(src, dst\[, weights\]) | Estimate the transformation from a set of corresponding points. |\
| [`inverse`](#cucim.skimage.transform.ProjectiveTransform.inverse "cucim.skimage.transform.ProjectiveTransform.inverse")
(coords) | Apply inverse transformation. |\
\
_property_ dimensionality[#](#cucim.skimage.transform.ProjectiveTransform.dimensionality "Permalink to this definition")\
\
The dimensionality of the transformation.\
\
estimate(_src_, _dst_, _weights\=None_)[#](#cucim.skimage.transform.ProjectiveTransform.estimate "Permalink to this definition")\
\
Estimate the transformation from a set of corresponding points.\
\
You can determine the over-, well- and under-determined parameters with the total least-squares method.\
\
Number of source and destination coordinates must match.\
\
The transformation is defined as:\
\
X \= (a0\*x + a1\*y + a2) / (c0\*x + c1\*y + 1)\
Y \= (b0\*x + b1\*y + b2) / (c0\*x + c1\*y + 1)\
\
These equations can be transformed to the following form:\
\
0 \= a0\*x + a1\*y + a2 \- c0\*x\*X \- c1\*y\*X \- X\
0 \= b0\*x + b1\*y + b2 \- c0\*x\*Y \- c1\*y\*Y \- Y\
\
which exist for each set of corresponding points, so we have a set of N \* 2 equations. The coefficients appear linearly so we can write A x = 0, where:\
\
A \= \[\[x y 1 0 0 0 \-x\*X \-y\*X \-X\]\
\[0 0 0 x y 1 \-x\*Y \-y\*Y \-Y\]\
...\
...\
\]\
x.T \= \[a0 a1 a2 b0 b1 b2 c0 c1 c3\]\
\
In case of total least-squares the solution of this homogeneous system of equations is the right singular vector of A which corresponds to the smallest singular value normed by the coefficient c3.\
\
Weights can be applied to each pair of corresponding points to indicate, particularly in an overdetermined system, if point pairs have higher or lower confidence or uncertainties associated with them. From the matrix treatment of least squares problems, these weight values are normalised, square-rooted, then built into a diagonal matrix, by which A is multiplied.\
\
In case of the affine transformation the coefficients c0 and c1 are 0. Thus the system of equations is:\
\
A \= \[\[x y 1 0 0 0 \-X\]\
\[0 0 0 x y 1 \-Y\]\
...\
...\
\]\
x.T \= \[a0 a1 a2 b0 b1 b2 c3\]\
\
Parameters:\
\
**src**(N, 2) ndarray\
\
Source coordinates.\
\
**dst**(N, 2) ndarray\
\
Destination coordinates.\
\
**weights**(N,) ndarray, optional\
\
Relative weight values for each pair of points.\
\
Returns:\
\
**success**bool\
\
True, if model estimation succeeds.\
\
inverse(_coords_)[#](#cucim.skimage.transform.ProjectiveTransform.inverse "Permalink to this definition")\
\
Apply inverse transformation.\
\
Parameters:\
\
**coords**(N, D) ndarray\
\
Destination coordinates.\
\
Returns:\
\
**coords\_out**(N, D) ndarray\
\
Source coordinates.\
\
_class_ cucim.skimage.transform.SimilarityTransform(_matrix=None_, _scale=None_, _rotation=None_, _translation=None_, _\*_, _dimensionality=2_, _xp=_)[#](#cucim.skimage.transform.SimilarityTransform "Permalink to this definition")\
\
Similarity transformation.\
\
Has the following form in 2D:\
\
X \= a0 \* x \- b0 \* y + a1 \=\
\= s \* x \* cos(rotation) \- s \* y \* sin(rotation) + a1\
\
Y \= b0 \* x + a0 \* y + b1 \=\
\= s \* x \* sin(rotation) + s \* y \* cos(rotation) + b1\
\
where `s` is a scale factor and the homogeneous transformation matrix is:\
\
\[\[a0 \-b0 a1\]\
\[b0 a0 b1\]\
\[0 0 1\]\]\
\
The similarity transformation extends the Euclidean transformation with a single scaling factor in addition to the rotation and translation parameters.\
\
Parameters:\
\
**matrix**(dim+1, dim+1) ndarray, optional\
\
Homogeneous transformation matrix.\
\
**scale**float, optional\
\
Scale factor. Implemented only for 2D and 3D.\
\
**rotation**float, optional\
\
Rotation angle, clockwise, as radians. Implemented only for 2D and 3D. For 3D, this is given in XZX Euler angles.\
\
**translation**(dim,) ndarray-like, optional\
\
x, y\[, z\] translation parameters. Implemented only for 2D and 3D.\
\
Attributes:\
\
**params**(dim+1, dim+1) ndarray\
\
Homogeneous transformation matrix.\
\
Methods\
\
| | |\
| --- | --- |\
| [`estimate`](#cucim.skimage.transform.SimilarityTransform.estimate "cucim.skimage.transform.SimilarityTransform.estimate")
(src, dst) | Estimate the transformation from a set of corresponding points. |\
\
estimate(_src_, _dst_)[#](#cucim.skimage.transform.SimilarityTransform.estimate "Permalink to this definition")\
\
Estimate the transformation from a set of corresponding points.\
\
You can determine the over-, well- and under-determined parameters with the total least-squares method.\
\
Number of source and destination coordinates must match.\
\
Parameters:\
\
**src**(N, 2) ndarray\
\
Source coordinates.\
\
**dst**(N, 2) ndarray\
\
Destination coordinates.\
\
Returns:\
\
**success**bool\
\
True, if model estimation succeeds.\
\
_property_ scale[#](#cucim.skimage.transform.SimilarityTransform.scale "Permalink to this definition")\
\
cucim.skimage.transform.downscale\_local\_mean(_image_, _factors_, _cval\=0_, _clip\=True_)[#](#cucim.skimage.transform.downscale_local_mean "Permalink to this definition")\
\
Down-sample N-dimensional image by local averaging.\
\
The image is padded with cval if it is not perfectly divisible by the integer factors.\
\
In contrast to interpolation in skimage.transform.resize and skimage.transform.rescale this function calculates the local mean of elements in each block of size factors in the input image.\
\
Parameters:\
\
**image**(M\[, …\]) ndarray\
\
Input image.\
\
**factors**array\_like\
\
Array containing down-sampling integer factor along each axis.\
\
**cval**float, optional\
\
Constant padding value if image is not perfectly divisible by the integer factors.\
\
**clip**bool, optional\
\
Unused, but kept here for API consistency with the other transforms in this module. (The local mean will never fall outside the range of values in the input image, assuming the provided cval also falls within that range.)\
\
Returns:\
\
**image**ndarray\
\
Down-sampled image with same number of dimensions as input image. For integer inputs, the output dtype will be `float64`. See [`numpy.mean()`](https://numpy.org/doc/stable/reference/generated/numpy.mean.html#numpy.mean "(in NumPy v2.2)")\
for details.\
\
Examples\
\
\>>> import cupy as cp\
\>>> a \= cp.arange(15).reshape(3, 5)\
\>>> a\
array(\[\[ 0, 1, 2, 3, 4\],\
\[ 5, 6, 7, 8, 9\],\
\[10, 11, 12, 13, 14\]\])\
\>>> downscale\_local\_mean(a, (2, 3))\
array(\[\[3.5, 4. \],\
\[5.5, 4.5\]\])\
\
cucim.skimage.transform.estimate\_transform(_ttype_, _src_, _dst_, _\*args_, _\*\*kwargs_)[#](#cucim.skimage.transform.estimate_transform "Permalink to this definition")\
\
Estimate 2D geometric transformation parameters.\
\
You can determine the over-, well- and under-determined parameters with the total least-squares method.\
\
Number of source and destination coordinates must match.\
\
Parameters:\
\
**ttype**{‘euclidean’, similarity’, ‘affine’, ‘piecewise-affine’, ‘projective’, ‘polynomial’}\
\
Type of transform.\
\
**kwargs**ndarray or int\
\
Function parameters (src, dst, n, angle):\
\
NAME / TTYPE FUNCTION PARAMETERS\
'euclidean' \`src, \`dst\`\
'similarity' \`src, \`dst\`\
'affine' \`src, \`dst\`\
'piecewise-affine' \`src, \`dst\`\
'projective' \`src, \`dst\`\
'polynomial' \`src, \`dst\`, \`order\` (polynomial order,\
default order is 2)\
\
Also see examples below.\
\
Returns:\
\
**tform**`GeometricTransform`\
\
Transform object containing the transformation parameters and providing access to forward and inverse transformation functions.\
\
Examples\
\
\>>> import cupy as cp\
\>>> from cucim.skimage import transform\
\
\>>> \# estimate transformation parameters\
\>>> src \= cp.array(\[0, 0, 10, 10\]).reshape((2, 2))\
\>>> dst \= cp.array(\[12, 14, 1, \-20\]).reshape((2, 2))\
\
\>>> tform \= transform.estimate\_transform('similarity', src, dst)\
\
\>>> cp.allclose(tform.inverse(tform(src)), src)\
array(True)\
\
\>>> \# warp image using the estimated transformation\
\>>> from skimage import data\
\>>> image \= cp.array(data.camera())\
\
\>>> transform.warp(image, inverse\_map\=tform.inverse) \
\
\>>> \# create transformation with explicit parameters\
\>>> tform2 \= transform.SimilarityTransform(scale\=1.1, rotation\=1,\
... translation\=(10, 20))\
\
\>>> \# unite transformations, applied in order from left to right\
\>>> tform3 \= tform + tform2\
\>>> cp.allclose(tform3(src), tform2(tform(src)))\
array(True)\
\
cucim.skimage.transform.integral\_image(_image_, _\*_, _dtype\=None_)[#](#cucim.skimage.transform.integral_image "Permalink to this definition")\
\
Integral image / summed area table.\
\
The integral image contains the sum of all elements above and to the left of it, i.e.:\
\
\\\[S\[m, n\] = \\sum\_{i \\leq m} \\sum\_{j \\leq n} X\[i, j\]\\\]\
\
Parameters:\
\
**image**ndarray\
\
Input image.\
\
Returns:\
\
**S**ndarray\
\
Integral image/summed area table of same shape as input image.\
\
Notes\
\
For better accuracy and to avoid potential overflow, the data type of the output may differ from the input’s when the default dtype of None is used. For inputs with integer dtype, the behavior matches that for [`numpy.cumsum()`](https://numpy.org/doc/stable/reference/generated/numpy.cumsum.html#numpy.cumsum "(in NumPy v2.2)")\
. Floating point inputs will be promoted to at least double precision. The user can set dtype to override this behavior.\
\
References\
\
\[1\]\
\
F.C. Crow, “Summed-area tables for texture mapping,” ACM SIGGRAPH Computer Graphics, vol. 18, 1984, pp. 207-212.\
\
cucim.skimage.transform.integrate(_ii_, _start_, _end_)[#](#cucim.skimage.transform.integrate "Permalink to this definition")\
\
Use an integral image to integrate over a given window.\
\
Parameters:\
\
**ii**ndarray\
\
Integral image.\
\
**start**List of tuples, each tuple of length equal to dimension of ii\
\
Coordinates of top left corner of window(s). Each tuple in the list contains the starting row, col, … index i.e \[(row\_win1, col\_win1, …), (row\_win2, col\_win2,…), …\].\
\
**end**List of tuples, each tuple of length equal to dimension of ii\
\
Coordinates of bottom right corner of window(s). Each tuple in the list containing the end row, col, … index i.e \[(row\_win1, col\_win1, …), (row\_win2, col\_win2, …), …\].\
\
Returns:\
\
**S**scalar or ndarray\
\
Integral (sum) over the given window(s).\
\
See also\
\
[`integral_image`](#cucim.skimage.transform.integral_image "cucim.skimage.transform.integral_image")\
\
Create an integral image / summed area table.\
\
Examples\
\
\>>> arr \= np.ones((5, 6), dtype\=float)\
\>>> ii \= integral\_image(arr)\
\>>> integrate(ii, (1, 0), (1, 2)) \# sum from (1, 0) to (1, 2)\
array(\[3.\])\
\>>> integrate(ii, \[(3, 3)\], \[(4, 5)\]) \# sum from (3, 3) to (4, 5)\
array(\[6.\])\
\>>> \# sum from (1, 0) to (1, 2) and from (3, 3) to (4, 5)\
\>>> integrate(ii, \[(1, 0), (3, 3)\], \[(1, 2), (4, 5)\])\
array(\[3., 6.\])\
\
cucim.skimage.transform.matrix\_transform(_coords_, _matrix_)[#](#cucim.skimage.transform.matrix_transform "Permalink to this definition")\
\
Apply 2D matrix transform.\
\
Parameters:\
\
**coords**(N, 2) ndarray\
\
x, y coordinates to transform\
\
**matrix**(3, 3) ndarray\
\
Homogeneous transformation matrix.\
\
Returns:\
\
**coords**(N, 2) ndarray\
\
Transformed coordinates.\
\
cucim.skimage.transform.pyramid\_expand(_image_, _upscale\=2_, _sigma\=None_, _order\=1_, _mode\='reflect'_, _cval\=0_, _preserve\_range\=False_, _\*_, _channel\_axis\=None_)[#](#cucim.skimage.transform.pyramid_expand "Permalink to this definition")\
\
Upsample and then smooth image.\
\
Parameters:\
\
**image**ndarray\
\
Input image.\
\
**upscale**float, optional\
\
Upscale factor.\
\
**sigma**float, optional\
\
Sigma for Gaussian filter. Default is 2 \* upscale / 6.0 which corresponds to a filter mask twice the size of the scale factor that covers more than 99% of the Gaussian distribution.\
\
**order**int, optional\
\
Order of splines used in interpolation of upsampling. See skimage.transform.warp for detail.\
\
**mode**{‘reflect’, ‘constant’, ‘edge’, ‘symmetric’, ‘wrap’}, optional\
\
The mode parameter determines how the array borders are handled, where cval is the value when mode is equal to ‘constant’.\
\
**cval**float, optional\
\
Value to fill past edges of input if mode is ‘constant’.\
\
**preserve\_range**bool, optional\
\
Whether to keep the original range of values. Otherwise, the input image is converted according to the conventions of img\_as\_float. Also see [https://scikit-image.org/docs/dev/user\_guide/data\_types.html](https://scikit-image.org/docs/dev/user_guide/data_types.html)\
\
**channel\_axis**int or None, optional\
\
If None, the image is assumed to be a grayscale (single channel) image. Otherwise, this parameter indicates which axis of the array corresponds to channels.\
\
Returns:\
\
**out**array\
\
Upsampled and smoothed float image.\
\
References\
\
\[1\]\
\
[http://persci.mit.edu/pub\_pdfs/pyramid83.pdf](http://persci.mit.edu/pub_pdfs/pyramid83.pdf)\
\
cucim.skimage.transform.pyramid\_gaussian(_image_, _max\_layer\=\-1_, _downscale\=2_, _sigma\=None_, _order\=1_, _mode\='reflect'_, _cval\=0_, _preserve\_range\=False_, _\*_, _channel\_axis\=None_)[#](#cucim.skimage.transform.pyramid_gaussian "Permalink to this definition")\
\
Yield images of the Gaussian pyramid formed by the input image.\
\
Recursively applies the pyramid\_reduce function to the image, and yields the downscaled images.\
\
Note that the first image of the pyramid will be the original, unscaled image. The total number of images is max\_layer + 1. In case all layers are computed, the last image is either a one-pixel image or the image where the reduction does not change its shape.\
\
Parameters:\
\
**image**ndarray\
\
Input image.\
\
**max\_layer**int, optional\
\
Number of layers for the pyramid. 0th layer is the original image. Default is -1 which builds all possible layers.\
\
**downscale**float, optional\
\
Downscale factor.\
\
**sigma**float, optional\
\
Sigma for Gaussian filter. Default is 2 \* downscale / 6.0 which corresponds to a filter mask twice the size of the scale factor that covers more than 99% of the Gaussian distribution.\
\
**order**int, optional\
\
Order of splines used in interpolation of downsampling. See skimage.transform.warp for detail.\
\
**mode**{‘reflect’, ‘constant’, ‘edge’, ‘symmetric’, ‘wrap’}, optional\
\
The mode parameter determines how the array borders are handled, where cval is the value when mode is equal to ‘constant’.\
\
**cval**float, optional\
\
Value to fill past edges of input if mode is ‘constant’.\
\
**preserve\_range**bool, optional\
\
Whether to keep the original range of values. Otherwise, the input image is converted according to the conventions of img\_as\_float. Also see [https://scikit-image.org/docs/dev/user\_guide/data\_types.html](https://scikit-image.org/docs/dev/user_guide/data_types.html)\
\
**channel\_axis**int or None, optional\
\
If None, the image is assumed to be a grayscale (single channel) image. Otherwise, this parameter indicates which axis of the array corresponds to channels.\
\
Returns:\
\
**pyramid**generator\
\
Generator yielding pyramid layers as float images.\
\
References\
\
\[1\]\
\
[http://persci.mit.edu/pub\_pdfs/pyramid83.pdf](http://persci.mit.edu/pub_pdfs/pyramid83.pdf)\
\
cucim.skimage.transform.pyramid\_laplacian(_image_, _max\_layer\=\-1_, _downscale\=2_, _sigma\=None_, _order\=1_, _mode\='reflect'_, _cval\=0_, _preserve\_range\=False_, _\*_, _channel\_axis\=None_)[#](#cucim.skimage.transform.pyramid_laplacian "Permalink to this definition")\
\
Yield images of the laplacian pyramid formed by the input image.\
\
Each layer contains the difference between the downsampled and the downsampled, smoothed image:\
\
layer \= resize(prev\_layer) \- smooth(resize(prev\_layer))\
\
Note that the first image of the pyramid will be the difference between the original, unscaled image and its smoothed version. The total number of images is max\_layer + 1. In case all layers are computed, the last image is either a one-pixel image or the image where the reduction does not change its shape.\
\
Parameters:\
\
**image**ndarray\
\
Input image.\
\
**max\_layer**int, optional\
\
Number of layers for the pyramid. 0th layer is the original image. Default is -1 which builds all possible layers.\
\
**downscale**float, optional\
\
Downscale factor.\
\
**sigma**float, optional\
\
Sigma for Gaussian filter. Default is 2 \* downscale / 6.0 which corresponds to a filter mask twice the size of the scale factor that covers more than 99% of the Gaussian distribution.\
\
**order**int, optional\
\
Order of splines used in interpolation of downsampling. See skimage.transform.warp for detail.\
\
**mode**{‘reflect’, ‘constant’, ‘edge’, ‘symmetric’, ‘wrap’}, optional\
\
The mode parameter determines how the array borders are handled, where cval is the value when mode is equal to ‘constant’.\
\
**cval**float, optional\
\
Value to fill past edges of input if mode is ‘constant’.\
\
**preserve\_range**bool, optional\
\
Whether to keep the original range of values. Otherwise, the input image is converted according to the conventions of img\_as\_float. Also see [https://scikit-image.org/docs/dev/user\_guide/data\_types.html](https://scikit-image.org/docs/dev/user_guide/data_types.html)\
\
**channel\_axis**int or None, optional\
\
If None, the image is assumed to be a grayscale (single channel) image. Otherwise, this parameter indicates which axis of the array corresponds to channels.\
\
Returns:\
\
**pyramid**generator\
\
Generator yielding pyramid layers as float images.\
\
References\
\
\[1\]\
\
[http://persci.mit.edu/pub\_pdfs/pyramid83.pdf](http://persci.mit.edu/pub_pdfs/pyramid83.pdf)\
\
\[2\]\
\
[http://sepwww.stanford.edu/data/media/public/sep/morgan/texturematch/paper\_html/node3.html](http://sepwww.stanford.edu/data/media/public/sep/morgan/texturematch/paper_html/node3.html)\
\
cucim.skimage.transform.pyramid\_reduce(_image_, _downscale\=2_, _sigma\=None_, _order\=1_, _mode\='reflect'_, _cval\=0_, _preserve\_range\=False_, _\*_, _channel\_axis\=None_)[#](#cucim.skimage.transform.pyramid_reduce "Permalink to this definition")\
\
Smooth and then downsample image.\
\
Parameters:\
\
**image**ndarray\
\
Input image.\
\
**downscale**float, optional\
\
Downscale factor.\
\
**sigma**float, optional\
\
Sigma for Gaussian filter. Default is 2 \* downscale / 6.0 which corresponds to a filter mask twice the size of the scale factor that covers more than 99% of the Gaussian distribution.\
\
**order**int, optional\
\
Order of splines used in interpolation of downsampling. See skimage.transform.warp for detail.\
\
**mode**{‘reflect’, ‘constant’, ‘edge’, ‘symmetric’, ‘wrap’}, optional\
\
The mode parameter determines how the array borders are handled, where cval is the value when mode is equal to ‘constant’.\
\
**cval**float, optional\
\
Value to fill past edges of input if mode is ‘constant’.\
\
**preserve\_range**bool, optional\
\
Whether to keep the original range of values. Otherwise, the input image is converted according to the conventions of img\_as\_float. Also see [https://scikit-image.org/docs/dev/user\_guide/data\_types.html](https://scikit-image.org/docs/dev/user_guide/data_types.html)\
\
**channel\_axis**int or None, optional\
\
If None, the image is assumed to be a grayscale (single channel) image. Otherwise, this parameter indicates which axis of the array corresponds to channels.\
\
Returns:\
\
**out**array\
\
Smoothed and downsampled float image.\
\
References\
\
\[1\]\
\
[http://persci.mit.edu/pub\_pdfs/pyramid83.pdf](http://persci.mit.edu/pub_pdfs/pyramid83.pdf)\
\
cucim.skimage.transform.rescale(_image_, _scale_, _order\=None_, _mode\='reflect'_, _cval\=0_, _clip\=None_, _preserve\_range\=False_, _anti\_aliasing\=None_, _anti\_aliasing\_sigma\=None_, _\*_, _channel\_axis\=None_)[#](#cucim.skimage.transform.rescale "Permalink to this definition")\
\
Scale image by a certain factor.\
\
Performs interpolation to up-scale or down-scale N-dimensional images. Note that anti-aliasing should be enabled when down-sizing images to avoid aliasing artifacts. For down-sampling with an integer factor also see skimage.transform.downscale\_local\_mean.\
\
Parameters:\
\
**image**(M, N\[, …\]\[, C\]) ndarray\
\
Input image.\
\
**scale**{float, tuple of floats}\
\
Scale factors for spatial dimensions. Separate scale factors can be defined as (m, n\[, …\]).\
\
Returns:\
\
**scaled**ndarray\
\
Scaled version of the input.\
\
Other Parameters:\
\
**order**int, optional\
\
The order of the spline interpolation, default is 0 if image.dtype is bool and 1 otherwise. The order has to be in the range 0-5. See skimage.transform.warp for detail.\
\
**mode**{‘constant’, ‘edge’, ‘symmetric’, ‘reflect’, ‘wrap’}, optional\
\
Points outside the boundaries of the input are filled according to the given mode. Modes match the behaviour of numpy.pad.\
\
**cval**float, optional\
\
Used in conjunction with mode ‘constant’, the value outside the image boundaries.\
\
**clip**bool, optional\
\
Whether to clip the output to the range of values of the input image. If order > 1, this will be enabled by default, since higher order interpolation may produce values outside the given input range.\
\
**preserve\_range**bool, optional\
\
Whether to keep the original range of values. Otherwise, the input image is converted according to the conventions of img\_as\_float. Also see [https://scikit-image.org/docs/dev/user\_guide/data\_types.html](https://scikit-image.org/docs/dev/user_guide/data_types.html)\
\
**anti\_aliasing**bool, optional\
\
Whether to apply a Gaussian filter to smooth the image prior to down-scaling. It is crucial to filter when down-sampling the image to avoid aliasing artifacts. If input image data type is bool, no anti-aliasing is applied.\
\
**anti\_aliasing\_sigma**{float, tuple of floats}, optional\
\
Standard deviation for Gaussian filtering to avoid aliasing artifacts. By default, this value is chosen as (s - 1) / 2 where s is the down-scaling factor.\
\
**channel\_axis**int or None, optional\
\
If None, the image is assumed to be a grayscale (single channel) image. Otherwise, this parameter indicates which axis of the array corresponds to channels.\
\
New in version 22.02.00: `channel_axis` was added in 22.02.00.\
\
Notes\
\
Modes ‘reflect’ and ‘symmetric’ are similar, but differ in whether the edge pixels are duplicated during the reflection. As an example, if an array has values \[0, 1, 2\] and was padded to the right by four values using symmetric, the result would be \[0, 1, 2, 2, 1, 0, 0\], while for reflect it would be \[0, 1, 2, 1, 0, 1, 2\].\
\
Examples\
\
\>>> from skimage import data\
\>>> from cucim.skimage.transform import rescale\
\>>> image \= cp.array(data.camera())\
\>>> rescale(image, 0.1).shape\
(51, 51)\
\>>> rescale(image, 0.5).shape\
(256, 256)\
\
cucim.skimage.transform.resize(_image_, _output\_shape_, _order\=None_, _mode\='reflect'_, _cval\=0_, _clip\=None_, _preserve\_range\=False_, _anti\_aliasing\=None_, _anti\_aliasing\_sigma\=None_)[#](#cucim.skimage.transform.resize "Permalink to this definition")\
\
Resize image to match a certain size.\
\
Performs interpolation to up-size or down-size N-dimensional images. Note that anti-aliasing should be enabled when down-sizing images to avoid aliasing artifacts. For downsampling with an integer factor also see skimage.transform.downscale\_local\_mean.\
\
Parameters:\
\
**image**ndarray\
\
Input image.\
\
**output\_shape**tuple or ndarray\
\
Size of the generated output image (rows, cols\[, …\]\[, dim\]). If dim is not provided, the number of channels is preserved. In case the number of input channels does not equal the number of output channels a n-dimensional interpolation is applied.\
\
Returns:\
\
**resized**ndarray\
\
Resized version of the input.\
\
Other Parameters:\
\
**order**int, optional\
\
The order of the spline interpolation, default is 0 if image.dtype is bool and 1 otherwise. The order has to be in the range 0-5. See skimage.transform.warp for detail.\
\
**mode**{‘constant’, ‘edge’, ‘symmetric’, ‘reflect’, ‘wrap’}, optional\
\
Points outside the boundaries of the input are filled according to the given mode. Modes match the behaviour of numpy.pad.\
\
**cval**float, optional\
\
Used in conjunction with mode ‘constant’, the value outside the image boundaries.\
\
**clip**bool, optional\
\
Whether to clip the output to the range of values of the input image. If order > 1, this will be enabled by default, since higher order interpolation may produce values outside the given input range.\
\
**preserve\_range**bool, optional\
\
Whether to keep the original range of values. Otherwise, the input image is converted according to the conventions of img\_as\_float. Also see [https://scikit-image.org/docs/dev/user\_guide/data\_types.html](https://scikit-image.org/docs/dev/user_guide/data_types.html)\
\
**anti\_aliasing**bool, optional\
\
Whether to apply a Gaussian filter to smooth the image prior to downsampling. It is crucial to filter when downsampling the image to avoid aliasing artifacts. If not specified, it is set to True when downsampling an image whose data type is not bool. It is also set to False when using nearest neighbor interpolation (`order` == 0) with integer input data type.\
\
**anti\_aliasing\_sigma**{float, tuple of floats}, optional\
\
Standard deviation for Gaussian filtering used when anti-aliasing. By default, this value is chosen as (s - 1) / 2 where s is the downsampling factor, where s > 1. For the up-size case, s < 1, no anti-aliasing is performed prior to rescaling.\
\
Notes\
\
Modes ‘reflect’ and ‘symmetric’ are similar, but differ in whether the edge pixels are duplicated during the reflection. As an example, if an array has values \[0, 1, 2\] and was padded to the right by four values using symmetric, the result would be \[0, 1, 2, 2, 1, 0, 0\], while for reflect it would be \[0, 1, 2, 1, 0, 1, 2\].\
\
Examples\
\
\>>> from skimage import data\
\>>> from cucim.skimage.transform import resize\
\>>> image \= cp.array(data.camera())\
\>>> resize(image, (100, 100)).shape\
(100, 100)\
\
cucim.skimage.transform.resize\_local\_mean(_image_, _output\_shape_, _grid\_mode\=True_, _preserve\_range\=False_, _\*_, _channel\_axis\=None_)[#](#cucim.skimage.transform.resize_local_mean "Permalink to this definition")\
\
Resize an array with the local mean / bilinear scaling.\
\
Parameters:\
\
**image**ndarray\
\
Input image. If this is a multichannel image, the axis corresponding to channels should be specified using channel\_axis.\
\
**output\_shape**tuple or ndarray\
\
Size of the generated output image. When channel\_axis is not None, the channel\_axis should either be omitted from output\_shape or the `output_shape[channel_axis]` must match `image.shape[channel_axis]`. If the length of output\_shape exceeds image.ndim, additional singleton dimensions will be appended to the input `image` as needed.\
\
**grid\_mode**bool, optional\
\
Defines `image` pixels position: if True, pixels are assumed to be at grid intersections, otherwise at cell centers. As a consequence, for example, a 1d signal of length 5 is considered to have length 4 when grid\_mode is False, but length 5 when grid\_mode is True. See the following visual illustration:\
\
| pixel 1 | pixel 2 | pixel 3 | pixel 4 | pixel 5 |\
|<-------------------------------------->|\
vs.\
|<----------------------------------------------->|\
\
The starting point of the arrow in the diagram above corresponds to coordinate location 0 in each mode.\
\
**preserve\_range**bool, optional\
\
Whether to keep the original range of values. Otherwise, the input image is converted according to the conventions of img\_as\_float. Also see [https://scikit-image.org/docs/dev/user\_guide/data\_types.html](https://scikit-image.org/docs/dev/user_guide/data_types.html)\
\
Returns:\
\
**resized**ndarray\
\
Resized version of the input.\
\
See also\
\
[`resize`](#cucim.skimage.transform.resize "cucim.skimage.transform.resize")\
, [`downscale_local_mean`](#cucim.skimage.transform.downscale_local_mean "cucim.skimage.transform.downscale_local_mean")\
\
Notes\
\
This method is sometimes referred to as “area-based” interpolation or “pixel mixing” interpolation [\[1\]](#ra76f015d1e1d-1)\
. When grid\_mode is True, it is equivalent to using OpenCV’s resize with INTER\_AREA interpolation mode. It is commonly used for image downsizing. If the downsizing factors are integers, then downscale\_local\_mean should be preferred instead.\
\
References\
\
\[[1](#id369)\
\]\
\
[http://entropymine.com/imageworsener/pixelmixing/](http://entropymine.com/imageworsener/pixelmixing/)\
\
Examples\
\
\>>> import cupy as cp\
\>>> from skimage import data\
\>>> from cucim.skimage.transform import resize\_local\_mean\
\>>> image \= cp.array(data.camera())\
\>>> resize\_local\_mean(image, (100, 100)).shape\
(100, 100)\
\
cucim.skimage.transform.rotate(_image_, _angle_, _resize\=False_, _center\=None_, _order\=None_, _mode\='constant'_, _cval\=0_, _clip\=True_, _preserve\_range\=False_)[#](#cucim.skimage.transform.rotate "Permalink to this definition")\
\
Rotate image by a certain angle around its center.\
\
Parameters:\
\
**image**ndarray\
\
Input image.\
\
**angle**float\
\
Rotation angle in degrees in counter-clockwise direction.\
\
**resize**bool, optional\
\
Determine whether the shape of the output image will be automatically calculated, so the complete rotated image exactly fits. Default is False.\
\
**center**iterable of length 2\
\
The rotation center. If `center=None`, the image is rotated around its center, i.e. `center=(cols / 2 - 0.5, rows / 2 - 0.5)`. Please note that this parameter is (cols, rows), contrary to normal skimage ordering.\
\
Returns:\
\
**rotated**ndarray\
\
Rotated version of the input.\
\
Other Parameters:\
\
**order**int, optional\
\
The order of the spline interpolation, default is 0 if image.dtype is bool and 1 otherwise. The order has to be in the range 0-5. See skimage.transform.warp for detail.\
\
**mode**{‘constant’, ‘edge’, ‘symmetric’, ‘reflect’, ‘wrap’}, optional\
\
Points outside the boundaries of the input are filled according to the given mode. Modes match the behaviour of numpy.pad.\
\
**cval**float, optional\
\
Used in conjunction with mode ‘constant’, the value outside the image boundaries.\
\
**clip**bool, optional\
\
Whether to clip the output to the range of values of the input image. If order > 1, this will be enabled by default, since higher order interpolation may produce values outside the given input range.\
\
**preserve\_range**bool, optional\
\
Whether to keep the original range of values. Otherwise, the input image is converted according to the conventions of img\_as\_float. Also see [https://scikit-image.org/docs/dev/user\_guide/data\_types.html](https://scikit-image.org/docs/dev/user_guide/data_types.html)\
\
Notes\
\
Modes ‘reflect’ and ‘symmetric’ are similar, but differ in whether the edge pixels are duplicated during the reflection. As an example, if an array has values \[0, 1, 2\] and was padded to the right by four values using symmetric, the result would be \[0, 1, 2, 2, 1, 0, 0\], while for reflect it would be \[0, 1, 2, 1, 0, 1, 2\].\
\
If `image.ndim > 2`, the rotation occurs for the first two dimensions of the array. Unlike the scikit-image implementation, more than one additional axis may be present on the array.\
\
Examples\
\
\>>> from skimage import data\
\>>> from cucim.skimage.transform import rotate\
\>>> image \= cp.array(data.camera())\
\>>> rotate(image, 2).shape\
(512, 512)\
\>>> rotate(image, 2, resize\=True).shape\
(530, 530)\
\>>> rotate(image, 90, resize\=True).shape\
(512, 512)\
\
cucim.skimage.transform.swirl(_image_, _center\=None_, _strength\=1_, _radius\=100_, _rotation\=0_, _output\_shape\=None_, _order\=None_, _mode\='reflect'_, _cval\=0_, _clip\=None_, _preserve\_range\=False_)[#](#cucim.skimage.transform.swirl "Permalink to this definition")\
\
Perform a swirl transformation.\
\
Parameters:\
\
**image**ndarray\
\
Input image.\
\
**center**(column, row) tuple or (2,) ndarray, optional\
\
Center coordinate of transformation.\
\
**strength**float, optional\
\
The amount of swirling applied.\
\
**radius**float, optional\
\
The extent of the swirl in pixels. The effect dies out rapidly beyond radius.\
\
**rotation**float, optional\
\
Additional rotation applied to the image.\
\
Returns:\
\
**swirled**ndarray\
\
Swirled version of the input.\
\
Other Parameters:\
\
**output\_shape**tuple (rows, cols), optional\
\
Shape of the output image generated. By default the shape of the input image is preserved.\
\
**order**int, optional\
\
The order of the spline interpolation, default is 0 if image.dtype is bool and 1 otherwise. The order has to be in the range 0-5. See skimage.transform.warp for detail.\
\
**mode**{‘constant’, ‘edge’, ‘symmetric’, ‘reflect’, ‘wrap’}, optional\
\
Points outside the boundaries of the input are filled according to the given mode, with ‘reflect’ used as the default. Modes match the behaviour of numpy.pad.\
\
**cval**float, optional\
\
Used in conjunction with mode ‘constant’, the value outside the image boundaries.\
\
**clip**bool, optional\
\
Whether to clip the output to the range of values of the input image. If order > 1, this will be enabled by default, since higher order interpolation may produce values outside the given input range.\
\
**preserve\_range**bool, optional\
\
Whether to keep the original range of values. Otherwise, the input image is converted according to the conventions of img\_as\_float. Also see [https://scikit-image.org/docs/dev/user\_guide/data\_types.html](https://scikit-image.org/docs/dev/user_guide/data_types.html)\
\
cucim.skimage.transform.warp(_image_, _inverse\_map_, _map\_args\=None_, _output\_shape\=None_, _order\=None_, _mode\='constant'_, _cval\=0.0_, _clip\=None_, _preserve\_range\=False_)[#](#cucim.skimage.transform.warp "Permalink to this definition")\
\
Warp an image according to a given coordinate transformation.\
\
Parameters:\
\
**image**ndarray\
\
Input image.\
\
**inverse\_map**transformation object, callable `cr = f(cr, **kwargs)`, or ndarray\
\
Inverse coordinate map, which transforms coordinates in the output images into their corresponding coordinates in the input image.\
\
There are a number of different options to define this map, depending on the dimensionality of the input image. A 2-D image can have 2 dimensions for gray-scale images, or 3 dimensions with color information.\
\
> * For 2-D images, you can directly pass a transformation object, e.g. skimage.transform.SimilarityTransform, or its inverse.\
> \
> * For 2-D images, you can pass a `(3, 3)` homogeneous transformation matrix, e.g. skimage.transform.SimilarityTransform.params.\
> \
> * For 2-D images, a function that transforms a `(M, 2)` array of `(col, row)` coordinates in the output image to their corresponding coordinates in the input image. Extra parameters to the function can be specified through map\_args.\
> \
> * For N-D images, you can directly pass an array of coordinates. The first dimension specifies the coordinates in the input image, while the subsequent dimensions determine the position in the output image. E.g. in case of 2-D images, you need to pass an array of shape `(2, rows, cols)`, where rows and cols determine the shape of the output image, and the first dimension contains the `(row, col)` coordinate in the input image. See scipy.ndimage.map\_coordinates for further documentation.\
> \
\
Note, that a `(3, 3)` matrix is interpreted as a homogeneous transformation matrix, so you cannot interpolate values from a 3-D input, if the output is of shape `(3,)`.\
\
See example section for usage.\
\
**map\_args**dict, optional\
\
Keyword arguments passed to inverse\_map.\
\
**output\_shape**tuple (rows, cols), optional\
\
Shape of the output image generated. By default the shape of the input image is preserved. Note that, even for multi-band images, only rows and columns need to be specified.\
\
**order**int, optional\
\
The order of interpolation. The order has to be in the range 0-5:\
\
* 0: Nearest-neighbor\
\
* 1: Bi-linear (default)\
\
* 2: Bi-quadratic\
\
* 3: Bi-cubic\
\
* 4: Bi-quartic\
\
* 5: Bi-quintic\
\
\
Default is 0 if image.dtype is bool and 1 otherwise.\
\
**mode**{‘constant’, ‘edge’, ‘symmetric’, ‘reflect’, ‘wrap’}, optional\
\
Points outside the boundaries of the input are filled according to the given mode. Modes match the behaviour of numpy.pad.\
\
**cval**float, optional\
\
Used in conjunction with mode ‘constant’, the value outside the image boundaries.\
\
**clip**bool, optional\
\
Whether to clip the output to the range of values of the input image. If order > 1, this will be enabled by default, since higher order interpolation may produce values outside the given input range.\
\
**preserve\_range**bool, optional\
\
Whether to keep the original range of values. Otherwise, the input image is converted according to the conventions of img\_as\_float. Also see [https://scikit-image.org/docs/dev/user\_guide/data\_types.html](https://scikit-image.org/docs/dev/user_guide/data_types.html)\
\
Returns:\
\
**warped**double ndarray\
\
The warped input image.\
\
Notes\
\
* The input image is converted to a double image.\
\
* In case of a SimilarityTransform, AffineTransform and ProjectiveTransform and order in \[0, 3\] this function uses the underlying transformation matrix to warp the image with a much faster routine.\
\
\
Examples\
\
\>>> from cucim.skimage.transform import warp\
\>>> from skimage import data\
\>>> image \= cp.array(data.camera())\
\
The following image warps are all equal but differ substantially in execution time. The image is shifted to the bottom.\
\
Use a geometric transform to warp an image (fast):\
\
\>>> from cucim.skimage.transform import SimilarityTransform\
\>>> tform \= SimilarityTransform(translation\=(0, \-10))\
\>>> warped \= warp(image, tform)\
\
Use a callable (slow):\
\
\>>> def shift\_down(xy):\
... xy\[:, 1\] \-= 10\
... return xy\
\>>> warped \= warp(image, shift\_down)\
\
Use a transformation matrix to warp an image (fast):\
\
\>>> import cupy as cp\
\>>> matrix \= cp.asarray(\[\[1, 0, 0\], \[0, 1, \-10\], \[0, 0, 1\]\])\
\>>> warped \= warp(image, matrix)\
\>>> from cucim.skimage.transform import ProjectiveTransform, warp\
\>>> warped \= warp(image, ProjectiveTransform(matrix\=matrix))\
\
You can also use the inverse of a geometric transformation (fast):\
\
\>>> warped \= warp(image, tform.inverse)\
\
For N-D images you can pass a coordinate array, that specifies the coordinates in the input image for every element in the output image. E.g. if you want to rescale a 3-D cube, you can do:\
\
\>>> cube\_shape \= (30, 30, 30)\
\>>> cube \= cp.random.rand(\*cube\_shape)\
\
Setup the coordinate array, that defines the scaling:\
\
\>>> scale \= 0.1\
\>>> output\_shape \= tuple(int(scale \* s) for s in cube\_shape)\
\>>> coords0, coords1, coords2 \= cp.mgrid\[:output\_shape\[0\],\
... :output\_shape\[1\], :output\_shape\[2\]\]\
\>>> coords \= cp.asarray(\[coords0, coords1, coords2\])\
\
Assume that the cube contains spatial data, where the first array element center is at coordinate (0.5, 0.5, 0.5) in real space, i.e. we have to account for this extra offset when scaling the image:\
\
\>>> coords \= (coords + 0.5) / scale \- 0.5\
\>>> warped \= warp(cube, coords)\
\
cucim.skimage.transform.warp\_coords(_coord\_map_, _shape_, _dtype=_)[#](#cucim.skimage.transform.warp_coords "Permalink to this definition")\
\
Build the source coordinates for the output of a 2-D image warp.\
\
Parameters:\
\
**coord\_map**callable like GeometricTransform.inverse\
\
Return input coordinates for given output coordinates. Coordinates are in the shape (P, 2), where P is the number of coordinates and each element is a `(row, col)` pair.\
\
**shape**tuple\
\
Shape of output image `(rows, cols[, bands])`.\
\
**dtype**np.dtype or string\
\
dtype for return value (sane choices: float32 or float64).\
\
Returns:\
\
**coords**(ndim, rows, cols\[, bands\]) array of dtype dtype\
\
Coordinates for scipy.ndimage.map\_coordinates, that will yield an image of shape (orows, ocols, bands) by drawing from source points according to the coord\_transform\_fn.\
\
Notes\
\
This is a lower-level routine that produces the source coordinates for 2-D images used by warp().\
\
It is provided separately from warp to give additional flexibility to users who would like, for example, to reuse a particular coordinate mapping, to use specific dtypes at various points along the the image-warping process, or to implement different post-processing logic than warp performs after the call to ndi.map\_coordinates.\
\
Examples\
\
Produce a coordinate map that shifts an image up and to the right:\
\
\>>> import cupy as cp\
\>>> from cucim.skimage.transform import warp\_coords\
\>>> from skimage import data\
\>>> from cupyx.scipy.ndimage import map\_coordinates\
\>>>\
\>>> def shift\_up10\_left20(xy):\
... return xy \- cp.array(\[\-20, 10\])\[None, :\]\
\>>>\
\>>> image \= cp.array(data.astronaut().astype(cp.float32))\
\>>> coords \= warp\_coords(shift\_up10\_left20, image.shape)\
\>>> warped\_image \= map\_coordinates(image, coords)\
\
cucim.skimage.transform.warp\_polar(_image_, _center\=None_, _\*_, _radius\=None_, _output\_shape\=None_, _scaling\='linear'_, _channel\_axis\=None_, _\*\*kwargs_)[#](#cucim.skimage.transform.warp_polar "Permalink to this definition")\
\
Remap image to polar or log-polar coordinates space.\
\
Parameters:\
\
**image**(M, N\[, C\]) ndarray\
\
Input image. For multichannel images channel\_axis has to be specified.\
\
**center**2-tuple, optional\
\
(row, col) coordinates of the point in image that represents the center of the transformation (i.e., the origin in Cartesian space). Values can be of type float. If no value is given, the center is assumed to be the center point of image.\
\
**radius**float, optional\
\
Radius of the circle that bounds the area to be transformed.\
\
**output\_shape**tuple (row, col), optional\
\
**scaling**{‘linear’, ‘log’}, optional\
\
Specify whether the image warp is polar or log-polar. Defaults to ‘linear’.\
\
**channel\_axis**int or None, optional\
\
If None, the image is assumed to be a grayscale (single channel) image. Otherwise, this parameter indicates which axis of the array corresponds to channels.\
\
New in version 22.02.00: `channel_axis` was added in 22.02.00.\
\
**\*\*kwargs**keyword arguments\
\
Passed to transform.warp.\
\
Returns:\
\
**warped**ndarray\
\
The polar or log-polar warped image.\
\
Examples\
\
Perform a basic polar warp on a grayscale image:\
\
\>>> from skimage import data\
\>>> from cucim.skimage.transform import warp\_polar\
\>>> image \= cp.array(data.checkerboard())\
\>>> warped \= warp\_polar(image)\
\
Perform a log-polar warp on a grayscale image:\
\
\>>> warped \= warp\_polar(image, scaling\='log')\
\
Perform a log-polar warp on a grayscale image while specifying center, radius, and output shape:\
\
\>>> warped \= warp\_polar(image, (100,100), radius\=100,\
... output\_shape\=image.shape, scaling\='log')\
\
Perform a log-polar warp on a color image:\
\
\>>> image \= cp.array(data.astronaut())\
\>>> warped \= warp\_polar(image, scaling\='log', channel\_axis\=-1)\
\
### util[#](#module-cucim.skimage.util "Permalink to this heading")\
\
Generic utilities.\
\
This module contains a number of utility functions to work with images in general.\
\
cucim.skimage.util.crop(_ar_, _crop\_width_, _copy\=False_, _order\='K'_)[#](#cucim.skimage.util.crop "Permalink to this definition")\
\
Crop array ar by crop\_width along each dimension.\
\
Parameters:\
\
**ar**array-like of rank N\
\
Input array.\
\
**crop\_width**{sequence, int}\
\
Number of values to remove from the edges of each axis. `((before_1, after_1),` … `(before_N, after_N))` specifies unique crop widths at the start and end of each axis. `((before, after),) or (before, after)` specifies a fixed start and end crop for every axis. `(n,)` or `n` for integer `n` is a shortcut for before = after = `n` for all axes.\
\
**copy**bool, optional\
\
If True, ensure the returned array is a contiguous copy. Normally, a crop operation will return a discontiguous view of the underlying input array.\
\
**order**{‘C’, ‘F’, ‘A’, ‘K’}, optional\
\
If `copy==True`, control the memory layout of the copy. See `np.copy`.\
\
Returns:\
\
**cropped**array\
\
The cropped array. If `copy=False` (default), this is a sliced view of the input array.\
\
cucim.skimage.util.dtype\_limits(_image_, _clip\_negative\=False_)[#](#cucim.skimage.util.dtype_limits "Permalink to this definition")\
\
Return intensity limits, i.e. (min, max) tuple, of the image’s dtype.\
\
Parameters:\
\
**image**ndarray\
\
Input image.\
\
**clip\_negative**bool, optional\
\
If True, clip the negative range (i.e. return 0 for min intensity) even if the image dtype allows negative values.\
\
Returns:\
\
**imin, imax**tuple\
\
Lower and upper intensity limits.\
\
cucim.skimage.util.img\_as\_bool(_image_, _force\_copy\=False_)[#](#cucim.skimage.util.img_as_bool "Permalink to this definition")\
\
Convert an image to boolean format.\
\
Parameters:\
\
**image**ndarray\
\
Input image.\
\
**force\_copy**bool, optional\
\
Force a copy of the data, irrespective of its current dtype.\
\
Returns:\
\
**out**ndarray of bool (bool\_)\
\
Output image.\
\
Notes\
\
The upper half of the input dtype’s positive range is True, and the lower half is False. All negative values (if present) are False.\
\
cucim.skimage.util.img\_as\_float(_image_, _force\_copy\=False_)[#](#cucim.skimage.util.img_as_float "Permalink to this definition")\
\
Convert an image to floating point format.\
\
This function is similar to img\_as\_float64, but will not convert lower-precision floating point arrays to float64.\
\
Parameters:\
\
**image**ndarray\
\
Input image.\
\
**force\_copy**bool, optional\
\
Force a copy of the data, irrespective of its current dtype.\
\
Returns:\
\
**out**ndarray of float\
\
Output image.\
\
Notes\
\
The range of a floating point image is \[0.0, 1.0\] or \[-1.0, 1.0\] when converting from unsigned or signed datatypes, respectively. If the input image has a float type, intensity values are not modified and can be outside the ranges \[0.0, 1.0\] or \[-1.0, 1.0\].\
\
cucim.skimage.util.img\_as\_float32(_image_, _force\_copy\=False_)[#](#cucim.skimage.util.img_as_float32 "Permalink to this definition")\
\
Convert an image to single-precision (32-bit) floating point format.\
\
Parameters:\
\
**image**ndarray\
\
Input image.\
\
**force\_copy**bool, optional\
\
Force a copy of the data, irrespective of its current dtype.\
\
Returns:\
\
**out**ndarray of float32\
\
Output image.\
\
Notes\
\
The range of a floating point image is \[0.0, 1.0\] or \[-1.0, 1.0\] when converting from unsigned or signed datatypes, respectively. If the input image has a float type, intensity values are not modified and can be outside the ranges \[0.0, 1.0\] or \[-1.0, 1.0\].\
\
cucim.skimage.util.img\_as\_float64(_image_, _force\_copy\=False_)[#](#cucim.skimage.util.img_as_float64 "Permalink to this definition")\
\
Convert an image to double-precision (64-bit) floating point format.\
\
Parameters:\
\
**image**ndarray\
\
Input image.\
\
**force\_copy**bool, optional\
\
Force a copy of the data, irrespective of its current dtype.\
\
Returns:\
\
**out**ndarray of float64\
\
Output image.\
\
Notes\
\
The range of a floating point image is \[0.0, 1.0\] or \[-1.0, 1.0\] when converting from unsigned or signed datatypes, respectively. If the input image has a float type, intensity values are not modified and can be outside the ranges \[0.0, 1.0\] or \[-1.0, 1.0\].\
\
cucim.skimage.util.img\_as\_int(_image_, _force\_copy\=False_)[#](#cucim.skimage.util.img_as_int "Permalink to this definition")\
\
Convert an image to 16-bit signed integer format.\
\
Parameters:\
\
**image**ndarray\
\
Input image.\
\
**force\_copy**bool, optional\
\
Force a copy of the data, irrespective of its current dtype.\
\
Returns:\
\
**out**ndarray of int16\
\
Output image.\
\
Notes\
\
The values are scaled between -32768 and 32767. If the input data-type is positive-only (e.g., uint8), then the output image will still only have positive values.\
\
cucim.skimage.util.img\_as\_ubyte(_image_, _force\_copy\=False_)[#](#cucim.skimage.util.img_as_ubyte "Permalink to this definition")\
\
Convert an image to 8-bit unsigned integer format.\
\
Parameters:\
\
**image**ndarray\
\
Input image.\
\
**force\_copy**bool, optional\
\
Force a copy of the data, irrespective of its current dtype.\
\
Returns:\
\
**out**ndarray of ubyte (uint8)\
\
Output image.\
\
Notes\
\
Negative input values will be clipped. Positive values are scaled between 0 and 255.\
\
cucim.skimage.util.img\_as\_uint(_image_, _force\_copy\=False_)[#](#cucim.skimage.util.img_as_uint "Permalink to this definition")\
\
Convert an image to 16-bit unsigned integer format.\
\
Parameters:\
\
**image**ndarray\
\
Input image.\
\
**force\_copy**bool, optional\
\
Force a copy of the data, irrespective of its current dtype.\
\
Returns:\
\
**out**ndarray of uint16\
\
Output image.\
\
Notes\
\
Negative input values will be clipped. Positive values are scaled between 0 and 65535.\
\
cucim.skimage.util.invert(_image_, _signed\_float\=False_)[#](#cucim.skimage.util.invert "Permalink to this definition")\
\
Invert an image.\
\
Invert the intensity range of the input image, so that the dtype maximum is now the dtype minimum, and vice-versa. This operation is slightly different depending on the input dtype:\
\
* unsigned integers: subtract the image from the dtype maximum\
\
* signed integers: subtract the image from -1 (see Notes)\
\
* floats: subtract the image from 1 (if signed\_float is False, so we assume the image is unsigned), or from 0 (if signed\_float is True).\
\
\
See the examples for clarification.\
\
Parameters:\
\
**image**ndarray\
\
Input image.\
\
**signed\_float**bool, optional\
\
If True and the image is of type float, the range is assumed to be \[-1, 1\]. If False and the image is of type float, the range is assumed to be \[0, 1\].\
\
Returns:\
\
**inverted**ndarray\
\
Inverted image.\
\
Notes\
\
Ideally, for signed integers we would simply multiply by -1. However, signed integer ranges are asymmetric. For example, for np.int8, the range of possible values is \[-128, 127\], so that -128 \* -1 equals -128! By subtracting from -1, we correctly map the maximum dtype value to the minimum.\
\
Examples\
\
\>>> import cupy as cp\
\>>> img \= cp.asarray(\[\[100, 0, 200\],\
... \[ 0, 50, 0\],\
... \[ 30, 0, 255\]\], np.uint8)\
\>>> invert(img)\
array(\[\[155, 255, 55\],\
\[255, 205, 255\],\
\[225, 255, 0\]\], dtype=uint8)\
\>>> img2 \= cp.asarray(\[\[ \-2, 0, \-128\],\
... \[127, 0, 5\]\], np.int8)\
\>>> invert(img2)\
array(\[\[ 1, -1, 127\],\
\[-128, -1, -6\]\], dtype=int8)\
\>>> img3 \= cp.asarray(\[\[ 0., 1., 0.5, 0.75\]\])\
\>>> invert(img3)\
array(\[\[1. , 0. , 0.5 , 0.25\]\])\
\>>> img4 \= cp.asarray(\[\[ 0., 1., \-1., \-0.25\]\])\
\>>> invert(img4, signed\_float\=True)\
array(\[\[-0. , -1. , 1. , 0.25\]\])\
\
cucim.skimage.util.map\_array(_input\_arr_, _input\_vals_, _output\_vals_, _out\=None_)[#](#cucim.skimage.util.map_array "Permalink to this definition")\
\
Map values from input array from input\_vals to output\_vals.\
\
Parameters:\
\
**input\_arr**array of int, shape (M\[, …\])\
\
The input label image.\
\
**input\_vals**array of int, shape (K,)\
\
The values to map from.\
\
**output\_vals**array, shape (K,)\
\
The values to map to.\
\
**out: array, same shape as \`input\_arr\`**\
\
The output array. Will be created if not provided. It should have the same dtype as output\_vals.\
\
Returns:\
\
**out**array, same shape as input\_arr\
\
The array of mapped values.\
\
Notes\
\
If input\_arr contains values that aren’t covered by input\_vals, they are set to 0.\
\
Examples\
\
\>>> import cupy as cp\
\>>> import cucim.skimage as ski\
\>>> ski.util.map\_array(\
... input\_arr\=cp.array(\[\[0, 2, 2, 0\], \[3, 4, 5, 0\]\]),\
... input\_vals\=cp.array(\[1, 2, 3, 4, 6\]),\
... output\_vals\=cp.array(\[6, 7, 8, 9, 10\]),\
... )\
array(\[\[0, 7, 7, 0\],\
\[8, 9, 0, 0\]\])\
\
cucim.skimage.util.random\_noise(_image_, _mode\='gaussian'_, _rng\=None_, _clip\=True_, _\*\*kwargs_)[#](#cucim.skimage.util.random_noise "Permalink to this definition")\
\
Function to add random noise of various types to a floating-point image.\
\
Parameters:\
\
**image**ndarray\
\
Input image data. Will be converted to float.\
\
**mode**str, optional\
\
One of the following strings, selecting the type of noise to add:\
\
‘gaussian’ (default)\
\
Gaussian-distributed additive noise.\
\
‘localvar’\
\
Gaussian-distributed additive noise, with specified local variance at each point of image.\
\
‘poisson’\
\
Poisson-distributed noise generated from the data.\
\
‘salt’\
\
Replaces random pixels with 1.\
\
‘pepper’\
\
Replaces random pixels with 0 (for unsigned images) or -1 (for signed images).\
\
‘s&p’\
\
Replaces random pixels with either 1 or low\_val, where low\_val is 0 for unsigned images or -1 for signed images.\
\
‘speckle’\
\
Multiplicative noise using `out = image + n * image`, where `n` is Gaussian noise with specified mean & variance.\
\
**rng**{cupy.random.Generator, int}, optional\
\
Pseudo-random number generator. By default, a PCG64 generator is used (see [`cupy.random.default_rng()`](https://docs.cupy.dev/en/stable/reference/generated/cupy.random.default_rng.html#cupy.random.default_rng "(in CuPy v13.4.0)")\
). If rng is an int, it is used to seed the generator.\
\
Note: cupy.random.Generator is not yet fully supported. Please use an integer seed instead.\
\
**clip**bool, optional\
\
If True (default), the output will be clipped after noise applied for modes ‘speckle’, ‘poisson’, and ‘gaussian’. This is needed to maintain the proper image data range. If False, clipping is not applied, and the output may extend beyond the range \[-1, 1\].\
\
**mean**float, optional\
\
Mean of random distribution. Used in ‘gaussian’ and ‘speckle’. Default : 0.\
\
**var**float, optional\
\
Variance of random distribution. Used in ‘gaussian’ and ‘speckle’. Note: variance = (standard deviation) \*\* 2. Default : 0.01\
\
**local\_vars**ndarray, optional\
\
Array of positive floats, same shape as image, defining the local variance at every image point. Used in ‘localvar’.\
\
**amount**float, optional\
\
Proportion of image pixels to replace with noise on range \[0, 1\]. Used in ‘salt’, ‘pepper’, and ‘salt & pepper’. Default : 0.05\
\
**salt\_vs\_pepper**float, optional\
\
Proportion of salt vs. pepper noise for ‘s&p’ on range \[0, 1\]. Higher values represent more salt. Default : 0.5 (equal amounts)\
\
Returns:\
\
**out**ndarray\
\
Output floating-point image data on range \[0, 1\] or \[-1, 1\] if the input image was unsigned or signed, respectively.\
\
Notes\
\
Speckle, Poisson, Localvar, and Gaussian noise may generate noise outside the valid image range. The default is to clip (not alias) these values, but they may be preserved by setting clip=False. Note that in this case the output may contain values outside the ranges \[0, 1\] or \[-1, 1\]. Use this option with care.\
\
Because of the prevalence of exclusively positive floating-point images in intermediate calculations, it is not possible to intuit if an input is signed based on dtype alone. Instead, negative values are explicitly searched for. Only if found does this function assume signed input. Unexpected results only occur in rare, poorly exposes cases (e.g. if all values are above 50 percent gray in a signed image). In this event, manually scaling the input to the positive domain will solve the problem.\
\
The Poisson distribution is only defined for positive integers. To apply this noise type, the number of unique values in the image is found and the next round power of two is used to scale up the floating-point result, after which it is scaled back down to the floating-point image range.\
\
To generate Poisson noise against a signed image, the signed image is temporarily converted to an unsigned image in the floating point domain, Poisson noise is generated, then it is returned to the original range.\
\
cucim.skimage.util.view\_as\_blocks(_arr\_in_, _block\_shape_)[#](#cucim.skimage.util.view_as_blocks "Permalink to this definition")\
\
Block view of the input n-dimensional array (using re-striding).\
\
Blocks are non-overlapping views of the input array.\
\
Parameters:\
\
**arr\_in**ndarray, shape (M\[, …\])\
\
Input array.\
\
**block\_shape**tuple\
\
The shape of the block. Each dimension must divide evenly into the corresponding dimensions of arr\_in.\
\
Returns:\
\
**arr\_out**ndarray\
\
Block view of the input array. If arr\_in is non-contiguous, a copy is made.\
\
Examples\
\
\>>> import cupy as cp\
\>>> from cucim.skimage.util.shape import view\_as\_blocks\
\>>> A \= cp.arange(4\*4).reshape(4,4)\
\>>> A\
array(\[\[ 0, 1, 2, 3\],\
\[ 4, 5, 6, 7\],\
\[ 8, 9, 10, 11\],\
\[12, 13, 14, 15\]\])\
\>>> B \= view\_as\_blocks(A, block\_shape\=(2, 2))\
\>>> B\[0, 0\]\
array(\[\[0, 1\],\
\[4, 5\]\])\
\>>> B\[0, 1\]\
array(\[\[2, 3\],\
\[6, 7\]\])\
\>>> B\[1, 0, 1, 1\]\
array(13)\
\
\>>> A \= cp.arange(4\*4\*6).reshape(4,4,6)\
\>>> A \
array(\[\[\[ 0, 1, 2, 3, 4, 5\],\
\[ 6, 7, 8, 9, 10, 11\],\
\[12, 13, 14, 15, 16, 17\],\
\[18, 19, 20, 21, 22, 23\]\],\
\[\[24, 25, 26, 27, 28, 29\],\
\[30, 31, 32, 33, 34, 35\],\
\[36, 37, 38, 39, 40, 41\],\
\[42, 43, 44, 45, 46, 47\]\],\
\[\[48, 49, 50, 51, 52, 53\],\
\[54, 55, 56, 57, 58, 59\],\
\[60, 61, 62, 63, 64, 65\],\
\[66, 67, 68, 69, 70, 71\]\],\
\[\[72, 73, 74, 75, 76, 77\],\
\[78, 79, 80, 81, 82, 83\],\
\[84, 85, 86, 87, 88, 89\],\
\[90, 91, 92, 93, 94, 95\]\]\])\
\>>> B \= view\_as\_blocks(A, block\_shape\=(1, 2, 2))\
\>>> B.shape\
(4, 2, 3, 1, 2, 2)\
\>>> B\[2:, 0, 2\] \
array(\[\[\[\[52, 53\],\
\[58, 59\]\]\],\
\[\[\[76, 77\],\
\[82, 83\]\]\]\])\
\
cucim.skimage.util.view\_as\_windows(_arr\_in_, _window\_shape_, _step\=1_)[#](#cucim.skimage.util.view_as_windows "Permalink to this definition")\
\
Rolling window view of the input n-dimensional array.\
\
Windows are overlapping views of the input array, with adjacent windows shifted by a single row or column (or an index of a higher dimension).\
\
Parameters:\
\
**arr\_in**ndarray, shape (M\[, …\])\
\
Input array.\
\
**window\_shape**integer or tuple of length arr\_in.ndim\
\
Defines the shape of the elementary n-dimensional orthotope (better know as hyperrectangle [\[1\]](#rba40a1c6483a-1)\
) of the rolling window view. If an integer is given, the shape will be a hypercube of sidelength given by its value.\
\
**step**integer or tuple of length arr\_in.ndim\
\
Indicates step size at which extraction shall be performed. If integer is given, then the step is uniform in all dimensions.\
\
Returns:\
\
**arr\_out**ndarray\
\
(rolling) window view of the input array.\
\
Notes\
\
One should be very careful with rolling views when it comes to memory usage. Indeed, although a ‘view’ has the same memory footprint as its base array, the actual array that emerges when this ‘view’ is used in a computation is generally a (much) larger array than the original, especially for 2-dimensional arrays and above.\
\
For example, let us consider a 3 dimensional array of size (100, 100, 100) of `float64`. This array takes about 8\*100\*\*3 Bytes for storage which is just 8 MB. If one decides to build a rolling view on this array with a window of (3, 3, 3) the hypothetical size of the rolling view (if one was to reshape the view for example) would be 8\*(100-3+1)\*\*3\*3\*\*3 which is about 203 MB! The scaling becomes even worse as the dimension of the input array becomes larger.\
\
References\
\
\[[1](#id371)\
\]\
\
[https://en.wikipedia.org/wiki/Hyperrectangle](https://en.wikipedia.org/wiki/Hyperrectangle)\
\
Examples\
\
\>>> import cupy as cp\
\>>> from cucim.skimage.util.shape import view\_as\_windows\
\>>> A \= cp.arange(4\*4).reshape(4,4)\
\>>> A\
array(\[\[ 0, 1, 2, 3\],\
\[ 4, 5, 6, 7\],\
\[ 8, 9, 10, 11\],\
\[12, 13, 14, 15\]\])\
\>>> window\_shape \= (2, 2)\
\>>> B \= view\_as\_windows(A, window\_shape)\
\>>> B\[0, 0\]\
array(\[\[0, 1\],\
\[4, 5\]\])\
\>>> B\[0, 1\]\
array(\[\[1, 2\],\
\[5, 6\]\])\
\
\>>> A \= cp.arange(10)\
\>>> A\
array(\[0, 1, 2, 3, 4, 5, 6, 7, 8, 9\])\
\>>> window\_shape \= (3,)\
\>>> B \= view\_as\_windows(A, window\_shape)\
\>>> B.shape\
(8, 3)\
\>>> B\
array(\[\[0, 1, 2\],\
\[1, 2, 3\],\
\[2, 3, 4\],\
\[3, 4, 5\],\
\[4, 5, 6\],\
\[5, 6, 7\],\
\[6, 7, 8\],\
\[7, 8, 9\]\])\
\
\>>> A \= cp.arange(5\*4).reshape(5, 4)\
\>>> A\
array(\[\[ 0, 1, 2, 3\],\
\[ 4, 5, 6, 7\],\
\[ 8, 9, 10, 11\],\
\[12, 13, 14, 15\],\
\[16, 17, 18, 19\]\])\
\>>> window\_shape \= (4, 3)\
\>>> B \= view\_as\_windows(A, window\_shape)\
\>>> B.shape\
(2, 2, 4, 3)\
\>>> B \
array(\[\[\[\[ 0, 1, 2\],\
\[ 4, 5, 6\],\
\[ 8, 9, 10\],\
\[12, 13, 14\]\],\
\[\[ 1, 2, 3\],\
\[ 5, 6, 7\],\
\[ 9, 10, 11\],\
\[13, 14, 15\]\]\],\
\[\[\[ 4, 5, 6\],\
\[ 8, 9, 10\],\
\[12, 13, 14\],\
\[16, 17, 18\]\],\
\[\[ 5, 6, 7\],\
\[ 9, 10, 11\],\
\[13, 14, 15\],\
\[17, 18, 19\]\]\]\])\
\
Submodule Contents[#](#submodule-contents "Permalink to this heading")\
\
-----------------------------------------------------------------------\
\
### skimage[#](#module-cucim.skimage "Permalink to this heading")\
\
GPU Image Processing for Python\
\
This module is a CuPy based implementation of a subset of scikit-image.\
\
It is a collection of algorithms for image processing and computer vision.\
\
The main package only provides a few utilities for converting between image data types; for most features, you need to import one of the following subpackages:\
\
#### Subpackages[#](#subpackages "Permalink to this heading")\
\
color\
\
Color space conversion.\
\
data\
\
Test images and example data.\
\
exposure\
\
Image intensity adjustment, e.g., histogram equalization, etc.\
\
feature\
\
Feature detection and extraction, e.g., texture analysis, corners, etc.\
\
filters\
\
Sharpening, edge finding, rank filters, thresholding, etc.\
\
measure\
\
Measurement of image properties, e.g., region properties, moments.\
\
metrics\
\
Metrics corresponding to images, e.g., distance metrics, similarity, etc.\
\
morphology\
\
Morphological algorithms, e.g., closing, opening, skeletonization.\
\
registration\
\
Image registration algorithms, e.g., optical flow or phase cross correlation.\
\
restoration\
\
Restoration algorithms, e.g., deconvolution algorithms, denoising, etc.\
\
segmentation\
\
Algorithms to partition images into meaningful regions or boundaries.\
\
transform\
\
Geometric and other transformations, e.g., rotations, warp.\
\
util\
\
Generic utilities.\
\
#### Utility Functions[#](#utility-functions "Permalink to this heading")\
\
img\_as\_float\
\
Convert an image to floating point format, with values in \[0, 1\]. Is similar to img\_as\_float64, but will not convert lower-precision floating point arrays to float64.\
\
img\_as\_float32\
\
Convert an image to single-precision (32-bit) floating point format, with values in \[0, 1\].\
\
img\_as\_float64\
\
Convert an image to double-precision (64-bit) floating point format, with values in \[0, 1\].\
\
img\_as\_uint\
\
Convert an image to unsigned integer format, with values in \[0, 65535\].\
\
img\_as\_int\
\
Convert an image to signed integer format, with values in \[-32768, 32767\].\
\
img\_as\_ubyte\
\
Convert an image to unsigned byte format, with values in \[0, 255\].\
\
img\_as\_bool\
\
Convert an image to boolean format, with values either True or False.\
\
dtype\_limits\
\
Return intensity limits, i.e. (min, max) tuple, of the image’s dtype.\
\
On this page\
\
[Show Source](../_sources/api.rst.txt)
---