point.h

/* 
 * Copyright (C) 2006-2013  Music Technology Group - Universitat Pompeu Fabra
 *
 * This file is part of Gaia
 * 
 * Gaia is free software: you can redistribute it and/or modify it under 
 * the terms of the GNU Affero General Public License as published by the Free 
 * Software Foundation (FSF), either version 3 of the License, or (at your 
 * option) any later version.
 * 
 * This program is distributed in the hope that it will be useful, but WITHOUT 
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 
 * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more 
 * details.
 * 
 * You should have received a copy of the Affero GNU General Public License
 * version 3 along with this program.  If not, see http://www.gnu.org/licenses/
 */

#ifndef GAIA_POINT_H
#define GAIA_POINT_H

#include <QStringList>
#include <QTextStream>
#include <vector>
#include "types.h"
#include "pointlayout.h"
#include "descriptor.h"
#include "yamlcpp.h"


namespace gaia2 {


class UnscopedData {
 public:
  RealDescriptor freal;
  Array<RealDescriptor> vreal;
  StringDescriptor flabel;
  Array<StringDescriptor> vlabel;
  EnumDescriptor fenumeration;
  Array<EnumDescriptor> venumeration;

  UnscopedData() : freal(0, Real()), flabel(0, QString()), fenumeration(0, Enum()) {}

  bool operator==(const UnscopedData& rhs) const {
    return (this->vreal == rhs.vreal)
      && (this->vlabel == rhs.vlabel)
      && (this->venumeration == rhs.venumeration)
      && (this->freal == rhs.freal)
      && (this->flabel == rhs.flabel)
      && (this->fenumeration == rhs.fenumeration);
  }
};

class Scope {
 public:
  QString name;
  Real start, end;
  Scope() : name(""), start(0.0), end(0.0) {}

  bool operator==(const Scope& rhs) const {
    return (this->name == rhs.name)
      && (this->start == rhs.start)
      && (this->end == rhs.end);
  }

  friend QDataStream& operator<<(QDataStream& out, const Scope& scope);
  friend QDataStream& operator>>(QDataStream& in, Scope& scope);
};

class ScopedData {
 public:
  Scope scope;
  UnscopedData data;

  bool operator==(const ScopedData& rhs) const {
    return (this->scope == rhs.scope) && (this->data == rhs.data);
  }

  bool operator!=(const ScopedData& rhs) const {
    return !operator==(rhs);
  }
};

QDataStream& operator<<(QDataStream& out, const ScopedData& s);
QDataStream& operator>>(QDataStream& in, ScopedData& s);


// actual point representation is point.scope.name.idx
// (e.g.: p->_data[scope_idx].data.real[name_idx][index_in_desc]
// is it smarter to have it like point.name.scope.idx
// (e.g.: p->_data.real[name_idx][scope_idx][index_in_desc]
// the first one is smarter when we want to be able to easily compute distances
// between two segments, including all descriptors, the second one is better if
// we want to compute distances between 2 descriptors, the scope maybe
// differents (e.g.: compute the distance between 2 beat segmentations...)
//
// first solution also means that we may want to have a layout for each scope
// e.g.: global -> only including bpm, key, etc...
//       segments -> centroid, zcr, etc...

class Point {

 public:

  // NOTE: refrain from returning a const ref here, as it creates memory problems
  //       with (at least) swig
  QString name() const { return _name; }

  void setName(const QString& name) { _name = name; }

  void load(const QString& filename,
            const QStringList& select = QStringList() << "*",
            const QStringList& exclude = QStringList());

  void loadFromString(const std::string& str,
                      const QStringList& select = QStringList() << "*",
                      const QStringList& exclude = QStringList());


  void fromBase64(const std::string& data);

  void fromBase64(const QByteArray& data);

  std::string toBase64() const;


  Point() : _data(1) {}
  Point(const Point& rhs) : _name(rhs._name), _data(rhs._data), _layout(rhs._layout) {}
  Point(const PointLayout& layout);
  Point(const QString& name, const PointLayout& layout);
  Point(const std::string& name, const PointLayout& layout);

  Point& operator=(const Point& rhs) {
    _name = rhs._name;
    _data = rhs._data;
    _layout = rhs._layout;
    return *this;
  }

  ~Point();

  bool operator==(const Point& rhs) const;

  static Point* fromSingleSegment(const Point* point, int nsegment);

  void setSegment(int nsegment, const Point* point, int origsegment = 0);

  const PointLayout& layout() const { return _layout; }

  PointLayout& layout() { return _layout; }

  void setLayout(const PointLayout& layout, int nsegments = 0);

  void switchLayout(const PointLayout& layout);

  //------- data access methods -------------------------------------
  const Array<ScopedData>& data() const { return _data; }
  Array<ScopedData>& data() { return _data; }

  int numberSegments() const { return _data.size(); }

  RealDescriptor value(const QString& name) const;
  RealDescriptor value(int nsegment, const QString& name) const;

  StringDescriptor label(const QString& name) const;
  StringDescriptor label(int nsegment, const QString& name) const;

  void setValue(const QString& name, const RealDescriptor& value);
  void setValue(int nsegment, const QString& name, const RealDescriptor& value);

  void setLabel(const QString& name, const StringDescriptor& label);
  void setLabel(int nsegment, const QString& name, const StringDescriptor& label);

  const Array<RealDescriptor>& vrealData(int i=0) const { return _data[i].data.vreal; }
  Array<RealDescriptor>& vrealData(int i=0) { return _data[i].data.vreal; }

  const Array<StringDescriptor>& vstringData(int i=0) const { return _data[i].data.vlabel; }
  Array<StringDescriptor>& vstringData(int i=0) { return _data[i].data.vlabel; }

  const Array<EnumDescriptor>& venumData(int i=0) const { return _data[i].data.venumeration; }
  Array<EnumDescriptor>& venumData(int i=0) { return _data[i].data.venumeration; }

  const RealDescriptor& frealData(int i=0) const { return _data[i].data.freal; }
  RealDescriptor& frealData(int i=0) { return _data[i].data.freal; }

  const StringDescriptor& fstringData(int i=0) const { return _data[i].data.flabel; }
  StringDescriptor& fstringData(int i=0) { return _data[i].data.flabel; }

  const EnumDescriptor& fenumData(int i=0) const { return _data[i].data.fenumeration; }
  EnumDescriptor& fenumData(int i=0) { return _data[i].data.fenumeration; }

  const Scope& scope(int i=0) const { checkValidSegment(this, i); return _data[i].scope; }
  Scope& scope(int i=0) { checkValidSegment(this, i); return _data[i].scope; }

 protected:
  QString _name;

  Array<ScopedData> _data;

  // should we have a layout for each different scope?
  // QMap<Scope, PointLayout*> _layouts;
  // e.g.: global -> only including bpm, key, etc...
  //       segments -> centroid, zcr, etc...
  PointLayout _layout;

  void setLayoutUnsafe(const PointLayout& layout) {
    _layout = layout;
  }

  void remapLayoutAndEnums(const PointLayout& layout);

  static void checkValidSegment(const Point* point, int segment);

  void applyLayout(int nsegments);

  void yamlNodeToLayout(const yaml::Node& root, PointLayout& layout,
                        const QString& parentName = "");

  void fillLayout(const yaml::Node& root, const PointLayout& layout,
                  UnscopedData& data, const QString& parentName = "");

  void load(yaml::Node& node,
            const QStringList& select,
            const QStringList& exclude);

  friend class DataSet; // mostly to be able to access setLayoutUnsafe

  friend QDataStream& operator<<(QDataStream& out, const Point& point);
  friend QDataStream& operator>>(QDataStream& in, Point& point);
};


// some useful defines that will be used in lots of places
#define FORSEG(p) for (int nseg=0; nseg<(p).numberSegments(); nseg++)

} // namespace gaia2

#endif // GAIA_POINT_H