static bool
flatten_ (ImageBuf &dst, const ImageBuf &src,
ROI roi, int nthreads)
{
if (nthreads != 1 && roi.npixels() >= 1000) {
// Possible multiple thread case -- recurse via parallel_image
ImageBufAlgo::parallel_image (
boost::bind(flatten_<DSTTYPE>, boost::ref(dst), boost::cref(src),
_1 /*roi*/, 1 /*nthreads*/),
roi, nthreads);
return true;
}
const ImageSpec &srcspec (src.spec());
int nc = srcspec.nchannels;
int alpha_channel, RA_channel, GA_channel, BA_channel;
int R_channel, G_channel, B_channel;
int Z_channel, Zback_channel;
if (! find_deep_channels (srcspec, alpha_channel,
RA_channel, GA_channel, BA_channel,
R_channel, G_channel, B_channel,
Z_channel, Zback_channel)) {
dst.error ("No alpha channel could be identified");
return false;
}
ASSERT (alpha_channel >= 0 ||
(RA_channel >= 0 && GA_channel >= 0 && BA_channel >= 0));
float *val = ALLOCA (float, nc);
float &RAval (RA_channel >= 0 ? val[RA_channel] : val[alpha_channel]);
float &GAval (GA_channel >= 0 ? val[GA_channel] : val[alpha_channel]);
float &BAval (BA_channel >= 0 ? val[BA_channel] : val[alpha_channel]);
for (ImageBuf::Iterator<DSTTYPE> r (dst, roi); !r.done(); ++r) {
int x = r.x(), y = r.y(), z = r.z();
int samps = src.deep_samples (x, y, z);
// Clear accumulated values for this pixel (0 for colors, big for Z)
memset (val, 0, nc*sizeof(float));
if (Z_channel >= 0 && samps == 0)
val[Z_channel] = 1.0e30;
if (Zback_channel >= 0 && samps == 0)
val[Zback_channel] = 1.0e30;
for (int s = 0; s < samps; ++s) {
float RA = RAval, GA = GAval, BA = BAval; // make copies
float alpha = (RA + GA + BA) / 3.0f;
if (alpha >= 1.0f)
break;
for (int c = 0; c < nc; ++c) {
float v = src.deep_value (x, y, z, c, s);
if (c == Z_channel || c == Zback_channel)
val[c] *= alpha; // because Z are not premultiplied
float a;
if (c == R_channel)
a = RA;
else if (c == G_channel)
a = GA;
else if (c == B_channel)
a = BA;
else
a = alpha;
val[c] += (1.0f - a) * v;
}
}
for (int c = roi.chbegin; c < roi.chend; ++c)
r[c] = val[c];
}
return true;
}
static void
print_stats (Oiiotool &ot,
const std::string &filename,
const ImageSpec &originalspec,
int subimage=0, int miplevel=0, bool indentmip=false)
{
const char *indent = indentmip ? " " : " ";
ImageBuf input;
if (! read_input (filename, input, subimage, miplevel)) {
ot.error ("stats", input.geterror());
return;
}
PixelStats stats;
if (! computePixelStats (stats, input)) {
std::string err = input.geterror();
ot.error ("stats", Strutil::format ("unable to compute: %s",
err.empty() ? "unspecified error" : err.c_str()));
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();
size_t maxsamples_npixels = 0;
float mindepth = std::numeric_limits<float>::max();
float maxdepth = -std::numeric_limits<float>::max();
Imath::V3i maxsamples_pixel(-1,-1,-1), minsamples_pixel(-1,-1,-1);
Imath::V3i mindepth_pixel(-1,-1,-1), maxdepth_pixel(-1,-1,-1);
Imath::V3i nonfinite_pixel(-1,-1,-1);
int nonfinite_pixel_samp(-1), nonfinite_pixel_chan(-1);
size_t sampoffset = 0;
int nchannels = dd->channels();
int depthchannel = -1;
long long nonfinites = 0;
for (int c = 0; c < nchannels; ++c)
if (Strutil::iequals (originalspec.channelnames[c], "Z"))
depthchannel = c;
int xend = originalspec.x + originalspec.width;
int yend = originalspec.y + originalspec.height;
int zend = originalspec.z + originalspec.depth;
size_t p = 0;
std::vector<size_t> nsamples_histogram;
for (int z = originalspec.z; z < zend; ++z) {
for (int y = originalspec.y; y < yend; ++y) {
for (int x = originalspec.x; x < xend; ++x, ++p) {
size_t samples = input.deep_samples (x, y, z);
totalsamples += samples;
if (samples == maxsamples)
++maxsamples_npixels;
if (samples > maxsamples) {
maxsamples = samples;
maxsamples_pixel.setValue (x, y, z);
maxsamples_npixels = 1;
}
if (samples < minsamples)
minsamples = samples;
if (samples == 0)
++emptypixels;
if (samples >= nsamples_histogram.size())
nsamples_histogram.resize (samples+1, 0);
nsamples_histogram[samples] += 1;
for (unsigned int s = 0; s < samples; ++s) {
for (int c = 0; c < nchannels; ++c) {
float d = input.deep_value (x, y, z, c, s);
if (! isfinite(d)) {
if (nonfinites++ == 0) {
nonfinite_pixel.setValue (x, y, z);
nonfinite_pixel_samp = s;
nonfinite_pixel_chan = c;
}
}
if (depthchannel == c) {
if (d < mindepth) {
mindepth = d;
mindepth_pixel.setValue (x, y, z);
}
if (d > maxdepth) {
maxdepth = d;
maxdepth_pixel.setValue (x, y, z);
}
}
}
}
sampoffset += samples;
}
}
}
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 ("%s%llu pixel%s had the max of %llu samples, including (x=%d, y=%d)\n",
indent, (unsigned long long)maxsamples_npixels,
maxsamples_npixels > 1 ? "s" : "",
(unsigned long long)maxsamples,
maxsamples_pixel.x, maxsamples_pixel.y);
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);
printf ("%sSamples/pixel histogram:\n", indent);
size_t grandtotal = 0;
for (size_t i = 0, e = nsamples_histogram.size(); i < e; ++i)
grandtotal += nsamples_histogram[i];
size_t binstart = 0, bintotal = 0;
for (size_t i = 0, e = nsamples_histogram.size(); i < e; ++i) {
bintotal += nsamples_histogram[i];
if (i < 8 || i == (e-1) || OIIO::ispow2(i+1)) {
// batch by powers of 2, unless it's a small number
if (i == binstart)
printf ("%s %3lld ", indent, (long long)i);
else
printf ("%s %3lld-%3lld", indent,
(long long)binstart, (long long)i);
printf (" : %8lld (%4.1f%%)\n", (long long)bintotal,
(100.0*bintotal)/grandtotal);
binstart = i+1;
bintotal = 0;
}
}
if (depthchannel >= 0) {
printf ("%sMinimum depth was %g at (%d, %d)\n", indent, mindepth,
mindepth_pixel.x, mindepth_pixel.y);
printf ("%sMaximum depth was %g at (%d, %d)\n", indent, maxdepth,
maxdepth_pixel.x, maxdepth_pixel.y);
}
if (nonfinites > 0) {
printf ("%sNonfinite values: %lld, including (x=%d, y=%d, chan=%s, samp=%d)\n",
indent, nonfinites, nonfinite_pixel.x, nonfinite_pixel.y,
input.spec().channelnames[nonfinite_pixel_chan].c_str(),
nonfinite_pixel_samp);
}
} 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);
}
}
}
static void
print_stats (const std::string &filename,
const ImageSpec &originalspec,
int subimage=0, int miplevel=0, bool indentmip=false)
{
const char *indent = indentmip ? " " : " ";
ImageBuf input;
if (! read_input (filename, input, subimage, miplevel)) {
std::cerr << "Stats: read error: " << input.geterror() << "\n";
return;
}
PixelStats stats;
if (! computePixelStats (stats, input)) {
printf ("%sStats: (unable to compute)\n", indent);
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->nsamples.size();
size_t totalsamples = 0, emptypixels = 0;
size_t maxsamples = 0, minsamples = std::numeric_limits<size_t>::max();
size_t maxsamples_npixels = 0;
float mindepth = std::numeric_limits<float>::max();
float maxdepth = -std::numeric_limits<float>::max();
Imath::V3i maxsamples_pixel(-1,-1,-1), minsamples_pixel(-1,-1,-1);
Imath::V3i mindepth_pixel(-1,-1,-1), maxdepth_pixel(-1,-1,-1);
size_t sampoffset = 0;
int depthchannel = -1;
for (int c = 0; c < input.nchannels(); ++c)
if (Strutil::iequals (originalspec.channelnames[c], "Z"))
depthchannel = c;
int xend = originalspec.x + originalspec.width;
int yend = originalspec.y + originalspec.height;
int zend = originalspec.z + originalspec.depth;
size_t p = 0;
for (int z = originalspec.z; z < zend; ++z) {
for (int y = originalspec.y; y < yend; ++y) {
for (int x = originalspec.x; x < xend; ++x, ++p) {
size_t c = input.deep_samples (x, y, z);
totalsamples += c;
if (c == maxsamples)
++maxsamples_npixels;
if (c > maxsamples) {
maxsamples = c;
maxsamples_pixel.setValue (x, y, z);
maxsamples_npixels = 1;
}
if (c < minsamples)
minsamples = c;
if (c == 0)
++emptypixels;
if (depthchannel >= 0) {
for (unsigned int s = 0; s < c; ++s) {
float d = input.deep_value (x, y, z, depthchannel, s);
if (d < mindepth) {
mindepth = d;
mindepth_pixel.setValue (x, y, z);
}
if (d > maxdepth) {
maxdepth = d;
maxdepth_pixel.setValue (x, y, z);
}
}
}
sampoffset += c;
}
}
}
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 ("%s%llu pixel%s had the max of %llu samples, including (x=%d, y=%d)\n",
indent, (unsigned long long)maxsamples_npixels,
maxsamples_npixels > 1 ? "s" : "",
(unsigned long long)maxsamples,
maxsamples_pixel.x, maxsamples_pixel.y);
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);
printf ("%sMinimum depth was %g at (%d, %d)\n", indent, mindepth,
mindepth_pixel.x, mindepth_pixel.y);
printf ("%sMaximum depth was %g at (%d, %d)\n", indent, maxdepth,
maxdepth_pixel.x, maxdepth_pixel.y);
} 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);
}
}
}
