db0_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 DB0_POINT_LOCATOR_H
#define DB0_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 SINGLY_LINKED_LIST_H
#include "SheafSystem/singly_linked_list.h"
#endif

#ifndef STD_QUEUE_H
#include "SheafSystem/std_queue.h"
#endif

#ifndef SECTION_EVAL_ITERATOR_H
#include "SheafSystem/section_eval_iterator.h"
#endif

//#undef DIAGNOSTIC_OUTPUT
//#define DIAGNOSTIC_OUTPUT

namespace geometry
{

template<int DC>
class SHEAF_DLL_SPEC db0_point_locator : public point_locator
{

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

public:

  db0_point_locator(sec_ed& xcoords, const block<size_type>& xbin_ub);

  db0_point_locator(sec_ed& xcoords, int xavg_occupancy = 2);

  typedef int bin_coord_type;

  virtual ~db0_point_locator();

  const block<size_type>& bin_ub() const;

  const block<sec_vd_value_type>& bin_size() const;

  bool is_empty() const;

  void relative_position(const sec_vd_value_type xpt[],
                         bin_coord_type xresult[]) const;

  virtual void clear();

protected:

  db0_point_locator() {};

  db0_point_locator(const db0_point_locator& xother) {};

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

  db0_point_locator& operator=(const db0_point_locator& xother) {return *this;};

  block<size_type> _bin_ub;

  block<sec_vd_value_type> _bin_size;

  sec_vd_value_type _bin_diag;

  block<sec_vd_value_type> _one_over_min_bin_size;

  virtual void update_bins();

  struct SHEAF_DLL_SPEC vertex_type
  {
    // The id of the  vertex.

    scoped_index disc_id;

    // The branch containing the vertex

    scoped_index branch_id;

    // The coordinates of the vertex in the branch.

    sec_vd_dof_type coords[DC];
  };

  typedef singly_linked_list<vertex_type> vertex_list_type;

  block<vertex_list_type> _bins;

  std::queue<int> _search_q;

  void find_closest_bin(const bin_coord_type xpt_pos[],
                        bin_coord_type xbin_pos[]);

  sec_vd_value_type _search_radius;

  bin_coord_type _search_region_lb[DC];

  bin_coord_type _search_region_ub[DC];

  void initialize_search_region(const sec_vd_value_type xvalue[]);

  void expand_search_region(const sec_vd_value_type xvalue[]);

  void compute_search_region(const sec_vd_value_type xvalue[]);

  void initialize_search_q();

  void update_search_q(bin_coord_type xold_lb[], bin_coord_type xold_ub[]);

  sec_vd_value_type
  vertex_distance_sq(const sec_vd_value_type xglobal_coords[],
                     const vertex_type& xvertex_entry);


  void find_closest_vertex(const sec_vd_value_type* xvalue,
                           sec_vd_value_type& xclosest_dist_sq,
                           chart_point& xresult);

  //  closest to the point with value xvalue and closer than _search_radius.
  void find_closest_vertex_in_bin(int xbin_id,
                                  const sec_vd_value_type* xvalue,
                                  chart_point& xresult,
                                  sec_vd_value_type& xclosest_dist);


  int bin_id(const bin_coord_type xcoord[]) const;

  void print_bins(std::ostream& xos, const std::string& xmsg) const;

  void print_queue(std::ostream& xos, const std::string& xmsg) const;

  void print_value(std::ostream& xos,
                   const sec_vd_value_type xvalue[],
                   const std::string& xmsg) const;


  void print_coords(std::ostream& xos,
                    const bin_coord_type xcoords[],
                    const std::string& xmsg) const;


  sec_vd_value_type max_bin_distance(const sec_vd_value_type xpt[],
                                     const bin_coord_type xbin_pos[]) const;



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

public:

  virtual bool invariant() const;

  virtual void update();

  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);


};

// ============================================================================
// SPECIALIZATIONS
// ============================================================================

//
// Puts all the bins from/ the search region
// onto the search queue; DC = 1 specialization
//
template<>
SHEAF_DLL_SPEC
void
db0_point_locator<1>::
initialize_search_q();

//
// Puts all the bins from the search region
// onto the search queue; DC = 2 specialization
//
template<>
SHEAF_DLL_SPEC
void
db0_point_locator<2>::
initialize_search_q();

//
// Puts all the bins from the search region
//onto the search queue; DC = 3 specialization
//
template<>
SHEAF_DLL_SPEC
void
db0_point_locator<3>::
initialize_search_q();

//
// Puts previous unsearched bins from the search region
// onto the search queue; DC = 1 specialization
//
template<>
SHEAF_DLL_SPEC
void
db0_point_locator<1>::
update_search_q(bin_coord_type xold_lb[], bin_coord_type xold_ub[]);

//
// Puts previous unsearched bins from the search region
// onto the search queue; DC = 2 specialization
//
template<>
SHEAF_DLL_SPEC
void
db0_point_locator<2>::
update_search_q(bin_coord_type xold_lb[], bin_coord_type xold_ub[]);

//
// Puts previous unsearched bins from the search region
// onto the search queue; DC = 3 specialization
//
template<>
SHEAF_DLL_SPEC
void
db0_point_locator<3>::
update_search_q(bin_coord_type xold_lb[], bin_coord_type xold_ub[]);

//
// The id of the bin with bin coords xcoord; DC = 1 specialization.
//
template<>
SHEAF_DLL_SPEC
int
db0_point_locator<1>::
bin_id(const bin_coord_type xcoord[]) const;


//
// The id of the bin with bin coords xcoord; DC = 2 specialization.
//
template<>
SHEAF_DLL_SPEC
int
db0_point_locator<2>::
bin_id(const bin_coord_type xcoord[]) const;


//
// The id of the bin with bin coords xcoord; DC = 3 specialization.
//
template<>
SHEAF_DLL_SPEC
int
db0_point_locator<3>::
bin_id(const bin_coord_type xcoord[]) const;

//
// The maximum distance from the query point xpt
// to any point in the bin with coordinates xbin_pos; DC=1 specialization.
//
template<>
SHEAF_DLL_SPEC
sec_vd_value_type
db0_point_locator<1>::
max_bin_distance(const sec_vd_value_type xpt[], const bin_coord_type xbin_pos[]) const;

//
// The maximum distance from the query point xpt
// to any point in the bin with coordinates xbin_pos; DC=2 specialization.
//
template<>
SHEAF_DLL_SPEC
sec_vd_value_type
db0_point_locator<2>::
max_bin_distance(const sec_vd_value_type xpt[], const bin_coord_type xbin_pos[]) const;

//
// The maximum distance from the query point xpt
// to any point in the bin with coordinates xbin_pos; DC=3 specialization.
//
template<>
SHEAF_DLL_SPEC
sec_vd_value_type
db0_point_locator<3>::
max_bin_distance(const sec_vd_value_type xpt[], const bin_coord_type xbin_pos[]) const;

//
// Prints the contents of the bins on xos; DC=3 specialization.
//
template<>
SHEAF_DLL_SPEC
void
db0_point_locator<3>::
print_bins(std::ostream& xos, const std::string& xmsg) const;

template<>
SHEAF_DLL_SPEC
void
db0_point_locator<1>::
initialize_search_q();


template<>
SHEAF_DLL_SPEC
void
db0_point_locator<2>::
initialize_search_q();


template<>
SHEAF_DLL_SPEC
void
db0_point_locator<3>::
initialize_search_q();

//
template<>
SHEAF_DLL_SPEC
void
db0_point_locator<1>::
update_search_q(bin_coord_type xold_lb[], bin_coord_type xold_ub[]);

//
template<>
SHEAF_DLL_SPEC
void
db0_point_locator<2>::
update_search_q(bin_coord_type xold_lb[], bin_coord_type xold_ub[]);

//
template<>
SHEAF_DLL_SPEC
void
db0_point_locator<3>::
update_search_q(bin_coord_type xold_lb[], bin_coord_type xold_ub[]);



} // namespace geometry

#endif // DB0_POINT_LOCATOR_H