Malcolm Humphreys <malcolmh...@...>
Oh I have never used this as it got released by RSR after we
implemented the csp format at RSP.
Not sure if it's helpful as I haven't spent anytime looking into it so
I wouldn't expect it to work out of the box.https://cinespacelutlib.svn.sourceforge.net/svnroot/cinespacelutlib/trunk/
On Jun 15, 10:13 pm, Malcolm Humphreys <malcolmh...@...>
Mostly using cinespace .csp, houdini .lut and .icc profiles for
The main lut format requirements for me is supporting some form of 1D
pre lut and a 3D cube.
I have uploaded the csp lut spec here as the RSR link out there never
seemed to work.http://groups.google.com.au/group/ocs-dev/web/cineSpace_LUT_format.zip
There is also an example 1D3D houdini lut if this helpshttp://groups.google.com.au/group/ocs-dev/web/lin_gamma22_1D3D.lut
On Jun 9, 7:16 am, Jeremy Selan <jeremy...@...> wrote:
Good feedback. How about this:
Let's support all trivial image formats, as long as it doesn't
introduce a library dependency or support headache. So PPM is in. If
there's a simple raw/ascii float format someone can recommend, let's
add that too.
Exr, dpx, tiff, jpg, etc are out.
As OIIO supports ppm we just need to validate the conversion path, and
then we can recommend it's use as a pre-process. (And OIIO will be
gaining DPX support this summer so then all bases are covered).
I'd like to avoid larry suggested 'raw lut access' approach in the
short-term, at least until the bundled .ocs file support is worked
On Tue, Jun 8, 2010 at 1:58 PM, bsloan <bsl...@...> wrote:
I've used 10bit DPX for this purpose in the past (when I thought I'd
invented 2D 3D LUTs).
8 or 16 bit PPM may be a good compromise. It won't please everyone but
implementation requires so little code -- and the advantage of *not*
having to depend on openimageio may outweigh the disadvantage of
whining developers :).
There's some precedent for this -- NVidia's early Cg SDK provided the
source for a lightweight PPM IO library.
Who knows? This may be one case where OCS can influence the standard.
On Jun 8, 11:28 am, Larry Gritz <l....@...> wrote:
I wouldn't burden OCS with the image-reading functionality. You'll never make everybody happy without supporting a bzillion formats. Why not just allow the lut to be specified as a big array and call it a day, and let apps that use OCS be responsible for reading the image files (or having its own dependency on an image-reading library) in order to pass the array?
On Jun 8, 2010, at 11:10 AM, Naty Hoffman wrote:
There are some subtleties with layout and mappings, so let me know
when it's time to implement the import/export logic and I'll write up
As for file formats, people use different ones - TIFF and TGA are
common. There are enough tools to support converting between 2D
formats that I don't know if it's worth adding complex library
dependencies to Open Color Space just for this. Does OCS have any 2D
image file formats supported at the moment? PPM (the RGB version of
PBM) could perhaps work - how widely is it supported by common image
viewing utilities, OS thumbnails, etc.?
Sent from my iPhone
On Jun 8, 2010, at 10:05 AM, Jeremy Selan <jeremy...@...>
Yah, the "lut as image" approach should be really easy to support,
I'll add that to the short list. My only concern would be which
fileformats to support. I'd still like to keep our dependencies as
low as possible though. Naty, when folks use this approach in
production, which file formats are actually used to store the pixel
If it were a trivial ascii format (such as pbm,pnm, etc) that would be
On Jun 7, 7:04 pm, "Nathaniel Hoffman" <n....@...> wrote:
The 2D LUT format I describe below is starting to become a bit more
standardized in the game industry - it is being used by two major
middleware companies (Crytek and Epic - see here:http://
udn.epicgames.com/Three/ColorGrading.html). So it might make sense
to support it after all...
There are two LUT formats I know of that are used in game
One is a 2D image format (any lossless image format will do -
BMP, TGA and PNG) with a 2D representation of the LUT where the
along the 3rd axis have been placed next to each other. So a
would turn into a 1024x32 2D image. A common usage is for an
in this format to be placed next to an ungraded screenshot, both
manipulated in Photoshop or some other color manipulation package,
then the colorized LUT is extracted.
The other format is a DDS (Microsoft DirectDraw Surface) file with
texture in it, typically uncompressed. This is usually loaded
into the game engine.
These are both a bit ad-hoc and not really standardized, so I
if they are relevant for OCS. If they are, let me know and I can
work up something more like an actual spec for each of these.
I'm at the stage where I would like to get a survey of lut file
formats (1d, 3d, matrix, etc) that folks actually use in the wild.
If you commonly use a lut format at your facility, or define one in
your software package, I would hugely appreciate it if you could
upload example files and/or spec documents so I can begin work on
Even if it's a proprietary format, I'd love to take a peek so I can
get a sense of the scope of formats out in the wild. (I need to
sure the internal API is rich enough to encompass current use
Many formats have been mentioned previously, including:
- Truelight ASCII .cub 3D lut
- Assimilate Scratch (Arri /Kodak .3dl)
- Iridas Framecycler (Iridas .cube)
- Autodesk (MESH3D, .lut, etc.)
For the majority of these, I do not have either example files or
specifications. Please help! :)
Also, does anyone know if the majority of lut formats
their extension? Are there common extension conflicts? Ideally,
like to try and have format reader registered based on file
and only if that fails give each lut loader a chance to read it.
(Similar to how reader plugins work in nuke).
(Note that I'm not assuming 1 file == 1 lut. (We will support
where 1 file can generate multiple transforms, such as a 1d
-> 3d lut -> 1d shaper lut.))