image.h

Go to the documentation of this file.

//
// Copyright 2016 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_IMAGING_HIO_IMAGE_H
#define PXR_IMAGING_HIO_IMAGE_H
 
 
#include "pxr/pxr.h"
#include "pxr/imaging/hio/api.h"
#include "pxr/imaging/hio/types.h"
 
#include "pxr/base/tf/token.h"
#include "pxr/base/tf/type.h"
#include "pxr/base/vt/dictionary.h"
#include "pxr/base/vt/value.h"
 
#include <memory>
#include <string>
 
PXR_NAMESPACE_OPEN_SCOPE
 
 
using HioImageSharedPtr = std::shared_ptr<class HioImage>;
 
class HioImage
{
public:
 
    enum ImageOriginLocation
    {
        OriginUpperLeft, 
        OriginLowerLeft
    }; 
 
    enum SourceColorSpace
    {
        Raw, 
        SRGB,
        Auto
    }; 
   
    class StorageSpec
    {
    public:
        StorageSpec()
            : width(0), height(0), depth(0)
            , format(HioFormatInvalid)
            , flipped(false)
            , data(0) { }
 
        int width, height, depth;
        HioFormat format;
        bool flipped;
        void * data;
    };
 
public:
    HioImage() = default;
 
    HIO_API
    virtual ~HioImage();
 
    // Disallow copies
    HioImage(const HioImage&) = delete;
    HioImage& operator=(const HioImage&) = delete;
 
    HIO_API
    static bool IsSupportedImageFile(std::string const & filename);
 
 
    HIO_API
    static HioImageSharedPtr OpenForReading(std::string const & filename,
                                            int subimage = 0,
                                            int mip = 0,
                                            SourceColorSpace sourceColorSpace = 
                                                SourceColorSpace::Auto,
                                            bool suppressErrors = false);
 
    virtual bool Read(StorageSpec const & storage) = 0;
 
    virtual bool ReadCropped(int const cropTop,
                             int const cropBottom,
                             int const cropLeft,
                             int const cropRight,
                             StorageSpec const & storage) = 0;
 
 
 
    HIO_API
    static HioImageSharedPtr OpenForWriting(std::string const & filename);
 
    virtual bool Write(StorageSpec const & storage,
                       VtDictionary const & metadata = VtDictionary()) = 0;
 
 
    virtual std::string const & GetFilename() const = 0;
 
    virtual int GetWidth() const = 0;
 
    virtual int GetHeight() const = 0;
 
    virtual HioFormat GetFormat() const = 0;
 
    virtual int GetBytesPerPixel() const = 0;
 
    virtual int GetNumMipLevels() const = 0;
 
    virtual bool IsColorSpaceSRGB() const = 0;
 
    template <typename T>
    bool GetMetadata(TfToken const & key, T * value) const;
 
    virtual bool GetMetadata(TfToken const & key, VtValue * value) const = 0;
 
    virtual bool GetSamplerMetadata(HioAddressDimension dim,
                                    HioAddressMode * param) const = 0;
 
 
protected:
    virtual bool _OpenForReading(std::string const & filename,
                                 int subimage,
                                 int mip,
                                 SourceColorSpace sourceColorSpace,
                                 bool suppressErrors) = 0;
 
    virtual bool _OpenForWriting(std::string const & filename) = 0;
};
 
template <typename T>
bool
HioImage::GetMetadata(TfToken const & key, T * value) const
{
    VtValue any;
    if (!GetMetadata(key, &any) || !any.IsHolding<T>()) {
        return false;
    }
    *value = any.UncheckedGet<T>();
    return true;
}
 
class HIO_API HioImageFactoryBase : public TfType::FactoryBase {
public:
    virtual HioImageSharedPtr New() const = 0;
};
 
template <class T>
class HioImageFactory : public HioImageFactoryBase {
public:
    virtual HioImageSharedPtr New() const
    {
        return HioImageSharedPtr(new T);
    }
};
 
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif  // PXR_IMAGING_HIO_IMAGE_H