naiso 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ad34abb90d874020e78ab7414a1e5265986a529622fdbe0d15e857313382c9e7
+  data.tar.gz: 8da518fa8a7c56f351519937f04c562ae7c1e76fcb462261fa08deb3d2a5c26d
+SHA512:
+  metadata.gz: 63757c465a29723ecdeff3f75d3d3a9cfc5ed5435a49a1660110688d3fbb6eea782e7f777735af19360712bd6e355a7ed6ce11e3838237981eafb3bff8dbdebd
+  data.tar.gz: 70b28db5d09ab2ddeaccf799c84e0ca40551317f2f47ed6aa2f811018594b9402cc29f5717c7b0950f87ed3e256580e33fd6fc62a57aec8175ec0d7dc014b045

data/README.md

@@ -0,0 +1,193 @@
+# Naiso
+
+상품 상세 이미지 섹션 분할 도구
+
+긴 세로형 상품 상세 이미지를 섹션별로 자동 분할하고, 텍스트 유무를 분석하는 Ruby gem입니다.
+
+## 설치
+
+### 시스템 요구사항
+
+```bash
+# macOS
+brew install vips
+brew install tesseract tesseract-lang
+
+# Ubuntu/Debian
+sudo apt-get install libvips-dev tesseract-ocr tesseract-ocr-kor
+```
+
+### Gem 설치
+
+```bash
+gem install naiso
+```
+
+또는 Gemfile에 추가:
+
+```ruby
+gem 'naiso'
+```
+
+### 버전 정보
+- Ruby 2.7+
+- libvips 8.10+
+- Tesseract 4.x / 5.x
+
+## 기능
+
+### 1. 이미지 분할
+
+긴 상세 이미지를 다음 기준으로 자동 분할합니다:
+
+| 감지 유형 | 설명 |
+|----------|------|
+| 단색 영역 | 연속된 solid color 배경 (variance < threshold) |
+| 구분선 | 가로 방향 구분선 (위아래 여백이 단색) |
+| 배경색 전환 | 흰색→회색 등 배경색이 바뀌는 지점 |
+| 복잡도 기반 | 최대 높이 초과 시 엣지 밀도가 낮은 지점 |
+
+### 2. 텍스트 분석 (OCR)
+
+분할된 섹션에서 텍스트 유무와 크기 정보를 분석합니다.
+
+**분석 정보:**
+- 텍스트 유무 (has_text)
+- 글자 수 (text_length)
+- 단어별 위치/크기 (x, y, width, height)
+- 통계 (min/max/avg 높이, 단어 수)
+
+### 3. 이미지 병합
+
+분할된 섹션들을 다시 하나로 합칩니다.
+
+## CLI 사용법
+
+```bash
+# 기본 분할
+naiso detail.jpg
+
+# 옵션 지정
+naiso detail.jpg -t 5 -g 100 -m 400
+
+# 텍스트 분석 포함
+naiso detail.jpg -c
+
+# JSON 결과 저장
+naiso detail.jpg -c -j result.json
+
+# 분할 후 병합
+naiso detail.jpg --merge
+
+# 기존 섹션만 병합
+naiso --merge-only sections/
+```
+
+### CLI 옵션
+
+| 옵션 | 설명 | 기본값 |
+|------|------|--------|
+| `-t, --threshold FLOAT` | 단색 판정 임계값 | 10.0 |
+| `-g, --gap INT` | 최소 단색 영역 높이 | 50px |
+| `-m, --min-height INT` | 최소 섹션 높이 | 너비 × 2/3 |
+| `-M, --max-height INT` | 최대 섹션 높이 | 너비 × 1.5 |
+| `-o, --output DIR` | 출력 디렉토리 | sections/ |
+| `-c, --check-text` | 텍스트 분석 수행 | - |
+| `-j, --json FILE` | JSON 결과 저장 경로 | 자동 생성 |
+| `--merge` | 분할 후 병합 | - |
+| `--merge-only DIR` | 섹션 병합만 수행 | - |
+| `-v, --version` | 버전 표시 | - |
+| `-h, --help` | 도움말 표시 | - |
+
+## Ruby API
+
+```ruby
+require 'naiso'
+
+# 이미지 분할
+config = Naiso::SplitConfig.new(
+  variance_threshold: 5.0,
+  min_gap_height: 100,
+  min_section_height: 400
+)
+splitter = Naiso::ImageSplitter.new(config)
+result = splitter.split('detail.jpg')
+
+puts result.output_files      # 생성된 파일 목록
+puts result.split_points      # 분할 위치
+puts result.uniform_regions   # 감지된 단색 영역
+
+# 텍스트 분석
+detector = Naiso::TextDetector.new
+analysis = detector.detect_with_size('section_01.jpg')
+
+puts analysis[:has_text]      # true/false
+puts analysis[:text]          # 검출된 텍스트
+puts analysis[:stats]         # 통계 정보
+
+# 여러 이미지 분석
+detector.analyze_images(result.output_files, json_path: 'result.json')
+
+# 이미지 병합
+Naiso::ImageMerger.merge_sections('sections/')
+
+# 개별 이미지 병합
+Naiso::ImageMerger.merge(['img1.jpg', 'img2.jpg'], 'output.jpg')
+```
+
+## 출력 파일
+
+```
+sections/
+├── detail_section_01.jpg
+├── detail_section_02.jpg
+├── ...
+├── detail_text_analysis.json  # -c 옵션 시
+└── detail_merged.jpg          # --merge 옵션 시
+```
+
+## JSON 출력 형식
+
+```json
+{
+  "generated_at": "2025-12-10T18:00:00+09:00",
+  "total_images": 11,
+  "images_with_text": 10,
+  "images_without_text": 1,
+  "sections": [
+    {
+      "filename": "detail_section_01.jpg",
+      "has_text": true,
+      "text_length": 22,
+      "text": "검출된 텍스트...",
+      "stats": {
+        "min_height": 15,
+        "max_height": 48,
+        "avg_height": 30.6,
+        "word_count": 18,
+        "filtered_count": 5
+      },
+      "words": [
+        {
+          "text": "단어",
+          "x": 100,
+          "y": 50,
+          "width": 40,
+          "height": 30,
+          "conf": 92.5
+        }
+      ]
+    }
+  ]
+}
+```
+
+## 의존성
+
+- [ruby-vips](https://github.com/libvips/ruby-vips) - 이미지 처리
+- [numo-narray](https://github.com/ruby-numo/numo-narray) - 수치 배열 연산
+- [rtesseract](https://github.com/dannnylo/rtesseract) - OCR (Tesseract 래퍼)
+
+## 라이선스
+
+MIT License

data/exe/naiso

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'naiso'
+
+Naiso::CLI.new.run

data/lib/naiso/cli.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module Naiso
+  # CLI 인터페이스
+  class CLI
+    def initialize
+      @options = {
+        threshold: 10.0,
+        gap: 50,
+        min_height: nil,
+        max_height: nil,
+        output: nil,
+        check_text: false,
+        json_output: nil,
+        merge: false,
+        merge_only: false
+      }
+    end
+
+    def run(args = ARGV)
+      parse_args(args)
+
+      # 병합만 수행하는 경우
+      if @options[:merge_only]
+        ImageMerger.merge_sections(@options[:merge_only])
+        return
+      end
+
+      config = SplitConfig.new(
+        variance_threshold: @options[:threshold],
+        min_gap_height: @options[:gap],
+        min_section_height: @options[:min_height],
+        max_section_height: @options[:max_height]
+      )
+
+      splitter = ImageSplitter.new(config)
+      result = splitter.split(@options[:image], output_dir: @options[:output])
+
+      # 텍스트 검출 옵션이 활성화된 경우
+      if @options[:check_text] && result.output_files.any?
+        detector = TextDetector.new
+
+        # JSON 경로 결정 (지정하지 않으면 출력 디렉토리에 자동 생성)
+        json_path = @options[:json_output]
+        if json_path.nil? && @options[:check_text]
+          output_dir = @options[:output] || File.join(File.dirname(@options[:image]), 'sections')
+          base_name = File.basename(@options[:image], '.*')
+          json_path = File.join(output_dir, "#{base_name}_text_analysis.json")
+        end
+
+        detector.analyze_images(result.output_files, json_path: json_path)
+      end
+
+      # 병합 옵션이 활성화된 경우
+      if @options[:merge] && result.output_files.any?
+        output_dir = @options[:output] || File.join(File.dirname(@options[:image]), 'sections')
+        ImageMerger.merge_sections(output_dir)
+      end
+    end
+
+    private
+
+    def parse_args(args)
+      parser = OptionParser.new do |opts|
+        opts.banner = "사용법: naiso [옵션] <이미지>"
+        opts.separator ''
+        opts.separator '상품 상세 이미지를 섹션별로 분할합니다.'
+        opts.separator ''
+        opts.separator '옵션:'
+
+        opts.on('-t', '--threshold FLOAT', Float, '단색 판정 임계값 (기본: 10.0)') do |v|
+          @options[:threshold] = v
+        end
+
+        opts.on('-g', '--gap INT', Integer, '최소 단색 영역 높이 (기본: 50px)') do |v|
+          @options[:gap] = v
+        end
+
+        opts.on('-m', '--min-height INT', Integer, '최소 섹션 높이 (기본: 이미지 너비의 2/3)') do |v|
+          @options[:min_height] = v
+        end
+
+        opts.on('-M', '--max-height INT', Integer, '최대 섹션 높이 (기본: 이미지 너비의 1.5배)') do |v|
+          @options[:max_height] = v
+        end
+
+        opts.on('-o', '--output DIR', '출력 디렉토리') do |v|
+          @options[:output] = v
+        end
+
+        opts.on('-c', '--check-text', '분할 후 텍스트 분석 (크기 정보 포함)') do
+          @options[:check_text] = true
+        end
+
+        opts.on('-j', '--json FILE', 'JSON 결과 저장 경로 (-c 옵션 필요)') do |v|
+          @options[:json_output] = v
+        end
+
+        opts.on('--merge', '분할된 이미지를 다시 하나로 병합') do
+          @options[:merge] = true
+        end
+
+        opts.on('--merge-only DIR', '기존 섹션 이미지들을 병합만 수행') do |v|
+          @options[:merge_only] = v
+        end
+
+        opts.on('-v', '--version', '버전 표시') do
+          puts "naiso #{Naiso::VERSION}"
+          exit
+        end
+
+        opts.on('-h', '--help', '도움말 표시') do
+          puts opts
+          exit
+        end
+
+        opts.separator ''
+        opts.separator '예시:'
+        opts.separator '  naiso detail.jpg'
+        opts.separator '  naiso detail.jpg -t 5 -g 100 -m 400'
+        opts.separator '  naiso detail.jpg -M 1200'
+        opts.separator '  naiso detail.jpg -c  # 텍스트 분석 포함'
+        opts.separator '  naiso detail.jpg -c -j result.json  # JSON 저장'
+        opts.separator '  naiso detail.jpg --merge  # 분할 후 병합'
+        opts.separator '  naiso --merge-only sections/  # 기존 섹션 병합'
+      end
+
+      parser.parse!(args)
+
+      @options[:image] = args[0] || 'detail.jpg'
+    end
+  end
+end

data/lib/naiso/image_merger.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'vips'
+
+module Naiso
+  # 이미지 병합기
+  class ImageMerger
+    # 여러 이미지를 세로로 합치기
+    # @param image_paths [Array<String>] 이미지 파일 경로 배열 (순서대로 합쳐짐)
+    # @param output_path [String] 출력 파일 경로
+    # @param verbose [Boolean] 상세 출력 여부
+    # @return [String] 출력 파일 경로
+    def self.merge(image_paths, output_path, verbose: true)
+      raise ArgumentError, '이미지가 없습니다' if image_paths.empty?
+
+      puts "이미지 병합 중... (#{image_paths.size}개)" if verbose
+
+      # 첫 번째 이미지 로드
+      images = image_paths.map { |path| Vips::Image.new_from_file(path) }
+
+      # 너비 확인 (모두 같아야 함)
+      widths = images.map(&:width).uniq
+      if widths.size > 1
+        puts "경고: 이미지 너비가 다릅니다 (#{widths.join(', ')}px). 첫 번째 이미지 너비로 맞춥니다." if verbose
+        target_width = images.first.width
+        images = images.map do |img|
+          img.width == target_width ? img : img.resize(target_width.to_f / img.width)
+        end
+      end
+
+      # 세로로 합치기
+      merged = images.first
+      images[1..].each do |img|
+        merged = merged.join(img, :vertical)
+      end
+
+      # 저장
+      merged.write_to_file(output_path, Q: 95)
+
+      if verbose
+        total_height = images.sum(&:height)
+        puts "  입력: #{image_paths.size}개 이미지"
+        puts "  출력: #{output_path}"
+        puts "  크기: #{merged.width} x #{merged.height}px"
+      end
+
+      output_path
+    end
+
+    # 디렉토리 내 섹션 이미지들을 합치기
+    # @param input_dir [String] 섹션 이미지가 있는 디렉토리
+    # @param output_path [String] 출력 파일 경로 (nil이면 자동 생성)
+    # @param pattern [String] 파일 패턴 (glob)
+    # @param verbose [Boolean] 상세 출력 여부
+    # @return [String] 출력 파일 경로
+    def self.merge_sections(input_dir, output_path: nil, pattern: '*_section_*.jpg', verbose: true)
+      # 섹션 파일 찾기 (정렬)
+      section_files = Dir.glob(File.join(input_dir, pattern)).sort
+
+      raise ArgumentError, "섹션 파일을 찾을 수 없습니다: #{input_dir}/#{pattern}" if section_files.empty?
+
+      # 출력 경로 자동 생성
+      if output_path.nil?
+        # 첫 번째 파일에서 기본 이름 추출: "vitac_section_01.jpg" -> "vitac"
+        base_name = File.basename(section_files.first).sub(/_section_\d+\.jpg$/, '')
+        output_path = File.join(input_dir, "#{base_name}_merged.jpg")
+      end
+
+      merge(section_files, output_path, verbose: verbose)
+    end
+  end
+end

data/lib/naiso/image_splitter.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require 'vips'
+require 'fileutils'
+
+module Naiso
+  # 이미지 분할기
+  class ImageSplitter
+    def initialize(config = nil)
+      @config = config || SplitConfig.new
+    end
+
+    def split(image_path, output_dir: nil, verbose: true)
+      result = SplitResult.new
+
+      # 이미지 로드
+      image = Vips::Image.new_from_file(image_path)
+
+      # 설정값 계산
+      min_height = @config.min_section_height || (image.width * 2 / 3)
+      max_height = @config.max_section_height || (image.width * 1.5).to_i
+
+      if verbose
+        puts "이미지 크기: #{image.width} x #{image.height}"
+        puts "최소 섹션 높이: #{min_height}px"
+        puts "최대 섹션 높이: #{max_height}px"
+      end
+
+      # 분석기 및 감지기 초기화
+      analyzer = RowAnalyzer.new(image)
+      detector = SplitPointDetector.new(analyzer, @config)
+
+      # 분할점 수집
+      result.uniform_regions = detector.find_uniform_regions
+      result.divider_lines = detector.find_divider_lines
+      result.background_transitions = detector.find_background_transitions
+
+      print_detection_results(result) if verbose
+
+      # 분할점 병합
+      split_points = merge_split_points(result, image.height, min_height)
+
+      # 최대 높이 초과 섹션 분할
+      if max_height > 0
+        split_points, complexity_splits = apply_max_height_splits(
+          split_points, max_height, min_height, detector, verbose
+        )
+        result.complexity_splits = complexity_splits
+      end
+
+      result.split_points = split_points
+
+      if verbose
+        puts "\n분할 위치: #{split_points}"
+        puts "생성될 섹션 수: #{split_points.size - 1}개"
+      end
+
+      # 이미지 분할 및 저장
+      if split_points.nil? || split_points.size < 2
+        puts '분할할 영역을 찾지 못했습니다.' if verbose
+        return result
+      end
+
+      output_dir = prepare_output_dir(image_path, output_dir)
+      result.output_files = save_sections(image, split_points, output_dir, image_path, verbose)
+
+      result
+    end
+
+    private
+
+    def merge_split_points(result, image_height, min_height)
+      split_y = [0]
+
+      # 단색 영역 중앙점 추가
+      result.uniform_regions.each do |start_pos, end_pos|
+        split_y << (start_pos + end_pos) / 2
+      end
+
+      # 구분선 추가
+      split_y.concat(result.divider_lines)
+
+      # 배경색 전환점 추가
+      split_y.concat(result.background_transitions)
+
+      split_y << image_height
+
+      # 정렬 및 중복 제거
+      split_y = split_y.uniq.sort
+
+      # 너무 작은 섹션 병합 (단, 시작점 0은 항상 유지)
+      filtered = [0]
+      split_y[1..].each do |y|
+        gap = y - filtered.last
+        if gap >= min_height
+          filtered << y
+        elsif filtered.size >= 2
+          new_prev_gap = y - filtered[-2]
+          filtered[-1] = y if new_prev_gap >= min_height
+        elsif filtered.last != 0
+          # 시작점이 0이면 유지, 아니면 대체
+          filtered[-1] = y
+        end
+        # filtered.last가 0이고 gap < min_height면, 다음 분할점을 기다림
+      end
+
+      filtered << image_height if filtered.last != image_height
+
+      filtered
+    end
+
+    def apply_max_height_splits(split_points, max_height, min_height, detector, verbose)
+      needs_split = (0...(split_points.size - 1)).any? do |i|
+        split_points[i + 1] - split_points[i] > max_height
+      end
+
+      return [split_points, []] unless needs_split
+
+      puts "\n최대 높이 초과 섹션 감지, 복잡도 기반 분할 수행..." if verbose
+
+      complexity_splits = []
+      final_splits = [split_points.first]
+
+      (0...(split_points.size - 1)).each do |i|
+        section_start = split_points[i]
+        section_end = split_points[i + 1]
+        section_height = section_end - section_start
+
+        if section_height > max_height
+          current_start = section_start
+
+          while current_start < section_end
+            remaining = section_end - current_start
+            break if remaining <= max_height
+
+            search_start = current_start + min_height
+            search_end = [current_start + max_height, section_end - min_height].min
+
+            best_split = if search_start >= search_end
+                           (current_start + [current_start + max_height, section_end].min) / 2
+                         else
+                           margin = [50, (search_end - search_start) / 4].min
+                           detector.find_best_split_in_range(search_start, search_end, margin: margin)
+                         end
+
+            final_splits << best_split
+            complexity_splits << best_split
+
+            puts "  복잡도 기반 분할: 행 #{best_split}" if verbose
+
+            current_start = best_split
+          end
+        end
+
+        final_splits << section_end
+      end
+
+      [final_splits.uniq.sort, complexity_splits]
+    end
+
+    def prepare_output_dir(image_path, output_dir)
+      output_dir ||= File.join(File.dirname(image_path), 'sections')
+      FileUtils.mkdir_p(output_dir)
+      output_dir
+    end
+
+    def save_sections(image, split_points, output_dir, image_path, verbose)
+      output_files = []
+      base_name = File.basename(image_path, '.*')
+
+      (0...(split_points.size - 1)).each do |i|
+        y_start = split_points[i]
+        y_end = split_points[i + 1]
+        height = y_end - y_start
+
+        # 섹션 추출
+        section = image.crop(0, y_start, image.width, height)
+
+        # 저장
+        output_path = File.join(output_dir, "#{base_name}_section_#{format('%02d', i + 1)}.jpg")
+        section.write_to_file(output_path, Q: 95)
+        output_files << output_path
+
+        puts "  저장: #{File.basename(output_path)} (높이: #{height}px)" if verbose
+      end
+
+      output_files
+    end
+
+    def print_detection_results(result)
+      puts "\n발견된 단색 영역: #{result.uniform_regions.size}개"
+      result.uniform_regions.each_with_index do |(start_pos, end_pos), i|
+        puts "  #{i + 1}. 행 #{start_pos} ~ #{end_pos} (높이: #{end_pos - start_pos}px)"
+      end
+
+      puts "\n발견된 구분선: #{result.divider_lines.size}개"
+      result.divider_lines.each_with_index do |y, i|
+        puts "  #{i + 1}. 행 #{y}"
+      end
+
+      puts "\n발견된 배경색 전환: #{result.background_transitions.size}개"
+      result.background_transitions.each_with_index do |y, i|
+        puts "  #{i + 1}. 행 #{y}"
+      end
+    end
+  end
+end

data/lib/naiso/row_analyzer.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'vips'
+require 'numo/narray'
+
+module Naiso
+  # 이미지 행 분석기
+  class RowAnalyzer
+    attr_reader :height, :width
+
+    def initialize(image)
+      @image = image
+      @width = image.width
+      @height = image.height
+      @variance = nil
+      @complexity = nil
+      @img_array = nil
+    end
+
+    # 이미지를 Numo::NArray로 변환 (지연 로딩)
+    def img_array
+      @img_array ||= begin
+        # Vips 이미지를 메모리 배열로 변환
+        bands = @image.bands
+        data = @image.write_to_memory
+
+        # 바이트 배열을 NArray로 변환
+        arr = Numo::UInt8.from_binary(data)
+        arr.reshape(@height, @width, bands)
+      end
+    end
+
+    # 각 행의 색상 분산 (지연 계산)
+    def variance
+      @variance ||= calculate_variance
+    end
+
+    # 각 행의 콘텐츠 복잡도 (지연 계산)
+    def complexity
+      @complexity ||= calculate_complexity
+    end
+
+    private
+
+    def calculate_variance
+      arr = img_array
+      result = Numo::DFloat.zeros(@height)
+
+      @height.times do |y|
+        row = arr[y, true, true].cast_to(Numo::DFloat)
+        # 각 채널별 표준편차 계산 후 평균
+        channel_stds = (0...arr.shape[2]).map do |c|
+          channel_data = row[true, c]
+          std_dev(channel_data)
+        end
+        result[y] = channel_stds.sum / channel_stds.size
+      end
+
+      result
+    end
+
+    def calculate_complexity
+      # Sobel 엣지 감지
+      gray = @image.colourspace(:b_w)
+      edges = gray.sobel
+
+      # 엣지 이미지를 배열로 변환
+      edge_data = edges.write_to_memory
+      edge_arr = Numo::UInt8.from_binary(edge_data).reshape(@height, @width)
+
+      # 각 행의 엣지 밀도
+      edge_density = Numo::DFloat.zeros(@height)
+      @height.times do |y|
+        edge_density[y] = edge_arr[y, true].cast_to(Numo::DFloat).mean
+      end
+
+      # 색상 분산
+      color_variance = variance
+
+      # 정규화
+      edge_max = edge_density.max
+      color_max = color_variance.max
+
+      edge_norm = edge_max > 0 ? edge_density / edge_max : edge_density
+      color_norm = color_max > 0 ? color_variance / color_max : color_variance
+
+      # 가중 합산
+      edge_norm * 0.7 + color_norm * 0.3
+    end
+
+    def std_dev(arr)
+      mean = arr.mean
+      variance = ((arr - mean) ** 2).mean
+      Math.sqrt(variance)
+    end
+  end
+end

data/lib/naiso/split_config.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Naiso
+  # 분할 설정
+  class SplitConfig
+    attr_accessor :variance_threshold, :min_gap_height, :min_section_height, :max_section_height
+
+    def initialize(
+      variance_threshold: 10.0,
+      min_gap_height: 50,
+      min_section_height: nil,
+      max_section_height: nil
+    )
+      @variance_threshold = variance_threshold
+      @min_gap_height = min_gap_height
+      @min_section_height = min_section_height
+      @max_section_height = max_section_height
+    end
+  end
+end

data/lib/naiso/split_point_detector.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require 'numo/narray'
+
+module Naiso
+  # 분할점 감지기
+  class SplitPointDetector
+    def initialize(analyzer, config)
+      @analyzer = analyzer
+      @config = config
+    end
+
+    # 연속된 단색 영역 찾기
+    def find_uniform_regions
+      variance = @analyzer.variance
+      threshold = @config.variance_threshold
+
+      regions = []
+      in_region = false
+      region_start = 0
+
+      @analyzer.height.times do |i|
+        uniform = variance[i] < threshold
+
+        if uniform && !in_region
+          in_region = true
+          region_start = i
+        elsif !uniform && in_region
+          in_region = false
+          if i - region_start >= @config.min_gap_height
+            regions << [region_start, i]
+          end
+        end
+      end
+
+      # 마지막까지 단색이면
+      if in_region
+        region_end = @analyzer.height
+        if region_end - region_start >= @config.min_gap_height
+          regions << [region_start, region_end]
+        end
+      end
+
+      regions
+    end
+
+    # 가로 구분선 감지
+    def find_divider_lines(
+      line_variance_threshold: 3.0,
+      margin_check: 30,
+      margin_variance_threshold: 5.0
+    )
+      img_array = @analyzer.img_array
+      variance = @analyzer.variance
+      height = @analyzer.height
+
+      dividers = []
+
+      (margin_check...(height - margin_check)).each do |y|
+        next if variance[y] > line_variance_threshold
+
+        margin_above = img_array[(y - margin_check)...y, true, true]
+        margin_below = img_array[(y + 1)...(y + 1 + margin_check), true, true]
+
+        above_variance = calculate_region_variance(margin_above)
+        below_variance = calculate_region_variance(margin_below)
+
+        next if above_variance > margin_variance_threshold
+        next if below_variance > margin_variance_threshold
+
+        above_mean = margin_above.cast_to(Numo::DFloat).mean
+        below_mean = margin_below.cast_to(Numo::DFloat).mean
+        line_mean = img_array[y, true, true].cast_to(Numo::DFloat).mean
+
+        color_diff = (line_mean - (above_mean + below_mean) / 2.0).abs
+        dividers << y if color_diff > 10
+      end
+
+      merge_nearby_points(dividers)
+    end
+
+    # 배경색 전환 지점 감지
+    def find_background_transitions(
+      variance_threshold: 5.0,
+      min_uniform_height: 20,
+      color_diff_threshold: 15.0
+    )
+      img_array = @analyzer.img_array
+      variance = @analyzer.variance
+      height = @analyzer.height
+
+      transitions = []
+
+      (min_uniform_height...(height - min_uniform_height)).each do |y|
+        # 위아래가 모두 단색인지 확인
+        above_uniform = variance[(y - min_uniform_height)...y].to_a.all? { |v| v < variance_threshold }
+        below_uniform = variance[y...(y + min_uniform_height)].to_a.all? { |v| v < variance_threshold }
+
+        next unless above_uniform && below_uniform
+
+        above_region = img_array[(y - min_uniform_height)...y, true, true]
+        below_region = img_array[y...(y + min_uniform_height), true, true]
+
+        above_color = calculate_mean_color(above_region)
+        below_color = calculate_mean_color(below_region)
+
+        # RGB 유클리드 거리
+        color_diff = Math.sqrt(
+          above_color.zip(below_color).map { |a, b| (a - b) ** 2 }.sum
+        )
+
+        transitions << y if color_diff > color_diff_threshold
+      end
+
+      merge_nearby_points(transitions)
+    end
+
+    # 주어진 범위 내에서 복잡도가 가장 낮은 분할점 찾기
+    def find_best_split_in_range(start_pos, end_pos, margin: 50)
+      search_start = start_pos + margin
+      search_end = end_pos - margin
+
+      return (start_pos + end_pos) / 2 if search_start >= search_end
+
+      window_size = 20
+      complexity = @analyzer.complexity
+
+      region = complexity[search_start...search_end]
+      return search_start + region.min_index if region.size < window_size
+
+      # 이동 평균으로 smoothing
+      smoothed = []
+      (0...(region.size - window_size)).each do |i|
+        smoothed << region[i...(i + window_size)].mean
+      end
+
+      best_idx = smoothed.each_with_index.min_by { |v, _| v }[1] + window_size / 2
+      search_start + best_idx
+    end
+
+    private
+
+    def calculate_region_variance(region)
+      # 각 행의 표준편차 평균
+      variances = []
+      region.shape[0].times do |y|
+        row = region[y, true, true].cast_to(Numo::DFloat)
+        channel_stds = (0...region.shape[2]).map do |c|
+          channel_data = row[true, c]
+          mean = channel_data.mean
+          Math.sqrt(((channel_data - mean) ** 2).mean)
+        end
+        variances << channel_stds.sum / channel_stds.size
+      end
+      variances.sum / variances.size
+    end
+
+    def calculate_mean_color(region)
+      channels = region.shape[2]
+      (0...channels).map do |c|
+        region[true, true, c].cast_to(Numo::DFloat).mean
+      end
+    end
+
+    def merge_nearby_points(points, threshold: 5)
+      return [] if points.empty?
+
+      merged = []
+      group_start = points.first
+      group_end = points.first
+
+      points[1..].each do |y|
+        if y <= group_end + threshold
+          group_end = y
+        else
+          merged << (group_start + group_end) / 2
+          group_start = y
+          group_end = y
+        end
+      end
+
+      merged << (group_start + group_end) / 2
+      merged
+    end
+  end
+end

data/lib/naiso/split_result.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Naiso
+  # 분할 결과
+  class SplitResult
+    attr_accessor :output_files, :split_points, :uniform_regions,
+                  :divider_lines, :background_transitions, :complexity_splits
+
+    def initialize
+      @output_files = []
+      @split_points = []
+      @uniform_regions = []
+      @divider_lines = []
+      @background_transitions = []
+      @complexity_splits = []
+    end
+  end
+end

data/lib/naiso/text_detector.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+require 'vips'
+require 'rtesseract'
+require 'json'
+
+module Naiso
+  # 텍스트 검출기
+  class TextDetector
+    # 최소 텍스트 길이 (공백 제외)
+    MIN_TEXT_LENGTH = 3
+    # 최소 신뢰도 (0-100, 이 값 미만은 무시)
+    MIN_CONFIDENCE = 60.0
+    # 최소 단어 크기 (픽셀, 이 값 미만은 노이즈로 간주)
+    MIN_WORD_SIZE = 10
+
+    def initialize(languages: %w[kor eng], min_confidence: MIN_CONFIDENCE, min_word_size: MIN_WORD_SIZE)
+      @languages = languages.join('+')
+      @min_confidence = min_confidence
+      @min_word_size = min_word_size
+    end
+
+    # 이미지에 텍스트가 있는지 검사
+    # 원본과 반전 이미지 모두에서 OCR 시도 (흰색 텍스트 대응)
+    # @param image_path [String] 이미지 파일 경로
+    # @return [Hash] { has_text: Boolean, text: String, text_length: Integer }
+    def detect(image_path)
+      # 원본 이미지에서 OCR
+      original_result = ocr_image(image_path)
+
+      # 원본에서 텍스트를 찾았으면 반환
+      return original_result if original_result[:has_text]
+
+      # 반전 이미지에서 OCR 시도 (흰색 텍스트 + 어두운 배경 대응)
+      inverted_result = ocr_inverted_image(image_path)
+
+      # 더 많은 텍스트를 찾은 결과 반환
+      if inverted_result[:text_length] > original_result[:text_length]
+        inverted_result
+      else
+        original_result
+      end
+    rescue StandardError => e
+      {
+        has_text: false,
+        text: '',
+        text_length: 0,
+        error: e.message
+      }
+    end
+
+    # 텍스트 크기 정보를 포함한 상세 검출
+    # @param image_path [String] 이미지 파일 경로
+    # @return [Hash] { has_text:, text:, text_length:, words: [{text:, x:, y:, width:, height:, conf:}], stats: {min_height:, max_height:, avg_height:} }
+    def detect_with_size(image_path)
+      result = detect_tsv(image_path)
+
+      # 원본에서 못 찾으면 반전 이미지 시도
+      unless result[:has_text]
+        inverted_result = detect_tsv_inverted(image_path)
+        result = inverted_result if inverted_result[:text_length] > result[:text_length]
+      end
+
+      result
+    rescue StandardError => e
+      {
+        has_text: false,
+        text: '',
+        text_length: 0,
+        words: [],
+        stats: nil,
+        error: e.message
+      }
+    end
+
+    # 여러 이미지에서 텍스트 분석 (크기 정보 포함)
+    # @param image_paths [Array<String>] 이미지 파일 경로 배열
+    # @param verbose [Boolean] 상세 출력 여부
+    # @param json_path [String, nil] JSON 저장 경로 (nil이면 저장 안함)
+    # @return [Array<Hash>] 분석 결과 배열
+    def analyze_images(image_paths, verbose: true, json_path: nil)
+      puts "\n텍스트 검출 중..." if verbose
+
+      results = []
+
+      image_paths.each_with_index do |path, i|
+        result = detect_with_size(path)
+        filename = File.basename(path)
+
+        analysis = {
+          filename: filename,
+          path: path,
+          has_text: result[:has_text],
+          text_length: result[:text_length],
+          text: result[:text],
+          stats: result[:stats],
+          words: result[:words]
+        }
+        results << analysis
+
+        if verbose
+          if result[:has_text] && result[:stats]
+            stats = result[:stats]
+            puts format('  %2d. %-30s 텍스트 있음 (%d자, %d단어) | 높이: %d~%dpx (평균 %.1fpx)',
+                        i + 1, filename, result[:text_length], stats[:word_count],
+                        stats[:min_height], stats[:max_height], stats[:avg_height])
+          else
+            puts format('  %2d. %-30s 텍스트 없음', i + 1, filename)
+          end
+        end
+      end
+
+      # JSON 저장
+      if json_path
+        save_json(results, json_path)
+        puts "\nJSON 저장: #{json_path}" if verbose
+      end
+
+      # 텍스트 없는 이미지 요약
+      no_text_images = results.reject { |r| r[:has_text] }
+      if verbose
+        puts "\n텍스트 없는 이미지: #{no_text_images.size}개"
+        no_text_images.each do |r|
+          puts "  - #{r[:filename]}"
+        end
+      end
+
+      results
+    end
+
+    # 여러 이미지에서 텍스트 없는 이미지 찾기 (하위 호환성)
+    # @param image_paths [Array<String>] 이미지 파일 경로 배열
+    # @param verbose [Boolean] 상세 출력 여부
+    # @return [Array<String>] 텍스트가 없는 이미지 경로 배열
+    def find_images_without_text(image_paths, verbose: true)
+      results = analyze_images(image_paths, verbose: verbose)
+      results.reject { |r| r[:has_text] }.map { |r| r[:path] }
+    end
+
+    private
+
+    def ocr_image(image_path)
+      # PSM 3 (기본값: 자동 페이지 세분화)로 시도
+      result = ocr_with_psm(image_path, 3)
+      return result if result[:has_text]
+
+      # PSM 6 (단일 텍스트 블록 가정)으로 재시도
+      ocr_with_psm(image_path, 6)
+    end
+
+    def ocr_with_psm(image_path, psm)
+      ocr = RTesseract.new(image_path, lang: @languages, psm: psm)
+      text = ocr.to_s.strip
+      clean_text = text.gsub(/[\s\p{P}\p{S}]/, '')
+
+      {
+        has_text: clean_text.length >= MIN_TEXT_LENGTH,
+        text: text,
+        text_length: clean_text.length
+      }
+    end
+
+    def ocr_inverted_image(image_path)
+      # libvips로 이미지 반전
+      image = Vips::Image.new_from_file(image_path)
+      inverted = image.invert
+
+      # 임시 파일로 저장
+      temp_path = "/tmp/inverted_#{File.basename(image_path)}"
+      inverted.write_to_file(temp_path)
+
+      result = ocr_image(temp_path)
+
+      # 임시 파일 삭제
+      File.delete(temp_path) if File.exist?(temp_path)
+
+      result
+    end
+
+    # TSV 출력으로 텍스트 크기 정보 추출
+    def detect_tsv(image_path)
+      parse_tsv_output(image_path, image_path)
+    end
+
+    def detect_tsv_inverted(image_path)
+      image = Vips::Image.new_from_file(image_path)
+      inverted = image.invert
+
+      temp_path = "/tmp/inverted_#{File.basename(image_path)}"
+      inverted.write_to_file(temp_path)
+
+      result = parse_tsv_output(temp_path, image_path)
+
+      File.delete(temp_path) if File.exist?(temp_path)
+
+      result
+    end
+
+    def parse_tsv_output(ocr_path, original_path)
+      # PSM 6으로 TSV 출력
+      tsv_output = `tesseract "#{ocr_path}" stdout -l #{@languages} --psm 6 tsv 2>/dev/null`
+
+      all_words = []
+      lines = tsv_output.split("\n")
+
+      # 헤더 스킵
+      lines[1..].each do |line|
+        cols = line.split("\t")
+        next if cols.size < 12
+
+        level = cols[0].to_i
+        next unless level == 5 # word level
+
+        text = cols[11].to_s.strip
+        next if text.empty?
+
+        conf = cols[10].to_f
+        next if conf < 0 # 빈 결과 제외
+
+        all_words << {
+          text: text,
+          x: cols[6].to_i,
+          y: cols[7].to_i,
+          width: cols[8].to_i,
+          height: cols[9].to_i,
+          conf: conf.round(1)
+        }
+      end
+
+      # 신뢰도 및 크기 필터링
+      confident_words = all_words.select do |w|
+        w[:conf] >= @min_confidence &&
+          w[:width] >= @min_word_size &&
+          w[:height] >= @min_word_size
+      end
+
+      # 신뢰도 높은 단어들로 텍스트 합치기
+      full_text = confident_words.map { |w| w[:text] }.join(' ')
+      clean_text = full_text.gsub(/[\s\p{P}\p{S}]/, '')
+
+      # 통계 계산 (신뢰도 높은 단어 기준)
+      stats = nil
+      if confident_words.any?
+        heights = confident_words.map { |w| w[:height] }
+        stats = {
+          min_height: heights.min,
+          max_height: heights.max,
+          avg_height: (heights.sum.to_f / heights.size).round(1),
+          word_count: confident_words.size,
+          filtered_count: all_words.size - confident_words.size
+        }
+      end
+
+      {
+        has_text: clean_text.length >= MIN_TEXT_LENGTH,
+        text: full_text,
+        text_length: clean_text.length,
+        words: confident_words,
+        stats: stats
+      }
+    end
+
+    def save_json(results, json_path)
+      # words 배열은 너무 길 수 있으므로 요약 버전도 생성
+      output = {
+        generated_at: Time.now.iso8601,
+        total_images: results.size,
+        images_with_text: results.count { |r| r[:has_text] },
+        images_without_text: results.count { |r| !r[:has_text] },
+        sections: results.map do |r|
+          {
+            filename: r[:filename],
+            has_text: r[:has_text],
+            text_length: r[:text_length],
+            text: r[:text],
+            stats: r[:stats],
+            words: r[:words]
+          }
+        end
+      }
+
+      File.write(json_path, JSON.pretty_generate(output))
+    end
+  end
+end

data/lib/naiso/version.rb

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

data/lib/naiso.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative 'naiso/version'
+require_relative 'naiso/split_config'
+require_relative 'naiso/split_result'
+require_relative 'naiso/row_analyzer'
+require_relative 'naiso/split_point_detector'
+require_relative 'naiso/image_splitter'
+require_relative 'naiso/image_merger'
+require_relative 'naiso/text_detector'
+require_relative 'naiso/cli'
+
+module Naiso
+  class Error < StandardError; end
+end

data/naiso.gemspec

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'lib/naiso/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'naiso'
+  spec.version       = Naiso::VERSION
+  spec.authors       = ['Wonsup Yoon']
+  spec.email         = ['wonsup@example.com']
+
+  spec.summary       = '상품 상세 이미지 섹션 분할 도구'
+  spec.description   = '긴 상세 이미지를 단색/그라데이션 배경 영역을 기준으로 자동 분할합니다.'
+  spec.homepage      = 'https://github.com/TeamMilestone/naiso'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = '>= 2.7.0'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+
+  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   = ['naiso']
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'numo-narray', '~> 0.9'
+  spec.add_dependency 'rtesseract', '~> 3.1'
+  spec.add_dependency 'ruby-vips', '~> 2.1'
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: naiso
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Wonsup Yoon
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: numo-narray
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: rtesseract
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: ruby-vips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+description: 긴 상세 이미지를 단색/그라데이션 배경 영역을 기준으로 자동 분할합니다.
+email:
+- wonsup@example.com
+executables:
+- naiso
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- exe/naiso
+- lib/naiso.rb
+- lib/naiso/cli.rb
+- lib/naiso/image_merger.rb
+- lib/naiso/image_splitter.rb
+- lib/naiso/row_analyzer.rb
+- lib/naiso/split_config.rb
+- lib/naiso/split_point_detector.rb
+- lib/naiso/split_result.rb
+- lib/naiso/text_detector.rb
+- lib/naiso/version.rb
+- naiso.gemspec
+homepage: https://github.com/TeamMilestone/naiso
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/TeamMilestone/naiso
+  source_code_uri: https://github.com/TeamMilestone/naiso
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.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: 상품 상세 이미지 섹션 분할 도구
+test_files: []