d_bin_point_locator.h

Go to the documentation of this file.

//
// Copyright (c) 2014 Limit Point Systems, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//


#ifndef D_BIN_POINT_LOCATOR_H
#define D_BIN_POINT_LOCATOR_H

#ifndef SHEAF_DLL_SPEC_H
#include "SheafSystem/sheaf_dll_spec.h"
#endif

#ifndef POINT_LOCATOR_H
#include "SheafSystem/point_locator.h"
#endif

#ifndef D_BOUNDING_BOX_H
#include "SheafSystem/d_bounding_box.h"
#endif

#ifndef EVAL_ITERATOR_H
#include "SheafSystem/eval_iterator.h"
#endif

#ifndef STD_SET_H
#include "SheafSystem/std_set.h"
#endif

#ifndef SINGLY_LINKED_LIST_H
#include "SheafSystem/singly_linked_list.h"
#endif

#ifndef STL_SCOPED_INDEX_H
#include "SheafSystem/stl_scoped_index.h"
#endif

//#undef DIAGNOSTIC_OUTPUT
//#define DIAGNOSTIC_OUTPUT

namespace geometry
{

template <int DC, int DB>
class d_bin_coordinates;

template <int DC, int DB>
class SHEAF_DLL_SPEC d_bin_point_locator : public point_locator
{

  // ===========================================================
  // ===========================================================

public:

  typedef singly_linked_list<const d_bounding_box<DC, DB>*> box_list_type;

  virtual ~d_bin_point_locator();

  virtual bool invariant() const;

  const block<size_type>& bin_ub() const;

  const block<sec_vd_value_type>& bin_size() const;

  size_type box_ct() const;

  bool is_empty() const;

  d_bin_coordinates<DC, DB>* relative_position(sec_vd_value_type* xpt,
                                               size_type xpt_ub) const;

  void relative_position_pa(sec_vd_value_type* xpt,
                            size_type xpt_ub,
                            d_bin_coordinates<DC, DB>& xresult) const;

  d_bounding_box<DC, DB>* assign_box(const scoped_index& xmbr_id, 
                     const scoped_index& xbranch_id, 
                     section_evaluator& xeval, 
                     const sec_vd_dof_type* xdofs, 
                     size_type xdofs_ct);  

  size_type box_capacity();

  d_bounding_box<DC, DB>* box(pod_index_type xi);

  void update_box(pod_index_type xi, const sec_vd_dof_type* xdofs, size_type xdofs_ct);  


  virtual void insert_box(d_bounding_box<DC, DB>* xbox) = 0;

  virtual void remove_box(d_bounding_box<DC, DB>* xbox) = 0;

  virtual const box_list_type& box_list(sec_vd_value_type* xpt,
                                        size_type xpt_ub) const = 0;

  virtual bool contains_box(d_bounding_box<DC, DB>* xbox) const = 0;

  virtual void clear() = 0;

  const block<sec_vd_dof_type>& gathered_dofs() const;

protected:

  d_bin_point_locator(sec_ed& xcoords);

  d_bin_point_locator() {};

  d_bin_point_locator(const d_bin_point_locator<DC, DB>& xother) {};

  virtual d_bin_point_locator& operator=(const point_locator& xother) {return *this;};

  d_bin_point_locator& operator=(const d_bin_point_locator<DC, DB>& xother) {return *this;};

  block<size_type> _bin_ub;

  block<sec_vd_value_type> _bin_size;

  block<sec_vd_value_type> _one_over_min_bin_size;

  virtual void update_bins() = 0;

  size_type _box_ct;

  block< d_bounding_box<DC, DB> > _boxes;

  block<sec_vd_dof_type> _gathered_dofs;

  eval_iterator _eval_itr;

  std::set< stl_scoped_index<> > _branches;



  // ===========================================================
  // ===========================================================

public:

  using point_locator::update;

  virtual void update();

  virtual void update(bool xpopulate, size_type xeval_capacity);

  virtual void point_at_value(const sec_vd_value_type* xvalue,
                              size_type xvalue_ub,
                              chart_point& xresult);

  virtual void all_points_at_value(const sec_vd_value_type* xvalue,
                                   size_type xvalue_ub,
                                   block<chart_point_3d>& xresult);

  virtual void branch_points_at_value(const sec_vd_value_type* xvalue,
                                      size_type xvalue_ub,
                                      block<branch_point_pair>& xresult);



};
 
} // namespace geometry

#endif // D_BIN_POINT_LOCATOR_H