bool ImageBufAlgo::ociofiletransform (ImageBuf &dst, const ImageBuf &src, string_view name, bool inverse, bool unpremult, ColorConfig *colorconfig, ROI roi, int nthreads) { if (name.empty()) { dst.error ("Unknown filetransform name"); return false; } ColorProcessor *processor = NULL; { spin_lock lock (colorconfig_mutex); if (! colorconfig) colorconfig = default_colorconfig.get(); if (! colorconfig) default_colorconfig.reset (colorconfig = new ColorConfig); processor = colorconfig->createFileTransform (name, inverse); if (! processor) { if (colorconfig->error()) dst.error ("%s", colorconfig->geterror()); else dst.error ("Could not construct the color transform"); return false; } } bool ok = colorconvert (dst, src, processor, unpremult, roi, nthreads); if (ok) dst.specmod().attribute ("oiio:ColorSpace", name); { spin_lock lock (colorconfig_mutex); colorconfig->deleteColorProcessor (processor); } return ok; }
bool ImageBufAlgo::cut (ImageBuf &dst, const ImageBuf &src, ROI roi, int nthreads) { bool ok = crop (dst, src, roi, nthreads); ASSERT(ok); if (! ok) return false; // Crop did the heavy lifting of copying the roi of pixels from src to // dst, but now we need to make it look like we cut that rectangle out // and repositioned it at the origin. dst.specmod().x = 0; dst.specmod().y = 0; dst.specmod().z = 0; dst.set_roi_full (dst.roi()); return true; }
bool ImageBufAlgo::ociolook (ImageBuf &dst, const ImageBuf &src, string_view looks, string_view from, string_view to, bool inverse, bool unpremult, string_view key, string_view value, ColorConfig *colorconfig, ROI roi, int nthreads) { if (from.empty() || from == "current") { from = src.spec().get_string_attribute ("oiio:Colorspace", "Linear"); } if (to.empty() || to == "current") { to = src.spec().get_string_attribute ("oiio:Colorspace", "Linear"); } if (from.empty() || to.empty()) { dst.error ("Unknown color space name"); return false; } ColorProcessor *processor = NULL; { spin_lock lock (colorconfig_mutex); if (! colorconfig) colorconfig = default_colorconfig.get(); if (! colorconfig) default_colorconfig.reset (colorconfig = new ColorConfig); processor = colorconfig->createLookTransform (looks, from, to, inverse, key, value); if (! processor) { if (colorconfig->error()) dst.error ("%s", colorconfig->geterror()); else dst.error ("Could not construct the color transform"); return false; } } bool ok = colorconvert (dst, src, processor, unpremult, roi, nthreads); if (ok) dst.specmod().attribute ("oiio:ColorSpace", to); { spin_lock lock (colorconfig_mutex); colorconfig->deleteColorProcessor (processor); } return ok; }
bool ImageBufAlgo::capture_image (ImageBuf &dst, int cameranum, TypeDesc convert) { #ifdef USE_OPENCV IplImage *frame = NULL; { // This block is mutex-protected lock_guard lock (opencv_mutex); CvCapture *cvcam = cameras[cameranum]; if (! cvcam) { dst.error ("Could not create a capture camera (OpenCV error)"); return false; // failed somehow } frame = cvQueryFrame (cvcam); if (! frame) { dst.error ("Could not cvQueryFrame (OpenCV error)"); return false; // failed somehow } } time_t now; time (&now); struct tm tmtime; Sysutil::get_local_time (&now, &tmtime); std::string datetime = Strutil::format ("%4d:%02d:%02d %02d:%02d:%02d", tmtime.tm_year+1900, tmtime.tm_mon+1, tmtime.tm_mday, tmtime.tm_hour, tmtime.tm_min, tmtime.tm_sec); bool ok = ImageBufAlgo::from_IplImage (dst, frame, convert); // cvReleaseImage (&frame); // unnecessary? if (ok) dst.specmod().attribute ("DateTime", datetime); return ok; #else dst.error ("capture_image not supported -- no OpenCV support at compile time"); return false; #endif }
bool ImageRec::read (ReadPolicy readpolicy) { if (elaborated()) return true; static ustring u_subimages("subimages"), u_miplevels("miplevels"); static boost::regex regex_sha ("SHA-1=[[:xdigit:]]*[ ]*"); int subimages = 0; ustring uname (name()); if (! m_imagecache->get_image_info (uname, 0, 0, u_subimages, TypeDesc::TypeInt, &subimages)) { error ("file not found: \"%s\"", name()); return false; // Image not found } m_subimages.resize (subimages); bool allok = true; for (int s = 0; s < subimages; ++s) { int miplevels = 0; m_imagecache->get_image_info (uname, s, 0, u_miplevels, TypeDesc::TypeInt, &miplevels); m_subimages[s].m_miplevels.resize (miplevels); m_subimages[s].m_specs.resize (miplevels); for (int m = 0; m < miplevels; ++m) { // Force a read now for reasonable-sized first images in the // file. This can greatly speed up the multithread case for // tiled images by not having multiple threads working on the // same image lock against each other on the file handle. // We guess that "reasonable size" is 50 MB, that's enough to // hold a 2048x1536 RGBA float image. Larger things will // simply fall back on ImageCache. bool forceread = (s == 0 && m == 0 && m_imagecache->imagespec(uname,s,m)->image_bytes() < 50*1024*1024); ImageBuf *ib = new ImageBuf (name(), m_imagecache); // If we were requested to bypass the cache, force a full read. if (readpolicy & ReadNoCache) forceread = true; // Convert to float unless asked to keep native. TypeDesc convert = (readpolicy & ReadNative) ? ib->nativespec().format : TypeDesc::FLOAT; if (! forceread && convert != TypeDesc::UINT8 && convert != TypeDesc::UINT16 && convert != TypeDesc::HALF && convert != TypeDesc::FLOAT) { // If we're still trying to use the cache but it doesn't // support the native type, force a full read. forceread = true; } bool ok = ib->read (s, m, forceread, convert); if (!ok) error ("%s", ib->geterror()); allok &= ok; // Remove any existing SHA-1 hash from the spec. ib->specmod().erase_attribute ("oiio:SHA-1"); std::string desc = ib->spec().get_string_attribute ("ImageDescription"); if (desc.size()) ib->specmod().attribute ("ImageDescription", boost::regex_replace (desc, regex_sha, "")); m_subimages[s].m_miplevels[m].reset (ib); m_subimages[s].m_specs[m] = ib->spec(); // For ImageRec purposes, we need to restore a few of the // native settings. const ImageSpec &nativespec (ib->nativespec()); // m_subimages[s].m_specs[m].format = nativespec.format; m_subimages[s].m_specs[m].tile_width = nativespec.tile_width; m_subimages[s].m_specs[m].tile_height = nativespec.tile_height; m_subimages[s].m_specs[m].tile_depth = nativespec.tile_depth; } } m_time = Filesystem::last_write_time (name()); m_elaborated = true; return allok; }
bool ImageBufAlgo::make_texture (ImageBufAlgo::MakeTextureMode mode, const std::vector<std::string> &filenames, const std::string &_outputfilename, const ImageSpec &_configspec, std::ostream *outstream_ptr) { ASSERT (mode >= 0 && mode < ImageBufAlgo::_MakeTxLast); Timer alltime; ImageSpec configspec = _configspec; // const char *modenames[] = { "texture map", "shadow map", // "latlong environment map" }; std::stringstream localstream; // catch output when user doesn't want it std::ostream &outstream (outstream_ptr ? *outstream_ptr : localstream); double stat_readtime = 0; double stat_writetime = 0; double stat_resizetime = 0; double stat_miptime = 0; double stat_colorconverttime = 0; std::string filename = filenames[0]; if (! Filesystem::exists (filename)) { outstream << "maketx ERROR: \"" << filename << "\" does not exist\n"; return false; } std::string outputfilename = _outputfilename.length() ? _outputfilename : Filesystem::replace_extension (filename, ".tx"); // When was the input file last modified? std::time_t in_time = Filesystem::last_write_time (filename); // When in update mode, skip making the texture if the output already // exists and has the same file modification time as the input file. bool updatemode = configspec.get_int_attribute ("maketx:updatemode"); if (updatemode && Filesystem::exists (outputfilename) && (in_time == Filesystem::last_write_time (outputfilename))) { outstream << "maketx: no update required for \"" << outputfilename << "\"\n"; return true; } bool shadowmode = (mode == ImageBufAlgo::MakeTxShadow); bool envlatlmode = (mode == ImageBufAlgo::MakeTxEnvLatl); // Find an ImageIO plugin that can open the output file, and open it std::string outformat = configspec.get_string_attribute ("maketx:fileformatname", outputfilename); ImageOutput *out = ImageOutput::create (outformat.c_str()); if (! out) { outstream << "maketx ERROR: Could not find an ImageIO plugin to write " << outformat << " files:" << geterror() << "\n"; return false; } if (! out->supports ("tiles")) { outstream << "maketx ERROR: \"" << outputfilename << "\" format does not support tiled images\n"; return false; } ImageBuf src (filename); src.init_spec (filename, 0, 0); // force it to get the spec, not read // The cache might mess with the apparent data format. But for the // purposes of what we should output, figure it out now, before the // file has been read and cached. TypeDesc out_dataformat = src.spec().format; if (configspec.format != TypeDesc::UNKNOWN) out_dataformat = configspec.format; // We cannot compute the prman / oiio options until after out_dataformat // has been determined, as it's required (and can potentially change // out_dataformat too!) if (configspec.get_int_attribute("maketx:prman_options")) out_dataformat = set_prman_options (out_dataformat, configspec); else if (configspec.get_int_attribute("maketx:oiio_options")) out_dataformat = set_oiio_options (out_dataformat, configspec); // Read the full file locally if it's less than 1 GB, otherwise // allow the ImageBuf to use ImageCache to manage memory. bool read_local = (src.spec().image_bytes() < size_t(1024*1024*1024)); bool verbose = configspec.get_int_attribute ("maketx:verbose"); if (verbose) outstream << "Reading file: " << filename << std::endl; Timer readtimer; if (! src.read (0, 0, read_local)) { outstream << "maketx ERROR: Could not read \"" << filename << "\" : " << src.geterror() << "\n"; return false; } stat_readtime += readtimer(); // If requested - and we're a constant color - make a tiny texture instead // Only safe if the full/display window is the same as the data window. // Also note that this could affect the appearance when using "black" // wrap mode at runtime. std::vector<float> constantColor(src.nchannels()); bool isConstantColor = false; if (configspec.get_int_attribute("maketx:constant_color_detect") && src.spec().x == 0 && src.spec().y == 0 && src.spec().z == 0 && src.spec().full_x == 0 && src.spec().full_y == 0 && src.spec().full_z == 0 && src.spec().full_width == src.spec().width && src.spec().full_height == src.spec().height && src.spec().full_depth == src.spec().depth) { isConstantColor = ImageBufAlgo::isConstantColor (src, &constantColor[0]); if (isConstantColor) { // Reset the image, to a new image, at the tile size ImageSpec newspec = src.spec(); newspec.width = std::min (configspec.tile_width, src.spec().width); newspec.height = std::min (configspec.tile_height, src.spec().height); newspec.depth = std::min (configspec.tile_depth, src.spec().depth); newspec.full_width = newspec.width; newspec.full_height = newspec.height; newspec.full_depth = newspec.depth; std::string name = src.name() + ".constant_color"; src.reset(name, newspec); ImageBufAlgo::fill (src, &constantColor[0]); if (verbose) { outstream << " Constant color image detected. "; outstream << "Creating " << newspec.width << "x" << newspec.height << " texture instead.\n"; } } } int nchannels = configspec.get_int_attribute ("maketx:nchannels", -1); // If requested -- and alpha is 1.0 everywhere -- drop it. if (configspec.get_int_attribute("maketx:opaque_detect") && src.spec().alpha_channel == src.nchannels()-1 && nchannels <= 0 && ImageBufAlgo::isConstantChannel(src,src.spec().alpha_channel,1.0f)) { ImageBuf newsrc(src.name() + ".noalpha", src.spec()); ImageBufAlgo::setNumChannels (newsrc, src, src.nchannels()-1); src.copy (newsrc); if (verbose) { outstream << " Alpha==1 image detected. Dropping the alpha channel.\n"; } } // If requested - and we're a monochrome image - drop the extra channels if (configspec.get_int_attribute("maketx:monochrome_detect") && nchannels <= 0 && src.nchannels() == 3 && src.spec().alpha_channel < 0 && // RGB only ImageBufAlgo::isMonochrome(src)) { ImageBuf newsrc(src.name() + ".monochrome", src.spec()); ImageBufAlgo::setNumChannels (newsrc, src, 1); src.copy (newsrc); if (verbose) { outstream << " Monochrome image detected. Converting to single channel texture.\n"; } } // If we've otherwise explicitly requested to write out a // specific number of channels, do it. if ((nchannels > 0) && (nchannels != src.nchannels())) { ImageBuf newsrc(src.name() + ".channels", src.spec()); ImageBufAlgo::setNumChannels (newsrc, src, nchannels); src.copy (newsrc); if (verbose) { outstream << " Overriding number of channels to " << nchannels << "\n"; } } if (shadowmode) { // Some special checks for shadow maps if (src.spec().nchannels != 1) { outstream << "maketx ERROR: shadow maps require 1-channel images,\n" << "\t\"" << filename << "\" is " << src.spec().nchannels << " channels\n"; return false; } // Shadow maps only make sense for floating-point data. if (out_dataformat != TypeDesc::FLOAT && out_dataformat != TypeDesc::HALF && out_dataformat != TypeDesc::DOUBLE) out_dataformat = TypeDesc::FLOAT; } if (configspec.get_int_attribute("maketx:set_full_to_pixels")) { // User requested that we treat the image as uncropped or not // overscan ImageSpec &spec (src.specmod()); spec.full_x = spec.x = 0; spec.full_y = spec.y = 0; spec.full_z = spec.z = 0; spec.full_width = spec.width; spec.full_height = spec.height; spec.full_depth = spec.depth; } // Copy the input spec const ImageSpec &srcspec = src.spec(); ImageSpec dstspec = srcspec; bool orig_was_volume = srcspec.depth > 1 || srcspec.full_depth > 1; bool orig_was_crop = (srcspec.x > srcspec.full_x || srcspec.y > srcspec.full_y || srcspec.z > srcspec.full_z || srcspec.x+srcspec.width < srcspec.full_x+srcspec.full_width || srcspec.y+srcspec.height < srcspec.full_y+srcspec.full_height || srcspec.z+srcspec.depth < srcspec.full_z+srcspec.full_depth); bool orig_was_overscan = (srcspec.x < srcspec.full_x && srcspec.y < srcspec.full_y && srcspec.x+srcspec.width > srcspec.full_x+srcspec.full_width && srcspec.y+srcspec.height > srcspec.full_y+srcspec.full_height && (!orig_was_volume || (srcspec.z < srcspec.full_z && srcspec.z+srcspec.depth > srcspec.full_z+srcspec.full_depth))); // Make the output not a crop window if (orig_was_crop) { dstspec.x = 0; dstspec.y = 0; dstspec.z = 0; dstspec.width = srcspec.full_width; dstspec.height = srcspec.full_height; dstspec.depth = srcspec.full_depth; dstspec.full_x = 0; dstspec.full_y = 0; dstspec.full_z = 0; dstspec.full_width = dstspec.width; dstspec.full_height = dstspec.height; dstspec.full_depth = dstspec.depth; } if (orig_was_overscan) configspec.attribute ("wrapmodes", "black,black"); if ((dstspec.x < 0 || dstspec.y < 0 || dstspec.z < 0) && (out && !out->supports("negativeorigin"))) { // User passed negative origin but the output format doesn't // support it. Try to salvage the situation by shifting the // image into the positive range. if (dstspec.x < 0) { dstspec.full_x -= dstspec.x; dstspec.x = 0; } if (dstspec.y < 0) { dstspec.full_y -= dstspec.y; dstspec.y = 0; } if (dstspec.z < 0) { dstspec.full_z -= dstspec.z; dstspec.z = 0; } } // Make the output tiled, regardless of input dstspec.tile_width = configspec.tile_width ? configspec.tile_width : 64; dstspec.tile_height = configspec.tile_height ? configspec.tile_height : 64; dstspec.tile_depth = configspec.tile_depth ? configspec.tile_depth : 1; // Try to force zip (still can be overriden by configspec dstspec.attribute ("compression", "zip"); // Always prefer contiguous channels, unless overridden by configspec dstspec.attribute ("planarconfig", "contig"); // Default to black wrap mode, unless overridden by configspec dstspec.attribute ("wrapmodes", "black,black"); if (configspec.get_int_attribute ("maketx:ignore_unassoc")) dstspec.erase_attribute ("oiio:UnassociatedAlpha"); // Put a DateTime in the out file, either now, or matching the date // stamp of the input file (if update mode). time_t date; if (updatemode) date = in_time; // update mode: use the time stamp of the input else time (&date); // not update: get the time now dstspec.attribute ("DateTime", datestring(date)); std::string cmdline = configspec.get_string_attribute ("maketx:full_command_line"); if (! cmdline.empty()) { // Append command to image history std::string history = dstspec.get_string_attribute ("Exif:ImageHistory"); if (history.length() && ! Strutil::iends_with (history, "\n")) history += std::string("\n"); history += cmdline; dstspec.attribute ("Exif:ImageHistory", history); } bool prman_metadata = configspec.get_int_attribute ("maketx:prman_metadata"); if (shadowmode) { dstspec.attribute ("textureformat", "Shadow"); if (prman_metadata) dstspec.attribute ("PixarTextureFormat", "Shadow"); } else if (envlatlmode) { dstspec.attribute ("textureformat", "LatLong Environment"); configspec.attribute ("wrapmodes", "periodic,clamp"); if (prman_metadata) dstspec.attribute ("PixarTextureFormat", "Latlong Environment"); } else { dstspec.attribute ("textureformat", "Plain Texture"); if (prman_metadata) dstspec.attribute ("PixarTextureFormat", "Plain Texture"); } // FIXME -- should we allow tile sizes to reduce if the image is // smaller than the tile size? And when we do, should we also try // to make it bigger in the other direction to make the total tile // size more constant? // If --checknan was used and it's a floating point image, check for // nonfinite (NaN or Inf) values and abort if they are found. if (configspec.get_int_attribute("maketx:checknan") && (srcspec.format.basetype == TypeDesc::FLOAT || srcspec.format.basetype == TypeDesc::HALF || srcspec.format.basetype == TypeDesc::DOUBLE)) { int found_nonfinite = 0; ImageBufAlgo::parallel_image (boost::bind(check_nan_block, &src, _1, boost::ref(found_nonfinite)), OIIO::get_roi(dstspec)); if (found_nonfinite) { if (found_nonfinite > 3) outstream << "maketx ERROR: ...and Nan/Inf at " << (found_nonfinite-3) << " other pixels\n"; return false; } } // Fix nans/infs (if requested ImageBufAlgo::NonFiniteFixMode fixmode = ImageBufAlgo::NONFINITE_NONE; std::string fixnan = configspec.get_string_attribute("maketx:fixnan"); if (fixnan.empty() || fixnan == "none") { } else if (fixnan == "black") { fixmode = ImageBufAlgo::NONFINITE_BLACK; } else if (fixnan == "box3") { fixmode = ImageBufAlgo::NONFINITE_BOX3; } else { outstream << "maketx ERROR: Unknown --fixnan mode " << " fixnan\n"; return false; } int pixelsFixed = 0; if (!ImageBufAlgo::fixNonFinite (src, src, fixmode, &pixelsFixed)) { outstream << "maketx ERROR: Error fixing nans/infs.\n"; return false; } if (verbose && pixelsFixed>0) { outstream << " Warning: " << pixelsFixed << " nan/inf pixels fixed.\n"; } // Color convert the pixels, if needed, in place. If a color // conversion is required we will promote the src to floating point // (or there wont be enough precision potentially). Also, // independently color convert the constant color metadata ImageBuf * ccSrc = &src; // Ptr to cc'd src image ImageBuf colorBuffer; std::string incolorspace = configspec.get_string_attribute ("incolorspace"); std::string outcolorspace = configspec.get_string_attribute ("outcolorspace"); if (!incolorspace.empty() && !outcolorspace.empty() && incolorspace != outcolorspace) { if (src.spec().format != TypeDesc::FLOAT) { ImageSpec floatSpec = src.spec(); floatSpec.set_format(TypeDesc::FLOAT); colorBuffer.reset("bitdepth promoted", floatSpec); ccSrc = &colorBuffer; } Timer colorconverttimer; ColorConfig colorconfig; if (verbose) { outstream << " Converting from colorspace " << incolorspace << " to colorspace " << outcolorspace << std::endl; } if (colorconfig.error()) { outstream << "Error Creating ColorConfig\n"; outstream << colorconfig.geterror() << std::endl; return false; } ColorProcessor * processor = colorconfig.createColorProcessor ( incolorspace.c_str(), outcolorspace.c_str()); if (!processor || colorconfig.error()) { outstream << "Error Creating Color Processor." << std::endl; outstream << colorconfig.geterror() << std::endl; return false; } bool unpremult = configspec.get_int_attribute ("maketx:unpremult"); if (unpremult && verbose) outstream << " Unpremulting image..." << std::endl; if (!ImageBufAlgo::colorconvert (*ccSrc, src, processor, unpremult)) { outstream << "Error applying color conversion to image.\n"; return false; } if (isConstantColor) { if (!ImageBufAlgo::colorconvert (&constantColor[0], static_cast<int>(constantColor.size()), processor, unpremult)) { outstream << "Error applying color conversion to constant color.\n"; return false; } } ColorConfig::deleteColorProcessor(processor); processor = NULL; stat_colorconverttime += colorconverttimer(); } // Force float for the sake of the ImageBuf math dstspec.set_format (TypeDesc::FLOAT); // Handle resize to power of two, if called for if (configspec.get_int_attribute("maketx:resize") && ! shadowmode) { dstspec.width = pow2roundup (dstspec.width); dstspec.height = pow2roundup (dstspec.height); dstspec.full_width = dstspec.width; dstspec.full_height = dstspec.height; } bool do_resize = false; // Resize if we're up-resing for pow2 if (dstspec.width != srcspec.width || dstspec.height != srcspec.height || dstspec.full_depth != srcspec.full_depth) do_resize = true; // resize if the original was a crop if (orig_was_crop) do_resize = true; // resize if we're converting from non-border sampling to border sampling // (converting TO an OpenEXR environment map). if (envlatlmode && (Strutil::iequals(configspec.get_string_attribute("maketx:fileformatname"),"openexr") || Strutil::iends_with(outputfilename,".exr"))) do_resize = true; if (do_resize && orig_was_overscan && out && !out->supports("displaywindow")) { outstream << "maketx ERROR: format " << out->format_name() << " does not support separate display windows,\n" << " which is necessary when combining resizing" << " and an input image with overscan."; return false; } std::string filtername = configspec.get_string_attribute ("maketx:filtername", "box"); Filter2D *filter = setup_filter (filtername); if (! filter) { outstream << "maketx ERROR: could not make filter '" << filtername << "\n"; return false; } Timer resizetimer; ImageBuf dst ("temp", dstspec); ImageBuf *toplevel = &dst; // Ptr to top level of mipmap if (! do_resize) { // Don't need to resize if (dstspec.format == ccSrc->spec().format) { // Even more special case, no format change -- just use // the original copy. toplevel = ccSrc; } else { ImageBufAlgo::parallel_image (boost::bind(copy_block,&dst,ccSrc,_1), OIIO::get_roi(dstspec)); } } else { // Resize if (verbose) outstream << " Resizing image to " << dstspec.width << " x " << dstspec.height << std::endl; if (filtername == "box" && filter->width() == 1.0f) ImageBufAlgo::parallel_image (boost::bind(resize_block, &dst, ccSrc, _1, envlatlmode), OIIO::get_roi(dstspec)); else ImageBufAlgo::parallel_image (boost::bind(resize_block_HQ, &dst, ccSrc, _1, filter), OIIO::get_roi(dstspec)); } stat_resizetime += resizetimer(); // Update the toplevel ImageDescription with the sha1 pixel hash and constant color std::string desc = dstspec.get_string_attribute ("ImageDescription"); bool updatedDesc = false; // Eliminate any SHA-1 or ConstantColor hints in the ImageDescription. if (desc.size()) { desc = boost::regex_replace (desc, boost::regex("SHA-1=[[:xdigit:]]*[ ]*"), ""); static const char *fp_number_pattern = "([+-]?((?:(?:[[:digit:]]*\\.)?[[:digit:]]+(?:[eE][+-]?[[:digit:]]+)?)))"; const std::string color_pattern = std::string ("ConstantColor=(\\[?") + fp_number_pattern + ",?)+\\]?[ ]*"; desc = boost::regex_replace (desc, boost::regex(color_pattern), ""); updatedDesc = true; } // The hash is only computed for the top mipmap level of pixel data. // Thus, any additional information that will effect the lower levels // (such as filtering information) needs to be manually added into the // hash. std::ostringstream addlHashData; addlHashData << filter->name() << " "; addlHashData << filter->width() << " "; std::string hash_digest = ImageBufAlgo::computePixelHashSHA1 (*toplevel, addlHashData.str()); if (hash_digest.length()) { if (desc.length()) desc += " "; desc += "SHA-1="; desc += hash_digest; if (verbose) outstream << " SHA-1: " << hash_digest << std::endl; updatedDesc = true; dstspec.attribute ("oiio:SHA-1", hash_digest); } if (isConstantColor) { std::ostringstream os; // Emulate a JSON array os << "["; for (unsigned int i=0; i<constantColor.size(); ++i) { if (i!=0) os << ","; os << constantColor[i]; } os << "]"; if (desc.length()) desc += " "; desc += "ConstantColor="; desc += os.str(); if (verbose) outstream << " ConstantColor: " << os.str() << std::endl; updatedDesc = true; dstspec.attribute ("oiio:ConstantColor", os.str()); } if (updatedDesc) { dstspec.attribute ("ImageDescription", desc); } if (configspec.get_float_attribute("fovcot") == 0.0f) configspec.attribute("fovcot", float(srcspec.full_width) / float(srcspec.full_height)); maketx_merge_spec (dstspec, configspec); // Write out, and compute, the mipmap levels for the speicifed image bool nomipmap = configspec.get_int_attribute ("maketx:nomipmap"); bool ok = write_mipmap (mode, *toplevel, dstspec, outputfilename, out, out_dataformat, !shadowmode && !nomipmap, filter, configspec, outstream, stat_writetime, stat_miptime); delete out; // don't need it any more // If using update mode, stamp the output file with a modification time // matching that of the input file. if (ok && updatemode) Filesystem::last_write_time (outputfilename, in_time); Filter2D::destroy (filter); if (verbose || configspec.get_int_attribute("maketx:stats")) { double all = alltime(); outstream << Strutil::format ("maketx run time (seconds): %5.2f\n", all);; outstream << Strutil::format (" file read: %5.2f\n", stat_readtime); outstream << Strutil::format (" file write: %5.2f\n", stat_writetime); outstream << Strutil::format (" initial resize: %5.2f\n", stat_resizetime); outstream << Strutil::format (" mip computation: %5.2f\n", stat_miptime); outstream << Strutil::format (" color convert: %5.2f\n", stat_colorconverttime); outstream << Strutil::format (" unaccounted: %5.2f\n", all-stat_readtime-stat_writetime-stat_resizetime-stat_miptime); size_t kb = Sysutil::memory_used(true) / 1024; outstream << Strutil::format ("maketx memory used: %5.1f MB\n", (double)kb/1024.0); } return ok; }
bool SMF::saveGrass() { if( verbose )cout << "INFO: saveGrass\n"; SMFEHGrass *grassHeader = NULL; for( unsigned int i = 0; i < extraHeaders.size(); ++i ) { if( extraHeaders[ i ]->type == 1 ) grassHeader = reinterpret_cast<SMFEHGrass *>( extraHeaders[ i ] ); } if( !grassHeader )return true; ImageBuf *imageBuf = NULL; ROI roi( 0, width * 16, 0, length * 16, 0, 1, 0, 1); ImageSpec imageSpec(roi.xend, roi.yend, roi.chend, TypeDesc::UINT8 ); if( is_smf(grassFile) ) { // Load from SMF SMF sourcesmf(grassFile); imageBuf = sourcesmf.getGrass(); } if( !imageBuf ) { // Load image file imageBuf = new ImageBuf( grassFile ); imageBuf->read( 0, 0, false, TypeDesc::UINT8 ); if( imageBuf->initialized() ) { delete imageBuf; imageBuf = NULL; } } if( !imageBuf ) { // Generate blank imageBuf = new ImageBuf( "grass", imageSpec ); } imageSpec = imageBuf->specmod(); ImageBuf fixBuf; // Fix the number of channels if( imageSpec.nchannels != roi.chend ) { int map[] = {0}; ImageBufAlgo::channels(fixBuf, *imageBuf, roi.chend, map ); imageBuf->copy( fixBuf ); fixBuf.clear(); } // Fix the Dimensions if ( imageSpec.width != roi.xend || imageSpec.height != roi.yend ) { if( verbose ) printf( "\tWARNING: %s is (%i,%i), wanted (%i, %i) Resampling.\n", typeFile.c_str(), imageSpec.width, imageSpec.height, roi.xend, roi.yend); ImageBufAlgo::resample(fixBuf, *imageBuf, false, roi); imageBuf->copy( fixBuf ); fixBuf.clear(); } unsigned char *pixels = (unsigned char *)imageBuf->localpixels(); char filename[256]; sprintf( filename, "%s.smf", outPrefix.c_str() ); if( verbose )printf( " Source: %s.\n", grassFile.c_str() ); fstream smf(filename, ios::binary | ios::in | ios::out); smf.seekp(grassHeader->grassPtr); smf.write( (char *)pixels, imageBuf->spec().image_bytes() ); smf.close(); delete imageBuf; if( is_smf( grassFile ) ) delete [] pixels; return false; }
bool SMF::saveTilemap() { if( verbose )cout << "INFO: saveTilemap\n"; char filename[256]; sprintf( filename, "%s.smf", outPrefix.c_str() ); fstream smf(filename, ios::binary | ios::in | ios::out); smf.seekp(tilesPtr); // Tiles Header int nTileFiles = smtList.size(); smf.write( (char *)&nTileFiles, 4); smf.write( (char *)&nTiles, 4); if(verbose)printf( " %i tiles referenced in %i files\n", nTiles, nTileFiles ); // SMT Names for(unsigned int i = 0; i < smtList.size(); ++i) { if( verbose )printf( "\t%i %s\n", smtTiles[i], smtList[i].c_str() ); smf.write( (char *)&smtTiles[i], 4); smf.write( smtList[i].c_str(), smtList[i].size() +1 ); } // Dimensions of displacement map. ImageBuf *imageBuf = NULL; ROI roi( 0, width * 16, // xbegin, xend 0, length * 16, // ybegin, yend 0, 1, // zbegin, zend 0, 1); // chbegin, chend ImageSpec imageSpec( roi.xend, roi.yend, roi.chend, TypeDesc::UINT ); if( is_smf(tilemapFile) ) { // Load from SMF SMF sourcesmf(tilemapFile); imageBuf = sourcesmf.getTilemap(); } if( !imageBuf ) { // load image file imageBuf = new ImageBuf( tilemapFile ); imageBuf->read( 0, 0, false, TypeDesc::UINT ); if( !imageBuf->initialized() ) { delete imageBuf; imageBuf = NULL; } } if( !imageBuf ) { // Generate blank imageBuf = new ImageBuf( "tilemap", imageSpec ); for ( unsigned int i = 0; i < imageSpec.image_pixels(); ++i ) ((unsigned int *)imageBuf->localpixels())[ i ] = i; } imageSpec = imageBuf->specmod(); ImageBuf fixBuf; // Fix the number of channels if( imageSpec.nchannels != roi.chend ) { int map[] = {0}; ImageBufAlgo::channels(fixBuf, *imageBuf, roi.chend, map); imageBuf->copy(fixBuf); fixBuf.clear(); } // Fix the size // FIXME image should never be resized, instead tiling either from an edge or centred. if ( imageSpec.width != roi.xend || imageSpec.height != roi.yend ) { if( verbose ) printf( "\tWARNING: %s is (%i,%i), wanted (%i, %i), Resampling.\n", tilemapFile.c_str(), imageSpec.width, imageSpec.height, roi.xend, roi.yend ); ImageBufAlgo::resample(fixBuf, *imageBuf, false, roi); imageBuf->copy(fixBuf); fixBuf.clear(); } unsigned int *pixels = (unsigned int *)imageBuf->localpixels(); // write the data to the smf smf.write( (char *)pixels, imageBuf->spec().image_bytes() ); smf.close(); delete imageBuf; if( is_smf( tilemapFile ) ) delete [] pixels; return false; }
bool SMF::saveMetal() { if( verbose )cout << "INFO: saveMetal\n"; // Dimensions of displacement map. ImageBuf *imageBuf = NULL; ROI roi( 0, width * 32, // xbegin, xend 0, length * 32, // ybegin, yend 0, 1, // zbegin, zend 0, 1); // chbegin, chend ImageSpec imageSpec( roi.xend, roi.yend, roi.chend, TypeDesc::UINT8 ); if( is_smf(metalFile) ) { // Load from smf SMF sourcesmf(metalFile); imageBuf = sourcesmf.getMetal(); } if( !imageBuf ) { //load from image imageBuf = new ImageBuf(metalFile); imageBuf->read( 0, 0, false, TypeDesc::UINT8 ); if( !imageBuf->initialized() ) { delete imageBuf; imageBuf = NULL; } } if( !imageBuf ) { // Generate blank imageBuf = new ImageBuf( "metal", imageSpec ); } imageSpec = imageBuf->specmod(); ImageBuf fixBuf; // Fix the number of channels if( imageSpec.nchannels != roi.chend ) { int map[] = {0}; ImageBufAlgo::channels(fixBuf, *imageBuf, roi.chend, map); imageBuf->copy(fixBuf); fixBuf.clear(); } // Fix the size if ( imageSpec.width != roi.xend || imageSpec.height != roi.yend ) { if( verbose ) printf( "\tWARNING: %s is (%i,%i), wanted (%i, %i), Resampling.\n", metalFile.c_str(), imageSpec.width, imageSpec.height, roi.xend, roi.yend ); ImageBufAlgo::resample(fixBuf, *imageBuf, true, roi); imageBuf->copy(fixBuf); fixBuf.clear(); } unsigned char *pixels = (unsigned char *)imageBuf->localpixels(); char filename[256]; sprintf( filename, "%s.smf", outPrefix.c_str() ); fstream smf(filename, ios::binary | ios::in | ios::out); smf.seekp(metalPtr); // write the data to the smf smf.write( (char *)pixels, imageBuf->spec().image_bytes() ); smf.close(); delete imageBuf; if( is_smf( metalFile ) ) delete [] pixels; return false; }
bool SMF::saveMinimap() { if( verbose )cout << "INFO: saveMinimap\n"; char filename[256]; sprintf( filename, "%s.smf", outPrefix.c_str() ); fstream smf(filename, ios::binary | ios::in | ios::out); smf.seekp(minimapPtr); unsigned char *pixels; if( is_smf(minimapFile) ) { // Copy from SMF pixels = new unsigned char[MINIMAP_SIZE]; ifstream inFile(minimapFile.c_str(), ifstream::in); inFile.seekg(header.minimapPtr); inFile.read( (char *)pixels, MINIMAP_SIZE); inFile.close(); smf.write( (char *)pixels, MINIMAP_SIZE); smf.close(); delete [] pixels; return false; } //OpenImageIO ROI roi( 0, 1024, 0, 1024, 0, 1, 0, 4); ImageSpec imageSpec( roi.xend, roi.yend, roi.chend, TypeDesc::UINT8 ); // Load image file ImageBuf *imageBuf = new ImageBuf( minimapFile ); imageBuf->read( 0, 0, false, TypeDesc::UINT8 ); //FIXME attempt to generate minimap from tile files. if( !imageBuf->initialized() ) { // Create from height imageBuf->reset( minimapFile ); imageBuf->read( 0, 0, false, TypeDesc::UINT8 ); } if( !imageBuf->initialized() ) { // Create blank imageBuf->reset( "minimap", imageSpec); } imageSpec = imageBuf->specmod(); ImageBuf fixBuf; // Fix channels if( imageSpec.nchannels != roi.chend ) { int map[] = {2,1,0,3}; float fill[] = {0,0,0,255}; ImageBufAlgo::channels(fixBuf, *imageBuf, roi.chend, map, fill); imageBuf->copy(fixBuf); fixBuf.clear(); } // Fix dimensions if( imageSpec.width != roi.xend || imageSpec.height != roi.yend ) { printf( "\tWARNING: %s is (%i,%i), wanted (%i, %i), Resampling.\n", minimapFile.c_str(), imageSpec.width, imageSpec.height, roi.xend, roi.yend ); ImageBufAlgo::resample(fixBuf, *imageBuf, true, roi); imageBuf->copy(fixBuf); fixBuf.clear(); } pixels = (unsigned char *)imageBuf->localpixels(); // setup DXT1 Compression nvtt::InputOptions inputOptions; inputOptions.setTextureLayout( nvtt::TextureType_2D, 1024, 1024 ); inputOptions.setMipmapData( pixels, 1024, 1024 ); nvtt::CompressionOptions compressionOptions; compressionOptions.setFormat( nvtt::Format_DXT1 ); if( slowcomp ) compressionOptions.setQuality( nvtt::Quality_Normal ); else compressionOptions.setQuality( nvtt::Quality_Fastest ); nvtt::OutputOptions outputOptions; outputOptions.setOutputHeader( false ); NVTTOutputHandler *outputHandler = new NVTTOutputHandler(MINIMAP_SIZE + 1); outputOptions.setOutputHandler( outputHandler ); nvtt::Compressor compressor; compressor.process( inputOptions, compressionOptions, outputOptions ); // Write data to smf smf.write( outputHandler->buffer, MINIMAP_SIZE ); delete outputHandler; smf.close(); delete imageBuf; return false; }
bool SMF::saveHeight() { if( verbose )cout << "INFO: saveHeight\n"; // Dimensions of displacement map. ImageBuf *imageBuf = NULL; ROI roi( 0, width * 64 + 1, // xbegin, xend 0, length * 64 + 1, // ybegin, yend 0, 1, // zbegin, zend 0, 1); // chbegin, chend ImageSpec imageSpec( roi.xend, roi.yend, roi.chend, TypeDesc::UINT16 ); if( is_smf(heightFile) ) { // Load from SMF SMF sourcesmf(heightFile); imageBuf = sourcesmf.getHeight(); } if( !imageBuf ) { // load image file imageBuf = new ImageBuf( heightFile ); imageBuf->read( 0, 0, false, TypeDesc::UINT16 ); if( !imageBuf->initialized() ) { delete imageBuf; imageBuf = NULL; } } if( !imageBuf ) { // Generate blank imageBuf = new ImageBuf( "height", imageSpec ); } imageSpec = imageBuf->specmod(); ImageBuf fixBuf; // Fix the number of channels if( imageSpec.nchannels != roi.chend ) { int map[] = {0}; ImageBufAlgo::channels(fixBuf, *imageBuf, roi.chend, map); imageBuf->copy(fixBuf); fixBuf.clear(); } // Fix the size if ( imageSpec.width != roi.xend || imageSpec.height != roi.yend ) { if( verbose ) printf( "\tWARNING: %s is (%i,%i), wanted (%i, %i), Resampling.\n", heightFile.c_str(), imageSpec.width, imageSpec.height, roi.xend, roi.yend ); ImageBufAlgo::resample(fixBuf, *imageBuf, true, roi); imageBuf->copy(fixBuf); fixBuf.clear(); } // Invert height if ( invert ) { ImageSpec fixSpec(roi.xend, roi.yend, roi.chend, TypeDesc::UINT16); fixBuf.reset( "fixBuf", fixSpec ); const float fill[] = {65535}; ImageBufAlgo::fill(fixBuf, fill); ImageBufAlgo::sub(*imageBuf, fixBuf, *imageBuf); fixBuf.clear(); } // FIXME filter to remove stepping artifacts from 8bit images, // if ( lowpass ) { // } unsigned short *pixels = (unsigned short *)imageBuf->localpixels(); // write height data to smf. char filename[256]; sprintf( filename, "%s.smf", outPrefix.c_str() ); fstream smf(filename, ios::binary | ios::in| ios::out); smf.seekp(heightPtr); smf.write( (char *)pixels, imageBuf->spec().image_bytes() ); smf.close(); delete imageBuf; if( is_smf( heightFile ) ) delete [] pixels; return false; }