static void
time_read_64_scanlines_at_a_time ()
{
ImageInput *in = ImageInput::open (input_filename.c_str());
ASSERT (in);
const ImageSpec &spec (in->spec());
size_t pixelsize = spec.nchannels * sizeof(float);
imagesize_t scanlinesize = spec.width * pixelsize;
for (int y = 0; y < spec.height; y += 64) {
in->read_scanlines (y+spec.y, std::min(y+spec.y+64, spec.y+spec.height),
0, TypeDesc::TypeFloat, &buffer[scanlinesize*y]);
}
in->close ();
delete in;
}
/**
* @brief Read in images
* @details Read foregournd and background images into program.
*
* @param image Image name to read in.
*/
void readImage(char *image) {
// Open image input
ImageInput *in = ImageInput::open(image);
// Error handeling
if (!in) {
printf("Error reading image: %s\n", geterror().c_str());
exit(EXIT_FAILURE);
}
// Get input spec
const ImageSpec &spec = in->spec();
// Get image details
originalWidth = spec.width;
originalHeight = spec.height;
channels = spec.nchannels;
// Init the global copy of the pixels
// Read in the pixels and close the file
oiioPixels.resize(originalWidth*originalHeight*channels*sizeof(float));
in->read_image(TypeDesc::FLOAT, &oiioPixels[0]);
in->close();
delete in;
// Initalize 2d array
pixels = new rgba_pixel*[originalHeight];
pixels[0] = new rgba_pixel[originalWidth*originalHeight];
for (int i=1; i<originalHeight; i++) {
pixels[i] = pixels[i-1] + originalWidth;
}
// Transfer into custom data structure
for (int row = 0; row < originalHeight; row++)
for (int col = 0; col < originalWidth; col++){
pixels[row][col].r = oiioPixels[(row*originalWidth+col)*channels + 0];
pixels[row][col].g = oiioPixels[(row*originalWidth+col)*channels + 1];
pixels[row][col].b = oiioPixels[(row*originalWidth+col)*channels + 2];
if(channels == 4) pixels[row][col].a = oiioPixels[(row*originalWidth+col)*channels + 3];
else pixels[row][col].a = 1.0;
}
}
bool
OiioTool::print_info (Oiiotool &ot,
const std::string &filename,
const print_info_options &opt,
long long &totalsize,
std::string &error)
{
using Strutil::format;
error.clear();
ImageSpec *config = ot.input_config_set ? &ot.input_config : NULL;
ImageInput *input = ImageInput::open (filename.c_str(), config);
if (! input) {
error = geterror();
if (error.empty())
error = Strutil::format ("Could not open \"%s\"", filename);
return false;
}
ImageSpec spec = input->spec();
ImageSpec::SerialFormat serformat = ImageSpec::SerialText;
if (Strutil::iequals (opt.infoformat, "xml"))
serformat = ImageSpec::SerialXML;
ImageSpec::SerialVerbose verbose = opt.verbose ? ImageSpec::SerialDetailedHuman : ImageSpec::SerialBrief;
boost::regex field_re;
boost::regex field_exclude_re;
if (! opt.metamatch.empty()) {
try {
field_re.assign (opt.metamatch,
boost::regex::extended | boost::regex_constants::icase);
} catch (const std::exception &e) {
error = Strutil::format ("Regex error '%s' on metamatch regex \"%s\"",
e.what(), opt.metamatch);
return false;
}
}
if (! opt.nometamatch.empty()) {
try {
field_exclude_re.assign (opt.nometamatch,
boost::regex::extended | boost::regex_constants::icase);
} catch (const std::exception &e) {
error = Strutil::format ("Regex error '%s' on metamatch regex \"%s\"",
e.what(), opt.nometamatch);
return false;
}
}
// checking how many subimages and mipmap levels are stored in the file
std::vector<int> num_of_miplevels;
int num_of_subimages;
for (num_of_subimages = 0; input->seek_subimage (num_of_subimages, 0, spec); ++num_of_subimages) {
int nmip = 1;
while (input->seek_subimage (num_of_subimages, nmip, spec))
++nmip;
num_of_miplevels.push_back (nmip);
}
for (int current_subimage = 0; current_subimage < num_of_subimages; ++current_subimage) {
if ( ! input->seek_subimage (current_subimage, 0, spec) )
break;
print_info_subimage (ot, current_subimage, num_of_subimages,
num_of_miplevels[current_subimage],
spec, input, filename, opt,
field_re, field_exclude_re, serformat, verbose);
// if the '-a' flag is not set we print info
// about first subimage only
if ( ! opt.subimages)
break;
}
input->close ();
delete input;
return true;
}
bool
OiioTool::print_info (const std::string &filename,
const print_info_options &opt,
long long &totalsize,
std::string &error)
{
error.clear();
ImageInput *input = ImageInput::open (filename.c_str());
if (! input) {
error = geterror();
if (error.empty())
error = Strutil::format ("Could not open \"%s\"", filename.c_str());
return false;
}
ImageSpec spec = input->spec();
boost::regex field_re;
boost::regex field_exclude_re;
if (! opt.metamatch.empty()) {
try {
field_re.assign (opt.metamatch,
boost::regex::extended | boost::regex_constants::icase);
} catch (const std::exception &e) {
error = Strutil::format ("Regex error '%s' on metamatch regex \"%s\"",
e.what(), opt.metamatch);
return false;
}
}
if (! opt.nometamatch.empty()) {
try {
field_exclude_re.assign (opt.nometamatch,
boost::regex::extended | boost::regex_constants::icase);
} catch (const std::exception &e) {
error = Strutil::format ("Regex error '%s' on metamatch regex \"%s\"",
e.what(), opt.nometamatch);
return false;
}
}
int padlen = std::max (0, (int)opt.namefieldlength - (int)filename.length());
std::string padding (padlen, ' ');
// checking how many subimages and mipmap levels are stored in the file
int num_of_subimages = 1;
bool any_mipmapping = false;
std::vector<int> num_of_miplevels;
{
int nmip = 1;
while (input->seek_subimage (input->current_subimage(), nmip, spec)) {
++nmip;
any_mipmapping = true;
}
num_of_miplevels.push_back (nmip);
}
while (input->seek_subimage (num_of_subimages, 0, spec)) {
// maybe we should do this more gently?
++num_of_subimages;
int nmip = 1;
while (input->seek_subimage (input->current_subimage(), nmip, spec)) {
++nmip;
any_mipmapping = true;
}
num_of_miplevels.push_back (nmip);
}
input->seek_subimage (0, 0, spec); // re-seek to the first
if (opt.metamatch.empty() ||
boost::regex_search ("resolution, width, height, depth, channels", field_re)) {
printf ("%s%s : %4d x %4d", filename.c_str(), padding.c_str(),
spec.width, spec.height);
if (spec.depth > 1)
printf (" x %4d", spec.depth);
printf (", %d channel, ", spec.nchannels);
if (spec.channelformats.size()) {
for (size_t c = 0; c < spec.channelformats.size(); ++c)
printf ("%s%s", c ? "/" : "",
spec.channelformats[c].c_str());
} else {
int bits = spec.get_int_attribute ("oiio:BitsPerSample", 0);
printf ("%s", extended_format_name(spec.format, bits));
}
if (spec.depth > 1)
printf (" volume");
printf (" %s", input->format_name());
if (opt.sum) {
imagesize_t imagebytes = spec.image_bytes (true);
totalsize += imagebytes;
printf (" (%.2f MB)", (float)imagebytes / (1024.0*1024.0));
}
// we print info about how many subimages are stored in file
// only when we have more then one subimage
if ( ! opt.verbose && num_of_subimages != 1)
printf (" (%d subimages%s)", num_of_subimages,
any_mipmapping ? " +mipmap)" : "");
if (! opt.verbose && num_of_subimages == 1 && any_mipmapping)
printf (" (+mipmap)");
printf ("\n");
}
if (opt.verbose && num_of_subimages != 1) {
// info about num of subimages and their resolutions
printf (" %d subimages: ", num_of_subimages);
for (int i = 0; i < num_of_subimages; ++i) {
input->seek_subimage (i, 0, spec);
if (spec.depth > 1)
printf ("%dx%dx%d ", spec.width, spec.height, spec.depth);
else
printf ("%dx%d ", spec.width, spec.height);
}
printf ("\n");
}
// if the '-a' flag is not set we print info
// about first subimage only
if ( ! opt.subimages)
num_of_subimages = 1;
for (int i = 0; i < num_of_subimages; ++i) {
print_info_subimage (i, num_of_subimages, spec, input,
filename, opt, field_re, field_exclude_re);
}
input->close ();
delete input;
return true;
}
static bool
convert_file (const std::string &in_filename, const std::string &out_filename)
{
if (noclobber && Filesystem::exists(out_filename)) {
std::cerr << "iconvert ERROR: Output file already exists \""
<< out_filename << "\"\n";
return false;
}
if (verbose)
std::cout << "Converting " << in_filename << " to " << out_filename << "\n";
std::string tempname = out_filename;
if (tempname == in_filename) {
tempname = out_filename + ".tmp"
+ Filesystem::extension (out_filename);
}
// Find an ImageIO plugin that can open the input file, and open it.
ImageInput *in = ImageInput::open (in_filename.c_str());
if (! in) {
std::string err = geterror();
std::cerr << "iconvert ERROR: "
<< (err.length() ? err : Strutil::format("Could not open \"%s\"", in_filename))
<< "\n";
delete in;
return false;
}
ImageSpec inspec = in->spec();
std::string metadatatime = inspec.get_string_attribute ("DateTime");
// Find an ImageIO plugin that can open the output file, and open it
ImageOutput *out = ImageOutput::create (tempname.c_str());
if (! out) {
std::cerr
<< "iconvert ERROR: Could not find an ImageIO plugin to write \""
<< out_filename << "\" :" << geterror() << "\n";
delete in;
return false;
}
// In order to deal with formats that support subimages, but not
// subimage appending, we gather them all first.
std::vector<ImageSpec> subimagespecs;
if (out->supports("multiimage") && !out->supports("appendsubimage")) {
ImageCache *imagecache = ImageCache::create ();
int nsubimages = 0;
ustring ufilename (in_filename);
imagecache->get_image_info (ufilename, 0, 0, ustring("subimages"),
TypeDesc::TypeInt, &nsubimages);
if (nsubimages > 1) {
subimagespecs.resize (nsubimages);
for (int i = 0; i < nsubimages; ++i) {
ImageSpec inspec = *imagecache->imagespec (ufilename, i, 0,
true /*native*/);
subimagespecs[i] = inspec;
adjust_spec (in, out, inspec, subimagespecs[i]);
}
}
ImageCache::destroy (imagecache);
}
bool ok = true;
bool mip_to_subimage_warning = false;
for (int subimage = 0;
ok && in->seek_subimage(subimage,0,inspec);
++subimage) {
if (subimage > 0 && !out->supports ("multiimage")) {
std::cerr << "iconvert WARNING: " << out->format_name()
<< " does not support multiple subimages.\n";
std::cerr << "\tOnly the first subimage has been copied.\n";
break; // we're done
}
int miplevel = 0;
do {
// Copy the spec, with possible change in format
ImageSpec outspec = inspec;
bool nocopy = adjust_spec (in, out, inspec, outspec);
if (miplevel > 0) {
// Moving to next MIP level
ImageOutput::OpenMode mode;
if (out->supports ("mipmap"))
mode = ImageOutput::AppendMIPLevel;
else if (out->supports ("multiimage") &&
out->supports ("appendsubimage")) {
mode = ImageOutput::AppendSubimage; // use if we must
if (! mip_to_subimage_warning
&& strcmp(out->format_name(),"tiff")) {
std::cerr << "iconvert WARNING: " << out->format_name()
<< " does not support MIPmaps.\n";
std::cerr << "\tStoring the MIPmap levels in subimages.\n";
}
mip_to_subimage_warning = true;
} else {
std::cerr << "iconvert WARNING: " << out->format_name()
<< " does not support MIPmaps.\n";
std::cerr << "\tOnly the first level has been copied.\n";
break; // on to the next subimage
}
ok = out->open (tempname.c_str(), outspec, mode);
} else if (subimage > 0) {
// Moving to next subimage
ok = out->open (tempname.c_str(), outspec,
ImageOutput::AppendSubimage);
} else {
// First time opening
if (subimagespecs.size())
ok = out->open (tempname.c_str(), int(subimagespecs.size()),
&subimagespecs[0]);
else
ok = out->open (tempname.c_str(), outspec, ImageOutput::Create);
}
if (! ok) {
std::string err = out->geterror();
std::cerr << "iconvert ERROR: "
<< (err.length() ? err : Strutil::format("Could not open \"%s\"", out_filename))
<< "\n";
ok = false;
break;
}
if (! nocopy) {
ok = out->copy_image (in);
if (! ok)
std::cerr << "iconvert ERROR copying \"" << in_filename
<< "\" to \"" << out_filename << "\" :\n\t"
<< out->geterror() << "\n";
} else {
// Need to do it by hand for some reason. Future expansion in which
// only a subset of channels are copied, or some such.
std::vector<char> pixels ((size_t)outspec.image_bytes(true));
ok = in->read_image (outspec.format, &pixels[0]);
if (! ok) {
std::cerr << "iconvert ERROR reading \"" << in_filename
<< "\" : " << in->geterror() << "\n";
} else {
ok = out->write_image (outspec.format, &pixels[0]);
if (! ok)
std::cerr << "iconvert ERROR writing \"" << out_filename
<< "\" : " << out->geterror() << "\n";
}
}
++miplevel;
} while (ok && in->seek_subimage(subimage,miplevel,inspec));
}
out->close ();
delete out;
in->close ();
delete in;
// Figure out a time for the input file -- either one supplied by
// the metadata, or the actual time stamp of the input file.
std::time_t in_time;
if (metadatatime.empty() ||
! DateTime_to_time_t (metadatatime.c_str(), in_time))
in_time = Filesystem::last_write_time (in_filename);
if (out_filename != tempname) {
if (ok) {
Filesystem::remove (out_filename);
Filesystem::rename (tempname, out_filename);
}
else
Filesystem::remove (tempname);
}
// If user requested, try to adjust the file's modification time to
// the creation time indicated by the file's DateTime metadata.
if (ok && adjust_time)
Filesystem::last_write_time (out_filename, in_time);
return ok;
}
static void LoadTexture(std::string const& filename, Scene::Texture& texture, std::vector<std::unique_ptr<char[]> >& data)
{
OIIO_NAMESPACE_USING
ImageInput* input = ImageInput::open(filename);
if (!input)
{
throw std::runtime_error("Can't load " + filename + " image");
}
ImageSpec const& spec = input->spec();
texture.w = spec.width;
texture.h = spec.height;
texture.d = spec.depth;
texture.fmt = GetTextureForemat(spec);
// Save old size for reading offset
texture.dataoffset = (int)data.size();
if (texture.fmt == Scene::RGBA8)
{
texture.size = spec.width * spec.height * spec.depth * 4;
// Resize storage
std::unique_ptr<char[]> texturedata(new char[spec.width * spec.height * spec.depth * 4]);
// Read data to storage
input->read_image(TypeDesc::UINT8, texturedata.get(), sizeof(char) * 4);
// Close handle
input->close();
// Add to texture pool
data.push_back(std::move(texturedata));
}
else if (texture.fmt == Scene::RGBA16)
{
texture.size = spec.width * spec.height * spec.depth * sizeof(float) * 2;
// Resize storage
std::unique_ptr<char[]> texturedata(new char[spec.width * spec.height * spec.depth * sizeof(float) * 2]);
// Read data to storage
input->read_image(TypeDesc::HALF, texturedata.get(), sizeof(float) * 2);
// Close handle
input->close();
// Add to texture pool
data.push_back(std::move(texturedata));
}
else
{
texture.size = spec.width * spec.height * spec.depth * sizeof(float3);
// Resize storage
std::unique_ptr<char[]> texturedata(new char[spec.width * spec.height * spec.depth * sizeof(float3)]);
// Read data to storage
input->read_image(TypeDesc::FLOAT, texturedata.get(), sizeof(float3));
// Close handle
input->close();
// Add to texture pool
data.push_back(std::move(texturedata));
}
// Cleanup
delete input;
}
