DYT/Tool/OpenSceneGraph-3.6.5/include/OpenEXR/ImfDeepImageLevel.h

412 lines
9.4 KiB
C
Raw Permalink Normal View History

2024-12-24 23:49:36 +00:00
//
// SPDX-License-Identifier: BSD-3-Clause
// Copyright (c) Contributors to the OpenEXR Project.
//
#ifndef INCLUDED_IMF_DEEP_IMAGE_LEVEL_H
#define INCLUDED_IMF_DEEP_IMAGE_LEVEL_H
//----------------------------------------------------------------------------
//
// class DeepImageLevel
// class DeepImageLevel::Iterator
// class DeepImageLevel::ConstIterator
//
// For an explanation of images, levels and channels,
// see the comments in header file Image.h.
//
//----------------------------------------------------------------------------
#include "ImfNamespace.h"
#include "ImfUtilExport.h"
#include "ImfDeepImageChannel.h"
#include "ImfImageLevel.h"
#include "ImfSampleCountChannel.h"
#include <map>
#include <string>
OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
class DeepImage;
class IMFUTIL_EXPORT_TYPE DeepImageLevel : public ImageLevel
{
public:
//
// Access to the image to which the level belongs.
//
IMFUTIL_EXPORT
DeepImage& deepImage ();
IMFUTIL_EXPORT
const DeepImage& deepImage () const;
//
// Access to deep channels by name:
//
// findChannel(n) returns a pointer to the image channel with
// name n, or 0 if no such channel exists.
//
// channel(n) returns a reference to the image channel with
// name n, or throws an Iex::ArgExc exception if
// no such channel exists.
//
// findTypedChannel<T>(n) returns a pointer to the image channel with
// name n and type T, or 0 if no such channel
// exists.
//
// typedChannel(n) returns a reference to the image channel with
// name n and type T, or throws an Iex::ArgExc
// exception if no such channel exists.
//
IMFUTIL_EXPORT
DeepImageChannel* findChannel (const std::string& name);
IMFUTIL_EXPORT
const DeepImageChannel* findChannel (const std::string& name) const;
IMFUTIL_EXPORT
DeepImageChannel& channel (const std::string& name);
IMFUTIL_EXPORT
const DeepImageChannel& channel (const std::string& name) const;
template <class T>
TypedDeepImageChannel<T>* findTypedChannel (const std::string& name);
template <class T>
const TypedDeepImageChannel<T>*
findTypedChannel (const std::string& name) const;
template <class T>
TypedDeepImageChannel<T>& typedChannel (const std::string& name);
template <class T>
const TypedDeepImageChannel<T>&
typedChannel (const std::string& name) const;
//
// Iterator-style access to deep channels
//
typedef std::map<std::string, DeepImageChannel*> ChannelMap;
class Iterator;
class ConstIterator;
IMFUTIL_EXPORT
Iterator begin ();
IMFUTIL_EXPORT
ConstIterator begin () const;
IMFUTIL_EXPORT
Iterator end ();
IMFUTIL_EXPORT
ConstIterator end () const;
//
// Access to the sample count channel
//
IMFUTIL_EXPORT
SampleCountChannel& sampleCounts ();
IMFUTIL_EXPORT
const SampleCountChannel& sampleCounts () const;
private:
friend class DeepImage;
friend class SampleCountChannel;
//
// The constructor and destructor are private.
// Deep image levels exist only as part of a deep image.
//
IMF_HIDDEN
DeepImageLevel (
DeepImage& image,
int xLevelNumber,
int yLevelNumber,
const IMATH_NAMESPACE::Box2i& dataWindow);
IMF_HIDDEN
~DeepImageLevel ();
IMF_HIDDEN
void setSamplesToZero (
size_t i, unsigned int oldNumSamples, unsigned int newNumSamples);
IMF_HIDDEN
void moveSampleList (
size_t i,
unsigned int oldNumSamples,
unsigned int newNumSamples,
size_t newSampleListPosition);
IMF_HIDDEN
void moveSamplesToNewBuffer (
const unsigned int* oldNumSamples,
const unsigned int* newNumSamples,
const size_t* newSampleListPositions);
IMF_HIDDEN
void initializeSampleLists ();
IMF_HIDDEN
virtual void resize (const IMATH_NAMESPACE::Box2i& dataWindow);
IMF_HIDDEN
virtual void shiftPixels (int dx, int dy);
IMF_HIDDEN
virtual void insertChannel (
const std::string& name,
PixelType type,
int xSampling,
int ySampling,
bool pLinear);
IMF_HIDDEN
virtual void eraseChannel (const std::string& name);
IMF_HIDDEN
virtual void clearChannels ();
IMF_HIDDEN
virtual void
renameChannel (const std::string& oldName, const std::string& newName);
IMF_HIDDEN
virtual void renameChannels (const RenamingMap& oldToNewNames);
ChannelMap _channels;
SampleCountChannel _sampleCounts;
};
class IMFUTIL_EXPORT_TYPE DeepImageLevel::Iterator
{
public:
IMFUTIL_EXPORT
Iterator ();
IMFUTIL_EXPORT
Iterator (const DeepImageLevel::ChannelMap::iterator& i);
//
// Advance the iterator
//
IMFUTIL_EXPORT
Iterator& operator++ ();
IMFUTIL_EXPORT
Iterator operator++ (int);
//
// Access to the channel to which the iterator points,
// and to the name of that channel.
//
IMFUTIL_EXPORT
const std::string& name () const;
IMFUTIL_EXPORT
DeepImageChannel& channel () const;
private:
friend class DeepImageLevel::ConstIterator;
DeepImageLevel::ChannelMap::iterator _i;
};
class IMFUTIL_EXPORT_TYPE DeepImageLevel::ConstIterator
{
public:
IMFUTIL_EXPORT
ConstIterator ();
IMFUTIL_EXPORT
ConstIterator (const DeepImageLevel::ChannelMap::const_iterator& i);
IMFUTIL_EXPORT
ConstIterator (const DeepImageLevel::Iterator& other);
//
// Advance the iterator
//
IMFUTIL_EXPORT
ConstIterator& operator++ ();
IMFUTIL_EXPORT
ConstIterator operator++ (int);
//
// Access to the channel to which the iterator points,
// and to the name of that channel.
//
IMFUTIL_EXPORT
const std::string& name () const;
IMFUTIL_EXPORT
const DeepImageChannel& channel () const;
private:
friend bool operator== (const ConstIterator&, const ConstIterator&);
friend bool operator!= (const ConstIterator&, const ConstIterator&);
DeepImageLevel::ChannelMap::const_iterator _i;
};
//-----------------------------------------------------------------------------
// Implementation of inline functions
//-----------------------------------------------------------------------------
template <class T>
TypedDeepImageChannel<T>*
DeepImageLevel::findTypedChannel (const std::string& name)
{
return dynamic_cast<TypedDeepImageChannel<T>*> (findChannel (name));
}
template <class T>
const TypedDeepImageChannel<T>*
DeepImageLevel::findTypedChannel (const std::string& name) const
{
return dynamic_cast<const TypedDeepImageChannel<T>*> (findChannel (name));
}
template <class T>
TypedDeepImageChannel<T>&
DeepImageLevel::typedChannel (const std::string& name)
{
TypedDeepImageChannel<T>* ptr = findTypedChannel<T> (name);
if (ptr == 0) throwBadChannelNameOrType (name);
return *ptr;
}
template <class T>
const TypedDeepImageChannel<T>&
DeepImageLevel::typedChannel (const std::string& name) const
{
const TypedDeepImageChannel<T>* ptr = findTypedChannel<T> (name);
if (ptr == 0) throwBadChannelNameOrType (name);
return *ptr;
}
inline SampleCountChannel&
DeepImageLevel::sampleCounts ()
{
return _sampleCounts;
}
inline const SampleCountChannel&
DeepImageLevel::sampleCounts () const
{
return _sampleCounts;
}
inline DeepImageLevel::Iterator::Iterator () : _i ()
{
// empty
}
inline DeepImageLevel::Iterator::Iterator (
const DeepImageLevel::ChannelMap::iterator& i)
: _i (i)
{
// empty
}
inline DeepImageLevel::Iterator&
DeepImageLevel::Iterator::operator++ ()
{
++_i;
return *this;
}
inline DeepImageLevel::Iterator
DeepImageLevel::Iterator::operator++ (int)
{
Iterator tmp = *this;
++_i;
return tmp;
}
inline const std::string&
DeepImageLevel::Iterator::name () const
{
return _i->first;
}
inline DeepImageChannel&
DeepImageLevel::Iterator::channel () const
{
return *_i->second;
}
inline DeepImageLevel::ConstIterator::ConstIterator () : _i ()
{
// empty
}
inline DeepImageLevel::ConstIterator::ConstIterator (
const DeepImageLevel::ChannelMap::const_iterator& i)
: _i (i)
{
// empty
}
inline DeepImageLevel::ConstIterator::ConstIterator (
const DeepImageLevel::Iterator& other)
: _i (other._i)
{
// empty
}
inline DeepImageLevel::ConstIterator&
DeepImageLevel::ConstIterator::operator++ ()
{
++_i;
return *this;
}
inline DeepImageLevel::ConstIterator
DeepImageLevel::ConstIterator::operator++ (int)
{
ConstIterator tmp = *this;
++_i;
return tmp;
}
inline const std::string&
DeepImageLevel::ConstIterator::name () const
{
return _i->first;
}
inline const DeepImageChannel&
DeepImageLevel::ConstIterator::channel () const
{
return *_i->second;
}
inline bool
operator== (
const DeepImageLevel::ConstIterator& x,
const DeepImageLevel::ConstIterator& y)
{
return x._i == y._i;
}
inline bool
operator!= (
const DeepImageLevel::ConstIterator& x,
const DeepImageLevel::ConstIterator& y)
{
return !(x == y);
}
OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
#endif