pbf_reverse_geocoder 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 70731208b30a178b40807a72415fcf6aede25018caadf24b2606b152a87c6e81
+  data.tar.gz: 53526751cd21450e88880bb3e12175641a161fea6907531b0d33418240a49625
+SHA512:
+  metadata.gz: d7fcf2add8ef30e4fb13eb349787d49e632c0de0001b97a159f2b7ca9d73364e52a8f6d5f367989422338948be134f2e0408055342e24863c0c831d1b8e98264
+  data.tar.gz: 6a80ed60cdc9c56e9a052568d541e84fdd864b3113894ef95bafc5c419fcda3beebeeee1150be6147f4683e7a5a3653b20ac3ab3d446eea27b443a1fc2a1d5f3

data/.rubocop.yml

@@ -0,0 +1,15 @@
+# RuboCop configuration for pbf_reverse_geocoder
+
+AllCops:
+  TargetRubyVersion: 3.4
+  NewCops: enable
+  SuggestExtensions: false
+  Exclude:
+    - 'vendor/**/*'
+    - 'tmp/**/*'
+
+# gemspecとRakefileはブロックが長くなるため除外
+Metrics/BlockLength:
+  Exclude:
+    - 'pbf_reverse_geocoder.gemspec'
+    - 'Rakefile'

data/.ruby-version

@@ -0,0 +1 @@
+3.4.7

data/CHANGELOG.md

@@ -0,0 +1,19 @@
+# 変更履歴
+
+このプロジェクトの主要な変更はこのファイルに記録されます。
+
+形式は [Keep a Changelog](https://keepachangelog.com/ja/1.0.0/) に基づいており、
+バージョニングは [Semantic Versioning](https://semver.org/lang/ja/) に準拠しています。
+
+## [Unreleased]
+
+## [0.1.0] - 2025-11-19
+
+### 追加
+- 初回リリース
+- Mapbox Vector Tiles用のPBFタイルリーダー
+- MVT形式のジオメトリデコーダー
+- Ray Casting Algorithmを使用したPoint-in-Polygon判定
+- タイル座標計算機
+- Protocol Buffersワイヤーフォーマット用のシンプルなPBFパーサー
+- 日本の行政区域データ対応（都道府県、市区町村、コード）

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Keisuke Terada
+
+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,264 @@
+# PbfReverseGeocoder
+
+日本の行政区域情報を取得するための軽量なリバースジオコーディングライブラリです。Mapbox Vector Tiles (PBF形式) を使用して、緯度経度から都道府県・市区町村を高速に検索します。
+
+[@geolonia/open-reverse-geocoder](https://github.com/geolonia/open-reverse-geocoder) のRuby実装版です。
+
+## 特徴
+
+- **軽量**: 外部APIやデータベース不要
+- **高速**: ローカルのPBFタイルから直接検索
+- **依存性なし**: 標準ライブラリのみで動作
+- **オフライン対応**: インターネット接続不要
+- **純粋Ruby実装**: ネイティブ拡張不要で簡単にインストール可能
+
+## インストール
+
+Gemfileに追加:
+
+```ruby
+gem 'pbf_reverse_geocoder'
+```
+
+コマンドラインからインストール:
+
+```bash
+gem install pbf_reverse_geocoder
+```
+
+## 使い方
+
+### クイックスタート
+
+```ruby
+require 'pbf_reverse_geocoder'
+
+# タイルディレクトリのパスを指定
+tiles_dir = './tiles'  # ダウンロードしたタイルの場所
+
+# 緯度経度から行政区域情報を取得（東京駅の例）
+result = PbfReverseGeocoder.reverse_geocode(139.7671, 35.6812, tiles_dir)
+
+puts result
+# => { "prefecture" => "東京都", "city" => "千代田区", "code" => "13101" }
+```
+
+### より詳しい使用例
+
+```ruby
+require 'pbf_reverse_geocoder'
+
+# 複数の地点を検索
+locations = [
+  { name: '東京駅', lng: 139.7671, lat: 35.6812 },
+  { name: '大阪城', lng: 135.5258, lat: 34.6873 },
+  { name: '札幌駅', lng: 141.3506, lat: 43.0686 }
+]
+
+tiles_dir = './tiles'
+
+locations.each do |loc|
+  result = PbfReverseGeocoder.reverse_geocode(loc[:lng], loc[:lat], tiles_dir)
+
+  if result
+    puts "#{loc[:name]}: #{result['prefecture']} #{result['city']} (#{result['code']})"
+  else
+    puts "#{loc[:name]}: 該当する行政区域が見つかりません"
+  end
+end
+
+# 出力:
+# 東京駅: 東京都 千代田区 (13101)
+# 大阪城: 大阪府 大阪市中央区 (27128)
+# 札幌駅: 北海道 札幌市北区 (01102)
+```
+
+### Railsでの使用例
+
+```ruby
+# config/initializers/reverse_geocoder.rb
+TILES_DIR = Rails.root.join('public', 'tiles').to_s
+
+# app/controllers/locations_controller.rb
+class LocationsController < ApplicationController
+  def reverse_geocode
+    lng = params[:lng].to_f
+    lat = params[:lat].to_f
+
+    result = PbfReverseGeocoder.reverse_geocode(lng, lat, TILES_DIR)
+
+    if result
+      render json: result
+    else
+      render json: { error: 'Not found' }, status: :not_found
+    end
+  end
+end
+```
+
+### タイルデータの準備
+
+このgemを使用するには、事前にPBF形式のタイルデータを準備する必要があります。
+
+以下の2つの方法があります：
+
+#### 方法1: Geoloniaのリポジトリから取得
+
+[@geolonia/open-reverse-geocoder](https://github.com/geolonia/open-reverse-geocoder)のリポジトリから直接タイルを取得できます。
+
+```bash
+# Geoloniaのリポジトリをクローン（タイルのみ）
+git clone --depth 1 --filter=blob:none --sparse \
+  https://github.com/geolonia/open-reverse-geocoder.git
+
+cd open-reverse-geocoder
+git sparse-checkout set docs/tiles
+
+# タイルをホスティング用のディレクトリに配置
+cp -r docs/tiles /path/to/hosting/directory
+```
+
+> **💡 配置例**
+> - **Webサーバ**: `public/tiles`（Rails/Nginxなど）
+> - **共有ストレージ**: NFS/S3マウントポイントなど
+> - **アプリケーション内蔵**: `vendor/tiles`
+> - タイルは約560個、合計サイズは数十MB程度です
+> 
+> **ホスティングのポイント**:
+> - タイルデータは全サーバで共有可能（読み取り専用）
+> - CDN経由での配信も可能（PBFファイルはバイナリ）
+> - コンテナ環境ではボリュームマウントで共有
+
+#### 方法2: ソースデータから自分でビルド（最新データが必要な場合）
+
+国土数値情報から最新の行政区域データを使って、自分でタイルをビルドすることもできます。
+
+**🔧 必要なツール:**
+- [ogr2ogr](https://gdal.org/programs/ogr2ogr.html) - GDALツール（GeoJSON変換用）
+- [Tippecanoe](https://github.com/felt/tippecanoe) - Mapboxのタイル生成ツール
+- [mb-util](https://github.com/mapbox/mbutil) - MBTiles変換ツール
+
+**macOSの場合:**
+
+```bash
+# 必要なツールをインストール
+brew install gdal tippecanoe
+pip install mbutil
+```
+
+**🏗️ ビルド手順:**
+
+```bash
+# 1. 元のリポジトリをクローン（ビルドスクリプトを使用）
+git clone https://github.com/geolonia/open-reverse-geocoder.git
+cd open-reverse-geocoder
+
+# 2. 依存関係をインストール
+npm install
+
+# 3. タイルをビルド（国土数値情報から自動ダウンロード＆ビルド）
+npm run build:tiles
+
+# 4. ビルドされたタイルをコピー
+cp -r docs/tiles /path/to/your/project/tiles
+```
+
+**ビルドプロセスの詳細:**
+
+1. 国土数値情報から最新の[行政区域データ](https://nlftp.mlit.go.jp/ksj/gml/datalist/KsjTmplt-N03-v2_4.html)をダウンロード
+2. `ogr2ogr`でShapefileをGeoJSONに変換
+3. プロパティ調整スクリプトを実行（prefecture, city, codeフィールドを整形）
+4. `tippecanoe`でMBTilesを生成（非圧縮で出力）
+5. `mb-util`でタイルを分解して静的ファイル化
+
+
+> 詳細は[@geolonia/open-reverse-geocoder](https://github.com/geolonia/open-reverse-geocoder#%E3%82%BF%E3%82%A4%E3%83%AB%E3%81%AE%E3%83%93%E3%83%AB%E3%83%89%E6%96%B9%E6%B3%95)のREADMEを参照してください。
+
+#### ディレクトリ構造
+
+タイルは以下の構造で配置してください:
+
+```
+tiles/
+└── 10/              # ズームレベル
+    ├── 896/
+    │   ├── 396.pbf
+    │   └── 397.pbf
+    ├── 904/
+    │   ├── 403.pbf  # 例: 東京周辺
+    │   └── 404.pbf
+    └── 926/
+        └── 413.pbf
+```
+
+#### タイルの範囲について
+
+- **ズームレベル10固定**: このライブラリは @geolonia/open-reverse-geocoder と同じくズームレベル10のタイルのみを使用します（約30km四方）
+- **日本全体**: X座標 896-926、Y座標 396-413の範囲で日本全国をカバー
+- **個別地域**: 必要な地域のタイルのみをダウンロードすることも可能
+
+### 戻り値
+
+成功時:
+```ruby
+{
+  "prefecture" => "東京都",
+  "city" => "千代田区",
+  "code" => "13101"  # 全国地方公共団体コード
+}
+```
+
+該当する行政区域が見つからない場合は `nil` を返します。
+
+## 仕組み
+
+1. **タイル座標計算**: 緯度経度からズームレベル10のタイル座標を計算
+2. **PBFパース**: 該当タイルのPBFファイルを読み込んで解析
+3. **ジオメトリデコード**: Mapbox Vector Tileのジオメトリを緯度経度に変換
+4. **Point-in-Polygon判定**: Ray Casting Algorithmで位置を判定
+
+## API ドキュメント
+
+### `PbfReverseGeocoder.reverse_geocode(lng, lat, tiles_dir)`
+
+指定された緯度経度の行政区域情報を取得します。
+
+**パラメータ:**
+- `lng` (Float): 経度 (-180 ~ 180)
+- `lat` (Float): 緯度 (-90 ~ 90)
+- `tiles_dir` (String): タイルディレクトリのパス
+
+**戻り値:**
+- Hash: 行政区域情報 (`{ "prefecture" => ..., "city" => ..., "code" => ... }`)
+- nil: 該当する行政区域が見つからない場合
+
+## 開発
+
+```bash
+# リポジトリをクローン
+git clone https://github.com/yourusername/pbf_reverse_geocoder.git
+cd pbf_reverse_geocoder
+
+# 依存関係をインストール
+bundle install
+
+# テストを実行
+bundle exec rspec
+
+# RuboCopを実行
+bundle exec rubocop
+```
+
+## ライセンス
+
+MIT License
+
+## クレジット
+
+このライブラリは以下のプロジェクトにインスパイアされています:
+- [@geolonia/open-reverse-geocoder](https://github.com/geolonia/open-reverse-geocoder)
+- [Mapbox Vector Tile Specification](https://github.com/mapbox/vector-tile-spec)
+
+## Contributing
+
+バグ報告やプルリクエストは大歓迎です。GitHubリポジトリでお待ちしています。

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/example.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'lib/pbf_reverse_geocoder'
+
+# 使用例
+tiles_dir = '/path/to/tiles'
+
+# 東京駅の座標
+result = PbfReverseGeocoder.reverse_geocode(139.7671, 35.6812, tiles_dir)
+
+if result
+  puts "都道府県: #{result['prefecture']}"
+  puts "市区町村: #{result['city']}"
+  puts "地方公共団体コード: #{result['code']}"
+else
+  puts '該当する行政区域が見つかりませんでした'
+end

data/lib/pbf_reverse_geocoder/geometry_decoder.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+# Mapbox Vector Tile (MVT) のジオメトリをデコードするモジュール
+# Command integers と ZigZag encoding, Delta encoding を処理
+module PbfReverseGeocoder
+
+  class GeometryDecoder
+
+    # MVT標準のタイル解像度
+    EXTENT = 4096
+
+    # MVTジオメトリをデコードして緯度経度ポリゴンに変換
+    #
+    # @param geometry [Array<Integer>] MVTエンコードされたジオメトリ
+    # @param tile_x [Integer] タイルX座標
+    # @param tile_y [Integer] タイルY座標
+    # @param zoom [Integer] ズームレベル
+    # @return [Array<Array<Float>>] [[lng, lat], ...] 緯度経度座標の配列
+    #
+    # @example
+    #   GeometryDecoder.decode([9, 50, 34, ...], 904, 403, 10)
+    #   #=> [[139.7671, 35.6812], ...]
+    def self.decode(geometry, tile_x, tile_y, zoom)
+      return [] if geometry.nil? || geometry.empty?
+
+      coordinates = decode_commands(geometry)
+      tile_coords_to_lng_lat(coordinates, tile_x, tile_y, zoom)
+    end
+
+    # Command integersをデコードしてタイル内座標に変換
+    #
+    # @param geometry [Array<Integer>] MVTエンコードされたジオメトリ
+    # @return [Array<Array<Integer>>] [[x, y], ...] タイル内座標の配列
+    #
+    # @private
+    def self.decode_commands(geometry)
+      coords = []
+      x = 0
+      y = 0
+      i = 0
+
+      while i < geometry.length
+        command_int = geometry[i]
+        command = command_int & 0x7  # 下位3ビット:コマンド種別
+        count = command_int >> 3     # 上位ビット:繰り返し回数
+
+        case command
+        when 1  # MoveTo:新しいパスを開始
+          count.times do
+            i += 1
+            dx = decode_zigzag(geometry[i])
+            i += 1
+            dy = decode_zigzag(geometry[i])
+
+            x += dx
+            y += dy
+            coords << [x, y]
+          end
+        when 2  # LineTo:現在位置から線を引く
+          count.times do
+            i += 1
+            dx = decode_zigzag(geometry[i])
+            i += 1
+            dy = decode_zigzag(geometry[i])
+
+            x += dx
+            y += dy
+            coords << [x, y]
+          end
+        when 7  # ClosePath:ポリゴンを閉じる
+          # 座標追加は不要(最初の点に戻る)
+        else
+          # 不明なコマンド:スキップ
+          warn "Unknown MVT command: #{command}" if $DEBUG
+        end
+
+        i += 1
+      end
+
+      coords
+    end
+
+    # ZigZag デコーディング
+    # 負数をサポートするための変換を戻す
+    #
+    # @param n [Integer] エンコードされた値
+    # @return [Integer] デコードされた値
+    #
+    # @private
+    def self.decode_zigzag(n)
+      (n >> 1) ^ -(n & 1)
+    end
+
+    # タイル内座標を緯度経度に変換
+    #
+    # @param coords [Array<Array<Integer>>] [[x, y], ...] タイル内座標
+    # @param tile_x [Integer] タイルX座標
+    # @param tile_y [Integer] タイルY座標
+    # @param zoom [Integer] ズームレベル
+    # @return [Array<Array<Float>>] [[lng, lat], ...] 緯度経度座標
+    #
+    # @private
+    def self.tile_coords_to_lng_lat(coords, tile_x, tile_y, zoom)
+      n = 2**zoom
+
+      coords.map do |x, y|
+        # タイル内相対座標 (0-4096) → 絶対座標 (0-1)
+        rel_x = x.to_f / EXTENT
+        rel_y = y.to_f / EXTENT
+
+        # Google XYZ → 緯度経度(Web Mercator逆投影)
+        pixel_x = (tile_x + rel_x) / n
+        pixel_y = (tile_y + rel_y) / n
+
+        lng = (pixel_x * 360.0) - 180.0
+
+        lat_rad = Math.atan(Math.sinh(Math::PI * (1 - (2 * pixel_y))))
+        lat = lat_rad * 180.0 / Math::PI
+
+        [lng, lat]
+      end
+    end
+
+    private_class_method :decode_commands, :decode_zigzag, :tile_coords_to_lng_lat
+
+  end
+
+end

data/lib/pbf_reverse_geocoder/pbf_tile_reader.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative 'simple_pbf_parser'
+require_relative 'geometry_decoder'
+
+# PBFタイルを読み込んでフィーチャー一覧を返すモジュール
+module PbfReverseGeocoder
+
+  class PbfTileReader
+
+    # @geoloniaと同じレイヤー名
+    LAYER_NAME = 'japanese-admins'
+
+    # PBFタイルを読み込んでフィーチャー一覧を返す
+    #
+    # @param tile_path [String, Pathname] PBFファイルパス
+    # @param tile_x [Integer] タイルX座標
+    # @param tile_y [Integer] タイルY座標
+    # @param zoom [Integer] ズームレベル
+    # @return [Array<Hash>] フィーチャー配列
+    #
+    # @example
+    #   features = PbfTileReader.read_tile('/app/public/tiles/10/904/403.pbf', 904, 403, 10)
+    def self.read_tile(tile_path, tile_x, tile_y, zoom)
+      return [] unless File.exist?(tile_path)
+
+      # バイナリ読み込み
+      pbf_data = File.binread(tile_path)
+
+      # SimplePbfParserでパース
+      tile = SimplePbfParser.parse(pbf_data)
+
+      # japanese-admins レイヤーを抽出
+      layer = tile[:layers].find { |l| l[:name] == LAYER_NAME }
+      return [] unless layer
+
+      # フィーチャーをGeoJSON形式に変換
+      layer[:features].map do |feature|
+        geometry = GeometryDecoder.decode(feature[:geometry], tile_x, tile_y, zoom)
+        properties = decode_properties(feature, layer)
+
+        {
+          geometry: geometry,
+          properties: properties
+        }
+      end
+    rescue StandardError => e
+      warn "Failed to read PBF tile: #{tile_path}, error: #{e.message}"
+      warn e.backtrace.join("\n") if $DEBUG
+      []
+    end
+
+    # フィーチャーのプロパティをデコード
+    # tagsは [key_index, value_index, key_index, value_index, ...] の形式
+    #
+    # @param feature [Hash] フィーチャーデータ
+    # @param layer [Hash] レイヤーデータ
+    # @return [Hash] プロパティハッシュ
+    #
+    # @private
+    def self.decode_properties(feature, layer)
+      props = {}
+
+      # IDがある場合はcodeとして扱う
+      if feature[:id]
+        code = feature[:id].to_s
+        # 4桁の場合は先頭にゼロを追加（例: 1101 → 01101）
+        code = code.rjust(5, '0') if code.length == 4
+        props['code'] = code
+      end
+
+      # tagsをデコード（2要素ずつペアになっている）
+      feature[:tags].each_slice(2) do |key_idx, val_idx|
+        key = layer[:keys][key_idx]
+        value_obj = layer[:values][val_idx]
+
+        # 値を文字列として取得
+        value = value_obj&.dig(:string_value) || ''
+
+        props[key] = value
+      end
+
+      props
+    end
+
+    private_class_method :decode_properties
+
+  end
+
+end

data/lib/pbf_reverse_geocoder/point_in_polygon.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# 点がポリゴン内にあるかを判定するモジュール
+# Ray Casting Algorithm を実装
+# d3-geo の geoContains に相当
+module PbfReverseGeocoder
+  class PointInPolygon
+
+    # 点がポリゴン内にあるか判定
+    # 点からX軸正方向に伸ばした半直線が、ポリゴンの辺と何回交差するかを数える
+    # 奇数回 = 内側、偶数回 = 外側
+    #
+    # @param point [Array<Float>] [lng, lat] 判定する点の座標
+    # @param polygon [Array<Array<Float>>] [[lng, lat], ...] ポリゴンの頂点座標配列
+    # @return [Boolean] true: 内側, false: 外側
+    def self.contains?(point, polygon)
+      return false if polygon.nil? || polygon.empty?
+
+      px, py = point
+      inside = false
+
+      # ポリゴンの各辺について交差判定
+      j = polygon.length - 1
+      polygon.length.times do |i|
+        xi, yi = polygon[i]
+        xj, yj = polygon[j]
+
+        # Y座標の範囲チェック:辺が点のY座標をまたいでいるか
+        if (yi > py) != (yj > py)
+          # X座標の交差判定:半直線が辺と交差する点のX座標を計算
+          x_intersect = ((xj - xi) * (py - yi) / (yj - yi)) + xi
+
+          # 点のX座標より右側で交差していたら、inside を反転
+          inside = !inside if px < x_intersect
+        end
+
+        j = i
+      end
+
+      inside
+    end
+
+  end
+end

data/lib/pbf_reverse_geocoder/simple_pbf_parser.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+# Mapbox Vector Tile (MVT) に特化した簡易PBFパーサー
+# Protocol Buffersの基本的なワイヤフォーマットをパース
+module PbfReverseGeocoder
+
+  class SimplePbfParser
+
+    # Protocol Buffersのワイヤタイプ
+    WIRE_TYPE_VARINT = 0
+    WIRE_TYPE_64BIT = 1
+    WIRE_TYPE_LENGTH_DELIMITED = 2
+    WIRE_TYPE_32BIT = 5
+
+    # PBFバイナリをパースしてMVTタイルデータを返す
+    #
+    # @param data [String] バイナリデータ
+    # @return [Hash] パースされたタイルデータ
+    def self.parse(data)
+      buffer = data.bytes
+      pos = 0
+      tile = { layers: [] }
+
+      while pos < buffer.length
+        field_key, pos = read_varint(buffer, pos)
+        field_number = field_key >> 3
+        wire_type = field_key & 0x7
+
+        case wire_type
+        when WIRE_TYPE_LENGTH_DELIMITED
+          length, pos = read_varint(buffer, pos)
+          value_bytes = buffer[pos, length]
+          pos += length
+
+          # Field 3: layers
+          if field_number == 3
+            layer = parse_layer(value_bytes)
+            tile[:layers] << layer if layer
+          end
+        else
+          # その他のフィールドはスキップ
+          pos = skip_field(buffer, pos, wire_type)
+        end
+      end
+
+      tile
+    end
+
+    # レイヤーをパース
+    #
+    # @param data [Array<Integer>] バイナリデータ
+    # @return [Hash] パースされたレイヤーデータ
+    # @private
+    def self.parse_layer(data)
+      pos = 0
+      layer = { name: '', features: [], keys: [], values: [] }
+
+      while pos < data.length
+        field_key, pos = read_varint(data, pos)
+        field_number = field_key >> 3
+        wire_type = field_key & 0x7
+
+        case wire_type
+        when WIRE_TYPE_LENGTH_DELIMITED
+          length, pos = read_varint(data, pos)
+          value_bytes = data[pos, length]
+          pos += length
+
+          case field_number
+          when 1  # name
+            layer[:name] = value_bytes.pack('C*').force_encoding('UTF-8')
+          when 2  # features
+            feature = parse_feature(value_bytes)
+            layer[:features] << feature if feature
+          when 3  # keys
+            layer[:keys] << value_bytes.pack('C*').force_encoding('UTF-8')
+          when 4  # values
+            value = parse_value(value_bytes)
+            layer[:values] << value if value
+          end
+        else
+          pos = skip_field(data, pos, wire_type)
+        end
+      end
+
+      layer
+    end
+
+    # フィーチャーをパース
+    #
+    # @param data [Array<Integer>] バイナリデータ
+    # @return [Hash] パースされたフィーチャーデータ
+    # @private
+    def self.parse_feature(data)
+      pos = 0
+      feature = { id: nil, tags: [], type: 0, geometry: [] }
+
+      while pos < data.length
+        field_key, pos = read_varint(data, pos)
+        field_number = field_key >> 3
+        wire_type = field_key & 0x7
+
+        case wire_type
+        when WIRE_TYPE_VARINT
+          value, pos = read_varint(data, pos)
+          case field_number
+          when 1  # id
+            feature[:id] = value
+          when 3  # type
+            feature[:type] = value
+          end
+        when WIRE_TYPE_LENGTH_DELIMITED
+          length, pos = read_varint(data, pos)
+          value_bytes = data[pos, length]
+          pos += length
+
+          case field_number
+          when 2  # tags (packed)
+            feature[:tags] = unpack_packed_varint(value_bytes)
+          when 4  # geometry (packed)
+            feature[:geometry] = unpack_packed_varint(value_bytes)
+          end
+        else
+          pos = skip_field(data, pos, wire_type)
+        end
+      end
+
+      feature
+    end
+
+    # 値をパース
+    #
+    # @param data [Array<Integer>] バイナリデータ
+    # @return [Hash] パースされた値
+    # @private
+    def self.parse_value(data)
+      pos = 0
+      value = {}
+
+      while pos < data.length
+        field_key, pos = read_varint(data, pos)
+        field_number = field_key >> 3
+        wire_type = field_key & 0x7
+
+        case wire_type
+        when WIRE_TYPE_LENGTH_DELIMITED
+          length, pos = read_varint(data, pos)
+          value_bytes = data[pos, length]
+          pos += length
+
+          value[:string_value] = value_bytes.pack('C*').force_encoding('UTF-8') if field_number == 1 # string_value
+        else
+          pos = skip_field(data, pos, wire_type)
+        end
+      end
+
+      value
+    end
+
+    # Varint (可変長整数) を読み取る
+    #
+    # @param buffer [Array<Integer>] バイトバッファ
+    # @param pos [Integer] 現在位置
+    # @return [Array<Integer, Integer>] [値, 新しい位置]
+    # @private
+    def self.read_varint(buffer, pos)
+      value = 0
+      shift = 0
+
+      loop do
+        byte = buffer[pos]
+        pos += 1
+
+        value |= (byte & 0x7F) << shift
+        shift += 7
+
+        break unless byte.anybits?(0x80)
+      end
+
+      [value, pos]
+    end
+
+    # Packed varint配列を展開
+    #
+    # @param data [Array<Integer>] バイトデータ
+    # @return [Array<Integer>] 展開された整数配列
+    # @private
+    def self.unpack_packed_varint(data)
+      pos = 0
+      result = []
+
+      while pos < data.length
+        value, pos = read_varint(data, pos)
+        result << value
+      end
+
+      result
+    end
+
+    # フィールドをスキップ
+    #
+    # @param buffer [Array<Integer>] バイトバッファ
+    # @param pos [Integer] 現在位置
+    # @param wire_type [Integer] ワイヤタイプ
+    # @return [Integer] 新しい位置
+    # @private
+    def self.skip_field(buffer, pos, wire_type)
+      case wire_type
+      when WIRE_TYPE_VARINT
+        _value, pos = read_varint(buffer, pos)
+      when WIRE_TYPE_64BIT
+        pos += 8
+      when WIRE_TYPE_LENGTH_DELIMITED
+        length, pos = read_varint(buffer, pos)
+        pos += length
+      when WIRE_TYPE_32BIT
+        pos += 4
+      end
+
+      pos
+    end
+
+    private_class_method :parse_layer, :parse_feature, :parse_value,
+                         :read_varint, :unpack_packed_varint, :skip_field
+
+  end
+
+end

data/lib/pbf_reverse_geocoder/tile_calculator.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+# 緯度経度からタイル座標を計算するモジュール
+# @geolonia/open-reverse-geocoder の lngLatToGoogle ロジックを実装
+module PbfReverseGeocoder
+
+  class TileCalculator
+
+    # ズームレベル10固定(@geoloniaと同じ、約30km四方)
+    ZOOM = 10
+
+    # Google XYZ タイル座標を計算
+    # Web Mercator投影を使用
+    #
+    # @param lng [Float] 経度 (-180 ~ 180)
+    # @param lat [Float] 緯度 (-90 ~ 90)
+    # @return [Array<Integer>] [x, y, zoom]
+    #
+    # @example
+    #   TileCalculator.lng_lat_to_tile(139.7671, 35.6812)
+    #   #=> [904, 403, 10]
+    def self.lng_lat_to_tile(lng, lat)
+      # global-mercator の pointToTileFraction ロジック
+      n = 2.0**ZOOM
+      lat_rad = lat * Math::PI / 180.0
+      sin_lat = Math.sin(lat_rad)
+
+      # X座標(経度ベース)
+      x = ((lng + 180.0) / 360.0 * n).floor
+
+      # Y座標(緯度ベース、メルカトル投影)
+      y = ((0.5 - (0.25 * Math.log((1 + sin_lat) / (1 - sin_lat)) / Math::PI)) * n).floor
+
+      [x, y, ZOOM]
+    end
+
+    # タイルのファイルパスを生成
+    #
+    # @param x [Integer] タイルX座標
+    # @param y [Integer] タイルY座標
+    # @param zoom [Integer] ズームレベル
+    # @param tiles_dir [String, Pathname] タイルディレクトリのベースパス
+    # @return [Pathname] PBFファイルのパス
+    #
+    # @example
+    #   TileCalculator.tile_path(904, 403, 10, '/app/public/tiles')
+    #   #=> #<Pathname:/app/public/tiles/10/904/403.pbf>
+    def self.tile_path(x, y, zoom, tiles_dir)
+      require 'pathname'
+      Pathname.new(tiles_dir).join(zoom.to_s, x.to_s, "#{y}.pbf")
+    end
+
+  end
+
+end

data/lib/pbf_reverse_geocoder/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module PbfReverseGeocoder
+  VERSION = '0.1.0'
+end

data/lib/pbf_reverse_geocoder.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative 'pbf_reverse_geocoder/version'
+require_relative 'pbf_reverse_geocoder/simple_pbf_parser'
+require_relative 'pbf_reverse_geocoder/geometry_decoder'
+require_relative 'pbf_reverse_geocoder/point_in_polygon'
+require_relative 'pbf_reverse_geocoder/tile_calculator'
+require_relative 'pbf_reverse_geocoder/pbf_tile_reader'
+
+# 日本の行政区域のためのPBFベースのリバースジオコーディング
+module PbfReverseGeocoder
+
+  class Error < StandardError; end
+
+  # リバースジオコーディングのメインエントリーポイント
+  #
+  # @param lng [Float] 経度
+  # @param lat [Float] 緯度
+  # @param tiles_dir [String, Pathname] タイルディレクトリへのパス
+  # @return [Hash, nil] 行政区域情報、見つからない場合はnil
+  #   { prefecture: '東京都', city: '千代田区', code: '13101' }
+  #
+  # @example
+  #   result = PbfReverseGeocoder.reverse_geocode(139.7671, 35.6812, '/path/to/tiles')
+  #   #=> { 'prefecture' => '東京都', 'city' => '千代田区', 'code' => '13101' }
+  def self.reverse_geocode(lng, lat, tiles_dir)
+    # タイル座標を計算
+    tile_x, tile_y, zoom = TileCalculator.lng_lat_to_tile(lng, lat)
+    tile_path = TileCalculator.tile_path(tile_x, tile_y, zoom, tiles_dir)
+
+    # PBFタイルを読み込んでパース
+    features = PbfTileReader.read_tile(tile_path, tile_x, tile_y, zoom)
+
+    # 点を含むポリゴンを検索
+    point = [lng, lat]
+    features.each do |feature|
+      if PointInPolygon.contains?(point, feature[:geometry])
+        return feature[:properties]
+      end
+    end
+
+    nil
+  end
+
+end

data/pbf_reverse_geocoder.gemspec

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative 'lib/pbf_reverse_geocoder/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'pbf_reverse_geocoder'
+  spec.version = PbfReverseGeocoder::VERSION
+  spec.authors = ['Keisuke Terada']
+  spec.email = ['rorensu2236@gmail.com']
+
+  spec.summary = 'PBF-based reverse geocoding library for Japanese administrative areas'
+  spec.description = 'A lightweight reverse geocoding library that uses Mapbox Vector Tiles (PBF format) to find Japanese administrative areas (prefecture, city) from latitude/longitude coordinates. Ruby implementation of @geolonia/open-reverse-geocoder.'
+  spec.homepage = 'https://github.com/keisuke2236/pbf_reverse_geocoder'
+  spec.license = 'MIT'
+  spec.required_ruby_version = '>= 3.0.0'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/keisuke2236/pbf_reverse_geocoder'
+  spec.metadata['changelog_uri'] = 'https://github.com/keisuke2236/pbf_reverse_geocoder/blob/main/CHANGELOG.md'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  # Specify which files should be added to the gem when it is released.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .github appveyor Gemfile])
+    end
+  end
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  # Runtime dependencies
+  # (現時点では標準ライブラリのみ使用)
+
+  # Development dependencies
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rubocop', '~> 1.21'
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: pbf_reverse_geocoder
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Keisuke Terada
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+description: A lightweight reverse geocoding library that uses Mapbox Vector Tiles
+  (PBF format) to find Japanese administrative areas (prefecture, city) from latitude/longitude
+  coordinates. Ruby implementation of @geolonia/open-reverse-geocoder.
+email:
+- rorensu2236@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- ".ruby-version"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- example.rb
+- lib/pbf_reverse_geocoder.rb
+- lib/pbf_reverse_geocoder/geometry_decoder.rb
+- lib/pbf_reverse_geocoder/pbf_tile_reader.rb
+- lib/pbf_reverse_geocoder/point_in_polygon.rb
+- lib/pbf_reverse_geocoder/simple_pbf_parser.rb
+- lib/pbf_reverse_geocoder/tile_calculator.rb
+- lib/pbf_reverse_geocoder/version.rb
+- pbf_reverse_geocoder.gemspec
+homepage: https://github.com/keisuke2236/pbf_reverse_geocoder
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/keisuke2236/pbf_reverse_geocoder
+  source_code_uri: https://github.com/keisuke2236/pbf_reverse_geocoder
+  changelog_uri: https://github.com/keisuke2236/pbf_reverse_geocoder/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: PBF-based reverse geocoding library for Japanese administrative areas
+test_files: []