Class: Rpdfium::Image::Embedded

Inherits:
Object
  • Object
show all
Defined in:
lib/rpdfium/image/embedded.rb

Overview

Wrapper per un image object inserito in una pagina. Permette di:

  • leggere metadata (dimensione pixel, DPI, colorspace, BPP)

  • ottenere bytes raw (così come stoccati: tipicamente JPEG)

  • ottenere bytes decoded (raster post-filtri)

  • ottenere bitmap renderizzato (con maschere e matrice applicate)

Constant Summary collapse

COLORSPACES = 
{
  0 => :unknown, 1 => :devicegray, 2 => :devicergb, 3 => :devicecmyk,
  4 => :calgray, 5 => :calrgb, 6 => :lab, 7 => :iccbased,
  8 => :separation, 9 => :devicen, 10 => :indexed, 11 => :pattern
}.freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(page, page_object_handle) ⇒ Embedded

Returns a new instance of Embedded.



19
20
21
22
 
# File 'lib/rpdfium/image/embedded.rb', line 19

def initialize(page, page_object_handle)
  @page   = page
  @handle = page_object_handle
end

Instance Attribute Details

#handle ⇒ Object (readonly)

Returns the value of attribute handle.



17
18
19
 
# File 'lib/rpdfium/image/embedded.rb', line 17

def handle
  @handle
end

#page ⇒ Object (readonly)

Returns the value of attribute page.



17
18
19
 
# File 'lib/rpdfium/image/embedded.rb', line 17

def page
  @page
end

Instance Method Details

#bbox ⇒ Object 



46
47
48
49
50
51
52
53
54
55
56
 
# File 'lib/rpdfium/image/embedded.rb', line 46

def bbox
  l = FFI::MemoryPointer.new(:float)
  r = FFI::MemoryPointer.new(:float)
  b = FFI::MemoryPointer.new(:float)
  t = FFI::MemoryPointer.new(:float)
  return nil if Raw.FPDFPageObj_GetBounds(@handle, l, r, b, t) == 0

  h = @page.height
  { x0: l.read_float, x1: r.read_float,
    top: h - t.read_float, bottom: h - b.read_float }
end

#decoded_bytes ⇒ Object

Bytes decoded: pixel raster dopo l’applicazione dei filtri. Layout dipende dal colorspace.



88
89
90
91
92
93
94
95
 
# File 'lib/rpdfium/image/embedded.rb', line 88

def decoded_bytes
  len = Raw.FPDFImageObj_GetImageDataDecoded(@handle, FFI::Pointer::NULL, 0)
  return "" if len.zero?

  buf = FFI::MemoryPointer.new(:uchar, len)
  Raw.FPDFImageObj_GetImageDataDecoded(@handle, buf, len)
  buf.read_bytes(len)
end

#filters ⇒ Object

Filtri applicati nell’ordine PDF: es. [“DCTDecode”] → JPEG,

“FlateDecode”

→ zlib, [“DCTDecode”,“DCTDecode”] → ricodifiche.



60
61
62
63
64
65
66
67
68
69
70
71
72
73
 
# File 'lib/rpdfium/image/embedded.rb', line 60

def filters
  n = Raw.FPDFImageObj_GetImageFilterCount(@handle)
  Array.new(n) do |i|
    # Probe + read
    len = Raw.FPDFImageObj_GetImageFilter(@handle, i, FFI::Pointer::NULL, 0)
    if len > 1
      buf = FFI::MemoryPointer.new(:uchar, len)
      Raw.FPDFImageObj_GetImageFilter(@handle, i, buf, len)
      buf.read_bytes(len - 1).force_encoding("UTF-8")
    else
      ""
    end
  end
end

#metadata ⇒ Object 



24
25
26
27
28
29
30
31
32
33
34
35
36
 
# File 'lib/rpdfium/image/embedded.rb', line 24

def metadata
  meta = Raw::FPDF_IMAGEOBJ_METADATA.new
  return nil if Raw.FPDFImageObj_GetImageMetadata(@handle, @page.handle, meta) == 0

  {
    width:           meta[:width],
    height:          meta[:height],
    horizontal_dpi:  meta[:horizontal_dpi],
    vertical_dpi:    meta[:vertical_dpi],
    bits_per_pixel:  meta[:bits_per_pixel],
    colorspace:      COLORSPACES[meta[:colorspace]] || :unknown
  }
end

#pixel_size ⇒ Object 



38
39
40
41
42
43
44
 
# File 'lib/rpdfium/image/embedded.rb', line 38

def pixel_size
  wbuf = FFI::MemoryPointer.new(:uint)
  hbuf = FFI::MemoryPointer.new(:uint)
  return nil if Raw.FPDFImageObj_GetImagePixelSize(@handle, wbuf, hbuf) == 0

  [wbuf.read_uint, hbuf.read_uint]
end

#raw_bytes ⇒ Object

Bytes “raw”: come sono stoccati nel PDF. Se filters == [“DCTDecode”] questi bytes sono un JPEG completo che puoi salvare con estensione .jpg.



77
78
79
80
81
82
83
84
 
# File 'lib/rpdfium/image/embedded.rb', line 77

def raw_bytes
  len = Raw.FPDFImageObj_GetImageDataRaw(@handle, FFI::Pointer::NULL, 0)
  return "" if len.zero?

  buf = FFI::MemoryPointer.new(:uchar, len)
  Raw.FPDFImageObj_GetImageDataRaw(@handle, buf, len)
  buf.read_bytes(len)
end

#render_bitmap ⇒ Object

Bitmap renderizzato applicando matrice e maschere. Ritorna [w, h, bytes(BGRA)].



98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
 
# File 'lib/rpdfium/image/embedded.rb', line 98

def render_bitmap
  bitmap = Raw.FPDFImageObj_GetRenderedBitmap(
    @page.document.handle, @page.handle, @handle
  )
  return nil if bitmap.null?

  begin
    w = Raw.FPDFBitmap_GetWidth(bitmap)
    h = Raw.FPDFBitmap_GetHeight(bitmap)
    stride = Raw.FPDFBitmap_GetStride(bitmap)
    buf = Raw.FPDFBitmap_GetBuffer(bitmap)
    [w, h, buf.read_bytes(stride * h), stride]
  ensure
    Raw.FPDFBitmap_Destroy(bitmap)
  end
end

#save(path) ⇒ Object

Salva il file. Se i filtri sono DCTDecode → scrive .jpg diretto. Altrimenti renderizza il bitmap a PNG.



117
118
119
120
121
122
123
124
125
126
127
 
# File 'lib/rpdfium/image/embedded.rb', line 117

def save(path)
  if filters == ["DCTDecode"]
    File.binwrite(path, raw_bytes)
  else
    w, h, bytes, stride = render_bitmap
    # I bitmap resi sono BGRA: convertiamo a RGBA per il PNG writer
    rgba = swap_bgra_to_rgba(bytes, w, h, stride)
    Rpdfium::IO::PNG.write(path, w, h, rgba, stride: w * 4)
  end
  path
end