RixDeepTexture.h

#ifndef RixDeepTexture_H
#define RixDeepTexture_H
/* $Revision: #1 $ $Date: 2015/04/23 $
# ------------------------------------------------------------------------------
#
# Copyright (c) 2010 Pixar Animation Studios. All rights reserved.
#
# The information in this file (the "Software") is provided for the
# exclusive use of the software licensees of Pixar.  Licensees have
# the right to incorporate the Software into other products for use
# by other authorized software licensees of Pixar, without fee.
# Except as expressly permitted herein, the Software may not be
# disclosed to third parties, copied or duplicated in any form, in
# whole or in part, without the prior written permission of
# Pixar Animation Studios.
#
# The copyright notices in the Software and this entire statement,
# including the above license grant, this restriction and the
# following disclaimer, must be included in all copies of the
# Software, in whole or in part, and all permitted derivative works of
# the Software, unless such copies or derivative works are solely
# in the form of machine-executable object code generated by a
# source language processor.
#
# PIXAR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
# ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT
# SHALL PIXAR BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES
# OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
# ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
# SOFTWARE.
#
# Pixar
# 1200 Park Ave
# Emeryville CA 94608
#
# ------------------------------------------------------------------------------
*/
#include "RixInterfaces.h"

class RixDeepTexture : public RixInterface
{
protected:
    RixDeepTexture() : RixInterface(2) {}

public:
    enum Compression
    {
        k_CmpNone = 0,
        k_CmpRLE = 2,
        k_CmpLZW = 3,
        k_CmpHUFFMAN = 5,
        k_CmpZIP = 6
    };
    
    enum DataType
    {
        k_TypeBYTE = 1,
        k_TypeSHORT = 2,
        k_TypeWORD = 3,
        k_TypeFLOAT = 4,
        k_TypeHALF = 5
    };
    
    enum ErrorCodes
    {
        k_ErrNOMETADATA = -14,       
        k_ErrBADCHANNEL = -13,       
        k_ErrREADONLY = -12,         
        k_ErrCAPACITY = -11,         
        k_ErrTILECOMPRESSION  = -10, 
        k_ErrUNFINISHED = -9,        
        k_ErrRANGE = -8,             
        k_ErrNOMEM = -7,             
        k_ErrEMPTY = -6,             
        k_ErrNOIMAGE = -5,           
        k_ErrUNSUPPORTED = -4,       
        k_ErrBADFILE = -3,           
        k_ErrNOFILE = -2,            
        k_ErrERR = -1,               
        k_ErrNOERR = 0               
    };
    
    // forward declaration of our types...
    class DeepCache;
    class DeepFile;
    class DeepImage;
    class DeepMetadata;
    class DeepPixel;
    
    virtual DeepCache *CreateCache(int numTiles)=0;

    virtual int DestroyCache(DeepCache *)=0;
    
    virtual int CreateFile(const char *name, DeepCache *, DeepFile **result)=0;

    virtual int IsDeepFile(const char *name, DeepCache *, int *version)=0;

    virtual int OpenFile(const char *name, const char *mode, DeepCache *, 
                        DeepFile **result)=0;

    virtual int DestroyFile(DeepFile *)=0;

    virtual DeepPixel *CreatePixel(int numChan)=0;

    virtual void DestroyPixel(DeepPixel *)=0;

    class DeepCache
    {
    public:
        virtual int Sync()=0;

    protected:
        virtual ~DeepCache() {} 
    };

    class DeepFile
    {
    protected:
        virtual ~DeepFile() {} 

    public:

        virtual int FileVersion()=0;

        virtual DeepMetadata *GetMetadata()=0;

        virtual int CountImages()=0;
        
        virtual int AddImage(const char *nm, int numChan,
                     int w, int h, 
                     int tw, int th,
                     float *NP,
                     float *Nl,
                     Compression,
                     DataType,
                     DeepImage **result)=0;

        virtual int AddImage(const char *nm, int numChan,
                     int w, int h, 
                     int tw, int th,
                     float *NP,
                     float *Nl,
                     Compression,
                     DataType,
                     const char *formatType,
                     int formatVersion,
                     DeepImage **result)=0;


        virtual int GetImageByName(const char *, DeepImage **result)=0;
                     
        virtual int GetImageByIndex(int, DeepImage **result)=0;
        
        virtual int Close()=0;
        
        virtual int Sync()=0;
    };

    class DeepImage
    {
    protected:
        virtual ~DeepImage() {}

    public:
        virtual const char *GetName()=0;
        virtual int GetNumChan()=0;
        virtual int GetWidth()=0;
        virtual int GetHeight()=0;
        virtual int GetTileWidth()=0;
        virtual int GetTileHeight()=0;
        virtual int GetNP(float *NP)=0;
        virtual int GetNl(float *Nl)=0;
        virtual Compression GetCompression()=0;
        virtual DataType GetDataType()=0;
        virtual DeepMetadata *GetMetadata()=0;


        virtual int SetPixelData(int x, int y, int numPoints, 
                                 float *data)=0;

        virtual int SetPixel(int x, int y, DeepPixel *pix)=0; 

        virtual int GetPixel(int x, int y, DeepPixel *pix)=0;

        virtual int Eval(int x, int y, float z, float *data)=0;

        virtual int GetZRange(int x, int y, float *min, float *max)=0;

        virtual int GetMeanDepth(int x, int y, float *mean, float *alpha)=0;
    };

    class DeepMetadata
    {
    protected:
        virtual ~DeepMetadata() {}

    public:

        virtual int Set(char const *token, void const *value)=0;

        virtual int Count()=0;

        virtual int GetByIndex(int index,
                               char const **token, void const **value)=0;

        virtual int GetByName(char const *name,
                              char const **token, void const **value)=0;
    };

    class DeepPixel
    {
    protected:
        virtual ~DeepPixel() {}

    public:
        virtual int Clear(int numChan)=0;
        virtual int Empty()=0;

        virtual int SpecifyPixel(int numChan, int numPoints, float *data)=0;

        virtual int IsMonochrome()=0;

        virtual int GetNumChan()=0;

        virtual int GetNumPoints()=0;

        virtual int GetPoint(int i, float *z, float *data)=0;

        virtual int SetPoint(int i, float z, float *data)=0;

        virtual int Copy(DeepPixel *src)=0;
        
        virtual int Merge(DeepPixel *src) = 0;

        virtual int Merge(DeepPixel *src,
                          int rgbChannel, int alphaChannel) = 0;


        virtual int Finish()=0;

        virtual int Append(float z, float *data, float tolerance)=0;

        virtual int Eval(float z, float *data)=0;

        virtual int Composite(int rgbChannel, int alphaChannel, float *data)=0;

        virtual int GetZRange(float *zmin, float *zmax)=0;

        virtual int Average(int n, DeepPixel *pixels[], float weights[],
                            float tolerance)=0;

        virtual int Compress(DeepPixel *src, float tolerance)=0;
        
    }; /* end of DeepPixel */
    
}; /* end of RixDeepTexture */

#endif