# Camera

Camera is a single, unified source node that replaces the separate
[ColorCamera](https://docs.luxonis.com/software-v3/depthai/depthai-components/nodes/color_camera.md) and
[MonoCamera](https://docs.luxonis.com/software-v3/depthai/depthai-components/nodes/mono_camera.md) nodes. It produces
[ImgFrame](https://docs.luxonis.com/software-v3/depthai/depthai-components/messages/img_frame.md) messages which can be used for
image processing and neural network inference.

## Key Features

 * Auto‑selection of sensor resolution & FPS when you don’t specify them — no more manual bookkeeping.

 * requestOutput()

```py
cam.requestOutput(size=(640, 480), type=dai.ImgFrame.Type.NV12,
                resize_mode=dai.ImgResizeMode.CROP,
                enableUndistortion=True)
```

 * Undistortion is opt-in per output via enableUndistortion (default = None). It is not applied automatically to any stream.
 * Undistortion keeps the original frame intrinsics, meaning the effective FOV is usually a bit reduced on the corners, especially
   for wide‑angle lenses.
 * requestFullResolutionOutput() with safety guard (stays ≤ 5 K×4 K unless you pass useHighestResolution=True).
 * setMockIsp() for synthetic or recorded inputs (attach a ReplayVideo node to feed pre‑captured frames).

Upgrading from ColorCamera or MonoCamera? Just search‑and‑replace the node creation and delete any manual setIspScale() logic.

## Placing the node

#### Python

```python
with dai.Pipeline() as pipeline:
    cam = pipeline.create(dai.node.Camera)
    cam.build(dai.CameraBoardSocket.CAM_A)  # optional — autodetects otherwise
```

#### C++

```cpp
// C++
dai::Pipeline pipeline;
auto cam = pipeline.create<dai::node::Camera>();
cam->build(dai::CameraBoardSocket::CAM_A);
```

## Inputs & Outputs

### Resizing modes

 * Crop: No NN accuracy decrease. Cons: Frame is cropped, so it's not full FOV.
 * Letterbox: Preserves full FOV. Cons: Smaller "frame" means less features might decrease NN accuracy.
 * Stretch: Preserves full FOV. Cons: Due to stretched frames, NNs accuracy might decrease.

```python
cam.requestOutput(size=(640, 480), type=dai.ImgFrame.Type.NV12,
                resize_mode=dai.ImgResizeMode.CROP)
cam.requestOutput(size=(640, 480), type=dai.ImgFrame.Type.NV12,
                resize_mode=dai.ImgResizeMode.RESIZE)
cam.requestOutput(size=(640, 480), type=dai.ImgFrame.Type.NV12,
                resize_mode=dai.ImgResizeMode.LETTERBOX)
```

## Usage Examples

#### Python

```python
pipeline = dai.Pipeline()

cam = pipeline.create(dai.node.Camera)
cam.build(boardSocket=dai.CameraBoardSocket.CAM_A)

# 1) Low‑latency preview for video encoder
nn_in = cam.requestOutput(size=(300,300), type=dai.ImgFrame.Type.NV12, fps=30)

# 2) HD stream for recording
hd_out = cam.requestOutput(size=(1280,720), type=dai.ImgFrame.Type.BGR888p, fps=30)

# 3) Full‑res stills every second
full = cam.requestFullResolutionOutput(type=dai.ImgFrame.Type.BGR888p, fps=1)

# Link to downstream nodes …
```

#### C++

```cpp
auto cam = pipeline.create<dai::node::Camera>();
cam->build(dai::CameraBoardSocket::CAM_A);

auto nnIn  = cam->requestOutput({300, 300}, dai::ImgFrame::Type::NV12,
                                dai::ImgResizeMode::CROP, 30);
auto hdOut = cam->requestOutput({1280,720}, dai::ImgFrame::Type::BGR888p,
                                dai::ImgResizeMode::STRETCH, 30);
auto full  = cam->requestFullResolutionOutput(dai::ImgFrame::Type::BGR888p, 1);
```

## Platform-Specific Limits

#### RVC2

ISP ~ 600 MP/s sustained (≈ 4 K @ 30 fps) → budget accordingly when running heavy NNs and video encoder. 3A runs on the embedded
micro-DSP and tops out at ~ 250 fps aggregated across all camera streams.

#### RVC4

See [RVC4 ISP specifications](https://docs.luxonis.com/hardware/platform/rvc/rvc4.md)

## Further Examples

 * [Camera Output](https://docs.luxonis.com/software-v3/depthai/examples/camera/camera_output.md)
 * [Camera ISP Output](https://docs.luxonis.com/software-v3/depthai/examples/camera/camera_isp.md)
 * [Multiple Outputs](https://docs.luxonis.com/software-v3/depthai/examples/camera/camera_all.md)
 * [Undistort Stream](https://docs.luxonis.com/software-v3/depthai/examples/camera/camera_undistort.md)

## API Reference

### dai::node::Camera

Kind: class

#### CameraControl initialControl

Kind: variable

Initial control options to apply to sensor

#### Input inputControl

Kind: variable

Input for CameraControl message, which can modify camera parameters in runtime

#### Input mockIsp

Kind: variable

Input for mocking 'isp' functionality on RVC2. Default queue is blocking with size 8

#### Output raw

Kind: variable

Outputs ImgFrame message that carries RAW10-packed (MIPI CSI-2 format) frame data. Captured directly from the camera sensor, and
the source for the 'isp' output.

#### OutputMap dynamicOutputs

Kind: variable

#### Node::Output * requestOutput(std::pair< uint32_t, uint32_t > size, std::optional< ImgFrame::Type > type, ImgResizeMode
resizeMode, std::optional< float > fps, std::optional< bool > enableUndistortion)

Kind: function

Get video output with specified size.

#### Node::Output * requestOutput(const Capability & capability, bool onHost)

Kind: function

Request output with advanced controls. Mainly to be used by custom node writers.

#### Node::Output * requestFullResolutionOutput(std::optional< ImgFrame::Type > type, std::optional< float > fps, bool
useHighestResolution)

Kind: function

Get a high resolution output with full FOV on the sensor. By default the function will not use the resolutions higher than
5000x4000, as those often need a lot of resources, making them hard to use in combination with other nodes. parameters: type: Type
of the output (NV12, BGR, ...) - by default it's auto-selected for best performance; fps: FPS of the output - by default it's
auto-selected to highest possible that a sensor config support or 30, whichever is lower; useHighestResolution: If true, the
function will use the highest resolution available on the sensor, even if it's higher than 5000x4000

#### Node::Output * requestIspOutput(std::optional< float > fps)

Kind: function

Request output with isp resolution. The fps does not vote.

#### std::shared_ptr< Camera > build(dai::CameraBoardSocket boardSocket, std::optional< std::pair< uint32_t, uint32_t >>
sensorResolution, std::optional< float > sensorFps)

Kind: function

Build with a specific board socket parameters: boardSocket: Board socket to use; sensorResolution: Sensor resolution to use - by
default it's auto-detected from the requested outputs; sensorFps: Sensor FPS to use - by default it's auto-detected from the
requested outputs (maximum is used)

#### std::shared_ptr< Camera > setSensorType(CameraSensorType sensorType)

Kind: function

Set the sensor type to use parameters: sensorType: Sensor type to use

#### CameraSensorType getSensorType()

Kind: function

Get the sensor type return: Sensor type

#### std::shared_ptr< Camera > setImageOrientation(CameraImageOrientation imageOrientation)

Kind: function

Set camera image orientation parameters: imageOrientation: Image orientation to set return: Shared pointer to the camera node

#### CameraImageOrientation getImageOrientation()

Kind: function

Get camera image orientation return: Image orientation

#### std::shared_ptr< Camera > build(dai::CameraBoardSocket boardSocket, ReplayVideo & replay)

Kind: function

Build with a specific board socket and mock input

#### std::shared_ptr< Camera > build(ReplayVideo & replay)

Kind: function

Build with mock input

#### uint32_t getMaxWidth()

Kind: function

Get max width of the camera (can only be called after build)

#### uint32_t getMaxHeight()

Kind: function

Get max height of the camera (can only be called after build)

#### CameraBoardSocket getBoardSocket()

Kind: function

Retrieves which board socket to use return: Board socket to use

#### std::shared_ptr< Camera > setRawNumFramesPool(int num)

Kind: function

Set number of frames in raw pool (will be automatically reduced if the maximum pool memory size is exceeded) parameters: num:
Number of frames return: Shared pointer to the camera node

#### std::shared_ptr< Camera > setMaxSizePoolRaw(int size)

Kind: function

Set maximum size of raw pool parameters: size: Maximum size in bytes of raw pool return: Shared pointer to the camera node

#### std::shared_ptr< Camera > setIspNumFramesPool(int num)

Kind: function

Set number of frames in isp pool (will be automatically reduced if the maximum pool memory size is exceeded) parameters: num:
Number of frames return: Shared pointer to the camera node

#### std::shared_ptr< Camera > setMaxSizePoolIsp(int size)

Kind: function

Set maximum size of isp pool parameters: size: Maximum size in bytes of isp pool return: Shared pointer to the camera node

#### std::shared_ptr< Camera > setNumFramesPools(int raw, int isp, int outputs)

Kind: function

Set number of frames in all pools (will be automatically reduced if the maximum pool memory size is exceeded) parameters: raw:
Number of frames in raw pool; isp: Number of frames in isp pool; outputs: Number of frames in outputs pools return: Shared pointer
to the camera node

#### std::shared_ptr< Camera > setMaxSizePools(int raw, int isp, int outputs)

Kind: function

Set maximum memory size of all pools parameters: raw: Maximum size in bytes of raw pool; isp: Maximum size in bytes of isp pool;
outputs: Maximum size in bytes of outputs pools return: Shared pointer to the camera node

#### std::shared_ptr< Camera > setOutputsNumFramesPool(int num)

Kind: function

Set number of frames in pools for all outputs parameters: num: Number of frames in pools for all outputs return: Shared pointer to
the camera node

#### std::shared_ptr< Camera > setOutputsMaxSizePool(int size)

Kind: function

Set maximum size of pools for all outputs parameters: size: Maximum size in bytes of pools for all outputs return: Shared pointer
to the camera node

#### int getRawNumFramesPool()

Kind: function

Get number of frames in raw pool return: Number of frames

#### int getMaxSizePoolRaw()

Kind: function

Get maximum size of raw pool return: Maximum size in bytes of raw pool

#### int getIspNumFramesPool()

Kind: function

Get number of frames in isp pool return: Number of frames

#### int getMaxSizePoolIsp()

Kind: function

Get maximum size of isp pool return: Maximum size in bytes of isp pool

#### std::optional< int > getOutputsNumFramesPool()

Kind: function

Get number of frames in outputs pool for all outputs return: Number of frames

#### std::optional< size_t > getOutputsMaxSizePool()

Kind: function

Get maximum size of outputs pool for all outputs return: Maximum size in bytes of image manip pool

#### Camera & setMockIsp(ReplayVideo & replay)

Kind: function

Set mock ISP for Camera node. Automatically sets mockIsp size. parameters: replay: ReplayVideo node to use as mock ISP

#### Camera()

Kind: function

#### Camera(std::shared_ptr< Device > & defaultDevice)

Kind: function

#### Camera(std::unique_ptr< Properties > props)

Kind: function

#### void buildStage1()

Kind: function

Build stages;.

#### float getMaxRequestedFps()

Kind: function

#### uint32_t getMaxRequestedWidth()

Kind: function

#### uint32_t getMaxRequestedHeight()

Kind: function

#### DeviceNodeCRTP()

Kind: function

#### DeviceNodeCRTP(const std::shared_ptr< Device > & device)

Kind: function

#### DeviceNodeCRTP(std::unique_ptr< Properties > props)

Kind: function

#### DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

Kind: function

#### DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

Kind: function

### Need assistance?

Head over to [Discussion Forum](https://discuss.luxonis.com/) for technical support or any other questions you might have.