> On Oct 13, 2020, at 2:15 PM, Arman Garakani <[email protected]> wrote:
>
> 2. Not calling release: got it. I am sure you have thought about a RAII way
> of dealing with this.
I hadn't really thought about this, but I think it would be fairly trivial,
like this sketch (caveat: I'm just typing this off the top of my head):
struct TileHolder {
ImageCache* ic;
ImageCache::Tile* tile;
// construct from pointers to IC and Tile (presumably returned by
ic->get_tile())
TileHolder(ImageCache* ic, ImageCache::Tile* tile)
: ic(ic), tile(tile) {}
// destructor releases the tile
~TileHolder() { ic->release_tile(tile); }
// operator() returns the Tile*
ImageCache::Tile* operator()() const { return tile; }
};
then use something like:
TileHolder th(ic, ic->get_tile(filename, subimage, miplevel, x, y, z));
...
roi = ic->tile_roi(th());
...
// When th exists scope, ic->release_tile(th()) is automatically called
Would something like this be generally handy for me to add to imagecache.h to
make it easier to juggle the Tile*'s?
The reason I didn't bother is that the Tile* interface is very specialized and
advanced. I didn't expect people to directly use it except in very rare
circumstances. The usual way to interact with ImageCache is either through
get_pixels (which copies whatever pixels you need to your buffer, without
needing to worry about how the tiles work at all), or by using ImageBuf (which
looks like an image, has pixel Iterator classes to traverse them, and hides all
the underlying ImageCache mechanism for large images).
>
> 3. Number of sub images:
>
> The takeaway is that get_imagespec returns the spec for current sub image.
> For multi-image files, calling it repeatedly returns the current sub image
> count. Hence calling it repeatedly, gets the number of sub images. Got it.
It does, but you can ask for the number of subimages directly (as in my
explanation), without having to copy spec after spec until you fail.
> The issue that I have is time stamps on a multi-image tif aka tif stack. I
> know there are time stamp information for every image. However I can not find
> a way to fetch them through the API. I could use the sub image index. If I
> could get duration or FramePerSecond ( floating point or a rational number
> ). Am I missing the API ? Does it make sense to support ?
Yes, like if you wanted the DateTime for each subimage, you could get it with:
ustring datetime;
ic->get_image_info (filename, subimage, /*miplevel=*/ 0,
ustring("DateTime"), OIIO::TypeString, &datetime);
This is assuming you want to use the ImageCache approach at all. Do you need
unlimited numbers of high-res images open all at the same time, but using a
small and fixed amount of memory and without having to keep track of any
allocations or open file handles? That's what IC is supposed to be for.
If you are primarily accessing just one or a few images/subimages at any one
time, it's probably easier to just use the ImageBuf interface:
// Make an ImageBuf for a file (by default, first subimage)
ImageBuf buf(filename);
// How many subimages does this image have?
int nsubimages = buf.nsubimages();
// Point to a different subimage
buf.reset(filename, subimage);
// Directly ask for some metadata about that subimage
std::string datetime = buf.spec().get_string_attribute("DateTime");
// Copy some pixels to my area, with data type conversion
buf.get_pixels(roi, TypeFloat, my_float_ptr);
--
Larry Gritz
[email protected]
_______________________________________________
Oiio-dev mailing list
[email protected]
http://lists.openimageio.org/listinfo.cgi/oiio-dev-openimageio.org
