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.              *
*                                                                            *
\*===========================================================================*/
 
 
 
 
//=============================================================================
//
//  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_impl.hh"
#endif
//=============================================================================
#endif // ACG_BSPLINESURFACET_HH defined
//=============================================================================