cylindrical_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 STD_CMATH_H
#include "SheafSystem/std_cmath.h"
#endif

#ifndef CYLINDRICAL_POINT_LOCATOR_H
#define CYLINDRICAL_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;

class SHEAF_DLL_SPEC cylindrical_point_locator : public point_locator
{

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

public:

  //  static const int DC = 3;

  //  static const int DB = 2;

  enum space_dimensions
    {
      DC = 3, DB = 2
    };

  typedef singly_linked_list<const d_bounding_box<2, 2>*> box_list_type;

  virtual ~cylindrical_point_locator();

  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<2, 2>* 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<2, 2>& xresult) const;

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

  virtual void remove_box(d_bounding_box<2, 2>* 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<2, 2>* xbox) const = 0;

  virtual void clear() = 0;

protected:

  cylindrical_point_locator(sec_ed& xcoords);

  cylindrical_point_locator() {};

  cylindrical_point_locator(const cylindrical_point_locator& xother) {};

  virtual cylindrical_point_locator& operator=(const point_locator& xother);

  cylindrical_point_locator& operator=(const cylindrical_point_locator& xother);

  block<size_type> _bin_ub;

  sec_vd_value_type _bin_0_max;

  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<2, 2> > _boxes;

  block<sec_vd_dof_type> _gathered_dofs;

  eval_iterator _eval_itr;

  std::set< stl_scoped_index<> > _branches;

  void insert_quad(block<sec_vd_dof_type>& xdofs,
                   const scoped_index& xbranch_id,
                   const scoped_index& xeval_id);

  void insert_triangle(block<sec_vd_dof_type>& xdofs,
                       const scoped_index& xbranch_id,
                       const scoped_index& xeval_id);


  void xyz_to_lat_lon(const sec_vd_dof_type xcartesian[3], sec_vd_dof_type xresult[2]);

  void make_quad_bounding_box(block<sec_vd_dof_type>& xlat_lon_dofs,
                              const scoped_index& xbranch_id,
                              const scoped_index& xeval_id);

  void make_triangle_bounding_box(block<sec_vd_dof_type>& xlat_lon_dofs,
                                  const scoped_index& xbranch_id,
                                  const scoped_index& xeval_id);



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

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



};
 
} // namespace geometry

#endif // CYLINDRICAL_POINT_LOCATOR_H