grmenu 4.1.0 → 5.0.0

data/grmenu/image.rb

@@ -0,0 +1,339 @@
+# frozen_string_literal: true
+
+class GRmenu
+  # Decodificador PNG nativo en Ruby puro sin dependencias de gemas externas.
+  # Procesa las cabeceras IHDR, descomprime los chunks IDAT con Zlib,
+  # reconstruye las lineas de escaneo (scanlines) segun los 5 filtros estandar de PNG
+  # y escala la imagen para convertirla a celdas de texto TrueColor (24 bits).
+  class PNGDecoder
+    attr_reader :width, :height, :pixels
+
+    # Carga y parsea un archivo PNG desde disco
+    def self.load(filepath)
+      return nil unless filepath && File.exist?(filepath)
+      new.parse(File.binread(filepath))
+    rescue StandardError
+      nil
+    end
+
+    # Parsea los bytes en binario del archivo PNG
+    def parse(data)
+      # Valida la firma magica de 8 bytes de un archivo PNG
+      return nil unless data && data[0, 8] == "\x89PNG\r\n\x1a\n".b
+
+      offset = 8
+      idat_data = String.new("".b)
+      palette = nil
+
+      # Itera sobre los chunks PNG: [4 bytes longitud][4 bytes tipo][datos][4 bytes CRC]
+      while offset < data.bytesize
+        len = data[offset, 4].unpack1("N")
+        type = data[offset + 4, 4]
+        chunk_data = data[offset + 8, len]
+        offset += 12 + len # Avanza los 4 de len + 4 de tipo + longitud de datos + 4 de CRC
+
+        case type
+        when "IHDR"
+          # Cabecera principal: ancho, alto, profundidad de bits y tipo de color
+          @width, @height, @bit_depth, @color_type = chunk_data.unpack("NNCC")
+        when "PLTE"
+          # Paleta de colores para imagenes indexadas (tipo 3)
+          palette = chunk_data.bytes.each_slice(3).to_a
+        when "IDAT"
+          # Concatena bloques de datos comprimidos de la imagen
+          idat_data << chunk_data
+        when "IEND"
+          break
+        end
+      end
+
+      # Canales segun tipo de color PNG:
+      # 0: escala de grises (1), 2: RGB (3), 3: indexado (1), 4: gris+alfa (2), 6: RGBA (4)
+      channels = case @color_type
+                 when 0 then 1
+                 when 2 then 3
+                 when 3 then 1
+                 when 4 then 2
+                 when 6 then 4
+                 else return nil
+                 end
+
+      bytes_per_pixel = [(@bit_depth * channels + 7) / 8, 1].max
+      row_stride = (@width * channels * @bit_depth + 7) / 8
+      scanline_length = row_stride + 1 # +1 byte inicial por cada scanline que define el tipo de filtro
+
+      # Descomprime el flujo de datos IDAT con zlib
+      raw_uncompressed = Zlib::Inflate.inflate(idat_data)
+      raw_bytes = raw_uncompressed.bytes
+      return nil if raw_bytes.length < (@height * scanline_length)
+
+      @pixels = Array.new(@height) { Array.new(@width) }
+      prev_reconstructed_row = Array.new(row_stride, 0)
+
+      # Reconstruccion de filtros PNG por cada linea de escaneo (RFC 2083):
+      # Filtro 0: None
+      # Filtro 1: Sub       (reconstruye con el byte de la izquierda: a)
+      # Filtro 2: Up        (reconstruye con el byte de arriba: b)
+      # Filtro 3: Average   (promedio entre izquierda y arriba: (a + b) / 2)
+      # Filtro 4: Paeth     (predictor lineal basado en izquierda, arriba y diagonal)
+      @height.times do |y|
+        row_start_index = y * scanline_length
+        filter_type = raw_bytes[row_start_index]
+        curr_filtered = raw_bytes[(row_start_index + 1)...(row_start_index + scanline_length)]
+        curr_reconstructed = Array.new(row_stride, 0)
+
+        row_stride.times do |i|
+          a = (i >= bytes_per_pixel) ? curr_reconstructed[i - bytes_per_pixel] : 0
+          b = prev_reconstructed_row[i]
+          c = (i >= bytes_per_pixel) ? prev_reconstructed_row[i - bytes_per_pixel] : 0
+          x = curr_filtered[i]
+
+          recon_val = case filter_type
+                      when 0 then x
+                      when 1 then (x + a) & 0xFF
+                      when 2 then (x + b) & 0xFF
+                      when 3 then (x + ((a + b) / 2)) & 0xFF
+                      when 4
+                        # Algoritmo predictor Paeth
+                        p_val = a + b - c
+                        pa = (p_val - a).abs
+                        pb = (p_val - b).abs
+                        pc = (p_val - c).abs
+                        pr = if pa <= pb && pa <= pc
+                               a
+                             elsif pb <= pc
+                               b
+                             else
+                               c
+                             end
+                        (x + pr) & 0xFF
+                      else x
+                      end
+          curr_reconstructed[i] = recon_val
+        end
+
+        prev_reconstructed_row = curr_reconstructed
+
+        # Mapea los bytes reconstruidos a la matriz de pixeles [R, G, B, A]
+        if @bit_depth == 16
+          @width.times do |x|
+            idx = x * channels * 2
+            r = curr_reconstructed[idx]
+            g = (channels >= 3) ? curr_reconstructed[idx + 2] : r
+            b = (channels >= 3) ? curr_reconstructed[idx + 4] : r
+            a = (channels == 4) ? curr_reconstructed[idx + 6] : (channels == 2 ? curr_reconstructed[idx + 2] : 255)
+            @pixels[y][x] = [r, g, b, a]
+          end
+        elsif @bit_depth == 8
+          @width.times do |x|
+            idx = x * channels
+            if @color_type == 3
+              p_idx = curr_reconstructed[idx]
+              rgb_val = palette ? (palette[p_idx] || [0, 0, 0]) : [0, 0, 0]
+              @pixels[y][x] = [rgb_val[0], rgb_val[1], rgb_val[2], 255]
+            else
+              r = curr_reconstructed[idx]
+              g = (channels >= 3) ? curr_reconstructed[idx + 1] : r
+              b = (channels >= 3) ? curr_reconstructed[idx + 2] : r
+              a = (channels == 4 || channels == 2) ? curr_reconstructed[idx + channels - 1] : 255
+              @pixels[y][x] = [r, g, b, a]
+            end
+          end
+        end
+      end
+      self
+    end
+
+    # Realiza un reescalado (resampling) de la matriz de pixeles por promedio de area (box average)
+    def resample(target_w, target_h)
+      resampled = Array.new(target_h) { Array.new(target_w) }
+      x_step = @width.to_f / target_w
+      y_step = @height.to_f / target_h
+
+      target_h.times do |ty|
+        sy_start = (ty * y_step).to_i
+        sy_end   = [((ty + 1) * y_step).to_i, @height].min
+
+        target_w.times do |tx|
+          sx_start = (tx * x_step).to_i
+          sx_end   = [((tx + 1) * x_step).to_i, @width].min
+
+          r_sum = g_sum = b_sum = a_sum = count = 0
+
+          (sy_start...sy_end).each do |sy|
+            (sx_start...sx_end).each do |sx|
+              pixel = @pixels[sy][sx]
+              next unless pixel
+              # Desprecia pixeles casi completamente transparentes (alfa <= 10)
+              if pixel[3] > 10
+                r_sum += pixel[0]
+                g_sum += pixel[1]
+                b_sum += pixel[2]
+                a_sum += pixel[3]
+                count += 1
+              end
+            end
+          end
+
+          if count > 0
+            resampled[ty][tx] = [
+              (r_sum / count).clamp(0, 255),
+              (g_sum / count).clamp(0, 255),
+              (b_sum / count).clamp(0, 255),
+              (a_sum / count).clamp(0, 255)
+            ]
+          else
+            mid_y = (sy_start + sy_end) / 2
+            mid_x = (sx_start + sx_end) / 2
+            resampled[ty][tx] = @pixels[mid_y][mid_x] || [0, 0, 0, 0]
+          end
+        end
+      end
+      resampled
+    end
+
+    # Convierte la imagen a lineas de texto ANSI TrueColor.
+    # Emplea el caracter de medio bloque superior '▀':
+    # El color frontal pinta el pixel superior y el color de fondo pinta el pixel inferior,
+    # permitiendo duplicar la resolucion vertical de la terminal en una sola linea de texto.
+    def render_ansi_lines(target_w = 40, target_h = nil)
+      target_h ||= [((@height.to_f / @width) * target_w).round, 2].max
+      target_h += 1 if target_h.odd? # Requiere altura par porque cada fila de texto empaqueta 2 pixeles verticales
+
+      grid = resample(target_w, target_h)
+      lines = []
+
+      (0...target_h).step(2) do |y|
+        row_top = grid[y]
+        row_bot = grid[y + 1] || grid[y]
+        line = String.new("")
+
+        target_w.times do |x|
+          r1, g1, b1, a1 = row_top[x]
+          r2, g2, b2, a2 = row_bot[x]
+
+          if a1 < 32 && a2 < 32
+            line << "\e[0m "
+          elsif a1 < 32
+            line << "\e[0m\e[38;2;#{r2};#{g2};#{b2}m▄"
+          elsif a2 < 32
+            line << "\e[0m\e[38;2;#{r1};#{g1};#{b1}m▀"
+          else
+            line << "\e[38;2;#{r1};#{g1};#{b1}m\e[48;2;#{r2};#{g2};#{b2}m▀"
+          end
+        end
+        line << "\e[0m"
+        lines << line
+      end
+
+      lines
+    end
+  end
+
+  # Carga una imagen y la renderiza en lineas ANSI TrueColor.
+  # Intenta usar ImageMagick (convert o magick) si esta disponible en el sistema operativo
+  # para aplicar escalado Lanczos de alta definicion; de lo contrario utiliza PNGDecoder nativo.
+  def self.load_and_render_image(filepath, width = 40, height = nil, max_cols = terminal_width)
+    return [] unless filepath && File.exist?(filepath)
+
+    req_w = [width.to_i, max_cols - 6].min
+    req_w = [req_w, 10].max
+
+    conv_bin = `which convert 2>/dev/null`.strip
+    conv_bin = `which magick 2>/dev/null`.strip if conv_bin.empty?
+
+    # Ruta con ImageMagick disponible en el sistema
+    if !conv_bin.empty?
+      info, _ = Open3.capture2("identify", "-format", "%w %h", filepath) rescue ["", nil]
+      orig_w, orig_h = info.strip.split.map(&:to_f)
+      aspect = (orig_w && orig_w > 0) ? (orig_h / orig_w) : 0.6
+      scale_h = height || (req_w * aspect).round
+      scale_h += 1 if scale_h.odd?
+      scale_h = [scale_h, 2].max
+
+      # Convierte la imagen a un flujo plano de bytes RGBA
+      cmd = [conv_bin, filepath, "-filter", "Lanczos", "-resize", "#{req_w}x#{scale_h}!", "-depth", "8", "rgba:-"]
+      stdout, status = Open3.capture2(*cmd) rescue [nil, nil]
+      if status && status.success? && stdout.bytesize == (req_w * scale_h * 4)
+        raw = stdout.bytes
+        lines = []
+        (0...scale_h).step(2) do |y|
+          line = String.new("")
+          req_w.times do |x|
+            top_idx = (y * req_w + x) * 4
+            bot_idx = ((y + 1) * req_w + x) * 4
+            r1, g1, b1, a1 = raw[top_idx, 4]
+            r2, g2, b2, a2 = raw[bot_idx, 4]
+
+            if a1 < 32 && a2 < 32
+              line << "\e[0m "
+            elsif a1 < 32
+              line << "\e[0m\e[38;2;#{r2};#{g2};#{b2}m▄"
+            elsif a2 < 32
+              line << "\e[0m\e[38;2;#{r1};#{g1};#{b1}m▀"
+            else
+              line << "\e[38;2;#{r1};#{g1};#{b1}m\e[48;2;#{r2};#{g2};#{b2}m▀"
+            end
+          end
+          line << "\e[0m"
+          lines << line
+        end
+        return lines
+      end
+    end
+
+    # Ruta de fallback: PNGDecoder nativo en Ruby puro
+    png = PNGDecoder.load(filepath)
+    return png.render_ansi_lines(req_w, height) if png
+
+    []
+  rescue StandardError
+    []
+  end
+
+  # Dibuja una imagen centrada en la terminal con marco decorativo opcional
+  def self.image(filepath, width: 40, height: nil, style: 3, color: "cyan", center: true)
+    term_w = terminal_width
+    raw_lines = load_and_render_image(filepath, width, height, term_w)
+    return nil if raw_lines.empty?
+
+    img_w = display_width(raw_lines.first)
+    box_w = img_w + 4
+    margin = (center && term_w > box_w) ? (" " * ((term_w - box_w) / 2)) : ""
+
+    if style && style > 0
+      border_cfg = BORDERS[style] || BORDERS[3]
+      is_rgb = (color.to_s.downcase == "rgb" || color.to_s.downcase == "rainbow" || color.to_s.downcase == "chroma")
+      color_code = is_rgb ? "" : ansi_color(color, 2)
+      reset_code = ansi_reset
+
+      h_top = border_cfg[:ht] || border_cfg[:h]
+      h_bot = border_cfg[:hb] || border_cfg[:h]
+      v_l   = border_cfg[:vl] || border_cfg[:v]
+      v_r   = border_cfg[:vr] || border_cfg[:v]
+
+      top_fill = (h_top * ((box_w - 2).to_f / h_top.length).ceil)[0...(box_w - 2)]
+      bot_fill = (h_bot * ((box_w - 2).to_f / h_bot.length).ceil)[0...(box_w - 2)]
+
+      if is_rgb
+        Kernel.print("#{margin}#{Color.rgb("#{border_cfg[:tl]}#{top_fill}#{border_cfg[:tr]}")}\r\n")
+        raw_lines.each do |line|
+          Kernel.print("#{margin}#{Color.rgb(v_l)} #{line} #{Color.rgb(v_r)}\r\n")
+        end
+        Kernel.print("#{margin}#{Color.rgb("#{border_cfg[:bl]}#{bot_fill}#{border_cfg[:br]}")}\r\n")
+      else
+        Kernel.print("#{margin}#{color_code}#{border_cfg[:tl]}#{top_fill}#{border_cfg[:tr]}#{reset_code}\r\n")
+        raw_lines.each do |line|
+          Kernel.print("#{margin}#{color_code}#{v_l}#{reset_code} #{line} #{color_code}#{v_r}#{reset_code}\r\n")
+        end
+        Kernel.print("#{margin}#{color_code}#{border_cfg[:bl]}#{bot_fill}#{border_cfg[:br]}#{reset_code}\r\n")
+      end
+    else
+      raw_lines.each do |line|
+        Kernel.print("#{margin}#{line}\r\n")
+      end
+    end
+
+    true
+  end
+end