opencv_dart

The FreeType2 class provides high-quality text rendering capabilities using FreeType fonts. You can create a renderer, load font data from files or memory buffers, and draw text onto images. It supports both synchronous and asynchronous operations for loading data and rendering text.

import 'package:opencv_dart/opencv_dart.dart' as cv;

// Create a FreeType2 instance and load a font file
final ft2 = cv.FreeType2.create(filename: 'path/to/font.ttf');

// Draw text on an image
// img: InputOutputArray (e.g., a Mat)
// text: The string to render
// org: Point for the text origin
// fontHeight: Size in pixels
// color: Scalar color
// thickness: Negative for filled glyphs, positive for line thickness
// lineType: e.g., cv.LINE_8
// bottomLeftOrigin: If true, origin is bottom-left
ft2.putText(
  img, 
  'Hello World', 
  cv.Point(10, 50), 
  24, 
  cv.Scalar(255, 255, 255), 
  thickness: -1
);

Use these methods to change how data is represented or to export it to Dart-native structures.

Type Conversion

• convertTo(MatType type, {bool inplace = false, double alpha = 1, double beta = 0}): Converts the matrix to a new type with optional scaling ($\alpha \cdot x + \beta$). This is the preferred method for type casting.
• reinterpret(MatType type): Resets the type of the matrix. If the element size remains the same, the buffer is reused.

Data Export

• toList({bool copy = true}): Converts the matrix to a 2D list List<List<num>>. If copy is false, it returns a zero-copy view (writing to the list writes to the native Mat).
• toList3D({bool copy = true}): For multi-channel matrices, returns a 3D list List<List<List<num>>> ordered as [row][col][channels].
• toFmtString({int fmtType = FMT_NUMPY, ...}): Returns a string representation of the matrix in various formats (NumPy, CSV, MATLAB, etc.).

// Convert to 8-bit unsigned integer with scaling
Mat gray = colorMat.convertTo(MatType.CV_8U, alpha: 1.0/255.0);

// Export to Dart list (deep copy)
List<List<num>> data = mat.toList(copy: true);

// Export to NumPy-style string
String numpyStr = mat.toFmtString(fmtType: Mat.FMT_NUMPY);

The Mat class (N-dimensional dense arrays) provides several factory constructors to initialize matrices from different data formats:

• From List: Mat.fromList(rows, cols, type, data) creates a Mat from a flat list. Note that this involves two copies of the data.
• From 2D/3D Lists: Mat.from2DList(data, type, {cols, rows}) and Mat.from3DList(data, type) allow using nested iterables.
• From Buffer (High Performance): Mat.fromBuffer(rows, cols, type, buff) creates a Mat that shares the memory of the provided ffi.Pointer<ffi.Void>.
  • Warning: You are responsible for managing the native pointer. The Mat does not own the buffer. The buffer must remain valid as long as the Mat is in use.
• From Vector: Mat.fromVec(vec, {rows, cols, type, copyData}) creates a Mat from a Vec instance (e.g., VecPoint, VecU8, etc.).
• From Scalar: Mat.fromScalar(rows, cols, type, s) initializes every element with the value in Scalar s.
• Specialized Initializers:
  • Mat.empty(): Creates an empty Mat.
  • Mat.zeros(rows, cols, type): Creates a zero-filled array.
  • Mat.ones(rows, cols, type): Creates an array of 1s.
  • Mat.eye(rows, cols, type): Creates an identity matrix.
  • Mat.randn(rows, cols, type, {mean, std}): Creates a matrix with random values from a normal distribution.
  • Mat.randu(rows, cols, type, {low, high}): Creates a matrix with random values from a uniform distribution.

// Example: Creating a Mat from a list
final mat = Mat.fromList(2, 2, MatType.CV_8UC1, [255, 0, 0, 255]);

// Example: High performance buffer sharing
// Note: You must ensure 'ptr' remains valid!
final matFromBuf = Mat.fromBuffer(rows, cols, type, ptr);