geotree 1.1.0

data/lib/geotree/loc.rb

@@ -0,0 +1,76 @@
+require_relative  'tools'
+
+module GeoTreeModule
+
+  if true
+    LOC_MAX = ((1 << 30)-1)
+    LOC_MIN = -LOC_MAX
+  else
+    warn("using very small bounds for test purposes")
+    LOC_MAX = 1000
+    LOC_MIN = 0
+  end
+
+  # Factor for converting integer locations to latitude/longitudes
+  LAT_LONG_FACTOR_ = 180.0 / LOC_MAX
+  
+  # Represents an x,y location.
+  # Each coordinate is stored internally as an integer, but may be
+  # referred to as a latitude and longitude as well.
+  #
+  class Loc
+
+    attr_accessor :x,:y
+    
+    def self.cvt_latlong_to_int(n)
+      m = (n / LAT_LONG_FACTOR_ + 0.5).to_i
+      raise ArgumentError,"Converting lat/long #{n} is out of range" if m < LOC_MIN || m > LOC_MAX
+      m
+    end
+    
+    # Construct a point.
+    # If x is a Float, it assumes that x and y are
+    # longitude and latitude respectively, and converts them
+    # to integer values.
+    #
+    def initialize(x = 0, y = 0)
+      if x.is_a? Float
+        x = Loc.cvt_latlong_to_int(x)
+        y = Loc.cvt_latlong_to_int(y)
+      end          
+      @x = x
+      @y = y
+    end
+
+    # Get x as a longitudinal coordinate
+    #
+    def longit 
+      @x * LAT_LONG_FACTOR_
+    end
+    
+    # Get y as a latitudinal coordinate
+    #
+    def latit
+      @y * LAT_LONG_FACTOR_
+    end
+    
+    def to_s
+      "(#{x},#{y})"
+    end
+
+    def inspect
+      to_s
+    end
+
+    def set_to(src)
+      @x = src.x
+      @y = src.y
+    end
+
+    # Return a version of the point with the coordinates exchanged
+    #
+    def flip
+      Loc.new(@y,@x)
+    end
+  end
+end

data/lib/geotree/multitree.rb

@@ -0,0 +1,190 @@
+require_relative 'tools'
+req 'geotree'
+
+module GeoTreeModule
+  
+  # A variant of GeoTree that supports queries at multiple resolutions.
+  #
+  # For example, a map application should return approximately the same number of
+  # datapoints when the screen displays the entire state of California, as well as
+  # when it is 'zoomed in' on a particular section of the Los Angeles area.
+  #
+  # To accomplish this, a MultiTree maintains several GeoTrees, each for a different
+  # level of detail.  The highest detail tree contains every datapoint that has been
+  # added to the tree, and lower detail trees will have progressively fewer points.
+  #
+  # When querying a MultiTree, the user must specify which level of detail (i.e.,
+  # which of the contained trees) is to be examined.   
+  #
+  class MultiTree
+
+    attr_reader :num_trees
+    
+    # Construct MultiTree
+    # @param path directory to store trees within
+    # @param num_trees the number of trees to maintain (equivalently, the number of
+    #   levels of detail to support)
+    #
+    def initialize(path,num_trees)
+      @buffer = PtBuffer.new(self)
+      @num_trees = num_trees
+      raise ArgumentError if File.file?(path)
+
+      @trees = []
+
+      if !File.directory?(path)
+        Dir::mkdir(path)
+      end
+
+      # Construct trees within this directory
+      num_trees.times do |i|
+        tp = File.join(path,"tree_#{i}.bin")
+        t = GeoTree.open(tp)
+        @trees << t
+      end
+
+      prepare_details
+    end
+
+    def buffering
+      @buffer.active
+    end
+
+    def buffering=(val)
+      db = false
+
+      raise IllegalStateException if !open?
+
+      @buffer.active = val
+    end
+
+    def open?
+      @trees != nil
+    end
+
+    def close
+      raise IllegalStateException if !open?
+
+      # Stop buffering, in case we were, to flush points to tree
+      @buffer.active = false
+
+      @trees.each{|t| t.close}
+      @trees = nil
+
+    end
+
+    # Add a datapoint to the trees.
+    # Does not ensure that a datapoint with this name already exists in the
+    # tree, even if it has the same location.
+    #
+    def add(data_point)
+      raise IllegalStateException if !open?
+      @buffer.add(data_point)
+    end
+
+    # Remove a datapoint.  Returns the datapoint if it was found and removed,
+    # otherwise nil.
+    # A datapoint will be removed iff both its name and location match
+    # the sought point; the weight is ignored.
+    def remove(data_point)
+
+      raise IllegalStateException if  @buffer.active
+
+      removed = nil
+
+      # Start with highest-detail tree, and continue to remove the
+      # same point until we reach a tree that doesn't contain it
+      @trees.each do |t|
+        rem = t.remove(data_point)
+        if rem
+          removed = true
+        else
+          break  # assume it's not in any lower detail tree
+        end
+      end
+      removed
+    end
+
+    # Find all points intersecting a rectangle.
+    # @param rect query rectangle
+    # @param detail level of detail, 0...num_trees-1
+    #
+    def find(rect, detail)
+      raise IllegalStateException if (!open? || @buffer.active)
+      tree(detail).find(rect)
+    end
+
+    # Determine if a particular datapoint lies in the tree
+    def find_point(df, detail)
+      raise IllegalStateException if (!open? || @buffer.active)
+      tree(detail).find(rect)
+    end
+
+    def add_buffered_point(data_point)
+      db = false
+      #      db = true
+
+      # Determine which is the lowest detail level at which
+      # this point is to be found
+
+      stretch = 1.5
+      contract = 0.5
+      rf = rand() - contract
+
+      wt = data_point.weight & (MAX_POINT_WEIGHT-1)
+
+      randval = (wt + stretch*rf) / MAX_POINT_WEIGHT
+
+      !db || pr("add pt#%4d  wt%2d  rf=%6.3f rand=%6.3f:  ",data_point.name,wt,rf,randval)
+
+      num_trees.times do |ti|
+        di = num_trees - 1 - ti
+
+        if ti > 0 && randval < @cutoffs[di]
+          break
+        end
+
+        !db || pr("  ++ #{di}  ")
+        tree(di).add_buffered_point(data_point)
+      end
+      !db || pr("\n")
+    end
+
+    private
+
+    def prepare_details
+
+      # Cutoffs are indexed by detail level;
+      # if the adjusted data point weights are less than the
+      # cutoff value, then the point will not appear in that level's tree
+
+      @cutoffs = []
+
+      cmin = -0.3
+      m = (1.0) / num_trees
+
+      num_trees.times do |ti|
+        dt = num_trees-1-ti
+        @cutoffs << (dt+1) * m + cmin
+      end
+    end
+
+    def tree(detail)
+      @trees[num_trees - 1 - detail]
+    end
+  end
+end
+
+if main?(__FILE__)
+  include GeoTreeModule
+  newdir = File.join(File.dirname(__FILE__),"../../test/workdir")
+  assert!(File.directory?(newdir))
+  Dir.chdir(newdir)
+  remove_file_or_dir("_multitree_")
+
+  mt = MultiTree.new("_multitree_",3)
+
+  pts = DataPoint.rnd_many(100)
+  pts.each{|x| mt.add(x)}
+
+end

data/lib/geotree/node.rb

@@ -0,0 +1,252 @@
+require_relative 'datapoint'
+
+module GeoTreeModule
+
+  DATAPOINT_INTS = 4
+  PARTITION_INTS = 2
+  INT_BYTES = 4
+  DATAPOINT_BYTES = DATAPOINT_INTS * INT_BYTES
+
+  if true
+    KDTREE_BLOCKSIZE = 256
+    NODEI_CHILDREN = (((KDTREE_BLOCKSIZE/INT_BYTES) - 6)/2)
+    NODEL_CAPACITY = (((KDTREE_BLOCKSIZE/INT_BYTES) - 4)/4)
+  else
+    KDTREE_BLOCKSIZE = 64
+    NODEI_CHILDREN = [(((KDTREE_BLOCKSIZE/INT_BYTES) - 6)/2),3].min
+    NODEL_CAPACITY = (((KDTREE_BLOCKSIZE/INT_BYTES) - 4)/4)
+    warn("using unusually small nodes; children=#{NODEI_CHILDREN}, capacity=#{NODEL_CAPACITY}")
+  end
+
+  # The maximum population of a leaf node (+ overflow nodes) without splitting
+  # (although splitting is disabled if the leaf bounds gets too small)
+  SPLIT_SIZE = (NODEL_CAPACITY * 3)
+
+  # The size below which a bounds cannot be further subdivided
+  # (to convert a leaf node that's at capacity to an internal node)
+  SPLITTABLE_LINEAR_SIZE = 2
+
+  if false
+    warn("setting cache very small")
+    KD_CACHE_SIZE = 5
+  else
+    KD_CACHE_SIZE = (100000/KDTREE_BLOCKSIZE)
+  end
+
+  # Block fields for Node base class (each is an int)
+  HDR_FLAGS = 0
+  HDR_INTS = 1
+
+  # Block fields for NodeI subclass
+  IFLD_POPULATION = HDR_INTS
+  IFLD_PARTITIONS = IFLD_POPULATION + 1
+  IFLD_INTS = IFLD_PARTITIONS + NODEI_CHILDREN * PARTITION_INTS
+
+  # Block fields for NodeL subclass
+  LFLD_OVERFLOW = HDR_INTS
+  LFLD_USED = LFLD_OVERFLOW+1
+  LFLD_DATAPOINTS  = LFLD_USED+1
+  LFLD_INTS = (LFLD_DATAPOINTS + NODEL_CAPACITY * DATAPOINT_INTS)
+
+  class Partition
+    attr_accessor :start_position, :child_name
+    def initialize(pos=0,child_name=0)
+      @start_position = pos
+      @child_name = child_name
+    end
+  end
+
+  # Base class for KDTree nodes
+  #
+  class Node
+
+    attr_accessor :leaf
+    attr_accessor :name
+    # If true, the slabs are stacked vertically; otherwise, they're arranged
+    # horizontally
+    attr_accessor :vertical
+    attr_accessor :prev_node, :next_node, :bounds
+    attr_accessor :modified
+    def initialize(name,leaf,vertical,bounds)
+      @name = name
+      @leaf = leaf
+      @vertical = vertical
+      @bounds = bounds
+      @modified = false
+    end
+
+    def splittable
+      s = [@bounds.w,@bounds.h].max
+      s >= SPLITTABLE_LINEAR_SIZE
+    end
+  end
+
+  class NodeL < Node
+    # name of overflow block (or zero)
+    attr_accessor :overflow
+    def initialize(name,vertical,bounds)
+      super(name,true,vertical,bounds)
+      @data_pts = []
+      @used = 0
+      @overflow = 0
+    end
+
+    def used
+      @data_pts.size
+    end
+
+    def pts
+      @data_pts
+    end
+
+    def set_data_point(index, dp)
+      @data_pts[index] = dp
+    end
+
+    def data_point(index)
+      @data_pts[index]
+    end
+
+    def add_data_point(dp)
+      @data_pts << dp
+    end
+
+    def pop_last_point
+      @data_pts.pop
+    end
+
+    # Find position of a point, given its name; returns -1 if not found
+    def find_point(pt)
+      ret = -1
+      @data_pts.each_with_index do |dp,i|
+        if DataPoint.match(dp,pt)
+          ret = i
+          break
+        end
+      end
+      ret
+    end
+
+    def to_s
+      s = "LEAF=> ##{name} "
+      s << "us=#{used} ov=#{overflow} ["
+      used.times do |i|
+        dp = data_point(i)
+        #        s <<   " #{dp}"
+        s <<   " #{dp.name}"
+      end
+      s << ']'
+      s
+    end
+
+    def inspect
+      to_s
+    end
+  end
+
+  class NodeI < Node
+
+    attr_accessor :population
+    def initialize(name, vertical, bounds)
+      super(name,false,vertical,bounds)
+      @population = 0
+      @p = []
+      NODEI_CHILDREN.times{ @p << Partition.new }
+    end
+
+    def adjust_population(amt)
+      @population += amt
+    end
+
+    def slot(slot_index)
+      @p[slot_index]
+    end
+
+    def set_slot(slot, p)
+      @p[slot] = p
+    end
+
+    # Determine which slot intersects a line perpendicular to the bounds
+    # > linePosition  if node is horizontal, the x coordinate of the line; else, the y coordinate
+    # < slot index
+    def slot_intersecting_line(line_position)
+
+      s0 = 0
+      s1 = NODEI_CHILDREN
+      while s0 < s1
+        s = (s0 + s1) / 2
+        if @p[s].start_position > line_position
+          s1 = s
+        else
+          s0 = s + 1
+        end
+      end
+      s0 - 1
+    end
+
+    # Determine which slot contains a particular point
+    # (assumes point lies within the bounds of some slot)
+    def slot_containing_point(loc)
+      line_pos = vertical ? loc.y : loc.x
+      slot_intersecting_line(line_pos)
+    end
+
+    def set_slot_child(slot, child_name)
+      @p[slot].child_name = child_name
+    end
+
+    def slot_child(slot)
+      @p[slot].child_name
+    end
+
+    def slot_bounds(slot)
+      nb = bounds
+      if vertical
+        nb = nb.flip
+      end
+
+      x = @p[slot].start_position
+      x2 = nb.x2
+
+      if slot+1 < NODEI_CHILDREN
+        x2 = @p[slot+1].start_position
+      end
+
+      b =  Bounds.new(x,nb.y,x2-x,nb.h)
+      if vertical
+        b = b.flip
+      end
+      b
+
+    end
+
+    def remove_child_named(name)
+      @p.each do |p|
+        p.child_name = 0 if p.child_name == name
+      end
+    end
+
+    def to_s
+      s = "INTR=> ##{name} "
+      s << (self.vertical ? "V" : "H")
+      s << " pop=#{population}"
+      s << " bnds #{bounds} "
+
+      NODEI_CHILDREN.times do |i|
+        pt = slot(i)
+
+        b = slot_bounds(i)
+        b = b.flip if vertical
+
+        s << "#{b.x}/#{b.x2}--> #{pt.child_name}  "
+      end
+      s
+    end
+
+    def inspect
+      to_s
+    end
+
+  end
+
+end