/* -*- c++ -*- */

/*

 * Copyright 2010, 2011 Free Software Foundation, Inc.

 *

 * This file is part of GNU Radio

 *

 * GNU Radio is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 3, or (at your option)

 * any later version.

 *

 * GNU Radio 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 GNU General Public License

 * along with GNU Radio; see the file COPYING.  If not, write to

 * the Free Software Foundation, Inc., 51 Franklin Street,

 * Boston, MA 02110-1301, USA.

 */

#ifndef INCLUDED_DIGITAL_CONSTELLATION_H

#define        INCLUDED_DIGITAL_CONSTELLATION_H

#include <vector>

#include <math.h>

#include <gr_complex.h>

#include <boost/enable_shared_from_this.hpp>

#include <digital_metric_type.h>

/************************************************************/

/* digital_constellation                                    */

/*                                                          */

/* Base class defining interface.                           */

/************************************************************/

class digital_constellation;

typedef boost::shared_ptr<digital_constellation> digital_constellation_sptr;

/*!

 * \brief An abstracted constellation object

 * \ingroup digital

 *

 * The constellation objects hold the necessary information to pass

 * around constellation information for modulators and

 * demodulators. These objects contain the mapping between the bits

 * and the constellation points used to represent them as well as

 * methods for slicing the symbol space. Various implementations are

 * possible for efficiency and ease of use.

 *

 * Standard constellations (BPSK, QPSK, QAM, etc) can be inherited

 * from this class and overloaded to perform optimized slicing and

 * constellation mappings.

 */

class digital_constellation : public boost::enable_shared_from_this<digital_constellation>

{

public:

  digital_constellation (std::vector<gr_complex> constellation,

                         std::vector<unsigned int> pre_diff_code,

                         unsigned int rotational_symmetry,

                         unsigned int dimensionality);

  digital_constellation ();

  //! Returns the constellation points for a symbol value

  void map_to_points(unsigned int value, gr_complex *points);

  std::vector<gr_complex> map_to_points_v(unsigned int value);

  //! Returns the constellation point that matches best.

  virtual unsigned int decision_maker (const gr_complex *sample) = 0;

  //! Takes a vector rather than a pointer.  Better for SWIG wrapping.

  unsigned int decision_maker_v (std::vector<gr_complex> sample);

  //! Also calculates the phase error.

  unsigned int decision_maker_pe (const gr_complex *sample, float *phase_error);

  //! Calculates distance.

  unsigned int decision_maker_e (const gr_complex *sample, float *error);

  //! Calculates metrics for all points in the constellation.

  //! For use with the viterbi algorithm.

  virtual void calc_metric(const gr_complex *sample, float *metric, trellis_metric_type_t type);

  virtual void calc_euclidean_metric(const gr_complex *sample, float *metric);

  virtual void calc_hard_symbol_metric(const gr_complex *sample, float *metric);

  //! Returns the set of points in this constellation.

  std::vector<gr_complex> points() { return d_constellation;}

  //! Returns the vector of points in this constellation.

  //! Raise error if dimensionality is not one.

  std::vector<gr_complex> s_points();

  //! Returns a vector of vectors of points.

  std::vector<std::vector<gr_complex> > v_points();

  //! Whether to apply an encoding before doing differential encoding. (e.g. gray coding)

  bool apply_pre_diff_code() { return d_apply_pre_diff_code;}

  //! Whether to apply an encoding before doing differential encoding. (e.g. gray coding)

  void set_pre_diff_code(bool a) { d_apply_pre_diff_code = a;}

  //! Returns the encoding to apply before differential encoding.

  std::vector<unsigned int> pre_diff_code() { return d_pre_diff_code;}

  //! Returns the order of rotational symmetry.

  unsigned int rotational_symmetry() { return d_rotational_symmetry;}

  //! Returns the number of complex numbers in a single symbol.

  unsigned int dimensionality() {return d_dimensionality;}

  unsigned int bits_per_symbol () {

    return floor(log(double(d_constellation.size()))/d_dimensionality/log(2.0));

  }

  unsigned int arity () {

    return d_arity;

  }

  digital_constellation_sptr base() {

    return shared_from_this();

  }  

 protected:

  std::vector<gr_complex> d_constellation;

  std::vector<unsigned int> d_pre_diff_code; 

  bool d_apply_pre_diff_code;

  unsigned int d_rotational_symmetry;

  unsigned int d_dimensionality;

  unsigned int d_arity;

  float get_distance(unsigned int index, const gr_complex *sample);

  unsigned int get_closest_point(const gr_complex *sample);

  void calc_arity ();

};

/************************************************************/

/* digital_constellation_calcdist                           */

/*                                                          */

/************************************************************/

class digital_constellation_calcdist;

typedef boost::shared_ptr<digital_constellation_calcdist> digital_constellation_calcdist_sptr;

// public constructor

digital_constellation_calcdist_sptr

digital_make_constellation_calcdist (std::vector<gr_complex> constellation,

                                     std::vector<unsigned int> pre_diff_code,

                                     unsigned int rotational_symmetry,

                                     unsigned int dimensionality);

/*! \brief Calculate Euclidian distance for any constellation

 *  \ingroup digital

 *

 * Constellation which calculates the distance to each point in the

 * constellation for decision making. Inefficient for large

 * constellations.

 */

class digital_constellation_calcdist : public digital_constellation

{

 public:

  digital_constellation_calcdist (std::vector<gr_complex> constellation,

                                  std::vector<unsigned int> pre_diff_code,

                                  unsigned int rotational_symmetry,

                                  unsigned int dimensionality);

  unsigned int decision_maker (const gr_complex *sample);

  // void calc_metric(gr_complex *sample, float *metric, trellis_metric_type_t type);

  // void calc_euclidean_metric(gr_complex *sample, float *metric);

  // void calc_hard_symbol_metric(gr_complex *sample, float *metric);

 private:

  friend digital_constellation_calcdist_sptr

  digital_make_constellation_calcdist (std::vector<gr_complex> constellation);

};

/************************************************************/

/*! digital_constellation_sector                             */

/************************************************************/

/*!

 * \brief Sectorized digital constellation

 * \ingroup digital

 *

 * Constellation space is divided into sectors. Each sector is

 * associated with the nearest constellation point.

 *

 */

class digital_constellation_sector : public digital_constellation

{

 public:

  digital_constellation_sector (std::vector<gr_complex> constellation,

                                std::vector<unsigned int> pre_diff_code,

                                unsigned int rotational_symmetry,

                                unsigned int dimensionality,

                                unsigned int n_sectors);

  unsigned int decision_maker (const gr_complex *sample);

 protected:

  virtual unsigned int get_sector (const gr_complex *sample) = 0;

  virtual unsigned int calc_sector_value (unsigned int sector) = 0;

  void find_sector_values ();

  unsigned int n_sectors;

 private:

  std::vector<unsigned int> sector_values;

};

/************************************************************/

/* digital_constellation_rect                               */

/************************************************************/

/*!

 * \brief Rectangular digital constellation

 * \ingroup digital

 *

 * Only implemented for 1-(complex)dimensional constellation.

 *

 * Constellation space is divided into rectangular sectors. Each

 * sector is associated with the nearest constellation point.

 *

 * Works well for square QAM.

 *

 * Works for any generic constellation provided sectors are not too

 * large.

 */

class digital_constellation_rect;

typedef boost::shared_ptr<digital_constellation_rect> digital_constellation_rect_sptr;

// public constructor

digital_constellation_rect_sptr 

digital_make_constellation_rect (std::vector<gr_complex> constellation,

                                 std::vector<unsigned int> pre_diff_code,

                                 unsigned int rotational_symmetry,

                                 unsigned int real_sectors,

                                 unsigned int imag_sectors,

                                 float width_real_sectors,

                                 float width_imag_sectors);

class digital_constellation_rect : public digital_constellation_sector

{

 public:

  digital_constellation_rect (std::vector<gr_complex> constellation,

                              std::vector<unsigned int> pre_diff_code,

                              unsigned int rotational_symmetry,

                              unsigned int real_sectors,

                              unsigned int imag_sectors,

                              float width_real_sectors,

                              float width_imag_sectors);

 protected:

  unsigned int get_sector (const gr_complex *sample);

  unsigned int calc_sector_value (unsigned int sector);

 private:

  unsigned int n_real_sectors;

  unsigned int n_imag_sectors;

  float d_width_real_sectors;

  float d_width_imag_sectors;

  friend digital_constellation_rect_sptr

  digital_make_constellation_rect (std::vector<gr_complex> constellation,

                                   std::vector<unsigned int> pre_diff_code,

                                   unsigned int rotational_symmetry,

                                   unsigned int real_sectors,

                                   unsigned int imag_sectors,

                                   float width_real_sectors,

                                   float width_imag_sectors);

};

/************************************************************/

/* digital_constellation_psk                                */

/************************************************************/

class digital_constellation_psk;

typedef boost::shared_ptr<digital_constellation_psk> digital_constellation_psk_sptr;

// public constructor

digital_constellation_psk_sptr 

digital_make_constellation_psk (std::vector<gr_complex> constellation,

                                std::vector<unsigned int> pre_diff_code,

                                unsigned int n_sectors);

/*! 

 * \brief digital_constellation_psk

 * \ingroup digital

 *

 * Constellation space is divided into pie slices sectors.

 *

 * Each slice is associated with the nearest constellation point. 

 *

 * Works well for PSK but nothing else.  

 *

 * Assumes that there is a constellation point at 1.x 

 */

class digital_constellation_psk : public digital_constellation_sector

{

 public:

  digital_constellation_psk (std::vector<gr_complex> constellation,

                             std::vector<unsigned int> pre_diff_code,

                             unsigned int n_sectors);

 protected:

  unsigned int get_sector (const gr_complex *sample);

  unsigned int calc_sector_value (unsigned int sector);

 private:

  friend digital_constellation_psk_sptr

  digital_make_constellation_psk (std::vector<gr_complex> constellation,

                                  std::vector<unsigned int> pre_diff_code,

                                  unsigned int n_sectors);

};

/************************************************************/

/* digital_constellation_bpsk                               */

/*                                                          */

/* Only works for BPSK.                                     */

/*                                                          */

/************************************************************/

class digital_constellation_bpsk;

typedef boost::shared_ptr<digital_constellation_bpsk> digital_constellation_bpsk_sptr;

// public constructor

digital_constellation_bpsk_sptr 

digital_make_constellation_bpsk ();

/*! 

 * \brief Digital constellation for BPSK 

 * \ingroup digital

 */

class digital_constellation_bpsk : public digital_constellation

{

 public:

  digital_constellation_bpsk ();

  unsigned int decision_maker (const gr_complex *sample);

  friend digital_constellation_bpsk_sptr

  digital_make_constellation_bpsk ();

};

/************************************************************/

/* digital_constellation_qpsk                               */

/*                                                          */

/* Only works for QPSK.                                     */

/*                                                          */

/************************************************************/

class digital_constellation_qpsk;

typedef boost::shared_ptr<digital_constellation_qpsk> digital_constellation_qpsk_sptr;

// public constructor

digital_constellation_qpsk_sptr 

digital_make_constellation_qpsk ();

/*! 

 * \brief Digital constellation for QPSK

 * \ingroup digital

 */

class digital_constellation_qpsk : public digital_constellation

{

 public:

  digital_constellation_qpsk ();

  unsigned int decision_maker (const gr_complex *sample);

  friend digital_constellation_qpsk_sptr

  digital_make_constellation_qpsk ();

};

/************************************************************/

/* digital_constellation_dqpsk                              */

/*                                                          */

/* Works with differential encoding; slower decisions.      */

/*                                                          */

/************************************************************/

class digital_constellation_dqpsk;

typedef boost::shared_ptr<digital_constellation_dqpsk> digital_constellation_dqpsk_sptr;

// public constructor

digital_constellation_dqpsk_sptr 

digital_make_constellation_dqpsk ();

/*!

 * \brief Digital constellation for DQPSK

 * \ingroup digital

 */

class digital_constellation_dqpsk : public digital_constellation

{

 public:

  digital_constellation_dqpsk ();

  unsigned int decision_maker (const gr_complex *sample);

  friend digital_constellation_dqpsk_sptr

  digital_make_constellation_dqpsk ();

};

/************************************************************/

/* digital_constellation_8psk                               */

/*                                                          */

/* Only works for 8PSK.                                     */

/*                                                          */

/************************************************************/

class digital_constellation_8psk;

typedef boost::shared_ptr<digital_constellation_8psk> digital_constellation_8psk_sptr;

// public constructor

digital_constellation_8psk_sptr 

digital_make_constellation_8psk ();

/*! 

 * \brief Digital constellation for 8PSK

 * \ingroup digital

 */

class digital_constellation_8psk : public digital_constellation

{

 public:

  digital_constellation_8psk ();

  unsigned int decision_maker (const gr_complex *sample);

  friend digital_constellation_8psk_sptr

  digital_make_constellation_8psk ();

};

#endif