BSplineSurfaceT.hh

/*===========================================================================*\
*                                                                            *
*                              OpenFlipper                                   *
 *           Copyright (c) 2001-2015, RWTH-Aachen University                 *
 *           Department of Computer Graphics and Multimedia                  *
 *                          All rights reserved.                             *
 *                            www.openflipper.org                            *
 *                                                                           *
 *---------------------------------------------------------------------------*
 * This file is part of OpenFlipper.                                         *
 *---------------------------------------------------------------------------*
 *                                                                           *
 * Redistribution and use in source and binary forms, with or without        *
 * modification, are permitted provided that the following conditions        *
 * are met:                                                                  *
 *                                                                           *
 * 1. Redistributions of source code must retain the above copyright notice, *
 *    this list of conditions and the following disclaimer.                  *
 *                                                                           *
 * 2. 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.   *
 *                                                                           *
 * 3. Neither the name of the copyright holder 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 HOLDER *
 * 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.              *
*                                                                            *
\*===========================================================================*/

/*===========================================================================*\
*                                                                            *
*   $Revision$                                                       *
*   $LastChangedBy$                                                *
*   $Date$                     *
*                                                                            *
\*===========================================================================*/


//=============================================================================
//
//  CLASS BSplineSurfaceT
//  Author:  Ellen Dekkers <dekkers@cs.rwth-aachen.de>
//
//=============================================================================


#ifndef BSPLINESURFACET_HH
#define BSPLINESURFACET_HH


//== INCLUDES =================================================================
#include <vector>
#include <iostream>

#include <ACG/Math/VectorT.hh>

#include <ObjectTypes/Knotvector/KnotvectorT.hh>

//== FORWARDDECLARATIONS ======================================================

//== NAMESPACES ===============================================================

namespace ACG {

//== CLASS DEFINITION =========================================================


template <class PointT>
class BSplineSurfaceT
{
public:

  // internal relevant Types
  typedef PointT                      Point;
  typedef typename Point::value_type  Scalar;
  typedef typename std::vector< std::vector< Point > > ControlNet;
  typedef typename std::vector< std::vector< unsigned char > > PropertyNet;

  explicit BSplineSurfaceT(unsigned int _degm = 3, unsigned int _degn = 3);

  void resize(unsigned int _m, unsigned int _n);

  std::vector< Scalar >& get_knots_m() {return knotvector_m_.getKnotvector();};
  std::vector< Scalar >& get_knots_n() {return knotvector_n_.getKnotvector();};

  Knotvector get_knotvector_m(){return knotvector_m_;};
  Knotvector get_knotvector_n(){return knotvector_n_;};

  Knotvector * get_knotvector_m_ref(){return &knotvector_m_;};
  Knotvector * get_knotvector_n_ref(){return &knotvector_n_;};

  Scalar get_knot_m(int _i) {return knotvector_m_(_i);};

  Scalar get_knot_n(int _i) {return knotvector_n_(_i);};

  void set_knots_m(std::vector< Scalar > _knots);

  void set_knots_n(std::vector< Scalar > _knots);

  void insert_knot_m(double _t);

  void insert_knot_n(double _t);

  void createKnots();

  void set_degree(unsigned int _degm, unsigned int _degn);


  int degree_m() const {return degree_m_;}
  int degree_n() const {return degree_n_;}

  unsigned int n_control_points_m() const {return dimm_;}
  unsigned int n_control_points_n() const {return dimn_;}

  unsigned int n_knots_m(){return knotvector_m_.size();};
  unsigned int n_knots_n(){return knotvector_n_.size();};


  void reset_control_net();

  Point& get_control_point(unsigned int _m, unsigned int _n)
  {
    assert (_m < dimm_ && _n < dimn_);
    return control_net_[_m][_n];
  }

  inline Point& operator()(unsigned int _m, unsigned int _n)
  {
    assert (_m < dimm_ && _n < dimn_);
    return control_net_[_m][_n];
  }

  inline const Point& operator()(unsigned int _m, unsigned int _n) const
  {
    assert (_m < dimm_ && _n < dimn_);
    return control_net_[_m][_n];
  }

  inline Point& operator()(Vec2i _param)
  {
    assert ( (0 <= _param[0]) && (_param[0] < dimm_) && (0 <= _param[1]) &&( _param[1] < dimn_ ) );
    return control_net_[_param[0]][_param[1]];
  }

  inline const Point& operator()(Vec2i _param) const
  {
    assert ( (0 <= _param[0]) && (_param[0] < dimm_) && (0 <= _param[1]) &&( _param[1] < dimn_ ) );
    return control_net_[_param[0]][_param[1]];
  }


  void get_vector_m(std::vector< Point> & _control_polygon, unsigned int _m);

  void get_vector_n(std::vector< Point> & _control_polygon, unsigned int _n);


  void add_vector_m(const std::vector< Point> & _control_polygon);

  void add_vector_n(const std::vector< Point> & _control_polygon);


  void insert_vector_m(const std::vector< Point> & _control_polygon, unsigned int _m);

  void insert_vector_n(const std::vector< Point> & _control_polygon, unsigned int _n);

  void delete_vector_m(unsigned int _m);

  void delete_vector_n(unsigned int _n);


  Point surfacePoint(double _u, double _v);

  void surfacePointNormal(Point& _pt, Point& _normal, double _u, double _v);

  Point surfacePoint_rec(double _u, double _v);

  Point derivativeSurfacePoint(double _u, double _v, int _derm, int _dern);

  Point normalSurfacePoint(double _u, double _v);
public:

  Scalar basisFunction(Knotvector & _knotvector, int _i, int _n, double _t);

  Scalar derivativeBasisFunction(Knotvector & _knotvector, int _i, int _n, double _t, int _der);

  ACG::Vec2i spanm(double _t);

  ACG::Vec2i spann(double _t);

  ACG::Vec2i interval_m(double _t);

  ACG::Vec2i interval_n(double _t);


public:

  Scalar loweru();
  Scalar upperu();

  Scalar lowerv();
  Scalar upperv();


public :

  void request_controlpoint_selections() { request_prop( ref_count_cpselections_, cpselections_);}
  void request_edge_selections()         { request_prop( ref_count_eselections_, eselections_);}

  void release_controlpoint_selections() { release_prop( ref_count_cpselections_, cpselections_);}
  void release_edge_selections()         { release_prop( ref_count_eselections_, eselections_);}

  bool controlpoint_selections_available() const {return bool(ref_count_cpselections_);}
  bool edge_selections_available()         const {return bool(ref_count_eselections_);}


  // property access ( no range or availability check! )
        unsigned char& controlpoint_selection(unsigned int _i, unsigned int _j)       {return cpselections_[_i][_j];}
  const unsigned char& controlpoint_selection(unsigned int _i, unsigned int _j) const {return cpselections_[_i][_j];}

//         unsigned char& controlpoint_selection(unsigned int _idx)       {return cpselections_[_idx];}
//   const unsigned char& controlpoint_selection(unsigned int _idx) const {return cpselections_[_idx];}

        unsigned char& edge_selection(unsigned int _i, unsigned int _j)       {return eselections_[_i][_j];}
  const unsigned char& edge_selection(unsigned int _i, unsigned int _j) const {return eselections_[_i][_j];}

//  /// acces with row / col indices
//         unsigned char& controlpoint_selection(unsigned int _i, unsigned int _j)       {int idx = _i * dimn_ + _j; return cpselections_[idx];}
//   const unsigned char& controlpoint_selection(unsigned int _i, unsigned int _j) const {int idx = _i * dimn_ + _j; return cpselections_[idx];}

//  /// access with global idx
//         unsigned char& controlpoint_selection(unsigned int _idx)       {return cpselections_[_idx];}
//   const unsigned char& controlpoint_selection(unsigned int _idx) const {return cpselections_[_idx];}

//         unsigned char& edge_selection(unsigned int _i, unsigned int _j)       {int idx = _i * dimn_ + _j; return eselections_[idx];}
//   const unsigned char& edge_selection(unsigned int _i, unsigned int _j) const {int idx = _i * dimn_ + _j; return eselections_[idx];}

  // Wrapper for selection functions
  void select_controlpoint(unsigned int _iIdx, unsigned int _jIdx) { controlpoint_selection(_iIdx, _jIdx) = 1; };
  void deselect_controlpoint(unsigned int _iIdx, unsigned int _jIdx) { controlpoint_selection(_iIdx, _jIdx) = 0; };
  
  bool controlpoint_selected(unsigned int _iIdx, unsigned int _jIdx) const { return (controlpoint_selection(_iIdx, _jIdx) == 1); };


private:

  template <class PropT>
  void request_prop( unsigned int& _ref_count, PropT& _prop);

  template <class PropT>
  void release_prop( unsigned int& _ref_count, PropT& _prop);

private:

  unsigned int dimm_;     
  unsigned int dimn_;     
  unsigned int degree_m_; 
  unsigned int degree_n_; 

  Knotvector knotvector_m_; 
  Knotvector knotvector_n_; 

  ControlNet control_net_;

private: // private properties

  // ############################### Standard Property Handling #############################

//   // list of vertex properties
//   std::vector< std::vector<unsigned char> > vselections_;
//   // list of edge properties
//   std::vector< std::vector<unsigned char> > eselections_;

//   std::vector<unsigned char> cpselections_;
  PropertyNet cpselections_;

//   std::vector<unsigned char> eselections_;
  PropertyNet eselections_;

  // property reference counter
  unsigned int ref_count_cpselections_;
  unsigned int ref_count_eselections_;

};


//=============================================================================
} // namespace ACG
//=============================================================================
#if defined(INCLUDE_TEMPLATES) && !defined(BSPLINESURFACE_BSPLINESURFACET_C)
#define BSPLINESURFACE_BSPLINESURFACET_TEMPLATES
#include "BSplineSurfaceT.cc"
#endif
//=============================================================================
#endif // ACG_BSPLINESURFACET_HH defined
//=============================================================================