Current File : //proc/thread-self/root/proc/thread-self/root/proc/self/root/usr/include/OpenEXR/ImfPartHelper.h
///////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2012, Weta Digital Ltd
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Weta Digital nor the names of
// its contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
///////////////////////////////////////////////////////////////////////////
#ifndef INCLUDED_IMF_PARTHELPER_H
#define INCLUDED_IMF_PARTHELPER_H
//-----------------------------------------------------------------------------
//
// Functions to help split channels into separate parts: provide a list of
// channels, with desired views. call SplitChannels to assign a part to each
// layer, or correct the name of the channel.
// Also can enumerate the parts in a file and list which parts channels are in
//
// This is a good way to offer a 'create Multipart file' checkbox to the user in a
// write dialog box: Populate a list of MultiViewChannelName objects,
// call SplitChannels with whether single or multipart files are required.
// Then write the number of parts it specifies, using internal_name for the channel
// names in the ChannelList and FrameBuffer objects. There should be no need
// for different codepaths for single part and multipart files
//
// Similarly, on reading a file as a MultiPartInputFile, use GetChannelsInMultiPartFile to
// enumerate all channels in the file, using internal_name in FrameBuffer objects
// to read the channel
//
//
//-----------------------------------------------------------------------------
#include "ImfForward.h"
#include "ImfNamespace.h"
#include "ImfExport.h"
#include "ImfMultiPartInputFile.h"
#include "ImfChannelList.h"
#include "ImfStringVectorAttribute.h"
#include "ImfStandardAttributes.h"
#include "ImfMultiView.h"
#include <string>
#include <map>
#include <set>
OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
struct MultiViewChannelName{
public:
std::string name; ///< name of channel
std::string view; ///< view for channel
int part_number; ///< part number: updated by SplitChannels
std::string internal_name;///< name used in headers: in singlepart mode, may contain viewname
virtual ~MultiViewChannelName() {}
//return layer for this channel, or "" if no layer
std::string getLayer() const
{
std::size_t q=name.rfind('.');
if( q==name.npos )
{
return "";
}
return name.substr(0,q);
}
std::string getSuffix() const
{
std::size_t q=name.rfind('.');
if( q==name.npos )
{
return name;
}
return name.substr(q+1);
}
};
//
///\brief assigns individual channels to different parts based on their layer and view name
/// input is an array, list, vector etc of MultiViewChannelName objects
/// on entry, each MultiViewChannelName name/view must be set (view can be empty if not multiview)
///
/// if singlepart set, then on exit part_number will be zero, and internal_name will have view name inserted
/// otherwise, each channel will be assigned to a different part based on its layer name and view name
///
/// @param begin pointer to first MultiViewChannelName item
/// @param end pointer to end of MultiViewChannelName item array
/// @return total number of parts required
//
template<typename T> int
SplitChannels(const T & begin,const T & end,bool multipart=true,const std::string & heroView="")
{
if(!multipart)
{
for(T i=begin;i!=end;i++)
{
i->part_number=0;
//does this have a view name set?
if(i->view=="")
{
i->internal_name=i->name;
}else{
std::string lname = i->getLayer();
// no layer, only non-hero views get view name in layer name
if(lname=="")
{
if(i->view==heroView)
{
i->internal_name = i->name;
}else{
i->internal_name = i->view+"."+i->name;
}
}else{
i->internal_name = lname+"."+i->view+"."+i->getSuffix();
}
}
}
// single part created
return 1;
}else{
// step 1: extract individual layers and parts
// for each layer, enumerate which views are active
std::map< std::string , std::set< std::string > > viewsInLayers;
for(T i=begin;i!=end;i++)
{
viewsInLayers[i->getLayer()].insert(i->view);
}
// step 2: assign a part number to each layer/view
std::map< std::pair<std::string,std::string> , int > layerToPart;
int partCount=0;
for(std::map< std::string , std::set< std::string > >::const_iterator layer=viewsInLayers.begin();
layer!=viewsInLayers.end();layer++)
{
// if this layer has a heroView, insert that first
bool layer_has_hero = layer->second.find(heroView)!=layer->second.end();
if( layer_has_hero )
{
layerToPart[ std::make_pair(layer->first,heroView) ] = partCount++;
}
// insert other layers which aren't the hero view
for(std::set< std::string >::const_iterator view=layer->second.begin();
view!=layer->second.end();view++)
{
if(*view!=heroView)
{
layerToPart[ std::make_pair(layer->first,*view) ] = partCount++;
}
}
}
// step 3: update part number of each provided channel
for( T i=begin;i!=end;i++)
{
i->internal_name=i->name;
i->part_number = layerToPart[ std::make_pair(i->getLayer(),i->view) ];
}
// return number of parts created
return partCount;
}
}
//
// populate the chans vector<MultiViewChannelName> with a list of channels in the file
// and their corresponding part number
//
template<class T> void
GetChannelsInMultiPartFile(const MultiPartInputFile & file,T & chans)
{
bool has_multiview=false;
StringVector mview;
if(file.parts()==1)
{
if(hasMultiView(file.header(0)))
{
mview=multiView(file.header(0));
has_multiview=true;
}
}
for(int p=0;p<file.parts();p++)
{
const ChannelList & c=file.header(p).channels();
std::string view="";
if(file.header(p).hasView())
{
view=file.header(p).view();
}
for(ChannelList::ConstIterator i=c.begin();i!=c.end();i++)
{
MultiViewChannelName m;
m.name=std::string(i.name());
m.internal_name=m.name;
if(has_multiview)
{
m.view=viewFromChannelName(m.name,mview);
m.name=removeViewName(m.internal_name,m.view);
}else{
m.view=view;
}
m.part_number=p;
chans.push_back(m);
}
}
}
OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
#endif
Mini Shell