lithop 0.1.0

data/docs/troubleshooting.md

@@ -0,0 +1,112 @@
+# トラブルシューティング
+
+既知のCLIエラーは`lithop: MESSAGE`として表示されます。まずメッセージ全文と実行したコマンドを保存してください。
+
+## `ruby-vips`または`libvips`を読み込めない
+
+**最初の確認:** `ruby`、`bundle`、`lithop`が同じRuby環境を使っているか確認します。
+
+**原因候補:** libvips未導入、Bundler未実行、複数Ruby環境の混在です。
+
+**対処:** macOSでは次を実行します。
+
+```sh
+brew install vips
+bundle install
+bundle exec ruby -e 'require "vips"; puts Vips.version_string'
+which ruby
+which bundle
+bundle exec lithop --version
+```
+
+**関連:** [導入と基本操作](getting-started.md#インストール)
+
+## 入力画像を読めない
+
+**最初の確認:** ファイルが実在し、JPEG、PNG、またはSVGとして画像アプリで開けるか確認します。
+
+**原因候補:** 拡張子だけを変更したファイル、壊れた画像、設定した`maximum_input_pixels`を超える画像です。SVGではlibrsvgローダー不足、寸法不正、15,000,000バイト（15 MB）超過、SVGZ、外部参照や動的要素も入力エラーになります。
+
+**対処:** JPEG、PNG、または自己完結した非圧縮SVGへ正しく書き出し、必要なら画像寸法や生成格子を下げます。macOSでSVGローダー不足が表示された場合は`brew install vips`で導入したlibvipsを使っているか確認します。SVGから別ファイル、HTTP(S)、`data:`、外部CSSへの参照を取り除き、`width`・`height`または`viewBox`を設定します。透明部分はWhiteへ合成されるため、別の背景色が必要なら入力側で先に合成します。
+
+**関連:** [入力画像の扱い](getting-started.md#入力画像の扱い)、[生成設定](config.md#生成設定)
+
+## 3MFの材料が期待した色に分かれない
+
+**最初の確認:** `cmyk_white.stl`ではなく`lithop.3mf`を開き、一つの親オブジェクトの下に材料部品があるか確認します。
+
+**原因候補:** White参照STLを開いた、部品を結合・修復・自動整列した、材料割り当てを変更した可能性があります。未使用顔料の省略は正常です。
+
+**対処:** 3MFを読み直し、部品を動かさず、Cyan=1、Magenta=2、Yellow=3、White=4を確認します。省略された番号は詰めません。
+
+**関連:** [3MFを読み込む](bambu-studio.md#3mfを読み込む)、[材料別メッシュの関係](color-model.md#材料別メッシュの関係)
+
+## 色が予想と違う
+
+**最初の確認:** 材料、ExtruderとAMS、ノズル、レイヤー高さ、観察方向、白色バックライトが生成記録と一致するか確認します。
+
+**原因候補:** 材料割り当て、スライス境界、フィラメント状態やロット、光源の違いです。未校正出力では、正しく印刷しても測色的一致は保証されません。
+
+**対処:** `settings.json`と`PRINT_README.md`に条件を合わせ、レイヤープレビューでCMY領域を確認します。必要な場合だけ実測プロファイルを作成します。
+
+**関連:** [スライス条件を合わせる](bambu-studio.md#スライス条件を合わせる)、[色校正](calibration.md)
+
+## `physical CMYW output requires at least 1.0 mm thickness`
+
+**最初の確認:** 色領域の層数、第1層、通常レイヤー、要求最小・最大厚さを確認します。
+
+**原因候補:** 選択した層構造に、下地White、色領域、`top_white_start`までのWhite領域、設定された最小上部White層を収容できません。メッセージ中の最小値は現在の設定から計算されます。標準設定の`minimum_top_white_layers`は`0`です。
+
+**対処:** `--min-thickness`または`--max-thickness`を必要最小厚さ以上にします。標準の7層構造では1.0 mmです。
+
+**関連:** [レイヤー境界と実効厚さ](config.md#レイヤー境界と実効厚さ)
+
+## `estimated mesh exceeds maximum_triangles`
+
+**最初の確認:** エラーメッセージに表示された三角形数と推奨`pixel_size`を確認します。
+
+**原因候補:** 幅と高さに対してXYセルが細かすぎます。
+
+**対処:** `pixel_size`を大きくするか、完成寸法を小さくします。最終寸法の前に小型・0.5 mm程度で確認してください。
+
+```sh
+bundle exec lithop image.png --width 20 --height 15 --pixel-size 0.5
+```
+
+**関連:** [生成設定](config.md#生成設定)
+
+## カラーチャートのYellowだけ明るく見える
+
+**最初の確認:** `preview.png`と`thickness.png`を開き、同じ明暗行を比較します。
+
+**原因候補:** `preview.png`は公称材料色を表示するため、`#FCE300`のYellowはCyanやMagentaより明るく見えます。これはWhite高さの差とは限りません。
+
+**対処:** White高さは`thickness.png`で確認します。同梱の`cmy-color-chart.svg`では、Yellowを含む全色列の同じ明暗行を共通のWhite高さへ変換します。古いジョブは生成時点の処理結果を保持するため、現行版で3MFを再生成してください。
+
+**関連:** [明暗を作る上部White](color-model.md#明暗を作る上部white)、[プレビューの座標と値](artifacts.md#プレビューの座標と値)
+
+## `clean`が削除を拒否する
+
+**最初の確認:** 選択したプロジェクトと`build/`の実体を確認します。
+
+**原因候補:** プロジェクトがファイルシステムのルート、`build`がシンボリックリンク、またはディレクトリではありません。
+
+**対処:** 正しい`--project-dir`を指定します。安全検査を回避しないでください。`clean`は個別ジョブではなく`build/`全体を削除します。
+
+**関連:** [生成物を削除する](command.md#生成物を削除する)
+
+## 不具合を報告する
+
+**最初の確認:** 入力画像、ローカルパス、ハッシュを公開してよいか判断します。公開できない画像は添付しないでください。
+
+**原因候補:** 再現情報が不足すると、設定、入力、libvips、3MF、Bambu Studioのどこで問題が起きたか切り分けられません。
+
+**対処:** 次を記録します。
+
+- `bundle exec lithop --version`
+- 実行コマンドとエラーメッセージ全文
+- 機密情報を除いた`settings.json`と`manifest.json`
+- Ruby、libvips、Bambu Studioのバージョン
+- 必要に応じてオブジェクト一覧とレイヤープレビューの画像
+
+**関連:** [ローカルパスと共有時の注意](artifacts.md#ローカルパスと共有時の注意)

data/lib/lithop/calibration/export.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "json"
+require "securerandom"
+require "time"
+
+module Lithop
+  module Calibration
+    # Exports a printable calibration target and its measurement profile.
+    class Export
+      Result = Data.define(:job_id, :path, :files, :triangle_count, :patch_count)
+
+      def initialize(settings:, project_dir:, clock: Time, random: SecureRandom)
+        @settings = settings
+        @project_dir = File.expand_path(project_dir)
+        @clock = clock
+        @random = random
+      end
+
+      def call
+        job_id = "#{@clock.now.utc.strftime("%Y%m%dT%H%M%SZ")}-#{@random.hex(4)}-calibration"
+        destination, generated = JobDirectory.new(project_dir: @project_dir, job_id:).call do |directory|
+          generate(directory, job_id)
+        end
+        Result.new(job_id:, path: destination, files: generated.fetch(:files),
+                   triangle_count: generated.fetch(:triangle_count), patch_count: generated.fetch(:patch_count))
+      end
+
+      private
+
+      def generate(directory, job_id)
+        target = Target.new(settings: @settings)
+        result = write_three_mf(File.join(directory, "calibration.3mf"), target)
+        TargetSVG.write(File.join(directory, "calibration.svg"), target)
+        profile = Profile.template(profile_id: job_id, settings: @settings, target:)
+        profile.write(File.join(directory, "calibration-profile.json"))
+        write_manifest(directory, job_id, target, result)
+        write_readme(directory, target)
+        {
+          files: Dir.children(directory).sort,
+          triangle_count: result.triangle_count,
+          patch_count: target.patches.length
+        }
+      end
+
+      def write_three_mf(path, target)
+        plan = MaterialMeshPlan.new(
+          model: target,
+          maximum_triangles: @settings.maximum_triangles,
+          label: "calibration mesh"
+        ).call
+        result = ThreeMF.write(path, parts: plan.parts)
+        plan.validate!(result)
+
+        result
+      end
+
+      def write_manifest(directory, job_id, target, result)
+        manifest = {
+          schema_version: 1,
+          artifact_type: "calibration_target",
+          job_id:,
+          generator_version: Lithop::VERSION,
+          structure: Profile.structure_for(@settings),
+          layout: {
+            width_mm: target.width, height_mm: target.height,
+            patch_width_mm: target.x_boundaries[1], patch_height_mm: target.y_boundaries[1],
+            columns: target.columns, rows: target.rows
+          },
+          recipe_patch_count: target.recipe_patches.length,
+          white_thickness_patch_count: target.white_patches.length,
+          triangle_count: result.triangle_count,
+          material_count: result.material_count,
+          object_count: result.object_count
+        }
+        File.write(File.join(directory, "manifest.json"), "#{JSON.pretty_generate(manifest)}\n")
+      end
+
+      def write_readme(directory, target)
+        contents = <<~MARKDOWN
+          # Calibration target
+
+          Use `calibration.svg` to review the patch IDs and layout. Print `calibration.3mf` without changing
+          its dimensions, layer heights, or material order. The plate is #{target.width} × #{target.height} mm.
+
+          - nozzle: #{@settings.nozzle_diameter} mm
+          - first layer: #{@settings.first_layer_height} mm
+          - later layers: #{@settings.layer_height} mm
+          - pigment order: #{@settings.pigment_order.join(" -> ")}
+
+          - `R000`–`R119`: all 120 standard seven-layer CMYW recipes, row-major from the upper-left corner
+          - `W00`–`W07`: White thickness stages from left to right on the bottom row
+          - the extra right column makes the plate orientation unambiguous
+
+          Add repeated transmitted-sRGB and luminance readings to each patch's `measurements` array in
+          `calibration-profile.json`. Record white and black references in the top-level `measurement` object.
+        MARKDOWN
+        File.write(File.join(directory, "CALIBRATION_README.md"), contents)
+      end
+    end
+  end
+end

data/lib/lithop/calibration/profile.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Lithop
+  module Calibration
+    # Reads, validates, and writes measured calibration data.
+    class Profile
+      include ProfileMeasurements
+
+      SCHEMA_VERSION = 1
+
+      attr_reader :data
+
+      def self.template(profile_id:, settings:, target:)
+        new(
+          "schema_version" => SCHEMA_VERSION,
+          "profile_id" => profile_id,
+          "status" => "draft",
+          "generator_version" => Lithop::VERSION,
+          "structure" => structure_for(settings),
+          "materials" => Palette::MATERIALS.to_h { |material| [material.to_s, { "lot" => nil }] },
+          "lighting" => { "source" => nil, "color_temperature_k" => nil, "illuminance_lux" => nil },
+          "measurement" => {
+            "method" => nil,
+            "device" => nil,
+            "white_point" => nil,
+            "black_point" => nil,
+            "uncertainty" => nil
+          },
+          "patches" => target.patches.map { |patch| patch_data(patch) }
+        )
+      end
+
+      def self.load(path)
+        new(JSON.parse(File.read(path)))
+      rescue JSON::ParserError => e
+        raise InputError, "invalid calibration profile JSON: #{e.message}"
+      rescue Errno::ENOENT
+        raise InputError, "calibration profile does not exist: #{File.expand_path(path)}"
+      end
+
+      def self.structure_for(settings)
+        {
+          "color_model" => settings.color_model,
+          "color_layer_count" => settings.color_layer_count,
+          "pigment_order" => settings.pigment_order.map(&:to_s),
+          "nozzle_diameter_mm" => settings.nozzle_diameter,
+          "first_layer_height_mm" => settings.first_layer_height,
+          "layer_height_mm" => settings.layer_height
+        }
+      end
+
+      def self.patch_data(patch)
+        {
+          "patch_id" => patch.id,
+          "kind" => patch.kind.to_s,
+          "row" => patch.row,
+          "column" => patch.column,
+          "recipe" => patch.recipe.to_h.fetch(:counts).transform_keys(&:to_s),
+          "total_thickness_mm" => patch.height,
+          "top_white_thickness_mm" => patch.top_white_thickness,
+          "measurements" => []
+        }
+      end
+      private_class_method :patch_data
+
+      def initialize(data)
+        @data = data
+        validate!
+      end
+
+      def write(path)
+        File.write(path, "#{JSON.pretty_generate(data)}\n")
+      end
+
+      def validate_for!(settings)
+        expected = self.class.send(:structure_for, settings)
+        return true if data.fetch("structure") == expected
+
+        raise ConfigurationError, "calibration profile does not match the active layer structure"
+      end
+
+      private
+
+      def validate!
+        raise InputError, "calibration profile must be a JSON object" unless data.is_a?(Hash)
+
+        unless data["schema_version"] == SCHEMA_VERSION
+          version = data["schema_version"]
+          raise InputError, "unsupported calibration profile schema_version: #{version.inspect}"
+        end
+        raise InputError, "calibration profile_id must be a non-empty string" unless present_string?(data["profile_id"])
+        raise InputError, "calibration profile structure must be an object" unless data["structure"].is_a?(Hash)
+        raise InputError, "calibration profile patches must be an array" unless data["patches"].is_a?(Array)
+
+        data.fetch("patches").each { |patch| validate_patch!(patch) }
+      end
+
+      def validate_patch!(patch)
+        valid = patch.is_a?(Hash) && present_string?(patch["patch_id"]) &&
+                patch["recipe"].is_a?(Hash) && patch["measurements"].is_a?(Array)
+        raise InputError, "calibration profile contains an invalid patch" unless valid
+
+        patch.fetch("measurements").each { |measurement| validate_measurement!(measurement) }
+      end
+
+      def validate_measurement!(measurement)
+        return if measurement.is_a?(Hash) && valid_rgb?(measurement["transmitted_srgb"]) &&
+                  nonnegative?(measurement["luminance"]) && optional_nonnegative?(measurement["error"])
+
+        raise InputError,
+              "calibration measurements require transmitted_srgb, non-negative luminance, and optional error"
+      end
+
+      def valid_rgb?(rgb)
+        rgb.is_a?(Array) && rgb.length == 3 &&
+          rgb.all? { |value| value.is_a?(Numeric) && value.finite? && value.between?(0.0, 1.0) }
+      end
+
+      def nonnegative?(value) = value.is_a?(Numeric) && value.finite? && value >= 0
+      def optional_nonnegative?(value) = value.nil? || nonnegative?(value)
+
+      def present_string?(value) = value.is_a?(String) && !value.empty?
+    end
+  end
+end

data/lib/lithop/calibration/profile_measurements.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Lithop
+  module Calibration
+    PatchMeasurement = Data.define(:patch_id, :recipe, :height, :transmitted_srgb, :luminance)
+
+    # Exposes averaged measurements and completeness checks for a profile.
+    module ProfileMeasurements
+      def profile_id = data.fetch("profile_id")
+      def status = data.fetch("status")
+
+      def measurements(kind)
+        data.fetch("patches").select { |patch| patch.fetch("kind") == kind.to_s }.map do |patch|
+          samples = patch.fetch("measurements")
+          PatchMeasurement.new(
+            patch_id: patch.fetch("patch_id"),
+            recipe: patch.fetch("recipe"),
+            height: patch.fetch("total_thickness_mm"),
+            transmitted_srgb: mean_rgb(samples),
+            luminance: mean(samples.map { |sample| sample.fetch("luminance") })
+          )
+        end
+      end
+
+      def validate_complete!
+        issues = []
+        patches = data.fetch("patches")
+        missing = missing_patch_ids(patches)
+        issues << "missing measurements for #{missing.join(", ")}" if missing.any?
+        issues << "recipe set does not match the active palette" unless complete_recipe_set?(patches)
+        issues << "expected #{Target::WHITE_STAGE_COUNT} White thickness patches" unless complete_white_stages?(patches)
+        issues << "white_point is missing" unless reference_present?("white_point")
+        issues << "black_point is missing" unless reference_present?("black_point")
+        return true if issues.empty?
+
+        raise InputError, "calibration profile is incomplete: #{issues.join("; ")}"
+      end
+
+      private
+
+      def missing_patch_ids(patches)
+        patches.filter_map { |patch| patch.fetch("patch_id") if patch.fetch("measurements").empty? }
+      end
+
+      def complete_recipe_set?(patches)
+        palette = Palette.new(
+          layer_count: data.dig("structure", "color_layer_count"),
+          pigment_order: data.dig("structure", "pigment_order").map(&:to_sym)
+        )
+        expected = palette.recipes.map { |recipe| recipe_key(recipe.to_h.fetch(:counts).transform_keys(&:to_s)) }
+        actual = patches.filter_map do |patch|
+          recipe_key(patch.fetch("recipe")) if patch.fetch("kind") == "recipe"
+        end
+        actual.length == expected.length && actual.uniq.sort == expected.sort
+      end
+
+      def complete_white_stages?(patches)
+        stages = patches.select { |patch| patch.fetch("kind") == "white_thickness" }
+        thicknesses = stages.map { |patch| patch.fetch("total_thickness_mm") }
+        stages.length == Target::WHITE_STAGE_COUNT && thicknesses.uniq.length == stages.length
+      end
+
+      def reference_present?(key)
+        reference = data.fetch("measurement").fetch(key)
+        validate_measurement!(reference)
+        true
+      rescue InputError, KeyError
+        false
+      end
+
+      def recipe_key(counts)
+        Palette::MATERIALS.map { |material| counts.fetch(material.to_s) }.join(":")
+      end
+
+      def mean_rgb(samples)
+        samples.map { |sample| sample.fetch("transmitted_srgb") }.transpose.map { |values| mean(values) }
+      end
+
+      def mean(values) = values.sum.fdiv(values.length)
+    end
+  end
+end

data/lib/lithop/calibration/recipe_selector.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Lithop
+  module Calibration
+    # Selects a printable recipe from measured transmitted colors.
+    class RecipeSelector
+      attr_reader :layer_count, :pigment_order, :recipes
+
+      def initialize(profile:, palette:)
+        profile.validate_complete!
+        @layer_count = palette.layer_count
+        @pigment_order = palette.pigment_order
+        @recipes = palette.recipes
+        @entries = build_entries(profile.measurements(:recipe))
+      end
+
+      def nearest(cmy)
+        validate_cmy!(cmy)
+        target = cmy.map { |component| 1.0 - component }
+        @entries.min_by do |_recipe, measured|
+          measured.zip(target).sum { |component, expected| (component - expected)**2 }
+        end.first
+      end
+
+      private
+
+      def build_entries(measurements)
+        measurements.map do |measurement|
+          recipe = recipes.find { |candidate| recipe_counts(candidate) == measurement.recipe }
+          raise InputError, "calibration profile contains an unknown recipe" unless recipe
+
+          [recipe, normalize(measurement.transmitted_srgb)]
+        end
+      end
+
+      def recipe_counts(recipe)
+        recipe.to_h.fetch(:counts).transform_keys(&:to_s)
+      end
+
+      def normalize(rgb)
+        maximum = rgb.max
+        return [0.0, 0.0, 0.0] if maximum.zero?
+
+        rgb.map { |component| component.fdiv(maximum) }
+      end
+
+      def validate_cmy!(cmy)
+        valid = cmy.is_a?(Array) && cmy.length == 3 &&
+                cmy.all? { |value| value.is_a?(Numeric) && value.finite? && value.between?(0.0, 1.0) }
+        raise InputError, "CMY must contain three values between 0 and 1" unless valid
+      end
+    end
+  end
+end

data/lib/lithop/calibration/target.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Lithop
+  module Calibration
+    # Validates the fixed layout requirements of a calibration target.
+    module TargetValidation
+      private
+
+      def validate_structure!
+        unless @settings.color_layer_count == 7 &&
+               @settings.pigment_order == Palette::PIGMENTS
+          raise ConfigurationError,
+                "calibration target requires seven layers in cyan,magenta,yellow pigment order"
+        end
+
+        levels = @settings.layer_structure.normal_layer_count(@settings.effective_maximum_thickness) -
+                 @settings.layer_structure.normal_layer_count(@settings.effective_minimum_thickness) + 1
+        return if levels >= Target::WHITE_STAGE_COUNT
+
+        raise ConfigurationError, "calibration target requires at least eight printable thickness levels"
+      end
+    end
+
+    # Builds a directly-addressed patch grid without image resampling.
+    class Target
+      include TargetValidation
+
+      WIDTH = 140.0
+      HEIGHT = 104.0
+      RECIPE_COLUMNS = 15
+      RECIPE_ROWS = 8
+      WHITE_STAGE_COUNT = 8
+      COLUMNS = RECIPE_COLUMNS + 1
+      ROWS = RECIPE_ROWS + 1
+
+      Patch = Data.define(
+        :id, :kind, :row, :column, :recipe, :height, :top_white_thickness
+      )
+
+      attr_reader :columns, :rows, :x_boundaries, :y_boundaries, :z_boundaries,
+                  :cells, :patches, :recipe_patches, :white_patches
+
+      def initialize(settings:)
+        @settings = settings
+        validate_structure!
+        @palette = Palette.new(
+          layer_count: settings.color_layer_count,
+          pigment_order: settings.pigment_order
+        )
+        @columns = COLUMNS
+        @rows = ROWS
+        @x_boundaries = boundaries(columns, WIDTH)
+        @y_boundaries = boundaries(rows, HEIGHT)
+        @recipe_patches = build_recipe_patches.freeze
+        @white_patches = build_white_patches.freeze
+        @patches = [*recipe_patches, *white_patches].freeze
+        @cells = build_cells.freeze
+        maximum_layers = cells.map { |cell| cell.materials.length }.max
+        @z_boundaries = @settings.layer_structure.z_boundaries(maximum_layers).freeze
+      end
+
+      def material_at(layer, row, column)
+        return if layer.negative? || row.negative? || column.negative? || row >= rows || column >= columns
+
+        cells.fetch((row * columns) + column).materials[layer]
+      end
+
+      def materials
+        @materials ||= cells.flat_map(&:materials).uniq.freeze
+      end
+
+      def width = x_boundaries.last
+      def height = y_boundaries.last
+
+      private
+
+      def boundaries(count, extent)
+        Array.new(count + 1) { |index| (extent * index.fdiv(count)).round(9) }
+      end
+
+      def build_recipe_patches
+        @palette.recipes.each_with_index.map do |recipe, index|
+          row, column = index.divmod(RECIPE_COLUMNS)
+          patch(format("R%03d", index), :recipe, row, column, recipe, @settings.effective_minimum_thickness)
+        end
+      end
+
+      def build_white_patches
+        white = @palette.recipes.find { |recipe| recipe.white == @palette.layer_count }
+        white_stage_heights.each_with_index.map do |height, column|
+          patch(format("W%02d", column), :white_thickness, RECIPE_ROWS, column, white, height)
+        end
+      end
+
+      def patch(id, kind, row, column, recipe, height)
+        Patch.new(
+          id:, kind:, row:, column:, recipe:, height:,
+          top_white_thickness: @settings.layer_structure.top_white_thickness(
+            height, pigment_layers: @palette.layer_count
+          )
+        )
+      end
+
+      def white_stage_heights
+        minimum = @settings.effective_minimum_thickness
+        maximum = @settings.effective_maximum_thickness
+        Array.new(WHITE_STAGE_COUNT) do |index|
+          candidate = minimum + ((maximum - minimum) * index.fdiv(WHITE_STAGE_COUNT - 1))
+          @settings.quantize_thickness(candidate)
+        end
+      end
+
+      def build_cells
+        indexed = patches.to_h { |patch| [[patch.row, patch.column], patch] }
+        marker = recipe_patches.first
+        Array.new(rows * columns) do |index|
+          row, column = index.divmod(columns)
+          cell_for(indexed.fetch([row, column], marker))
+        end
+      end
+
+      def cell_for(patch)
+        top_white_layers = @settings.layer_structure.top_white_layer_count(
+          patch.height, pigment_layers: @palette.layer_count
+        )
+        materials = [
+          *Array.new(@settings.base_white_layers, :white),
+          *patch.recipe.layers,
+          *Array.new(top_white_layers, :white)
+        ].freeze
+        MaterialModel::Cell.new(height: patch.height, recipe: patch.recipe, materials:)
+      end
+    end
+  end
+end