Date   

Re: [ocs-dev] An OCS by any other name?

Bruno Nicoletti <bruno.j....@...>
 

How about "Open Colour Management"? Seeing as it is more about
coordinating the whole mess of colour spaces and displays and so on,
rather than being a colour space per se.

b

On 18 June 2010 08:52, Jeremy Selan <jeremy...@...> wrote:
I wasn't originally in love with the name Open Color Space, but I have
to admit it's grown on me.

What are other people's feeling on "OCS"?

Previously, David (Gordon) has suggested that the use of "Open" is
very 90s/cliche, and recommended dropping it. It's hard to disagree,
plain "ColorSpace" is not really googleable.

Malcolm has also suggested that a name such as "Open Color Space" is
perhaps misleading...

Malcolm: "I was telling one of the digital sups about it at DrD today.
His first response was asking which monitor probes it will support,
which I then had to go through and explain what OCS is trying to
achieve and what that would mean for productions at DrD (ie for DrD
this doesn't replace truelight or cinespace, just compliments them)."

Malcolm's suggested a few additions (with my added notes)

- OpenColorWorkSpace   (Sony's DI facility is called ColorWorks, not
sure if this is good or bad)
- OpenColorIO
- OpenColorFlow  (same name as kodak product)
- OpenColorWorkFlow
- OpenColorTransfer
- OpenColorBase (makes me think it's related to baselight)

None of these particularly jump out at me, but I'm open to all ideas.

What are peoples thoughts?

There's time yet to rethink OCS's name, but the window is closing...
--
Bruno Nicoletti


An OCS by any other name?

Jeremy Selan <jeremy...@...>
 

I wasn't originally in love with the name Open Color Space, but I have
to admit it's grown on me.

What are other people's feeling on "OCS"?

Previously, David (Gordon) has suggested that the use of "Open" is
very 90s/cliche, and recommended dropping it. It's hard to disagree,
plain "ColorSpace" is not really googleable.

Malcolm has also suggested that a name such as "Open Color Space" is
perhaps misleading...

Malcolm: "I was telling one of the digital sups about it at DrD today.
His first response was asking which monitor probes it will support,
which I then had to go through and explain what OCS is trying to
achieve and what that would mean for productions at DrD (ie for DrD
this doesn't replace truelight or cinespace, just compliments them)."

Malcolm's suggested a few additions (with my added notes)

- OpenColorWorkSpace (Sony's DI facility is called ColorWorks, not
sure if this is good or bad)
- OpenColorIO
- OpenColorFlow (same name as kodak product)
- OpenColorWorkFlow
- OpenColorTransfer
- OpenColorBase (makes me think it's related to baselight)

None of these particularly jump out at me, but I'm open to all ideas.

What are peoples thoughts?

There's time yet to rethink OCS's name, but the window is closing...


OCS now on github

Jeremy Selan <jeremy...@...>
 

We've setup a private repository for developers on github! Please
email your github account details you'd like access.

For everyone else, we will continue to post weekly code drops.


Re: Got Luts?

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/

.malcolm

On Jun 15, 10:13 pm, Malcolm Humphreys <malcolmh...@...>
wrote:
Mostly using cinespace .csp, houdini .lut and .icc profiles for
photoshop.

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

.malcolm

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
out.
-- Jeremy
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.
-blake
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
a spec.
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.?
Naty
Sent from my iPhone
On Jun 8, 2010, at 10:05 AM, Jeremy Selan <jeremy...@...>
wrote:
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
data?
If it were a trivial ascii format (such as pbm,pnm, etc) that would be
ideal... ;)
-- Jeremy
On Jun 7, 7:04 pm, "Nathaniel Hoffman" <n....@...> wrote:
Jeremy,
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...
Thanks,
Naty
Jeremy,
There are two LUT formats I know of that are used in game
development.
One is a 2D image format (any lossless image format will do -
we've used
BMP, TGA and PNG) with a 2D representation of the LUT where the
planes
along the 3rd axis have been placed next to each other. So a
32x32x32 LUT
would turn into a 1024x32 2D image. A common usage is for an
identity LUT
in this format to be placed next to an ungraded screenshot, both
manipulated in Photoshop or some other color manipulation package,
and
then the colorized LUT is extracted.
The other format is a DDS (Microsoft DirectDraw Surface) file with
a 3D
texture in it, typically uncompressed. This is usually loaded
directly
into the game engine.
These are both a bit ad-hoc and not really standardized, so I
don't know
if they are relevant for OCS. If they are, let me know and I can
try to
work up something more like an actual spec for each of these.
Thanks,
Naty
Hello!
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
the
importers.
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
make
sure the internal API is rich enough to encompass current use
cases).
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
identifiable by
their extension?  Are there common extension conflicts?  Ideally,
I'd
like to try and have format reader registered based on file
extension,
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
readers
where 1 file can generate multiple transforms, such as a 1d
shaper lut
-> 3d lut -> 1d shaper lut.))
--
Larry Gritz
l....@...


Re: Got Luts?

Malcolm Humphreys <malcolmh...@...>
 

Mostly using cinespace .csp, houdini .lut and .icc profiles for
photoshop.

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 helps
http://groups.google.com.au/group/ocs-dev/web/lin_gamma22_1D3D.lut

.malcolm

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
out.

-- Jeremy

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.
-blake
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
a spec.
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.?
Naty
Sent from my iPhone
On Jun 8, 2010, at 10:05 AM, Jeremy Selan <jeremy...@...>
wrote:
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
data?
If it were a trivial ascii format (such as pbm,pnm, etc) that would be
ideal... ;)
-- Jeremy
On Jun 7, 7:04 pm, "Nathaniel Hoffman" <n....@...> wrote:
Jeremy,
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...
Thanks,
Naty
Jeremy,
There are two LUT formats I know of that are used in game
development.
One is a 2D image format (any lossless image format will do -
we've used
BMP, TGA and PNG) with a 2D representation of the LUT where the
planes
along the 3rd axis have been placed next to each other. So a
32x32x32 LUT
would turn into a 1024x32 2D image. A common usage is for an
identity LUT
in this format to be placed next to an ungraded screenshot, both
manipulated in Photoshop or some other color manipulation package,
and
then the colorized LUT is extracted.
The other format is a DDS (Microsoft DirectDraw Surface) file with
a 3D
texture in it, typically uncompressed. This is usually loaded
directly
into the game engine.
These are both a bit ad-hoc and not really standardized, so I
don't know
if they are relevant for OCS. If they are, let me know and I can
try to
work up something more like an actual spec for each of these.
Thanks,
Naty
Hello!
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
the
importers.
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
make
sure the internal API is rich enough to encompass current use
cases).
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
identifiable by
their extension?  Are there common extension conflicts?  Ideally,
I'd
like to try and have format reader registered based on file
extension,
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
readers
where 1 file can generate multiple transforms, such as a 1d
shaper lut
-> 3d lut -> 1d shaper lut.))
--
Larry Gritz
l....@...


OCS 0.5.7 posted

Jeremy Selan <jeremy...@...>
 

0.5.7 features:
* Python API is much more fleshed out (object ownership is clarified),
object mutability is explicit
* Improved public C++ header (functions if-def'd out have been removed
(temporarily))

Coming up soon:
* Addl image processing ops
* DisplayTransform / GPU


Re: [ocs-dev] Re: Got Luts?

Jeremy Selan <jeremy...@...>
 

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
out.

-- Jeremy

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.

-blake


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
a spec.
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.?
Naty
Sent from my iPhone
On Jun 8, 2010, at 10:05 AM, Jeremy Selan <jeremy...@...>
wrote:
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
data?
If it were a trivial ascii format (such as pbm,pnm, etc) that would be
ideal... ;)
-- Jeremy
On Jun 7, 7:04 pm, "Nathaniel Hoffman" <n....@...> wrote:
Jeremy,
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...
Thanks,
Naty
Jeremy,
There are two LUT formats I know of that are used in game
development.
One is a 2D image format (any lossless image format will do -
we've used
BMP, TGA and PNG) with a 2D representation of the LUT where the
planes
along the 3rd axis have been placed next to each other. So a
32x32x32 LUT
would turn into a 1024x32 2D image. A common usage is for an
identity LUT
in this format to be placed next to an ungraded screenshot, both
manipulated in Photoshop or some other color manipulation package,
and
then the colorized LUT is extracted.
The other format is a DDS (Microsoft DirectDraw Surface) file with
a 3D
texture in it, typically uncompressed. This is usually loaded
directly
into the game engine.
These are both a bit ad-hoc and not really standardized, so I
don't know
if they are relevant for OCS. If they are, let me know and I can
try to
work up something more like an actual spec for each of these.
Thanks,
Naty
Hello!
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
the
importers.
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
make
sure the internal API is rich enough to encompass current use
cases).
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
identifiable by
their extension?  Are there common extension conflicts?  Ideally,
I'd
like to try and have format reader registered based on file
extension,
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
readers
where 1 file can generate multiple transforms, such as a 1d
shaper lut
-> 3d lut -> 1d shaper lut.))
--
Larry Gritz
l....@...


Re: Got Luts?

bsloan <bsl...@...>
 

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.

-blake

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  
a spec.
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.?
Naty
Sent from my iPhone
On Jun 8, 2010, at 10:05 AM, Jeremy Selan <jeremy...@...>  
wrote:
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
data?
If it were a trivial ascii format (such as pbm,pnm, etc) that would be
ideal... ;)
-- Jeremy
On Jun 7, 7:04 pm, "Nathaniel Hoffman" <n....@...> wrote:
Jeremy,
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...
Thanks,
Naty
Jeremy,
There are two LUT formats I know of that are used in game  
development.
One is a 2D image format (any lossless image format will do -  
we've used
BMP, TGA and PNG) with a 2D representation of the LUT where the  
planes
along the 3rd axis have been placed next to each other. So a  
32x32x32 LUT
would turn into a 1024x32 2D image. A common usage is for an  
identity LUT
in this format to be placed next to an ungraded screenshot, both
manipulated in Photoshop or some other color manipulation package,  
and
then the colorized LUT is extracted.
The other format is a DDS (Microsoft DirectDraw Surface) file with  
a 3D
texture in it, typically uncompressed. This is usually loaded  
directly
into the game engine.
These are both a bit ad-hoc and not really standardized, so I  
don't know
if they are relevant for OCS. If they are, let me know and I can  
try to
work up something more like an actual spec for each of these.
Thanks,
Naty
Hello!
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  
the
importers.
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  
make
sure the internal API is rich enough to encompass current use  
cases).
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  
identifiable by
their extension?  Are there common extension conflicts?  Ideally,  
I'd
like to try and have format reader registered based on file  
extension,
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  
readers
where 1 file can generate multiple transforms, such as a 1d  
shaper lut
-> 3d lut -> 1d shaper lut.))
--
Larry Gritz
l....@...


Re: [ocs-dev] Re: Got Luts?

Larry Gritz <l...@...>
 

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
a spec.

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.?

Naty

Sent from my iPhone

On Jun 8, 2010, at 10:05 AM, Jeremy Selan <jeremy...@...>
wrote:

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
data?
If it were a trivial ascii format (such as pbm,pnm, etc) that would be
ideal... ;)

-- Jeremy

On Jun 7, 7:04 pm, "Nathaniel Hoffman" <n....@...> wrote:
Jeremy,

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...

Thanks,

Naty



Jeremy,
There are two LUT formats I know of that are used in game
development.
One is a 2D image format (any lossless image format will do -
we've used
BMP, TGA and PNG) with a 2D representation of the LUT where the
planes
along the 3rd axis have been placed next to each other. So a
32x32x32 LUT
would turn into a 1024x32 2D image. A common usage is for an
identity LUT
in this format to be placed next to an ungraded screenshot, both
manipulated in Photoshop or some other color manipulation package,
and
then the colorized LUT is extracted.
The other format is a DDS (Microsoft DirectDraw Surface) file with
a 3D
texture in it, typically uncompressed. This is usually loaded
directly
into the game engine.
These are both a bit ad-hoc and not really standardized, so I
don't know
if they are relevant for OCS. If they are, let me know and I can
try to
work up something more like an actual spec for each of these.
Thanks,
Naty
Hello!
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
the
importers.
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
make
sure the internal API is rich enough to encompass current use
cases).
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
identifiable by
their extension? Are there common extension conflicts? Ideally,
I'd
like to try and have format reader registered based on file
extension,
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
readers
where 1 file can generate multiple transforms, such as a 1d
shaper lut
-> 3d lut -> 1d shaper lut.))
--
Larry Gritz
l...@...


Re: [ocs-dev] Re: Got Luts?

Naty Hoffman <na...@...>
 

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 a spec.

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.?

Naty

On Jun 8, 2010, at 10:05 AM, Jeremy Selan <jeremy...@...> wrote:

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
data?
If it were a trivial ascii format (such as pbm,pnm, etc) that would be
ideal... ;)

-- Jeremy

On Jun 7, 7:04 pm, "Nathaniel Hoffman" <n....@...> wrote:
Jeremy,

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...

Thanks,

Naty



Jeremy,
There are two LUT formats I know of that are used in game development.
One is a 2D image format (any lossless image format will do - we've used
BMP, TGA and PNG) with a 2D representation of the LUT where the planes
along the 3rd axis have been placed next to each other. So a 32x32x32 LUT
would turn into a 1024x32 2D image. A common usage is for an identity LUT
in this format to be placed next to an ungraded screenshot, both
manipulated in Photoshop or some other color manipulation package, and
then the colorized LUT is extracted.
The other format is a DDS (Microsoft DirectDraw Surface) file with a 3D
texture in it, typically uncompressed. This is usually loaded directly
into the game engine.
These are both a bit ad-hoc and not really standardized, so I don't know
if they are relevant for OCS. If they are, let me know and I can try to
work up something more like an actual spec for each of these.
Thanks,
Naty
Hello!
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 the
importers.
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 make
sure the internal API is rich enough to encompass current use cases).
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 identifiable by
their extension? Are there common extension conflicts? Ideally, I'd
like to try and have format reader registered based on file extension,
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 readers
where 1 file can generate multiple transforms, such as a 1d shaper lut
-> 3d lut -> 1d shaper lut.))


Re: OCS v0.5.6 posted

Jeremy Selan <jeremy...@...>
 

Oh, and for those who geek out on python binding implementations, I'd
invite you to check out:
src/pyglue/
PyConfig.h
PyConfig.cpp

I'm curious to see how people feel about this approach. Rather than
automatically generating bindings (or using tools like boost::python),
I'm hand-crafting them to allow for explicit object / interface
design. The biggest issue is that we're making explicit use of const-
ness on the C side, and python does not have a way to carry this
information over. Our custom binding approach lets us handle this in
a way that's uber-explicit to the end user, with calls such as:

config.isEditable()
config.createEditableCopy()

The hope is that this leads to minimal confusion on the python API
side.

If anyone knows of an approach which automates binding generation, but
also tackles this issue please let me know.

Thanks!

-- Jeremy

On Jun 8, 10:14 am, Jeremy Selan <jeremy...@...> wrote:
Version 0.5.6 (June 8 2010):
    * PyConfig stub implementation
    * Dropped ImageDesc.init; added PlanarImageDesc / PackedImageDesc
    * Dropped tr1::shared_ptr; added boost::shared_ptr


OCS v0.5.6 posted

Jeremy Selan <jeremy...@...>
 

Version 0.5.6 (June 8 2010):
* PyConfig stub implementation
* Dropped ImageDesc.init; added PlanarImageDesc / PackedImageDesc
* Dropped tr1::shared_ptr; added boost::shared_ptr


Re: Got Luts?

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
data?
If it were a trivial ascii format (such as pbm,pnm, etc) that would be
ideal... ;)

-- Jeremy

On Jun 7, 7:04 pm, "Nathaniel Hoffman" <n....@...> wrote:
Jeremy,

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...

Thanks,

Naty



Jeremy,
There are two LUT formats I know of that are used in game development.
One is a 2D image format (any lossless image format will do - we've used
BMP, TGA and PNG) with a 2D representation of the LUT where the planes
along the 3rd axis have been placed next to each other. So a 32x32x32 LUT
would turn into a 1024x32 2D image. A common usage is for an identity LUT
in this format to be placed next to an ungraded screenshot, both
manipulated in Photoshop or some other color manipulation package, and
then the colorized LUT is extracted.
The other format is a DDS (Microsoft DirectDraw Surface) file with a 3D
texture in it, typically uncompressed. This is usually loaded directly
into the game engine.
These are both a bit ad-hoc and not really standardized, so I don't know
if they are relevant for OCS. If they are, let me know and I can try to
work up something more like an actual spec for each of these.
Thanks,
Naty
Hello!
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 the
importers.
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 make
sure the internal API is rich enough to encompass current use cases).
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 identifiable by
their extension?  Are there common extension conflicts?  Ideally, I'd
like to try and have format reader registered based on file extension,
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 readers
where 1 file can generate multiple transforms, such as a 1d shaper lut
-> 3d lut -> 1d shaper lut.))


Re: [ocs-dev] Got Luts?

"Nathaniel Hoffman" <na...@...>
 

Jeremy,

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...

Thanks,

Naty

Jeremy,

There are two LUT formats I know of that are used in game development.

One is a 2D image format (any lossless image format will do - we've used
BMP, TGA and PNG) with a 2D representation of the LUT where the planes
along the 3rd axis have been placed next to each other. So a 32x32x32 LUT
would turn into a 1024x32 2D image. A common usage is for an identity LUT
in this format to be placed next to an ungraded screenshot, both
manipulated in Photoshop or some other color manipulation package, and
then the colorized LUT is extracted.

The other format is a DDS (Microsoft DirectDraw Surface) file with a 3D
texture in it, typically uncompressed. This is usually loaded directly
into the game engine.

These are both a bit ad-hoc and not really standardized, so I don't know
if they are relevant for OCS. If they are, let me know and I can try to
work up something more like an actual spec for each of these.

Thanks,

Naty

Hello!

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 the
importers.

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 make
sure the internal API is rich enough to encompass current use cases).

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 identifiable by
their extension? Are there common extension conflicts? Ideally, I'd
like to try and have format reader registered based on file extension,
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 readers
where 1 file can generate multiple transforms, such as a 1d shaper lut
-> 3d lut -> 1d shaper lut.))


Re: [ocs-dev] Re: OCS v0.5.5 posted

Bruno Nicoletti <bruno.j....@...>
 

My fear is that TR1 is somewhat variably implemented at the moment,
though smart pointers should be pretty much stable. The biggie is that
we can't support it on Windows yet.

b

On 4 June 2010 16:49, Jeremy Selan <jeremy...@...> wrote:
Oh, and to clarify,

Is your fear related to the specific include of the TR1 shared_ptr, or
to shared_ptrs in public headers in general?

-- Jeremy

looking much nicer. However, I have The Fear as you are using C++ TR1
for smart pointer magic.
--
Bruno Nicoletti


Re: [ocs-dev] OCS v0.5.5 posted

Bruno Nicoletti <bruno.j....@...>
 

Hi Jeremy,

thanks for the reply. I'm a firm believer in smart pointers, choosing
what to expose can be problematic in an API like this when there is no
firm standard. #ifndefs is the way around it.

As for the ctors, derive thin classes from the base one, which have
nothing but ctors in them.

class PackedImageDesc : public ImageDesc {
public : PackedImageDesc(....);
};

class PlanarImageDesc : public ImageDesc {
public : PlanarImageDesc(....);
};

All you functions should take const references to ImageDesc, and it
will all work happily.

That should do it.

On 4 June 2010 16:41, Jeremy Selan <jeremy...@...> wrote:
The use of tr1 shared_ptr is only a stub.  When we get multi-platform
stuff sorted out that section will definitely be replaced with
platform / compiler specific #ifdefs. Any shared_ptr that provides a
dynamic_cast will suffice. (tr1 does work on osx already though  :) )

First a justification of shared_ptrs in general...
We've spend a long time thinking about object ownership and object
lifetimes, and the choice to expose a smart pointer was not arrived at
lightly.  I do not see a graceful alternative.  If people are
interested we should probably discuss this further to bring everyone
on board.  (Or to prove me wrong!)  The quick summary is that in the
context of multi-threaded apps, where there exists a 'global' config
people can get/set, you need to have some form of reference counting
to assure that configs aren't destroyed while still in use.   I would
have ended up just re inventing a shared_ptr / intrusive_ptr, so it
seemed expedient to just use a real one.  It will also allow for a
more simper python use model, as objects can now be created on either
side of the fence (C++ or python) and passed back and forth without
concern for object lifetime.  (Keeping a reference to the python
object will keep the C++ object alive, which is very desirable). This
will particularly be useful in python UIs that make use of the mutable
API. (To create and edit configs 'live')

One related thing of note - all exposed objects which use shared-ptrs
have private constructors; the only way to create them is with static
factory functions.   Example: ColorSpaceRcPtr ColorSpace::Create() .
This is done so that the shared pointer is always created with a
custom object deallocator.  Our hope is this will work solve the
windows dll memory management issue.  (And we hope to verify this
soon).

OCS::ImageDesc
The init functions could definitely be constructors. My concerns is
that it would then rely on type signatures to maintain uniqueness, and
this has hosed me in the past. (Particularly where default values /
int / bools are involved).  You can accidentally create a change which
is binary compatible, but not source compatible.

I really like having super explicit names such as initRGBA,
initSingleBuffer, initMultiBuffer.  This will also let us add new
convenience constructors should they be desired without worrying about
compatibility.   (Consider 'initRGB', which would have the same type
signature as initRGBA.

But I agree the current init functions aren't ideal.  Does anyone have ideas?


Soon enough we will have a live share of the GIT repo, and which point
everyone can start contributing... ;)

-- Jeremy


On Fri, Jun 4, 2010 at 4:09 AM, Bruno Nicoletti
<bruno.j....@...> wrote:
Hi Jeremy,

looking much nicer. However, I have The Fear as you are using C++ TR1
for smart pointer magic. We are on Visual Studio 2005 for Windows and
there is no TR1 for VS5 (we won't be changing in the near future, long
story). A #ifndef around SharedPtr and DynamicPtrCast would help, as
we could redirect this to boost.

Another minor quibble, should not the OCS::ImageDesc have ctors rather
than the initRGBA/initSingleBuffer/initMultiBuffer methods? Similarly
for other classes?

b

On 4 June 2010 00:44, Jeremy Selan <jeremy...@...> wrote:
This one will actually build on other people's machines...

please see INSTALL file for instructions on how to build the Nuke
example (posted here as well):

Make a build directory, cd into it:
mkdir -p build
cd build
Configure cmake, pointing at your nuke include dir:
cmake -D NUKE:FILEPATH=/usr/local/nuke6.0.3/include/ -D CMAKE_BUILD_TYPE=Release ../
Build all targets:
make
You will now see the built .so files:
ls
Set the environment variable pointing at which configuration to use:
(Point this to your install)
setenv OCS /net/homedirs/jeremys/git/Color/configs/spivfx/config.ocs
Launch nuke (the same version you used for the include files), then
load the plugin (this can also go in your init.py)

nuke.load('/net/homedirs/jeremys/git/Color//build/libNukeColorSpaceConversion.so')
nuke.menu('Nodes').addMenu('Color').addCommand('OCSColorSpaceConversion', 'nuke.createNode("OCSColorSpaceConversion")')
Connect an image to the OCSColorSpaceConversion node.
Our 'spivfx' config has only a few example colorspaces, this one
demonstrates a conversion between scene linear and a film-log
colorspace.


--
Bruno Nicoletti
--
Bruno Nicoletti


Re: OCS v0.5.5 posted

Jeremy Selan <jeremy...@...>
 

Oh, and to clarify,

Is your fear related to the specific include of the TR1 shared_ptr, or
to shared_ptrs in public headers in general?

-- Jeremy

looking much nicer. However, I have The Fear as you are using C++ TR1
for smart pointer magic.


Re: [ocs-dev] OCS v0.5.5 posted

Jeremy Selan <jeremy...@...>
 

The use of tr1 shared_ptr is only a stub. When we get multi-platform
stuff sorted out that section will definitely be replaced with
platform / compiler specific #ifdefs. Any shared_ptr that provides a
dynamic_cast will suffice. (tr1 does work on osx already though :) )

First a justification of shared_ptrs in general...
We've spend a long time thinking about object ownership and object
lifetimes, and the choice to expose a smart pointer was not arrived at
lightly. I do not see a graceful alternative. If people are
interested we should probably discuss this further to bring everyone
on board. (Or to prove me wrong!) The quick summary is that in the
context of multi-threaded apps, where there exists a 'global' config
people can get/set, you need to have some form of reference counting
to assure that configs aren't destroyed while still in use. I would
have ended up just re inventing a shared_ptr / intrusive_ptr, so it
seemed expedient to just use a real one. It will also allow for a
more simper python use model, as objects can now be created on either
side of the fence (C++ or python) and passed back and forth without
concern for object lifetime. (Keeping a reference to the python
object will keep the C++ object alive, which is very desirable). This
will particularly be useful in python UIs that make use of the mutable
API. (To create and edit configs 'live')

One related thing of note - all exposed objects which use shared-ptrs
have private constructors; the only way to create them is with static
factory functions. Example: ColorSpaceRcPtr ColorSpace::Create() .
This is done so that the shared pointer is always created with a
custom object deallocator. Our hope is this will work solve the
windows dll memory management issue. (And we hope to verify this
soon).

OCS::ImageDesc
The init functions could definitely be constructors. My concerns is
that it would then rely on type signatures to maintain uniqueness, and
this has hosed me in the past. (Particularly where default values /
int / bools are involved). You can accidentally create a change which
is binary compatible, but not source compatible.

I really like having super explicit names such as initRGBA,
initSingleBuffer, initMultiBuffer. This will also let us add new
convenience constructors should they be desired without worrying about
compatibility. (Consider 'initRGB', which would have the same type
signature as initRGBA.

But I agree the current init functions aren't ideal. Does anyone have ideas?


Soon enough we will have a live share of the GIT repo, and which point
everyone can start contributing... ;)

-- Jeremy


On Fri, Jun 4, 2010 at 4:09 AM, Bruno Nicoletti
<bruno.j....@...> wrote:
Hi Jeremy,

looking much nicer. However, I have The Fear as you are using C++ TR1
for smart pointer magic. We are on Visual Studio 2005 for Windows and
there is no TR1 for VS5 (we won't be changing in the near future, long
story). A #ifndef around SharedPtr and DynamicPtrCast would help, as
we could redirect this to boost.

Another minor quibble, should not the OCS::ImageDesc have ctors rather
than the initRGBA/initSingleBuffer/initMultiBuffer methods? Similarly
for other classes?

b

On 4 June 2010 00:44, Jeremy Selan <jeremy...@...> wrote:
This one will actually build on other people's machines...

please see INSTALL file for instructions on how to build the Nuke
example (posted here as well):

Make a build directory, cd into it:
mkdir -p build
cd build
Configure cmake, pointing at your nuke include dir:
cmake -D NUKE:FILEPATH=/usr/local/nuke6.0.3/include/ -D CMAKE_BUILD_TYPE=Release ../
Build all targets:
make
You will now see the built .so files:
ls
Set the environment variable pointing at which configuration to use:
(Point this to your install)
setenv OCS /net/homedirs/jeremys/git/Color/configs/spivfx/config.ocs
Launch nuke (the same version you used for the include files), then
load the plugin (this can also go in your init.py)

nuke.load('/net/homedirs/jeremys/git/Color//build/libNukeColorSpaceConversion.so')
nuke.menu('Nodes').addMenu('Color').addCommand('OCSColorSpaceConversion', 'nuke.createNode("OCSColorSpaceConversion")')
Connect an image to the OCSColorSpaceConversion node.
Our 'spivfx' config has only a few example colorspaces, this one
demonstrates a conversion between scene linear and a film-log
colorspace.


--
Bruno Nicoletti


Re: [ocs-dev] OCS v0.5.5 posted

Bruno Nicoletti <bruno.j....@...>
 

Hi Jeremy,

looking much nicer. However, I have The Fear as you are using C++ TR1
for smart pointer magic. We are on Visual Studio 2005 for Windows and
there is no TR1 for VS5 (we won't be changing in the near future, long
story). A #ifndef around SharedPtr and DynamicPtrCast would help, as
we could redirect this to boost.

Another minor quibble, should not the OCS::ImageDesc have ctors rather
than the initRGBA/initSingleBuffer/initMultiBuffer methods? Similarly
for other classes?

b

On 4 June 2010 00:44, Jeremy Selan <jeremy...@...> wrote:
This one will actually build on other people's machines...

please see INSTALL file for instructions on how to build the Nuke
example (posted here as well):

Make a build directory, cd into it:
mkdir -p build
cd build
Configure cmake, pointing at your nuke include dir:
cmake -D NUKE:FILEPATH=/usr/local/nuke6.0.3/include/ -D CMAKE_BUILD_TYPE=Release ../
Build all targets:
make
You will now see the built .so files:
ls
Set the environment variable pointing at which configuration to use:
(Point this to your install)
setenv OCS /net/homedirs/jeremys/git/Color/configs/spivfx/config.ocs
Launch nuke (the same version you used for the include files), then
load the plugin (this can also go in your init.py)

nuke.load('/net/homedirs/jeremys/git/Color//build/libNukeColorSpaceConversion.so')
nuke.menu('Nodes').addMenu('Color').addCommand('OCSColorSpaceConversion', 'nuke.createNode("OCSColorSpaceConversion")')
Connect an image to the OCSColorSpaceConversion node.
Our 'spivfx' config has only a few example colorspaces, this one
demonstrates a conversion between scene linear and a film-log
colorspace.
--
Bruno Nicoletti


OCS v0.5.5 posted

Jeremy Selan <jeremy...@...>
 

This one will actually build on other people's machines...

please see INSTALL file for instructions on how to build the Nuke
example (posted here as well):

Make a build directory, cd into it:
mkdir -p build
cd build
Configure cmake, pointing at your nuke include dir:
cmake -D NUKE:FILEPATH=/usr/local/nuke6.0.3/include/ -D CMAKE_BUILD_TYPE=Release ../
Build all targets:
make
You will now see the built .so files:
ls
Set the environment variable pointing at which configuration to use:
(Point this to your install)
setenv OCS /net/homedirs/jeremys/git/Color/configs/spivfx/config.ocs
Launch nuke (the same version you used for the include files), then
load the plugin (this can also go in your init.py)

nuke.load('/net/homedirs/jeremys/git/Color//build/libNukeColorSpaceConversion.so')
nuke.menu('Nodes').addMenu('Color').addCommand('OCSColorSpaceConversion', 'nuke.createNode("OCSColorSpaceConversion")')
Connect an image to the OCSColorSpaceConversion node.
Our 'spivfx' config has only a few example colorspaces, this one
demonstrates a conversion between scene linear and a film-log
colorspace.

2161 - 2180 of 2215