imagebufalgo.cpp

#include <OpenImageIO/imagebufalgo.h>
#include <OpenImageIO/color.h>

#include <stdint.h>
#include <string>

#include "oiio.h"
#include "color.h"
#include "handles.h"

using oiio_go::Handle;

extern "C" {

bool zero(ImageBuf *dst, ROI* roi, int nthreads) {
	return OIIO::ImageBufAlgo::zero(*(static_cast<OIIO::ImageBuf*>(dst)),
									*(static_cast<OIIO::ROI*>(roi)),
									nthreads);
}

bool fill(ImageBuf *dst, const float *values, ROI* roi, int nthreads) {
	auto* buf = static_cast<OIIO::ImageBuf*>(dst);
	int nchans = buf->nchannels();
	return OIIO::ImageBufAlgo::fill(*(static_cast<OIIO::ImageBuf*>(dst)),
									OIIO::cspan<float>(values, nchans),
									*(static_cast<OIIO::ROI*>(roi)),
									nthreads);
}

bool checker(ImageBuf *dst, int width, int height, int depth, const float *color1, const float *color2,
			  int xoffset, int yoffset, int zoffset, ROI* roi, int nthreads)
{
	auto* buf = static_cast<OIIO::ImageBuf*>(dst);
	int nchans = buf->nchannels();
	return OIIO::ImageBufAlgo::checker(
		*(static_cast<OIIO::ImageBuf*>(dst)),
		width, height, depth,
		OIIO::cspan<float>(color1, nchans),
		OIIO::cspan<float>(color2, nchans),
		xoffset, yoffset, zoffset,
		*(static_cast<OIIO::ROI*>(roi)),
		nthreads);
}

bool channels(ImageBuf *dst, const ImageBuf *src, int nchannels, const int32_t *channelorder,
			   const float *channelvalues, const char **newchannelnames,
			   bool shuffle_channel_names)
{
	std::vector<std::string> vec_names;

	if (nchannels > 0 && newchannelnames != NULL) {
		vec_names.assign(newchannelnames, newchannelnames+nchannels);
	}

	OIIO::cspan<int> order_span;
	if (channelorder != NULL) {
		order_span = OIIO::cspan<int>(channelorder, nchannels);
	}

	OIIO::cspan<float> values_span;
	if (channelvalues != NULL) {
		values_span = OIIO::cspan<float>(channelvalues, nchannels);
	}

	bool ok = OIIO::ImageBufAlgo::channels(*(static_cast<OIIO::ImageBuf*>(dst)),
											*(static_cast<const OIIO::ImageBuf*>(src)),
											nchannels, order_span, values_span,
											vec_names, shuffle_channel_names );
	return ok;
}

bool channel_append(ImageBuf *dst, const ImageBuf *A, const ImageBuf *B, 
	ROI* roi, int nthreads) 
{
	return OIIO::ImageBufAlgo::channel_append(
			*(static_cast<OIIO::ImageBuf*>(dst)),
			*(static_cast<const OIIO::ImageBuf*>(A)),
			*(static_cast<const OIIO::ImageBuf*>(B)),
			*(static_cast<OIIO::ROI*>(roi)),
			nthreads);		
}

bool flatten(ImageBuf *dst, const ImageBuf *src, ROI* roi, int nthreads) {
	return OIIO::ImageBufAlgo::flatten(
			*(static_cast<OIIO::ImageBuf*>(dst)),
			*(static_cast<const OIIO::ImageBuf*>(src)),
			*(static_cast<OIIO::ROI*>(roi)),
			nthreads);	
}

bool crop(ImageBuf *dst, const ImageBuf *src, ROI* roi, int nthreads) {
	return OIIO::ImageBufAlgo::crop(
			*(static_cast<OIIO::ImageBuf*>(dst)),
			*(static_cast<const OIIO::ImageBuf*>(src)),
			*(static_cast<OIIO::ROI*>(roi)),
			nthreads);
}

bool cut (ImageBuf *dst, const ImageBuf *src, ROI* roi, int nthreads) {
	return OIIO::ImageBufAlgo::cut(
			*(static_cast<OIIO::ImageBuf*>(dst)),
			*(static_cast<const OIIO::ImageBuf*>(src)),
			*(static_cast<OIIO::ROI*>(roi)),
			nthreads);	
}

bool paste(ImageBuf *dst, int xbegin, int ybegin, int zbegin, int chbegin,
			const ImageBuf *src, ROI* srcroi, int nthreads) 
{
	return OIIO::ImageBufAlgo::paste(
			*(static_cast<OIIO::ImageBuf*>(dst)),
			xbegin,
			ybegin,
			zbegin,
			chbegin,
			*(static_cast<const OIIO::ImageBuf*>(src)),
			*(static_cast<OIIO::ROI*>(srcroi)),
			nthreads);
}

bool flip(ImageBuf *dst, const ImageBuf *src, ROI* roi, int nthreads) {
	return OIIO::ImageBufAlgo::flip(
			*(static_cast<OIIO::ImageBuf*>(dst)),
			*(static_cast<const OIIO::ImageBuf*>(src)),
			*(static_cast<OIIO::ROI*>(roi)),
			nthreads);
}

bool flop(ImageBuf *dst, const ImageBuf *src, ROI* roi, int nthreads) {
	return OIIO::ImageBufAlgo::flop(
			*(static_cast<OIIO::ImageBuf*>(dst)),
			*(static_cast<const OIIO::ImageBuf*>(src)),
			*(static_cast<OIIO::ROI*>(roi)),
			nthreads);
}

bool flipflop(ImageBuf *dst, const ImageBuf *src, ROI* roi, int nthreads) {
	// flipflop removed in OIIO 3.x, implemented as rotate180
	return OIIO::ImageBufAlgo::rotate180(
			*(static_cast<OIIO::ImageBuf*>(dst)),
			*(static_cast<const OIIO::ImageBuf*>(src)),
			*(static_cast<OIIO::ROI*>(roi)),
			nthreads);
}

bool transpose(ImageBuf *dst, const ImageBuf *src, ROI* roi, int nthreads) {
	return OIIO::ImageBufAlgo::transpose(
			*(static_cast<OIIO::ImageBuf*>(dst)),
			*(static_cast<const OIIO::ImageBuf*>(src)),
			*(static_cast<OIIO::ROI*>(roi)),
			nthreads);	
}

bool add(ImageBuf *dst, const ImageBuf *A, const ImageBuf *B, ROI* roi, int nthreads) {
	return OIIO::ImageBufAlgo::add(
			*(static_cast<OIIO::ImageBuf*>(dst)),
			*(static_cast<const OIIO::ImageBuf*>(A)),
			*(static_cast<const OIIO::ImageBuf*>(B)),
			*(static_cast<OIIO::ROI*>(roi)),
			nthreads);	
}

bool add_values(ImageBuf *dst, const ImageBuf *A, const float *B, ROI* roi, int nthreads) {
	auto* buf = static_cast<const OIIO::ImageBuf*>(A);
	int nchans = buf->nchannels();
	return OIIO::ImageBufAlgo::add(
			*(static_cast<OIIO::ImageBuf*>(dst)),
			*buf,
			OIIO::cspan<float>(B, nchans),
			*(static_cast<OIIO::ROI*>(roi)),
			nthreads);
}

bool add_value(ImageBuf *dst, const ImageBuf *A, float B, ROI* roi, int nthreads) {
	return OIIO::ImageBufAlgo::add(
			*(static_cast<OIIO::ImageBuf*>(dst)),
			*(static_cast<const OIIO::ImageBuf*>(A)),
			B,
			*(static_cast<OIIO::ROI*>(roi)),
			nthreads);	
}

bool sub(ImageBuf *dst, const ImageBuf *A, const ImageBuf *B, ROI* roi, int nthreads) {
	return OIIO::ImageBufAlgo::sub(
			*(static_cast<OIIO::ImageBuf*>(dst)),
			*(static_cast<const OIIO::ImageBuf*>(A)),
			*(static_cast<const OIIO::ImageBuf*>(B)),
			*(static_cast<OIIO::ROI*>(roi)),
			nthreads);	
}

bool sub_values(ImageBuf *dst, const ImageBuf *A, const float *B, ROI* roi, int nthreads) {
	auto* buf = static_cast<const OIIO::ImageBuf*>(A);
	int nchans = buf->nchannels();
	return OIIO::ImageBufAlgo::sub(
			*(static_cast<OIIO::ImageBuf*>(dst)),
			*buf,
			OIIO::cspan<float>(B, nchans),
			*(static_cast<OIIO::ROI*>(roi)),
			nthreads);
}

bool sub_value(ImageBuf *dst, const ImageBuf *A, float B, ROI* roi, int nthreads) {
	return OIIO::ImageBufAlgo::sub(
			*(static_cast<OIIO::ImageBuf*>(dst)),
			*(static_cast<const OIIO::ImageBuf*>(A)),
			B,
			*(static_cast<OIIO::ROI*>(roi)),
			nthreads);
}

bool mul(ImageBuf *dst, const ImageBuf *A, const ImageBuf *B, ROI* roi, int nthreads) {
	return OIIO::ImageBufAlgo::mul(
			*(static_cast<OIIO::ImageBuf*>(dst)),
			*(static_cast<const OIIO::ImageBuf*>(A)),
			*(static_cast<const OIIO::ImageBuf*>(B)),
			*(static_cast<OIIO::ROI*>(roi)),
			nthreads);	
}

bool mul_values(ImageBuf *dst, const ImageBuf *A, const float *B, ROI* roi, int nthreads) {
	auto* buf = static_cast<const OIIO::ImageBuf*>(A);
	int nchans = buf->nchannels();
	return OIIO::ImageBufAlgo::mul(
			*(static_cast<OIIO::ImageBuf*>(dst)),
			*buf,
			OIIO::cspan<float>(B, nchans),
			*(static_cast<OIIO::ROI*>(roi)),
			nthreads);
}

bool mul_value(ImageBuf *dst, const ImageBuf *A, float B, ROI* roi, int nthreads) {
	return OIIO::ImageBufAlgo::mul(
			*(static_cast<OIIO::ImageBuf*>(dst)),
			*(static_cast<const OIIO::ImageBuf*>(A)),
			B,
			*(static_cast<OIIO::ROI*>(roi)),
			nthreads);
}

bool colorconvert(ImageBuf *dst, const ImageBuf *src, const char *from, const char *to,
				   bool unpremult, ROI* roi, int nthreads)
{
	// OIIO 3.x added context_key, context_value, and colorconfig parameters
	return OIIO::ImageBufAlgo::colorconvert(
			*(static_cast<OIIO::ImageBuf*>(dst)),
			*(static_cast<const OIIO::ImageBuf*>(src)),
			from,
			to,
			unpremult,
			"",  // context_key
			"",  // context_value
			nullptr,  // colorconfig
			*(static_cast<OIIO::ROI*>(roi)),
			nthreads);

}

bool colorconvert_processor(ImageBuf *dst, const ImageBuf *src, const ColorProcessor *processor,
				   			bool unpremult, ROI* roi, int nthreads)
{
	auto* handle = static_cast<const Handle<OIIO::ColorProcessor>*>(processor);
	return OIIO::ImageBufAlgo::colorconvert(
			*(static_cast<OIIO::ImageBuf*>(dst)),
			*(static_cast<const OIIO::ImageBuf*>(src)),
			handle->ptr.get(),
			unpremult,
			*(static_cast<OIIO::ROI*>(roi)),
			nthreads);
}

bool unpremult(ImageBuf *dst, const ImageBuf *src, ROI* roi, int nthreads) {
	return OIIO::ImageBufAlgo::unpremult(
			*(static_cast<OIIO::ImageBuf*>(dst)),
			*(static_cast<const OIIO::ImageBuf*>(src)),
			*(static_cast<OIIO::ROI*>(roi)),
			nthreads);
}

bool premult(ImageBuf *dst, const ImageBuf *src, ROI* roi, int nthreads) {
	return OIIO::ImageBufAlgo::premult(
			*(static_cast<OIIO::ImageBuf*>(dst)),
			*(static_cast<const OIIO::ImageBuf*>(src)),
			*(static_cast<OIIO::ROI*>(roi)),
			nthreads);
}

bool is_constant_color(const ImageBuf *src, float *color, ROI* roi, int nthreads) {
	if (!src) {
		return false;
	}

	auto* buf = static_cast<const OIIO::ImageBuf*>(src);
	OIIO::ROI oiio_roi = roi ? *(static_cast<OIIO::ROI*>(roi)) : buf->roi();

	// If ROI doesn't have valid channel bounds, use the buffer's full channel range
	int chbegin = oiio_roi.chbegin;
	int chend = oiio_roi.chend;
	if (chend <= chbegin) {
		chbegin = 0;
		chend = buf->nchannels();
		oiio_roi.chbegin = chbegin;
		oiio_roi.chend = chend;
	}
	int nchans = chend - chbegin;

	// Allocate temp buffer - OIIO writes to indices [chbegin, chend)
	std::vector<float> temp_color(chend, 0.0f);
	OIIO::span<float> color_span(temp_color.data(), temp_color.size());

	bool result = OIIO::ImageBufAlgo::isConstantColor(
			*buf,
			0.0f,  // threshold
			color_span,
			oiio_roi,
			nthreads);

	// Copy from the span only if caller wants the color values
	if (result && color) {
		for (int i = 0; i < nchans; ++i) {
			color[i] = temp_color[chbegin + i];
		}
	}

	return result;
}

bool is_constant_channel(const ImageBuf *src, int channel, float val, ROI* roi, int nthreads) {
	return OIIO::ImageBufAlgo::isConstantChannel(
				*(static_cast<const OIIO::ImageBuf*>(src)),
				channel,
				val,
				0.0f,  // threshold
				*(static_cast<OIIO::ROI*>(roi)),
				nthreads);
}

bool is_monochrome(const ImageBuf *src, ROI* roi, int nthreads) {
	return OIIO::ImageBufAlgo::isMonochrome(
				*(static_cast<const OIIO::ImageBuf*>(src)),
				0.0f,  // threshold
				*(static_cast<OIIO::ROI*>(roi)),
				nthreads);
}

char* computePixelHashSHA1(const ImageBuf *src, const char *extrainfo,
						   ROI* roi, int blocksize, int nthreads) {
	std::string aHash = OIIO::ImageBufAlgo::computePixelHashSHA1(
							*(static_cast<const OIIO::ImageBuf*>(src)),
							extrainfo,
							*(static_cast<OIIO::ROI*>(roi)),
							blocksize,
							nthreads);

    return strdup(aHash.c_str());
}

bool resize(ImageBuf *dst, const ImageBuf *src, const char *filtername,
			 float filterwidth, ROI* roi, int nthreads)
{
	// Use the OIIO 3.x keyword args API to avoid deprecation warning
	OIIO::ParamValueList options;
	if (filtername && filtername[0] != '\0') {
		options.push_back(OIIO::ParamValue("filtername", OIIO::string_view(filtername)));
	}
	if (filterwidth != 0.0f) {
		options.push_back(OIIO::ParamValue("filterwidth", filterwidth));
	}

	return OIIO::ImageBufAlgo::resize(
			*(static_cast<OIIO::ImageBuf*>(dst)),
			*(static_cast<const OIIO::ImageBuf*>(src)),
			options,
			*(static_cast<OIIO::ROI*>(roi)),
			nthreads);
}

bool resample(ImageBuf *dst, const ImageBuf *src, bool interpolate, ROI* roi, int nthreads) {
	return OIIO::ImageBufAlgo::resample(
			*(static_cast<OIIO::ImageBuf*>(dst)),
			*(static_cast<const OIIO::ImageBuf*>(src)),
			interpolate,
			*(static_cast<OIIO::ROI*>(roi)),
			nthreads);
}

bool over(ImageBuf *dst, const ImageBuf *A, const ImageBuf *B, ROI* roi, int nthreads) {
	return OIIO::ImageBufAlgo::over(
			*(static_cast<OIIO::ImageBuf*>(dst)),
			*(static_cast<const OIIO::ImageBuf*>(A)),
			*(static_cast<const OIIO::ImageBuf*>(B)),
			*(static_cast<OIIO::ROI*>(roi)),
			nthreads);	
}

bool render_text(ImageBuf *dst, int x, int y, const char *text, int fontsize,
				  const char *fontname, const float *textcolor) {

	if (fontsize <= 0) fontsize = 16;

	OIIO::cspan<float> color_span;
	if (textcolor != NULL) {
		color_span = OIIO::cspan<float>(textcolor, 4);  // RGBA
	}

	// Use a specific font file path when fontname is empty
	// OIIO can't find a default font without an explicit path
	OIIO::string_view font = OIIO::string_view(fontname);
	if (font.empty()) {
		font = OIIO::string_view("/usr/share/fonts/truetype/freefont/FreeSans.ttf");
	}

	return OIIO::ImageBufAlgo::render_text(
			*(static_cast<OIIO::ImageBuf*>(dst)),
			x, y,
			OIIO::string_view(text),
			fontsize,
			font,
			color_span);
}

} // extern "C"