h3 3.2.0

data/spec/hierarchy_spec.rb

@@ -0,0 +1,159 @@
+RSpec.describe H3 do
+  include_context "constants"
+
+  describe ".h3_to_parent" do
+    let(:h3_index) { "89283082993ffff".to_i(16) }
+    let(:parent_resolution) { 8 }
+    let(:result) { "8828308299fffff".to_i(16) }
+
+    subject(:h3_to_parent) { H3.h3_to_parent(h3_index, parent_resolution) }
+
+    it { is_expected.to eq(result) }
+  end
+
+  describe ".h3_to_children" do
+    let(:h3_index) { "8928308280fffff".to_i(16) }
+
+    subject(:h3_to_children) { H3.h3_to_children(h3_index, child_resolution) }
+
+    context "when resolution is 3" do
+      let(:child_resolution) { 3 }
+      let(:count) { 0 }
+
+      it "has 0 children" do
+        expect(h3_to_children.count).to eq count
+      end
+    end
+
+    context "when resolution is 9" do
+      let(:child_resolution) { 9 }
+      let(:count) { 1 }
+      let(:expected) { "8928308280fffff".to_i(16) }
+
+      it "has 1 child" do
+        expect(h3_to_children.count).to eq count
+      end
+
+      it "is the expected value" do
+        expect(h3_to_children.first).to eq expected
+      end
+    end
+
+    context "when resolution is 10" do
+      let(:child_resolution) { 10 }
+      let(:count) { 7 }
+
+      it "has 7 children" do
+        expect(h3_to_children.count).to eq count
+      end
+    end
+
+    context "when resolution is 15" do
+      let(:child_resolution) { 15 }
+      let(:count) { 117649 }
+
+      it "has 117649 children" do
+        expect(h3_to_children.count).to eq count
+      end
+    end
+  end
+
+  describe ".max_h3_to_children_size" do
+    let(:h3_index) { "8928308280fffff".to_i(16) }
+
+    subject(:h3_to_children) { H3.max_h3_to_children_size(h3_index, child_resolution) }
+
+    context "when resolution is 3" do
+      let(:child_resolution) { 3 }
+      let(:count) { 0 }
+
+      it { is_expected.to eq(count) }
+    end
+
+    context "when resolution is 9" do
+      let(:child_resolution) { 9 }
+      let(:count) { 1 }
+
+      it { is_expected.to eq(count) }
+    end
+
+    context "when resolution is 10" do
+      let(:child_resolution) { 10 }
+      let(:count) { 7 }
+
+      it { is_expected.to eq(count) }
+    end
+
+    context "when resolution is 15" do
+      let(:child_resolution) { 15 }
+      let(:count) { 117649 }
+
+      it { is_expected.to eq(count) }
+    end
+  end
+
+  describe ".compact" do
+    let(:h3_index) { "89283470c27ffff".to_i(16) }
+    let(:k) { 9 }
+    let(:uncompacted) do
+      H3.k_ring(h3_index, k)
+    end
+
+    subject(:compact) { H3.compact(uncompacted) }
+
+    it "has an uncompacted size of 271" do
+      expect(uncompacted.size).to eq 271
+    end
+
+    it "has a compacted size of 73" do
+      expect(compact.size).to eq 73
+    end
+  end
+
+  describe ".uncompact" do
+    let(:h3_index) { "89283470c27ffff".to_i(16) }
+    let(:resolution) { 9 }
+    let(:uncompacted) do
+      H3.k_ring(h3_index, resolution)
+    end
+    let(:compacted) do
+      H3.compact(uncompacted)
+    end
+
+    subject(:uncompact) { H3.uncompact(compacted, resolution) }
+
+    it "has an uncompacted size of 271" do
+      expect(uncompact.size).to eq 271
+    end
+
+    it "has a compacted size of 73" do
+      expect(compacted.size).to eq 73
+    end
+
+    context "when resolution is incorrect for index" do
+      let(:resolution) { 8 }
+
+      it "raises error" do
+        expect { uncompact }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe ".max_uncompact_size" do
+    let(:h3_indexes) { ["8928308280fffff", "89283470893ffff"].map { |i| i.to_i(16) } }
+    let(:resolution) { 9 }
+    let(:result) { 2 }
+
+    subject(:max_uncompact_size) { H3.max_uncompact_size(h3_indexes, resolution) }
+
+    it { is_expected.to eq result }
+
+    context "when resolution is incorrect for index" do
+      let(:resolution) { 8 }
+
+      it "raises an error" do
+        expect { max_uncompact_size }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end

data/spec/indexing_spec.rb

@@ -0,0 +1,92 @@
+RSpec.describe H3 do
+  include_context "constants"
+
+  describe ".geo_to_h3" do
+    let(:resolution) { 8 }
+    let(:coords) { [53.959130, -1.079230]}
+    let(:result) { valid_h3_index }
+
+    subject(:geo_to_h3) { H3.geo_to_h3(coords, resolution) }
+
+    it { is_expected.to eq(result) }
+
+    context "when given more than 2 values" do
+      let(:coords) { [1, 2, 3] }
+
+      it "raises an error" do
+        expect { geo_to_h3 }.to raise_error(ArgumentError)
+      end
+    end
+
+    context "when given a non array" do
+      let(:coords) { "boom" }
+
+      it "raises an error" do
+        expect { geo_to_h3 }.to raise_error(ArgumentError)
+      end
+    end
+
+    context "when given bad coordinates" do
+      let(:coords) { [-1.1323222, 190.1020102] }
+
+      it "raises an error" do
+        expect { geo_to_h3 }.to raise_error(ArgumentError)
+      end
+    end    
+  end
+
+  describe ".h3_to_geo" do
+    let(:h3_index) { valid_h3_index }
+    let(:expected_lat) { 53.95860421941 }
+    let(:expected_lon) { -1.08119564709 }
+
+    subject(:h3_to_geo) { H3.h3_to_geo(h3_index) }
+
+    it "should return the expected latitude" do
+      expect(h3_to_geo[0]).to be_within(0.000001).of(expected_lat)
+    end
+
+    it "should return the expected longitude" do
+      expect(h3_to_geo[1]).to be_within(0.000001).of(expected_lon)
+    end
+
+    context "when given an invalid h3_index" do
+      let(:h3_index) { "boom" }
+
+      it "raises an error" do
+        expect { h3_to_geo }.to raise_error(TypeError)
+      end
+    end
+
+    context "when given an index that's too large" do
+      let(:h3_index) { too_long_number }
+
+      it "raises an error" do
+        expect { h3_to_geo }.to raise_error(RangeError)
+      end
+    end
+  end
+
+  describe ".h3_to_geo_boundary" do
+    let(:h3_index) { "85283473fffffff".to_i(16) }
+    let(:expected) do
+      [
+        [37.2713558667319, -121.91508032705622],
+        [37.353926450852256, -121.8622232890249],
+        [37.42834118609435, -121.92354999630156],
+        [37.42012867767779, -122.03773496427027],
+        [37.33755608435299, -122.090428929044],
+        [37.26319797461824, -122.02910130918998]
+      ]
+    end
+
+    subject(:h3_to_geo_boundary) { H3.h3_to_geo_boundary(h3_index) }
+
+    it "matches expected boundary coordinates" do
+      h3_to_geo_boundary.zip(expected) do |(lat, lon), (exp_lat, exp_lon)|
+        expect(lat).to be_within(0.000001).of(exp_lat)
+        expect(lon).to be_within(0.000001).of(exp_lon)
+      end
+    end
+  end
+end

data/spec/inspection_spec.rb

@@ -0,0 +1,90 @@
+RSpec.describe H3 do
+  include_context "constants"
+
+  describe ".h3_resolution" do
+    let(:h3_index) { valid_h3_index }
+    let(:result) { 8 }
+
+    subject(:h3_resolution) { H3.h3_resolution(h3_index) }
+
+    it { is_expected.to eq(result) }
+  end
+
+  describe ".h3_base_cell" do
+    let(:h3_index) { valid_h3_index }
+    let(:result) { 12 }
+
+    subject(:h3_base_cell) { H3.h3_base_cell(h3_index) }
+
+    it { is_expected.to eq(result) }
+  end
+
+  describe ".string_to_h3" do
+    let(:h3_index) { "8928308280fffff"}
+    let(:result) { h3_index.to_i(16) }
+
+    subject(:string_to_h3) { H3.string_to_h3(h3_index) }
+
+    it { is_expected.to eq(result) }
+  end
+
+  describe ".h3_to_string" do
+    let(:h3_index) { "8928308280fffff".to_i(16) }
+    let(:result) { h3_index.to_s(16) }
+
+    subject(:h3_to_string) { H3.h3_to_string(h3_index) }
+
+    it { is_expected.to eq(result) }
+  end
+
+  describe ".h3_valid?" do
+    let(:h3_index) { valid_h3_index }
+    let(:result) { true }
+
+    subject(:h3_valid?) { H3.h3_valid?(h3_index) }
+
+    it { is_expected.to eq(result) }
+
+    context "when given an invalid h3_index" do
+      let(:h3_index) { 1 }
+
+      let(:result) { false }
+
+      it "returns the expected result" do
+        expect(h3_valid?).to eq(result)
+      end
+    end
+  end
+
+  describe ".h3_res_class_3?" do
+    let(:h3_index) { "8928308280fffff".to_i(16) }
+    let(:result) { true }
+
+    subject(:h3_res_class_3) { H3.h3_res_class_3?(h3_index) }
+
+    it { is_expected.to eq(result) }
+
+    context "when the h3 index is not class III" do
+      let(:h3_index) { "8828308280fffff".to_i(16) }
+      let(:result) { false }
+
+      it { is_expected.to eq(result) }
+    end
+  end
+
+  describe ".h3_pentagon?" do
+    let(:h3_index) { "821c07fffffffff".to_i(16) }
+    let(:result) { true }
+
+    subject(:h3_pentagon?) { H3.h3_pentagon?(h3_index) }
+
+    it { is_expected.to eq(result) }
+
+    context "when the h3 index is not a pentagon" do
+      let(:h3_index) { "8928308280fffff".to_i(16) }
+      let(:result) { false }
+
+      it { is_expected.to eq(result) } 
+    end
+  end
+end

data/spec/miscellaneous_spec.rb

@@ -0,0 +1,75 @@
+RSpec.describe H3 do
+  include_context "constants"
+
+  describe ".num_hexagons" do
+    let(:resolution) { 2 }
+    let(:result) { 5882 }
+
+    subject(:num_hexagons) { H3.num_hexagons(resolution) }
+
+    it { is_expected.to eq(result) }
+
+    context "when given an invalid resolution" do
+      let(:resolution) { too_long_number }
+      let(:result) { false }
+
+      it "returns the expected result" do
+        expect { num_hexagons }.to raise_error(RangeError)
+      end
+    end
+  end
+
+  describe ".degs_to_rads" do
+    let(:degs) { 100 }
+    let(:result) { 1.7453292519943295 }
+
+    subject(:degs_to_rads) { H3.degs_to_rads(degs) }
+
+    it { is_expected.to eq(result) }
+  end
+
+  describe ".rads_to_degs" do
+    let(:rads) { 1.7453292519943295 }
+    let(:result) { 100 }
+
+    subject(:rads_to_degs) { H3.rads_to_degs(rads) }
+
+    it { is_expected.to eq(result) }
+  end
+
+  describe ".hex_area_km2" do
+    let(:resolution) { 2 }
+    let(:result) { 86745.85403 }
+
+    subject(:hex_area_km2) { H3.hex_area_km2(resolution) }
+
+    it { is_expected.to eq(result) }
+  end
+
+  describe ".hex_area_m2" do
+    let(:resolution) { 2 }
+    let(:result) { 86745854035.0 }
+
+    subject(:hex_area_m2) { H3.hex_area_m2(resolution) }
+
+    it { is_expected.to eq(result) }
+  end
+
+  describe ".edge_length_km" do
+    let(:resolution) { 2 }
+    let(:result) { 158.2446558 }
+
+    subject(:edge_length_km) { H3.edge_length_km(resolution) }
+
+    it { is_expected.to eq(result) }
+  end
+      
+  describe ".edge_length_m" do
+    let(:resolution) { 2 }
+    let(:result) { 158244.6558 }
+
+    subject(:edge_length_m) { H3.edge_length_m(resolution) }
+
+    it { is_expected.to eq(result) }
+  end
+end

data/spec/region_spec.rb

@@ -0,0 +1,71 @@
+RSpec.describe H3 do
+  include_context "constants"
+
+  describe ".polyfill" do
+    let(:geojson) do
+      File.read(File.join(File.dirname(__FILE__), "support/fixtures/banbury_without_holes.json"))
+    end
+    let(:resolution) { 9 }
+    let(:expected_count) { 14_369 }
+
+    subject(:polyfill) { H3.polyfill(geojson, resolution) }
+
+    it "has the correct number of hexagons" do
+      expect(polyfill.count).to eq expected_count
+    end
+
+    context "when banbury area has two holes in it" do
+      let(:geojson) do
+        File.read(File.join(File.dirname(__FILE__), "support/fixtures/banbury.json"))
+      end
+      let(:expected_count) { 13_526 }
+
+      it "has fewer hexagons" do
+        expect(polyfill.count).to eq expected_count
+      end
+    end
+
+    context "when polyfilling australia" do
+      let(:geojson) do
+        File.read(File.join(File.dirname(__FILE__), "support/fixtures/australia.json"))
+      end
+      let(:expect_count) { 92 }
+
+      it "has the correct number of hexagons" do
+        expect(polyfill.count).to eq expect_count
+      end
+    end
+  end
+
+  describe ".max_polyfill_size" do
+    let(:geojson) do
+      File.read(File.join(File.dirname(__FILE__), "support/fixtures/banbury.json"))
+    end
+    let(:resolution) { 9 }
+    let(:expected_count) { 33_391 }
+
+    subject(:max_polyfill_size) { H3.max_polyfill_size(geojson, resolution) }
+
+    it "has the correct number of hexagons" do
+      expect(max_polyfill_size).to eq expected_count
+    end
+  end
+
+  describe ".h3_set_to_linked_geo" do
+    let(:geojson) do
+      File.read(File.join(File.dirname(__FILE__), "support/fixtures/banbury.json"))
+    end
+    let(:resolution) { 8 }
+    let(:hexagons) { H3.polyfill(geojson, resolution) }
+
+    subject(:h3_set_to_linked_geo) { H3.h3_set_to_linked_geo(hexagons) }
+    
+    it "has 3 outlines" do
+      h3_set_to_linked_geo.count == 3
+    end
+
+    it "can be converted to GeoJSON" do
+      expect(H3.coordinates_to_geo_json(h3_set_to_linked_geo)).to be_truthy
+    end
+  end
+end