RixDeepTexture.h

Go to the documentation of this file.

/*
# ------------------------------------------------------------------------------
#
# Copyright (c) 2020 Pixar. All rights reserved.
#
# The information in this file (the "Software") is provided for the exclusive
# use of the software licensees of Pixar ("Licensees").  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.
#
# 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.  IN NO CASE WILL
# PIXAR'S TOTAL LIABILITY FOR ALL DAMAGES ARISING OUT OF OR IN CONNECTION WITH
# THE USE OR PERFORMANCE OF THIS SOFTWARE EXCEED $50.
#
# Pixar
# 1200 Park Ave
# Emeryville CA 94608
#
# ------------------------------------------------------------------------------
*/

#ifndef RixDeepTexture_H
#define RixDeepTexture_H

#include "RixInterfaces.h"  // for RixInterface

class [[deprecated]] RixDeepTexture : public RixInterface
{
protected:
    RixDeepTexture() : RixInterface(2) {}

public:
    // clang-format off
    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    
    };
    // clang-format on

    // 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* name,
            int numChan,
            int w,
            int h,
            int tileW,
            int tileH,
            float* NP,
            float* Nl,
            Compression,
            DataType,
            DeepImage** result) = 0;

        virtual int AddImage(
            const char* name,
            int numChan,
            int w,
            int h,
            int tileW,
            int tileH,
            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