opencv/3rdparty/openexr/IlmImf/ImfMultiView.cpp

///////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2007, 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.
//
///////////////////////////////////////////////////////////////////////////

//-----------------------------------------------------------------------------
//
//	Functions related to accessing channels
//	and views in multi-view OpenEXR files.
//
//-----------------------------------------------------------------------------

#include <ImfMultiView.h>

using namespace std;

namespace Imf {
namespace {

StringVector
parseString (string name, char c = '.')
{
    //
    // Turn name into a list of strings, separating
    // on char 'c' with whitespace stripped.
    //

    StringVector r;

    while (name.size() > 0)
    {  
	size_t s = name.find (c);
	string sec = name.substr (0, s);

	//
	// Strip spaces from beginning
	//

	while (sec.size() > 0 && sec[0] == ' ')
	    sec.erase (0, 1);

	//
	// Strip spaces from end
	//

	while (sec.size() > 0 && sec[sec.size() - 1] == ' ')
	    sec.erase (sec.size() - 1);

	r.push_back (sec);

	//
	// Strip off name including ending 'c'
	//

	if (s == name.npos)
	    name = "";
	else
	    name = name.substr (s + 1);
    } 

    return r;
}


int
viewNum (const string &view, const StringVector &multiView)
{
    //
    // returns which view number is called 'view'
    // returns -1 if no member of multiView is 'view'
    // (i.e. if viewNum() returns -1, 'view' isn't a view name
    //       if viewNum() returns 0, 'view' is the default view
    // otherwise, it's some other (valid) view
    //

    for (int i = 0; i < multiView.size(); ++i)
    {
	if (multiView[i] == view)
	    return i;
    }

    return -1;
}

} // namespace


string
defaultViewName (const StringVector &multiView)
{
    if (multiView.size() > 0)
	return multiView[0];
    else
	return "";
}


string
viewFromChannelName (const string &channel,
		     const StringVector &multiView)
{
    //
    // Given the name of a channel, return the name of the view to
    // which it belongs.
    //

    //
    // View name is penultimate section of name separated by periods ('.'s)
    //

    StringVector s = parseString (channel, '.');

    if (s.size() == 0)
	return ""; // nothing in, nothing out

    if (s.size() == 1)
    {
	//
	// Return default view name.
	// The rules say ALL channels with no periods
	// in the name belong to the default view.
	//

	return multiView[0];
    }
    else
    { 
	//
	// size >= 2 - the last part is the channel name,
	// the next-to-last part is the view name.
	// Check if that part of the name really is
	// a valid view and, if it is, return it.
	//

	const string &viewName = s[s.size() - 2];

	if (viewNum (viewName, multiView) >= 0)
	    return viewName;
	else
	    return ""; // not associated with any particular view
    }
}


ChannelList
channelsInView (const string & viewName,
	        const ChannelList & channelList,
		const StringVector & multiView)
{
    //
    // Return a list of all channels belonging to view viewName.
    //

    ChannelList q;

    for (ChannelList::ConstIterator i = channelList.begin();
	 i != channelList.end();
	 ++i)
    {
	//
	// Get view name for this channel
	//

	string view = viewFromChannelName (i.name(), multiView);


	//
	// Insert channel into q if it's a member of view viewName
	//

	if (view == viewName)
	   q.insert (i.name(), i.channel());
    }

    return q;
}


ChannelList
channelsInNoView (const ChannelList &channelList,
		  const StringVector &multiView)
{
    //
    // Return a list of channels not associated with any named view.
    //

    return channelsInView ("", channelList, multiView); 
}



bool
areCounterparts (const string &channel1, 
	         const string &channel2,
		 const StringVector &multiView)
{
    //
    // Given two channels, return true if they are the same
    // channel in two different views.
    //

    StringVector chan1 = parseString (channel1);
    unsigned int size1 = chan1.size();	// number of SECTIONS in string
    					// name (not string length)

    StringVector chan2 = parseString (channel2);
    unsigned int size2 = chan2.size();

    if (size1 == 0 || size2 == 0)
	return false;
     
    //
    // channel1 and channel2 can't be counterparts
    // if either channel is in no view.
    //

    if (size1 > 1 && viewNum (chan1[size1 - 2], multiView) == -1)
	return false;

    if (size2 > 1 && viewNum (chan2[size2 - 2], multiView) == -1)
	return false; 

    if (viewFromChannelName (channel1, multiView) ==
	viewFromChannelName (channel2, multiView))
    {
	//
	// channel1 and channel2 are not counterparts
	// if they are in the same view.
	//

	return false;
    }

    if (size1 == 1)
    { 
	//
	// channel1 is a default channel - the channels will only be
	// counterparts if channel2 is of the form <view>.<channel1>
	//

	return size2 == 2 && chan1[0] == chan2[1];
    }

    if (size2 == 1)
    {
	//
	// channel2 is a default channel - the channels will only be
	// counterparts if channel1 is of the form <view>.<channel2>
	//

	return size1 == 2 && chan2[0] == chan1[1];
    }

    //
    // Neither channel is a default channel.  To be counterparts both
    // channel names must have the same number of components, and
    // all components except the penultimate one must be the same.
    //

    if (size1 != size2)
	return false;

    for(int i = 0; i < size1; ++i)
    {
	if (i != size1 - 2 && chan1[i] != chan2[i])
	    return false;
    }

    return true;
}


ChannelList
channelInAllViews (const string &channelName,
		   const ChannelList &channelList,
		   const StringVector &multiView)
{
    //
    // Given the name of a channel, return a
    // list of the same channel in all views.
    //

    ChannelList q;

    for (ChannelList::ConstIterator i=channelList.begin();
	 i != channelList.end();
	 ++i)
    {
	if (i.name() == channelName ||
	    areCounterparts (i.name(), channelName, multiView))
	{
	    q.insert (i.name(), i.channel());
	}
    }

    return q;
}


string
channelInOtherView (const string &channelName,
		    const ChannelList &channelList,
		    const StringVector &multiView,
		    const string &otherViewName)
{
    //
    // Given the name of a channel in one view, return the
    // corresponding channel name for view otherViewName.
    //

    for (ChannelList::ConstIterator i=channelList.begin();
	 i != channelList.end();
	 ++i)
    {
	if (viewFromChannelName (i.name(), multiView) == otherViewName &&
	    areCounterparts (i.name(), channelName, multiView))
	{
	    return i.name(); 
	}
    }

    return "";
}


string
insertViewName (const string &channel,
		const StringVector &multiView,
		int i)
{
    //
    // Insert multiView[i] into the channel name if appropriate.
    //

    StringVector s = parseString (channel, '.');

    if (s.size() == 0)
	return ""; // nothing in, nothing out

    if (s.size() == 1 && i == 0)
    {
	//
	// Channel in the default view, with no periods in its name.
	// Do not insert view name.
	//

	return channel;
    }

    //
    // View name becomes penultimate section of new channel name.
    //

    string newName;

    for (int j = 0; j < s.size(); ++j)
    {
	if (j < s.size() - 1)
	    newName += s[j] + ".";
	else
	    newName += multiView[i] + "." + s[j];
    }

    return newName;
}


} // namespace Imf