ImageBuf
ImageBufAlgo::sub(Image_or_Const A, Image_or_Const B, ROI roi, int nthreads)
{
ImageBuf result;
bool ok = sub(result, A, B, roi, nthreads);
if (!ok && !result.has_error())
result.error("ImageBufAlgo::sub() error");
return result;
}
bool
ImageBufAlgo::histogram (const ImageBuf &A, int channel,
std::vector<imagesize_t> &histogram, int bins,
float min, float max, imagesize_t *submin,
imagesize_t *supermax, ROI roi)
{
if (A.spec().format != TypeDesc::TypeFloat) {
A.error ("Unsupported pixel data format '%s'", A.spec().format);
return false;
}
if (A.nchannels() == 0) {
A.error ("Input image must have at least 1 channel");
return false;
}
if (channel < 0 || channel >= A.nchannels()) {
A.error ("Invalid channel %d for input image with channels 0 to %d",
channel, A.nchannels()-1);
return false;
}
if (bins < 1) {
A.error ("The number of bins must be at least 1");
return false;
}
if (max <= min) {
A.error ("Invalid range, min must be strictly smaller than max");
return false;
}
// Specified ROI -> use it. Unspecified ROI -> initialize from A.
if (! roi.defined())
roi = get_roi (A.spec());
histogram_impl<float> (A, channel, histogram, bins, min, max,
submin, supermax, roi);
return ! A.has_error();
}
bool
ImageBufAlgo::zover (ImageBuf &R, const ImageBuf &A, const ImageBuf &B,
bool z_zeroisinf, ROI roi, int nthreads)
{
const ImageSpec &specR = R.spec();
const ImageSpec &specA = A.spec();
const ImageSpec &specB = B.spec();
int nchannels_R, nchannels_A, nchannels_B;
int alpha_R, alpha_A, alpha_B;
int z_R, z_A, z_B;
int colors_R, colors_A, colors_B;
bool initialized_R = decode_over_channels (R, nchannels_R, alpha_R,
z_R, colors_R);
bool initialized_A = decode_over_channels (A, nchannels_A, alpha_A,
z_A, colors_A);
bool initialized_B = decode_over_channels (B, nchannels_B, alpha_B,
z_B, colors_B);
if (! initialized_A || ! initialized_B) {
R.error ("Can't 'zover' uninitialized images");
return false;
}
// Fail if the input images don't have a Z channel.
if (z_A < 0 || z_B < 0 || (initialized_R && z_R < 0)) {
R.error ("'zover' requires Z channels");
return false;
}
// Fail if the input images don't have an alpha channel.
if (alpha_A < 0 || alpha_B < 0 || (initialized_R && alpha_R < 0)) {
R.error ("'zover' requires alpha channels");
return false;
}
// Fail for mismatched channel counts
if (colors_A != colors_B || colors_A < 1) {
R.error ("Can't 'zover' images with mismatched color channel counts (%d vs %d)",
colors_A, colors_B);
return false;
}
// Fail for unaligned alpha or z channels
if (alpha_A != alpha_B || z_A != z_B ||
(initialized_R && alpha_R != alpha_A) ||
(initialized_R && z_R != z_A)) {
R.error ("Can't 'zover' images with mismatched channel order",
colors_A, colors_B);
return false;
}
// At present, this operation only supports ImageBuf's containing
// float pixel data.
if ((initialized_R && specR.format != TypeDesc::TypeFloat) ||
specA.format != TypeDesc::TypeFloat ||
specB.format != TypeDesc::TypeFloat) {
R.error ("Unsupported pixel data format combination '%s = %s zover %s'",
specR.format, specA.format, specB.format);
return false;
}
// Uninitialized R -> size it to the union of A and B.
if (! initialized_R) {
ImageSpec newspec = specA;
set_roi (newspec, roi_union (get_roi(specA), get_roi(specB)));
R.reset ("zover", newspec);
}
// Specified ROI -> use it. Unspecified ROI -> initialize from R.
if (! roi.defined())
roi = get_roi (R.spec());
parallel_image (boost::bind (over_impl<float,float,float>, boost::ref(R),
boost::cref(A), boost::cref(B), _1,
true, z_zeroisinf),
roi, nthreads);
return ! R.has_error();
}
static bool
computePixelStats_ (const ImageBuf &src, ImageBufAlgo::PixelStats &stats,
ROI roi, int nthreads)
{
if (! roi.defined())
roi = get_roi (src.spec());
else
roi.chend = std::min (roi.chend, src.nchannels());
int nchannels = src.spec().nchannels;
// Use local storage for smaller batches, then merge the batches
// into the final results. This preserves precision for large
// images, where the running total may be too big to incorporate the
// contributions of individual pixel values without losing
// precision.
//
// This approach works best when the batch size is the sqrt of
// numpixels, which makes the num batches roughly equal to the
// number of pixels / batch.
ImageBufAlgo::PixelStats tmp;
reset (tmp, nchannels);
reset (stats, nchannels);
int PIXELS_PER_BATCH = std::max (1024,
static_cast<int>(sqrt((double)src.spec().image_pixels())));
if (src.deep()) {
// Loop over all pixels ...
for (ImageBuf::ConstIterator<T> s(src, roi); ! s.done(); ++s) {
int samples = s.deep_samples();
if (! samples)
continue;
for (int c = roi.chbegin; c < roi.chend; ++c) {
for (int i = 0; i < samples; ++i) {
float value = s.deep_value (c, i);
val (tmp, c, value);
if ((tmp.finitecount[c] % PIXELS_PER_BATCH) == 0) {
merge (stats, tmp);
reset (tmp, nchannels);
}
}
}
}
} else { // Non-deep case
// Loop over all pixels ...
for (ImageBuf::ConstIterator<T> s(src, roi); ! s.done(); ++s) {
for (int c = roi.chbegin; c < roi.chend; ++c) {
float value = s[c];
val (tmp, c, value);
if ((tmp.finitecount[c] % PIXELS_PER_BATCH) == 0) {
merge (stats, tmp);
reset (tmp, nchannels);
}
}
}
}
// Merge anything left over
merge (stats, tmp);
// Compute final results
finalize (stats);
return ! src.has_error();
};
static void
print_stats (const std::string &filename,
const ImageSpec &originalspec,
int subimage=0, int miplevel=0, bool indentmip=false)
{
PixelStats stats;
const char *indent = indentmip ? " " : " ";
ImageBuf input;
if (! read_input (filename, input, subimage, miplevel)) {
std::cerr << "Stats: read error: " << input.geterror() << "\n";
return;
}
if (! computePixelStats (stats, input)) {
printf ("%sStats: (unable to compute)\n", indent);
if (input.has_error())
std::cerr << "Error: " << input.geterror() << "\n";
return;
}
// The original spec is used, otherwise the bit depth will
// be reported incorrectly (as FLOAT)
unsigned int maxval = (unsigned int)get_intsample_maxval (originalspec);
printf ("%sStats Min: ", indent);
for (unsigned int i=0; i<stats.min.size(); ++i) {
print_stats_num (stats.min[i], maxval, true);
printf (" ");
}
print_stats_footer (maxval);
printf ("\n");
printf ("%sStats Max: ", indent);
for (unsigned int i=0; i<stats.max.size(); ++i) {
print_stats_num (stats.max[i], maxval, true);
printf (" ");
}
print_stats_footer (maxval);
printf ("\n");
printf ("%sStats Avg: ", indent);
for (unsigned int i=0; i<stats.avg.size(); ++i) {
print_stats_num (stats.avg[i], maxval, false);
printf (" ");
}
print_stats_footer (maxval);
printf ("\n");
printf ("%sStats StdDev: ", indent);
for (unsigned int i=0; i<stats.stddev.size(); ++i) {
print_stats_num (stats.stddev[i], maxval, false);
printf (" ");
}
print_stats_footer (maxval);
printf ("\n");
printf ("%sStats NanCount: ", indent);
for (unsigned int i=0; i<stats.nancount.size(); ++i) {
printf ("%llu ", (unsigned long long)stats.nancount[i]);
}
printf ("\n");
printf ("%sStats InfCount: ", indent);
for (unsigned int i=0; i<stats.infcount.size(); ++i) {
printf ("%llu ", (unsigned long long)stats.infcount[i]);
}
printf ("\n");
printf ("%sStats FiniteCount: ", indent);
for (unsigned int i=0; i<stats.finitecount.size(); ++i) {
printf ("%llu ", (unsigned long long)stats.finitecount[i]);
}
printf ("\n");
if (input.deep()) {
const DeepData *dd (input.deepdata());
size_t npixels = dd->pixels();
size_t totalsamples = 0, emptypixels = 0;
size_t maxsamples = 0, minsamples = std::numeric_limits<size_t>::max();
for (size_t p = 0; p < npixels; ++p) {
size_t c = dd->samples(p);
totalsamples += c;
if (c > maxsamples)
maxsamples = c;
if (c < minsamples)
minsamples = c;
if (c == 0)
++emptypixels;
}
printf ("%sMin deep samples in any pixel : %llu\n", indent, (unsigned long long)minsamples);
printf ("%sMax deep samples in any pixel : %llu\n", indent, (unsigned long long)maxsamples);
printf ("%sAverage deep samples per pixel: %.2f\n", indent, double(totalsamples)/double(npixels));
printf ("%sTotal deep samples in all pixels: %llu\n", indent, (unsigned long long)totalsamples);
printf ("%sPixels with deep samples : %llu\n", indent, (unsigned long long)(npixels-emptypixels));
printf ("%sPixels with no deep samples: %llu\n", indent, (unsigned long long)emptypixels);
} else {
std::vector<float> constantValues(input.spec().nchannels);
if (isConstantColor(input, &constantValues[0])) {
printf ("%sConstant: Yes\n", indent);
printf ("%sConstant Color: ", indent);
for (unsigned int i=0; i<constantValues.size(); ++i) {
print_stats_num (constantValues[i], maxval, false);
printf (" ");
}
print_stats_footer (maxval);
printf ("\n");
}
else {
printf ("%sConstant: No\n", indent);
}
if (isMonochrome(input)) {
printf ("%sMonochrome: Yes\n", indent);
} else {
printf ("%sMonochrome: No\n", indent);
}
}
}
