kml_contains 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2fbcf0a4ed8ab0c472a4b71a29d6dd44701d4137ebac81c4ca7738b3a5ca03ec
+  data.tar.gz: 9079e91ee5602095d782e0641c619bebf631685d2f9b9ddaa60469efc79888df
+SHA512:
+  metadata.gz: 63f084937feb4043fa6044ffff06e3bb31add9d3f20035b8b7041ca53f2d907343a8632c95cbb93af1f5569feadaceae71f9da08c833a6292f88a5c082f22bb4
+  data.tar.gz: c525d102e0dc0b551601fac286a18dbabfd8e1be000853660407d5b88552fd7b8acf0c223c2613b7d7e9b4fb36d13be01e9b02136a6b5bbc5430a234c5938d9c

data/.gitignore

@@ -0,0 +1,5 @@
+*~
+#*
+*.sw*
+.bundle
+Gemfile.lock

data/.tool-versions

@@ -0,0 +1 @@
+ruby 4.0.1

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright © 2009 Square, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the “Software”), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,44 @@
+# KmlContains
+
+Parse a KML file and check if geographic points fall inside the polygons it defines. Supports multiple polygons and polygons with holes (inner boundaries).
+
+## Usage
+
+Using [NSW Local Government Areas](https://data.gov.au/data/dataset/nsw-local-government-areas) from data.gov.au as an example — download the ESRI Shapefile (GDA94) and convert it to KML with [GDAL](https://gdal.org):
+
+```bash
+ogr2ogr -f KML nsw-lga.kml nsw_lga.shp
+```
+
+Then in Ruby:
+
+```ruby
+region = KmlContains.parse_kml(File.read('nsw-lga.kml'))
+
+sydney = KmlContains::Point.new(151.21, -33.87)
+region.contains_point?(sydney)             # => true
+region.contains_point?(151.21, -33.87)     # also works
+
+melbourne = KmlContains::Point.new(144.96, -37.81)
+region.contains_point?(melbourne)          # => false
+
+# find which polygon contains a point and access its ExtendedData
+lga = region.find { |p| p.contains_point?(sydney) }
+lga.extended_data['LGA_NAME']              # => "Council of the City of Sydney"
+```
+
+Points are `(longitude, latitude)`. You can pass a `KmlContains::Point`, a longitude/latitude pair, or any object that responds to `x` and `y`.
+
+## Dependencies
+
+* [Nokogiri](https://nokogiri.org)
+
+## Credits
+
+Originally created as `border_patrol` at Square by **Zach Brock** and **Matt Wilson**.
+
+Contributors: **Scott Gonyea**, **Rob Olson**, **Omar Qazi**, **Denis Haskin**, **Tamir Duberstein**, **Erica Kwan**.
+
+## License
+
+MIT

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler/gem_tasks'
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/kml_contains.gemspec

@@ -0,0 +1,21 @@
+$LOAD_PATH.push File.expand_path('lib', __dir__)
+require 'kml_contains/version'
+
+Gem::Specification.new do |s|
+  s.name = 'kml_contains'
+  s.version = KmlContains::VERSION
+  s.authors = ['Zach Brock', 'Matt Wilson']
+  s.description = 'Check if points are inside or outside the region polygons in an imported KML file.'
+  s.summary = 'Import and query KML regions'
+  s.homepage = 'https://github.com/qapn/kml_contains'
+  s.license = 'MIT'
+  s.required_ruby_version = '>= 3.0'
+
+  s.require_paths = ['lib']
+  s.files = `git ls-files`.split("\n")
+  s.add_runtime_dependency('nokogiri')
+
+  s.add_development_dependency('benchmark')
+  s.add_development_dependency('rake')
+  s.add_development_dependency('rspec')
+end

data/lib/kml_contains/point.rb

@@ -0,0 +1,32 @@
+module KmlContains
+  Point = Struct.new(:x, :y) unless defined?(::KmlContains::Point)
+
+  class Point
+    alias_method :latitude,   :y
+    alias_method :latitude=,  :y=
+    alias_method :lat,        :y
+    alias_method :lat=,       :y=
+
+    alias_method :longitude,  :x
+    alias_method :longitude=, :x=
+    alias_method :lng,        :x
+    alias_method :lng=,       :x=
+    alias_method :lon,        :x
+    alias_method :lon=,       :x=
+
+    # Lots of Map APIs want the coordinates in lat-lng order
+    def latlng
+      [lat, lon]
+    end
+    alias_method :coords, :latlng
+
+    def inspect
+      self.class.inspect_string % latlng
+    end
+
+    # IE: #<KmlContains::Point(lat, lng) = (-25.363882, 131.044922)>
+    def self.inspect_string
+      @inspect_string ||= "#<#{name}(lat, lng) = (%p, %p)>"
+    end
+  end
+end

data/lib/kml_contains/polygon.rb

@@ -0,0 +1,120 @@
+module KmlContains
+  class Polygon
+    attr_reader :placemark_name, :inner_boundaries, :extended_data
+    extend Forwardable
+
+    # Note @points is the outer boundary.
+    # A polygon may also have 1 or more inner boundaries.  In order to not change the ctor signature,
+    # the inner boundaries are not settable at construction.
+    def initialize(*args)
+      args.flatten!
+      args.uniq!
+      raise InsufficientPointsToActuallyFormAPolygonError unless args.size > 2
+      @inner_boundaries = []
+      @extended_data = {}
+      @points = args.dup
+      precompute_normalised_bounds
+    end
+
+    def_delegators :@points, :size, :each, :first, :include?, :[], :index
+
+    def with_inner_boundaries(polygons)
+      @inner_boundaries = [polygons].flatten
+      self
+    end
+
+    def with_placemark_name(placemark)
+      @placemark_name ||= placemark
+      self
+    end
+
+    def with_extended_data(data)
+      @extended_data = data
+      self
+    end
+
+    def ==(other)
+      # Do we have the right number of points?
+      return false unless other.size == size
+
+      # Are the points in the right order?
+      first, second = first(2)
+      index = other.index(first)
+      return false unless index
+      direction = (other[index - 1] == second ? -1 : 1)
+      # Check if the two polygons have the same edges and the same points
+      # i.e. [point1, point2, point3] is the same as [point2, point3, point1] is the same as [point3, point2, point1]
+      each do |i|
+        return false unless i == other[index]
+        index += direction
+        index = 0 if index == size
+      end
+      return true if @inner_boundaries.empty?
+      @inner_boundaries == other.inner_boundaries
+    end
+
+    # Quick and dirty hash function
+    def hash
+      @points.map { |point| point.x + point.y }.reduce(&:+).to_i
+    end
+
+    def contains_point?(point)
+      return false unless inside_bounding_box?(point)
+      px = normalise_lng(point.x)
+      c = false
+      i = -1
+      j = size - 1
+      while (i += 1) < size
+        iy = self[i].y
+        jy = self[j].y
+        if (iy <= point.y && point.y < jy) ||
+           (jy <= point.y && point.y < iy)
+          if px < (@norm_xs[j] - @norm_xs[i]) * (point.y - iy) / (jy - iy) + @norm_xs[i]
+            c = !c
+          end
+        end
+        j = i
+      end
+      return c if c == false
+      # Check if excluded by any of the inner boundaries
+      @inner_boundaries.each do |inner_boundary|
+        return false if inner_boundary.contains_point?(point)
+      end
+      c
+    end
+
+    def inside_bounding_box?(point)
+      px = normalise_lng(point.x)
+      !(px < @bb_min_x || px > @bb_max_x ||
+        point.y < @bb_min_y || point.y > @bb_max_y)
+    end
+
+    def bounding_box
+      [KmlContains::Point.new(@bb_min_x, @bb_max_y),
+       KmlContains::Point.new(@bb_max_x, @bb_min_y)]
+    end
+
+    def central_point
+      KmlContains.central_point(bounding_box)
+    end
+
+    private
+
+    def normalise_lng(lng)
+      diff = lng - @ref_x
+      diff -= 360 while diff > 180
+      diff += 360 while diff < -180
+      @ref_x + diff
+    end
+
+    def precompute_normalised_bounds
+      @ref_x = @points.first.x
+      @norm_xs = @points.map { |p| normalise_lng(p.x) }
+      ys = @points.map(&:y)
+      @bb_min_x = @norm_xs.min
+      @bb_max_x = @norm_xs.max
+      @bb_min_y = ys.min
+      @bb_max_y = ys.max
+    end
+  end
+end

data/lib/kml_contains/region.rb

@@ -0,0 +1,31 @@
+module KmlContains
+  class Region < Set
+    def contains_point?(*point)
+      point = case point.length
+              when 1
+                point.first
+              when 2
+                KmlContains::Point.new(point[0], point[1])
+              else
+                raise ArgumentError, "#{point} is invalid.  Arguments can either be an object, or a longitude,lattitude pair."
+              end
+      any? { |polygon| polygon.contains_point?(point) }
+    end
+
+    # The below are some general helper methods
+    def bounding_boxes
+      map(&:bounding_box)
+    end
+
+    def bounding_box
+      boxes = bounding_boxes
+      boxes.flatten!
+
+      KmlContains.bounding_box(boxes)
+    end
+
+    def central_point
+      KmlContains.central_point(bounding_box)
+    end
+  end
+end

data/lib/kml_contains/version.rb

@@ -0,0 +1,3 @@
+module KmlContains
+  VERSION = '0.3.0'
+end

data/lib/kml_contains.rb

@@ -0,0 +1,90 @@
+require 'set'
+require 'forwardable'
+require 'nokogiri'
+require 'kml_contains/version'
+require 'kml_contains/point'
+require 'kml_contains/polygon'
+require 'kml_contains/region'
+
+module KmlContains
+  class InsufficientPointsToActuallyFormAPolygonError < ArgumentError; end
+
+  def self.parse_kml(string)
+    doc = Nokogiri::XML(string)
+
+    polygons = doc.search('Polygon').map do |polygon_kml|
+      placemark_name = placemark_name_for_polygon(polygon_kml)
+      extended_data = extended_data_for_polygon(polygon_kml)
+      parse_kml_polygon_data(polygon_kml.to_s, placemark_name, extended_data)
+    end
+    KmlContains::Region.new(polygons)
+  end
+
+  def self.bounding_box(points)
+    xs = points.map(&:x)
+    ys = points.map(&:y)
+    [Point.new(xs.min, ys.max), Point.new(xs.max, ys.min)]
+  end
+
+  def self.central_point(box)
+    point1, point2 = box
+
+    x = (point1.x + point2.x) / 2
+    y = (point1.y + point2.y) / 2
+
+    Point.new(x, y)
+  end
+
+  private
+
+  def self.parse_kml_polygon_data(string, name = nil, extended_data = {})
+    doc = Nokogiri::XML(string)
+    # "A Polygon is defined by an outer boundary and 0 or more inner boundaries."
+    outerboundary = doc.xpath('//outerBoundaryIs')
+    innerboundaries = doc.xpath('//innerBoundaryIs')
+    coordinates = outerboundary.xpath('.//coordinates').text.strip.split(/\s+/)
+    points = points_from_coordinates(coordinates)
+    if innerboundaries
+      inner_boundary_polygons = innerboundaries.map do |i|
+        KmlContains::Polygon.new(points_from_coordinates(i.xpath('.//coordinates').text.strip.split(/\s+/)))
+      end
+      KmlContains::Polygon.new(points).with_placemark_name(name).with_extended_data(extended_data).with_inner_boundaries(inner_boundary_polygons)
+    else
+      KmlContains::Polygon.new(points).with_placemark_name(name).with_extended_data(extended_data)
+    end
+  end
+
+  def self.points_from_coordinates c
+    c.map do |coord|
+      x, y, _ = coord.strip.split(',')
+      KmlContains::Point.new(x.to_f, y.to_f)
+    end
+  end
+
+  def self.placemark_for_polygon(p)
+    # A polygon can be contained by a MultiGeometry or Placemark
+    parent = p.parent
+    parent = parent.parent if parent.name == 'MultiGeometry'
+
+    return nil unless parent.name == 'Placemark'
+
+    parent
+  end
+
+  def self.placemark_name_for_polygon(p)
+    placemark = placemark_for_polygon(p)
+    return nil unless placemark
+
+    placemark.search('name').text
+  end
+
+  def self.extended_data_for_polygon(p)
+    placemark = placemark_for_polygon(p)
+    return {} unless placemark
+
+    data = {}
+    placemark.search('Data').each { |d| data[d['name']] = d.search('value').text }
+    placemark.search('SimpleData').each { |sd| data[sd['name']] = sd.text }
+    data
+  end
+end

data/script/benchmark.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby -w
+require 'kml_contains'
+require 'benchmark'
+
+colorado_region = KmlContains.parse_kml(File.read('spec/support/colorado-test.kml'))
+multi_polygon_region = KmlContains.parse_kml(File.read('spec/support/multi-polygon-test.kml'))
+Benchmark.bm(20) do |x|
+  x.report('colorado region') do
+    10_000.times do |_i|
+      multiple = (rand(2) == 1 ? -1 : 1)
+      colorado_region.contains_point?(rand * 180 * multiple, rand * 180 * multiple)
+    end
+  end
+
+  x.report('multi polygon region') do
+    10_000.times do |_i|
+      multiple = (rand(2) == 1 ? -1 : 1)
+      multi_polygon_region.contains_point?(rand * 180 * multiple, rand * 180 * multiple)
+    end
+  end
+end

data/spec/lib/kml_contains/polygon_spec.rb

@@ -0,0 +1,238 @@
+require 'spec_helper'
+
+describe KmlContains::Polygon do
+  describe '==' do
+    it 'is true if polygons are congruent' do
+      points = [KmlContains::Point.new(1, 2), KmlContains::Point.new(3, 4), KmlContains::Point.new(0, 0)]
+      poly1 = KmlContains::Polygon.new(points)
+      poly2 = KmlContains::Polygon.new(points.unshift(points.pop))
+
+      expect(poly1).to eq(poly2)
+      expect(poly2).to eq(poly1)
+      poly3 = KmlContains::Polygon.new(points.reverse)
+      expect(poly1).to eq(poly3)
+      expect(poly3).to eq(poly1)
+
+    end
+
+    it 'cares about order of points' do
+      points = [KmlContains::Point.new(1, 2), KmlContains::Point.new(3, 4), KmlContains::Point.new(5, 5), KmlContains::Point.new(0, 0)]
+      poly1 = KmlContains::Polygon.new(points)
+      points = [KmlContains::Point.new(5, 5), KmlContains::Point.new(1, 2), KmlContains::Point.new(0, 0), KmlContains::Point.new(3, 4)]
+      poly2 = KmlContains::Polygon.new(points)
+
+      expect(poly1).not_to eq(poly2)
+      expect(poly2).not_to eq(poly1)
+
+    end
+
+    it 'is false if one polygon is a subset' do
+      poly1 = KmlContains::Polygon.new(KmlContains::Point.new(1, 2), KmlContains::Point.new(3, 4), KmlContains::Point.new(0, 0))
+      poly2 = KmlContains::Polygon.new(KmlContains::Point.new(1, 2), KmlContains::Point.new(3, 4), KmlContains::Point.new(0, 0), KmlContains::Point.new(4, 4))
+      expect(poly2).not_to eq(poly1)
+      expect(poly1).not_to eq(poly2)
+    end
+
+    it 'is false if the polygons are not congruent' do
+      poly1 = KmlContains::Polygon.new(KmlContains::Point.new(1, 2), KmlContains::Point.new(3, 4), KmlContains::Point.new(0, 0))
+      poly2 = KmlContains::Polygon.new(KmlContains::Point.new(2, 1), KmlContains::Point.new(3, 4), KmlContains::Point.new(0, 0))
+      expect(poly2).not_to eq(poly1)
+      expect(poly1).not_to eq(poly2)
+    end
+
+    it 'is true if polygons and their inner boundaries are congruent' do
+      poly1 = KmlContains::Polygon.new(KmlContains::Point.new(0, 0), KmlContains::Point.new(3, 0), KmlContains::Point.new(3,3), KmlContains::Point.new(0,3))
+      poly1.with_inner_boundaries(KmlContains::Polygon.new(KmlContains::Point.new(1,1), KmlContains::Point.new(2, 1), KmlContains::Point.new(2, 2), KmlContains::Point.new(1,2)))
+      poly2 = KmlContains::Polygon.new(KmlContains::Point.new(0, 0), KmlContains::Point.new(3, 0), KmlContains::Point.new(3,3), KmlContains::Point.new(0,3))
+      poly2.with_inner_boundaries(KmlContains::Polygon.new(KmlContains::Point.new(1,1), KmlContains::Point.new(2, 1), KmlContains::Point.new(2, 2), KmlContains::Point.new(1,2)))
+      expect(poly1).to eq(poly2)
+    end
+
+    it 'is false if polygons inner boundaries are not congruent' do
+      poly1 = KmlContains::Polygon.new(KmlContains::Point.new(0, 0), KmlContains::Point.new(3, 0), KmlContains::Point.new(3,3), KmlContains::Point.new(0,3))
+      poly1.with_inner_boundaries(KmlContains::Polygon.new(KmlContains::Point.new(1,1), KmlContains::Point.new(2, 1), KmlContains::Point.new(2, 2), KmlContains::Point.new(1,2)))
+      poly2 = KmlContains::Polygon.new(KmlContains::Point.new(0, 0), KmlContains::Point.new(3, 0), KmlContains::Point.new(3,3), KmlContains::Point.new(0,3))
+      poly2.with_inner_boundaries(KmlContains::Polygon.new(KmlContains::Point.new(1.1,1.1), KmlContains::Point.new(2.1, 1.1), KmlContains::Point.new(2.1, 2.1), KmlContains::Point.new(1.1,2.1)))
+      expect(poly1).not_to eq(poly2)
+    end
+  end
+
+  describe '#initialize' do
+    it 'stores a list of points' do
+      points = [KmlContains::Point.new(1, 2), KmlContains::Point.new(3, 4), KmlContains::Point.new(0, 0)]
+      polygon = KmlContains::Polygon.new(points)
+      points.each do |point|
+        expect(polygon).to include point
+      end
+    end
+
+    it 'can be instantiated with a arbitrary argument list' do
+      points = [KmlContains::Point.new(1, 2), KmlContains::Point.new(3, 4), KmlContains::Point.new(0, 0)]
+      poly1 = KmlContains::Polygon.new(* points)
+      poly2 = KmlContains::Polygon.new(points)
+      expect(poly1).to eq(poly2)
+    end
+
+    it 'raises if less than 3 points are given' do
+      points = [KmlContains::Point.new(1, 2), KmlContains::Point.new(2, 3)]
+      expect { KmlContains::Polygon.new(points) }.to raise_exception(KmlContains::InsufficientPointsToActuallyFormAPolygonError)
+      points = [KmlContains::Point.new(1, 2)]
+      expect { KmlContains::Polygon.new(points) }.to raise_exception(KmlContains::InsufficientPointsToActuallyFormAPolygonError)
+      points = []
+      expect { KmlContains::Polygon.new(points) }.to raise_exception(KmlContains::InsufficientPointsToActuallyFormAPolygonError)
+    end
+
+    it "doesn't store duplicated points" do
+      points = [KmlContains::Point.new(1, 2), KmlContains::Point.new(3, 4), KmlContains::Point.new(0, 0)]
+      duplicate_point = [KmlContains::Point.new(1, 2)]
+      polygon = KmlContains::Polygon.new(points + duplicate_point)
+      expect(polygon.size).to eq(3)
+      points.each do |point|
+        expect(polygon).to include point
+      end
+    end
+  end
+
+  describe '#bounding_box' do
+    it 'returns the (max top, max left), (max bottom, max right) as points' do
+      points = [KmlContains::Point.new(-1, 3), KmlContains::Point.new(4, -3), KmlContains::Point.new(10, 4), KmlContains::Point.new(0, 12)]
+      polygon = KmlContains::Polygon.new(points)
+      expect(polygon.bounding_box).to eq([KmlContains::Point.new(-1, 12), KmlContains::Point.new(10, -3)])
+    end
+  end
+
+  describe '#contains_point?' do
+    context 'when there is no inner boundary' do
+      before do
+        points = [KmlContains::Point.new(-10, 0), KmlContains::Point.new(10, 0), KmlContains::Point.new(0, 10)]
+        @polygon = KmlContains::Polygon.new(points)
+      end
+
+      it 'is true if the point is in the polygon' do
+        expect(@polygon.contains_point?(KmlContains::Point.new(0.5, 0.5))).to be true
+        expect(@polygon.contains_point?(KmlContains::Point.new(0, 5))).to be true
+        expect(@polygon.contains_point?(KmlContains::Point.new(-1, 3))).to be true
+      end
+
+      it 'does not include points on the lines with slopes between vertices' do
+        expect(@polygon.contains_point?(KmlContains::Point.new(5.0, 5.0))).to be false
+        expect(@polygon.contains_point?(KmlContains::Point.new(4.999999, 4.9999999))).to be true
+        expect(@polygon.contains_point?(KmlContains::Point.new(0, 0))).to be true
+        expect(@polygon.contains_point?(KmlContains::Point.new(0.000001, 0.000001))).to be true
+      end
+
+      it 'includes points at the vertices' do
+        expect(@polygon.contains_point?(KmlContains::Point.new(-10, 0))).to be true
+      end
+
+      it 'is false if the point is outside of the polygon' do
+        expect(@polygon.contains_point?(KmlContains::Point.new(9, 5))).to be false
+        expect(@polygon.contains_point?(KmlContains::Point.new(-5, 8))).to be false
+        expect(@polygon.contains_point?(KmlContains::Point.new(-10, -1))).to be false
+        expect(@polygon.contains_point?(KmlContains::Point.new(-20, -20))).to be false
+      end
+    end
+
+    context 'when the polygon crosses the international date line' do
+      before do
+        points = [
+          KmlContains::Point.new(170, 10),
+          KmlContains::Point.new(-170, 10),
+          KmlContains::Point.new(-170, -10),
+          KmlContains::Point.new(170, -10),
+        ]
+        @polygon = KmlContains::Polygon.new(points)
+      end
+
+      it 'is true for a point inside the polygon (between 170 and 180)' do
+        expect(@polygon.contains_point?(KmlContains::Point.new(175, 0))).to be true
+      end
+
+      it 'is true for a point inside the polygon (between -180 and -170)' do
+        expect(@polygon.contains_point?(KmlContains::Point.new(-175, 0))).to be true
+      end
+
+      it 'is false for a point outside the polygon' do
+        expect(@polygon.contains_point?(KmlContains::Point.new(0, 0))).to be false
+        expect(@polygon.contains_point?(KmlContains::Point.new(160, 0))).to be false
+        expect(@polygon.contains_point?(KmlContains::Point.new(-160, 0))).to be false
+      end
+
+      it 'is false for a point outside the latitude range' do
+        expect(@polygon.contains_point?(KmlContains::Point.new(175, 15))).to be false
+      end
+    end
+
+    context 'when there is an inner boundary' do
+      before do
+        @polygon = KmlContains::Polygon.new(KmlContains::Point.new(0, 0), KmlContains::Point.new(3, 0), KmlContains::Point.new(3,3), KmlContains::Point.new(0,3))
+        @polygon.with_inner_boundaries(KmlContains::Polygon.new(KmlContains::Point.new(1,1), KmlContains::Point.new(2, 1), KmlContains::Point.new(2, 2), KmlContains::Point.new(1,2)))
+      end
+
+      it 'is true if the point is in the polygon but not in the inner boundary' do
+        expect(@polygon.contains_point?(KmlContains::Point.new(0.5, 1.5))).to be true
+        expect(@polygon.contains_point?(KmlContains::Point.new(0.5, 0.5))).to be true
+        expect(@polygon.contains_point?(KmlContains::Point.new(1.5, 0.5))).to be true
+      end
+
+      it 'is false if the point is outside the polygon' do
+        expect(@polygon.contains_point?(KmlContains::Point.new(4, 0.5))).to be false
+        expect(@polygon.contains_point?(KmlContains::Point.new(2.5, 4))).to be false
+        expect(@polygon.contains_point?(KmlContains::Point.new(-1, 1.5))).to be false
+      end
+
+      it 'is false if the point is inside the inner boundary' do
+        expect(@polygon.contains_point?(KmlContains::Point.new(1.5, 1.5))).to be false
+      end
+
+    end
+  end
+
+  describe '#inside_bounding_box?' do
+    before do
+      points = [KmlContains::Point.new(-10, 0), KmlContains::Point.new(10, 0), KmlContains::Point.new(0, 10)]
+      @polygon = KmlContains::Polygon.new(points)
+    end
+
+    it 'is false if it is outside the bounding box' do
+      expect(@polygon.inside_bounding_box?(KmlContains::Point.new(-10, -1))).to be false
+      expect(@polygon.inside_bounding_box?(KmlContains::Point.new(-20, -20))).to be false
+      expect(@polygon.inside_bounding_box?(KmlContains::Point.new(1, 20))).to be false
+    end
+
+    it 'returns true if it is inside the bounding box' do
+      expect(@polygon.inside_bounding_box?(KmlContains::Point.new(9, 5))).to be true
+      expect(@polygon.inside_bounding_box?(KmlContains::Point.new(-5, 8))).to be true
+      expect(@polygon.inside_bounding_box?(KmlContains::Point.new(1, 1))).to be true
+    end
+
+  end
+
+  describe '#with_placemark_name' do
+    before(:each) do
+      points = [KmlContains::Point.new(-10, 0), KmlContains::Point.new(10, 0), KmlContains::Point.new(0, 10)]
+      @polygon = KmlContains::Polygon.new(points)
+    end
+
+    it 'adds a placemark name to a polygon' do
+      expect(@polygon.placemark_name).to be_nil
+
+      @polygon.with_placemark_name('Twin Peaks, San Francisco')
+      expect(@polygon.placemark_name).to eq('Twin Peaks, San Francisco')
+    end
+
+    it 'returns the Polygon object' do
+      expect(@polygon.with_placemark_name('Silverlake, Los Angeles')).to equal @polygon
+    end
+
+    it 'only allows the placemark name to be set once' do
+      expect(@polygon.placemark_name).to be_nil
+
+      @polygon.with_placemark_name('Santa Clara, California')
+      expect(@polygon.placemark_name).to eq('Santa Clara, California')
+
+      @polygon.with_placemark_name('Santa Cruz, California')
+      expect(@polygon.placemark_name).to eq('Santa Clara, California')
+    end
+  end
+end