/**
* Convert a 3-channel {@link MultiSpectral} image from RGB into YUV.
*
* @param rgb (Input) RGB encoded image
* @param yuv (Output) YUV encoded image
*/
public static void rgbToYuv_F32(
MultiSpectral<ImageFloat32> rgb, MultiSpectral<ImageFloat32> yuv) {
InputSanityCheck.checkSameShape(yuv, rgb);
ImageFloat32 R = rgb.getBand(0);
ImageFloat32 G = rgb.getBand(1);
ImageFloat32 B = rgb.getBand(2);
ImageFloat32 Y = yuv.getBand(0);
ImageFloat32 U = yuv.getBand(1);
ImageFloat32 V = yuv.getBand(2);
for (int row = 0; row < yuv.height; row++) {
int indexYuv = yuv.startIndex + row * yuv.stride;
int indexRgb = rgb.startIndex + row * rgb.stride;
for (int col = 0; col < yuv.width; col++, indexYuv++, indexRgb++) {
float r = R.data[indexRgb];
float g = G.data[indexRgb];
float b = B.data[indexRgb];
float y = 0.299f * r + 0.587f * g + 0.114f * b;
Y.data[indexRgb] = y;
U.data[indexRgb] = 0.492f * (b - y);
V.data[indexRgb] = 0.877f * (r - y);
}
}
}
/**
* Convert a 3-channel {@link MultiSpectral} image from YUV into RGB.
*
* @param rgb (Input) RGB encoded image
* @param yuv (Output) YUV encoded image
*/
public static void yuvToRgb_F32(
MultiSpectral<ImageFloat32> yuv, MultiSpectral<ImageFloat32> rgb) {
InputSanityCheck.checkSameShape(yuv, rgb);
ImageFloat32 Y = yuv.getBand(0);
ImageFloat32 U = yuv.getBand(1);
ImageFloat32 V = yuv.getBand(2);
ImageFloat32 R = rgb.getBand(0);
ImageFloat32 G = rgb.getBand(1);
ImageFloat32 B = rgb.getBand(2);
for (int row = 0; row < yuv.height; row++) {
int indexYuv = yuv.startIndex + row * yuv.stride;
int indexRgb = rgb.startIndex + row * rgb.stride;
for (int col = 0; col < yuv.width; col++, indexYuv++, indexRgb++) {
float y = Y.data[indexYuv];
float u = U.data[indexYuv];
float v = V.data[indexYuv];
R.data[indexRgb] = y + 1.13983f * v;
G.data[indexRgb] = y - 0.39465f * u - 0.58060f * v;
B.data[indexRgb] = y + 2.032f * u;
}
}
}
/**
* Performs a horizontal 1D convolution across the image. Borders are handled as specified by the
* 'border' parameter.
*
* @param image The original image. Not modified.
* @param dest Where the resulting image is written to. Modified.
* @param kernel The kernel that is being convolved. Not modified.
* @param border How the image borders are handled.
*/
public static void horizontal(
Kernel1D_I32 kernel, GrayU8 image, GrayI16 dest, ImageBorder_S32 border) {
InputSanityCheck.checkSameShape(image, dest);
border.setImage(image);
ConvolveImageNoBorder.horizontal(kernel, image, dest);
ConvolveJustBorder_General.horizontal(kernel, border, dest);
}
/**
* Performs a 2D convolution across the image. Borders are handled as specified by the 'border'
* parameter.
*
* @param image The original image. Not modified.
* @param dest Where the resulting image is written to. Modified.
* @param kernel The kernel that is being convolved. Not modified.
* @param border How the image borders are handled.
*/
public static void convolve(
Kernel2D_F32 kernel, GrayF32 image, GrayF32 dest, ImageBorder_F32 border) {
InputSanityCheck.checkSameShape(image, dest);
border.setImage(image);
ConvolveImageNoBorder.convolve(kernel, image, dest);
ConvolveJustBorder_General.convolve(kernel, border, dest);
}
/**
* Converts an image from one type to another type. Creates a new image instance if an output is
* not provided.
*
* @param src Input image. Not modified.
* @param dst Converted output image. If null a new one will be declared. Modified.
* @param typeDst The type of output image.
* @return Converted image.
*/
public static <T extends ImageSingleBand> T convert(
ImageSingleBand<?> src, T dst, Class<T> typeDst) {
if (dst == null) {
dst = (T) createSingleBand(typeDst, src.width, src.height);
} else {
InputSanityCheck.checkSameShape(src, dst);
}
convert(src, dst);
return dst;
}
/**
* Computes disparity between two stereo images
*
* @param left Left rectified stereo image. Input
* @param right Right rectified stereo image. Input
* @param disparity Disparity between the two images. Output
*/
public void process(Input left, Input right, Disparity disparity) {
// initialize data structures
InputSanityCheck.checkSameShape(left, right, disparity);
if (maxDisparity > left.width - 2 * radiusX)
throw new RuntimeException(
"The maximum disparity is too large for this image size: max size "
+ (left.width - 2 * radiusX));
lengthHorizontal = left.width * rangeDisparity;
_process(left, right, disparity);
}
/**
* Computes the optical flow form 'prev' to 'curr' and stores the output into output
*
* @param prev Previous image
* @param curr Current image
* @param output Dense optical flow output
*/
public void process(T prev, T curr, ImageFlow output) {
InputSanityCheck.checkSameShape(prev, curr);
output.invalidateAll();
int N = prev.width * prev.height;
if (scores.length < N) scores = new float[N];
int r = searchRadius + regionRadius;
int x1 = prev.width - r;
int y1 = prev.height - r;
for (int y = r; y < y1; y++) {
for (int x = r; x < x1; x++) {
extractTemplate(x, y, prev);
float score = findFlow(x, y, curr, tmp);
if (tmp.valid) checkNeighbors(x, y, tmp, output, score);
}
}
// TODO process image border
}
/**
* Converts the gray scale input image into a binary image
*
* @param input Input image
* @param output Output binary image
*/
public void process(T input, ImageUInt8 output) {
InputSanityCheck.checkSameShape(input, output);
if (input.width < requestedBlockWidth || input.height < requestedBlockWidth) {
throw new IllegalArgumentException("Image is smaller than block size");
}
selectBlockSize(input.width, input.height);
minmax.reshape(input.width / blockWidth, input.height / blockHeight);
int innerWidth =
input.width % blockWidth == 0
? input.width
: input.width - blockWidth - input.width % blockWidth;
int innerHeight =
input.height % blockHeight == 0
? input.height
: input.height - blockHeight - input.height % blockHeight;
computeMinMax(input, innerWidth, innerHeight);
applyThreshold(input, output);
}