# keypoints

Python API: `depthai_nodes.node.parsers.keypoints`

## Classes

### KeypointParser

Parser class for 2D or 3D keypoints models. It expects one output layer containing keypoints. The number of keypoints must be
specified. Moreover, the keypoints are normalized by a scale factor if provided.

> **Note**
> Emits `dai.beta.Keypoints` messages. Output containing 2D or 3D keypoints.

Raises

 * `ValueError`: If the number of keypoints is not specified.
 * `ValueError`: If the number of coordinates per keypoint is not 2 or 3.
 * `ValueError`: If the number of output layers is not 1.

#### Methods

##### init

```python
def __init__(output_layer_name: str = '', scale_factor: float = 1.0, n_keypoints: int = None, score_threshold: float = None, label_names: list[str] | None = None, edges: list[list[int]] | None = None):
```

Initializes the parser node.

Parameters

 * `output_layer_name` (`str`): Name of the output layer relevant to the parser.
 * `scale_factor` (`float`): Scale factor to divide the keypoints by.
 * `n_keypoints` (`int`): Number of keypoints.
 * `score_threshold` (`float`): Optional confidence threshold stored in the parser configuration.
 * `label_names` (`list[str] | None`): Label names for the keypoints.
 * `edges` (`list[list[int]] | None`): Pairs of keypoint indexes defining skeleton edges. For example, `[(0, 1), (1, 2)]` connects
   keypoint 0 to 1 and 1 to 2.

##### build

```python
def build(head_config: dict[str, Any]) -> KeypointParser:
```

Configures the parser.

Parameters

 * `head_config` (`dict[str, Any]`): The head configuration for the parser.

Returns

 * `KeypointParser`: The parser object with the head configuration set.

##### compute

```python
def compute(keypoints: np.ndarray, *, n_keypoints: int, scale_factor: float = 1.0) -> np.ndarray:
```

Compute parser results from extracted tensors without sending messages.

> **Note**
> Uses [depthai_nodes.node.parsers.utils.keypoints.compute_keypoints](https://docs.luxonis.com/software-v3/ai-inference/inference/depthai-nodes/depthai-nodes-api-reference/node/parsers/utils/keypoints.md); see that helper for tensor layout and validation details.

Parameters

 * `keypoints` (`np.ndarray`): Model keypoint tensor.
 * `n_keypoints` (`int`): Number of keypoints encoded per prediction.
 * `scale_factor` (`float`): Nonzero divisor used to convert model coordinates to normalized coordinates.

Returns

 * `np.ndarray`: Float32 coordinates of shape `(n_keypoints, 2)` or `(n_keypoints, 3)`, divided by `scale_factor` and clipped to
   [0, 1].

##### emit

```python
def emit(output: dai.NNData, keypoints: np.ndarray):
```

Create a `dai.beta.Keypoints` message and send it on `out`.

Copies source timestamps and sequence number, and carries the source image transformation when present.

Parameters

 * `output` (`dai.NNData`): Neural network output carrying tensors and source timestamps, sequence number, and optional image
   transformation.
 * `keypoints` (`np.ndarray`): Normalized keypoint coordinates returned by `compute()`.

##### extract

```python
def extract(output: dai.NNData) -> np.ndarray:
```

Select and dequantize the model tensors needed for parsing.

Parameters

 * `output` (`dai.NNData`): Neural network output carrying tensors and source timestamps, sequence number, and optional image
   transformation.

Returns

 * `np.ndarray`: Dequantized float32 keypoint tensor.

Raises

 * `ValueError`: If no output name is configured and the message does not contain exactly one layer, or configured class
   requirements are not met.

##### run

```python
def run(self):
```

Read queued network outputs, parse them, and emit results while running.

The pipeline invokes this processing loop. It exits when the input queue closes or the node stops.

##### setEdges

```python
def setEdges(edges: list[tuple[int, int]]):
```

Sets the edges for the keypoints.

Parameters

 * `edges` (`list[tuple[int, int]]`): List of edges for the keypoints. Example: [(0,1), (1,2), (2,3), (3,0)] shows that keypoint 0
   is connected to keypoint 1, keypoint 1 is connected to keypoint 2, etc.

##### setLabelNames

```python
def setLabelNames(label_names: list[str]):
```

Sets the label names for the keypoints.

Parameters

 * `label_names` (`list[str]`): List of label names for the keypoints.

##### setNumKeypoints

```python
def setNumKeypoints(n_keypoints: int):
```

Sets the number of keypoints.

Parameters

 * `n_keypoints` (`int`): Number of keypoints.

##### setOutputLayerName

```python
def setOutputLayerName(output_layer_name: str):
```

Sets the name of the output layer.

Parameters

 * `output_layer_name` (`str`): The name of the output layer.

##### setScaleFactor

```python
def setScaleFactor(scale_factor: float):
```

Sets the scale factor to divide the keypoints by.

Parameters

 * `scale_factor` (`float`): Scale factor to divide the keypoints by.

##### setScoreThreshold

```python
def setScoreThreshold(threshold: float):
```

Sets the confidence score threshold for the detected body keypoints.

Parameters

 * `threshold` (`float`): Confidence score threshold for detected keypoints.

#### Attributes

##### edges

Pairs of keypoint indexes defining skeleton edges. For example, `[(0, 1), (1, 2)]` connects keypoint 0 to 1 and 1 to 2.

##### label_names

Label names for the keypoints.

##### n_keypoints

Number of keypoints the model detects.

##### output_layer_name

Name of the output layer relevant to the parser.

##### scale_factor

Scale factor to divide the keypoints by.

##### score_threshold

Confidence score threshold for detected keypoints.