// TnzCore includes
#include "tundo.h"
#include "tconvert.h"
#include "tstream.h"
// TnzBase includes
#include "tdoubleparam.h"
// STD includes
#include <set>
#include "tspectrumparam.h"
typedef std::pair<TDoubleParamP, TPixelParamP> ColorKeyParam;
//=========================================================
class TSpectrumParamImp
{
TSpectrumParam *m_sp;
std::vector<ColorKeyParam> m_keys;
public:
bool m_draggingEnabled;
bool m_notificationEnabled;
bool m_isMatteEnabled;
std::set<TParamObserver *> m_observers;
public:
TSpectrumParamImp(TSpectrumParam *sp) : m_sp(sp), m_keys(), m_draggingEnabled(false), m_notificationEnabled(true), m_isMatteEnabled(true)
{
}
TSpectrumParamImp(const TSpectrumParamImp &s)
{
copy(s);
}
void copy(const TSpectrumParamImp &src)
{
m_keys.clear();
std::vector<ColorKeyParam>::const_iterator it = src.m_keys.begin();
for (; it != src.m_keys.end(); ++it) {
TDoubleParamP s(it->first->clone());
TPixelParamP c(it->second->clone());
m_keys.push_back(std::make_pair(s, c));
}
}
void addKey(const ColorKeyParam &colorKey)
{
/*
m_sp->addParam(colorKey.first);
m_sp->addParam(colorKey.second);
*/
m_keys.push_back(colorKey);
}
void insertKey(int index, ColorKeyParam &colorKey)
{
/*
m_sp->addParam(colorKey.first);
m_sp->addParam(colorKey.second);
*/
std::vector<ColorKeyParam>::iterator it = m_keys.begin() + index;
m_keys.insert(it, colorKey);
}
void eraseKey(int index)
{
std::vector<ColorKeyParam>::iterator colorKeyIt = m_keys.begin() + index;
/*
m_sp->removeParam((*colorKeyIt).first);
m_sp->removeParam((*colorKeyIt).second);
*/
m_keys.erase(colorKeyIt);
}
int getKeyCount() const
{
return m_keys.size();
}
ColorKeyParam getKey(int index) const
{
return m_keys[index];
}
void clearKeys()
{
m_keys.clear();
}
void notify(const TParamChange &change)
{
for (std::set<TParamObserver *>::iterator it = m_observers.begin();
it != m_observers.end(); ++it)
(*it)->onChange(change);
}
private:
TSpectrumParamImp &operator=(const TSpectrumParamImp &); //not implemented
};
//=========================================================
PERSIST_IDENTIFIER(TSpectrumParam, "spectrumParam")
//---------------------------------------------------------
TSpectrumParam::TSpectrumParam(): m_imp(new TSpectrumParamImp(this)) //brutto...
{
ColorKeyParam ck1(TDoubleParamP(0.0), TPixelParamP(TPixel32::Black));
ColorKeyParam ck2(TDoubleParamP(1.0), TPixelParamP(TPixel32::White));
m_imp->addKey(ck1);
m_imp->addKey(ck2);
}
//---------------------------------------------------------
TSpectrumParam::TSpectrumParam(const TSpectrumParam &src)
: TParam(src.getName())
, m_imp(new TSpectrumParamImp(*src.m_imp))
{
}
//---------------------------------------------------------
void TSpectrumParam::addObserver(TParamObserver *obs)
{
m_imp->m_observers.insert(obs);
}
//---------------------------------------------------------
void TSpectrumParam::removeObserver(TParamObserver *obs)
{
m_imp->m_observers.erase(obs);
}
//---------------------------------------------------------
TSpectrumParam::TSpectrumParam(int keyCount, TSpectrum::ColorKey keys[])
: m_imp(new TSpectrumParamImp(this))
{
for (int i = 0; i < keyCount; i++) {
double v = keys[i].first;
TPixel32 pix = keys[i].second;
TDoubleParamP dp(v);
TPixelParamP pp(pix);
pp->enableMatte(m_imp->m_isMatteEnabled);
ColorKeyParam ck(dp, pp);
m_imp->addKey(ck);
}
}
//---------------------------------------------------------
void TSpectrumParam::copy(TParam *src)
{
TSpectrumParam *p = dynamic_cast<TSpectrumParam *>(src);
if (!p)
throw TException("invalid source for copy");
setName(src->getName());
m_imp->copy(*(p->m_imp));
}
//---------------------------------------------------------
TSpectrumParam::~TSpectrumParam()
{
}
//---------------------------------------------------------
TSpectrum TSpectrumParam::getValue(double frame) const
{
assert(m_imp);
std::vector<TSpectrum::ColorKey> keys;
int keyCount = m_imp->getKeyCount();
for (int i = 0; i < keyCount; i++) {
ColorKeyParam paramKey = m_imp->getKey(i);
TSpectrum::ColorKey key(
paramKey.first->getValue(frame),
paramKey.second->getValue(frame));
keys.push_back(key);
}
return TSpectrum(keys.size(), &keys[0]);
}
//---------------------------------------------------------
TSpectrum64 TSpectrumParam::getValue64(double frame) const
{
assert(m_imp);
std::vector<TSpectrum64::ColorKey> keys;
int keyCount = m_imp->getKeyCount();
for (int i = 0; i < keyCount; i++) {
ColorKeyParam paramKey = m_imp->getKey(i);
TSpectrum64::ColorKey key(
paramKey.first->getValue(frame),
toPixel64(paramKey.second->getValue(frame)));
keys.push_back(key);
}
return TSpectrum64(keys.size(), &keys[0]);
}
//---------------------------------------------------------
void TSpectrumParam::setValue(double frame, const TSpectrum &spectrum, bool undoing)
{
assert(getKeyCount() == spectrum.getKeyCount());
int keyCount = getKeyCount();
for (int i = 0; i < keyCount; i++) {
TSpectrum::Key key = spectrum.getKey(i);
setValue(frame, i, key.first, key.second, undoing);
}
}
//---------------------------------------------------------
TDoubleParamP TSpectrumParam::getPosition(int index) const
{
assert(index <= m_imp->getKeyCount());
return m_imp->getKey(index).first;
}
//---------------------------------------------------------
TPixelParamP TSpectrumParam::getColor(int index) const
{
assert(index <= m_imp->getKeyCount());
return m_imp->getKey(index).second;
}
//---------------------------------------------------------
int TSpectrumParam::getKeyCount() const
{
assert(m_imp);
return m_imp->getKeyCount();
}
//---------------------------------------------------------
void TSpectrumParam::setValue(double frame, int index, double s, const TPixel32 &color, bool undoing)
{
assert(m_imp);
int keyCount = m_imp->getKeyCount();
if (index < 0 || index >= keyCount)
throw TException("TSpectrumParam::setValue. Index out of range");
ColorKeyParam key = m_imp->getKey(index);
// beginParameterChange();
key.first->setValue(frame, s);
key.second->setValue(frame, color);
// endParameterChange();
m_imp->notify(TParamChange(this, TParamChange::m_minFrame, TParamChange::m_maxFrame, true, m_imp->m_draggingEnabled, false));
}
//---------------------------------------------------------
void TSpectrumParam::setDefaultValue(const TSpectrum &value)
{
assert(value.getKeyCount() == getKeyCount());
for (int i = 0; i < getKeyCount(); i++) {
ColorKeyParam dstKeyParam = m_imp->getKey(i);
TSpectrum::Key srcKey = value.getKey(i);
dstKeyParam.first->setDefaultValue(srcKey.first);
dstKeyParam.second->setDefaultValue(srcKey.second);
}
}
//---------------------------------------------------------
void TSpectrumParam::insertKey(int index, double s, const TPixel32 &color)
{
assert(m_imp);
int keyCount = m_imp->getKeyCount();
if (index < 0)
index = 0;
else if (index >= keyCount)
index = keyCount;
TDoubleParamP dp(s);
TPixelParamP pp(color);
pp->enableMatte(m_imp->m_isMatteEnabled);
ColorKeyParam ck(dp, pp);
m_imp->insertKey(index, ck);
}
//---------------------------------------------------------
void TSpectrumParam::addKey(double s, const TPixel32 &color)
{
/*
assert(m_imp);
insertKey(m_imp->getKeyCount(), s,color);
*/
int index = m_imp->getKeyCount();
assert(m_imp);
int keyCount = m_imp->getKeyCount();
if (index < 0)
index = 0;
else if (index >= keyCount)
index = keyCount;
TDoubleParamP dp(s);
TPixelParamP pp(color);
pp->enableMatte(m_imp->m_isMatteEnabled);
ColorKeyParam ck(dp, pp);
m_imp->insertKey(index, ck);
}
//---------------------------------------------------------
void TSpectrumParam::removeKey(int index)
{
assert(m_imp);
int keyCount = m_imp->getKeyCount();
if (index < 0 || index >= keyCount)
throw TException("TSpectrumParam::removeKey. Index out of range");
m_imp->eraseKey(index);
}
//---------------------------------------------------------
bool TSpectrumParam::isKeyframe(double frame) const
{
int keyCount = m_imp->getKeyCount();
for (int i = 0; i < keyCount; i++) {
ColorKeyParam currentKey = m_imp->getKey(i);
if (currentKey.first->isKeyframe(frame))
return true;
if (currentKey.second->isKeyframe(frame))
return true;
}
return false;
}
//---------------------------------------------------------
void TSpectrumParam::deleteKeyframe(double frame)
{
int keyCount = m_imp->getKeyCount();
for (int i = 0; i < keyCount; i++) {
ColorKeyParam currentKey = m_imp->getKey(i);
currentKey.first->deleteKeyframe(frame);
currentKey.second->deleteKeyframe(frame);
}
}
//---------------------------------------------------------
void TSpectrumParam::clearKeyframes()
{
assert(m_imp);
int k, keyCount = m_imp->getKeyCount();
for (k = 0; k < keyCount; ++k) {
const ColorKeyParam &key = m_imp->getKey(k);
key.first->clearKeyframes();
key.second->clearKeyframes();
}
m_imp->notify(TParamChange(this, TParamChange::m_minFrame, TParamChange::m_maxFrame, true, m_imp->m_draggingEnabled, false));
}
//---------------------------------------------------------
void TSpectrumParam::assignKeyframe(
double frame,
const TParamP &src, double srcFrame,
bool changedOnly)
{
TSpectrumParamP spectrum = src;
if (!spectrum)
return;
int keyCount = m_imp->getKeyCount();
if (keyCount != spectrum->m_imp->getKeyCount())
return;
for (int i = 0; i < keyCount; i++) {
ColorKeyParam dstKey = m_imp->getKey(i);
ColorKeyParam srcKey = spectrum->m_imp->getKey(i);
dstKey.first->setValue(frame, srcKey.first->getValue(srcFrame));
dstKey.second->setValue(frame, srcKey.second->getValue(srcFrame));
}
}
//---------------------------------------------------------
void TSpectrumParam::loadData(TIStream &is)
{
assert(m_imp);
m_imp->clearKeys();
std::string tagName;
is.openChild(tagName);
assert(tagName == "spectrum");
while (!is.eos()) {
TDoubleParamP pos(0.0);
TPixelParamP color(TPixel32::Black);
is.openChild(tagName);
pos->loadData(is);
is.closeChild();
is.openChild(tagName);
color->loadData(is);
is.closeChild();
ColorKeyParam ck(pos, color);
m_imp->addKey(ck);
}
is.closeChild();
}
//---------------------------------------------------------
void TSpectrumParam::saveData(TOStream &os)
{
assert(m_imp);
int keyCount = m_imp->getKeyCount();
os.openChild("spectrum");
for (int i = 0; i < keyCount; i++) {
ColorKeyParam key = m_imp->getKey(i);
os.openChild("s_value");
key.first->saveData(os);
os.closeChild();
os.openChild("col_value");
key.second->saveData(os);
os.closeChild();
}
os.closeChild();
}
//---------------------------------------------------------
void TSpectrumParam::enableDragging(bool on)
{
m_imp->m_draggingEnabled = on;
}
//---------------------------------------------------------
void TSpectrumParam::enableNotification(bool on)
{
m_imp->m_notificationEnabled = on;
}
//---------------------------------------------------------
bool TSpectrumParam::isNotificationEnabled() const
{
return m_imp->m_notificationEnabled;
}
//---------------------------------------------------------
namespace
{
inline std::string toString(const TPixel32 &color)
{
std::string alias = "(";
alias += ::toString(color.r) + ",";
alias += ::toString(color.g) + ",";
alias += ::toString(color.b) + ",";
alias += ::toString(color.m);
alias += ")";
return alias;
}
inline std::string toString(const TSpectrum::ColorKey &key, int precision)
{
std::string alias = "(";
alias += ::toString(key.first, precision) + ",";
alias += toString(key.second);
alias += ")";
return alias;
}
} // namespace
std::string TSpectrumParam::getValueAlias(double frame, int precision)
{
std::vector<TSpectrum::ColorKey> keys;
int keyCount = m_imp->getKeyCount();
for (int i = 0; i < keyCount; i++) {
ColorKeyParam paramKey = m_imp->getKey(i);
TSpectrum::ColorKey key(
paramKey.first->getValue(frame),
paramKey.second->getValue(frame));
keys.push_back(key);
}
std::string alias = "(";
if (!keys.empty()) {
std::vector<TSpectrum::ColorKey>::iterator it = keys.begin();
std::vector<TSpectrum::ColorKey>::iterator end = keys.begin();
std::advance(end, keys.size() - 1);
for (; it != end; ++it) {
alias += toString(*it, precision);
alias += ",";
}
alias += toString(*it, precision);
}
alias += ")";
return alias;
}
//=========================================================
//---------------------------------------------------------
void TSpectrumParam::enableMatte(bool on)
{
m_imp->m_isMatteEnabled = on;
}
//---------------------------------------------------------
bool TSpectrumParam::isMatteEnabled() const
{
return m_imp->m_isMatteEnabled;
}
//---------------------------------------------------------
bool TSpectrumParam::hasKeyframes() const
{
int keyCount = m_imp->getKeyCount();
for (int i = 0; i < keyCount; i++) {
ColorKeyParam currentKey = m_imp->getKey(i);
if (currentKey.first->hasKeyframes() || currentKey.second->hasKeyframes())
return true;
}
return false;
}
//---------------------------------------------------------
void TSpectrumParam::getKeyframes(std::set<double> &frames) const
{
int keyCount = m_imp->getKeyCount();
for (int i = 0; i < keyCount; i++) {
ColorKeyParam currentKey = m_imp->getKey(i);
currentKey.first->getKeyframes(frames);
currentKey.second->getKeyframes(frames);
}
}
//---------------------------------------------------------
int TSpectrumParam::getNextKeyframe(double frame) const
{
std::set<double> frames;
getKeyframes(frames);
std::set<double>::iterator it = frames.upper_bound(frame);
if (it == frames.end())
return -1;
else
return std::distance(frames.begin(), it);
}
//---------------------------------------------------------
int TSpectrumParam::getPrevKeyframe(double frame) const
{
std::set<double> frames;
getKeyframes(frames);
std::set<double>::iterator it = frames.lower_bound(frame);
if (it == frames.begin())
return -1;
else {
--it;
return std::distance(frames.begin(), it);
}
}
//---------------------------------------------------------
double TSpectrumParam::keyframeIndexToFrame(int index) const
{
std::set<double> frames;
getKeyframes(frames);
assert(0 <= index && index < (int)frames.size());
std::set<double>::const_iterator it = frames.begin();
std::advance(it, index);
return *it;
}
TIStream &operator>>(TIStream &in, TSpectrumParamP &p)
{
TPersist *tmp;
in >> tmp;
p = TSpectrumParamP(dynamic_cast<TSpectrumParam *>(tmp));
return in;
}