phantom_svg 1.0.0

data/lib/phantom/parser/json_animation_reader.rb

@@ -0,0 +1,42 @@
+
+require 'json'
+
+require_relative '../frame.rb'
+require_relative 'abstract_animation_reader.rb'
+
+module Phantom
+  module SVG
+    module Parser
+      # AnimationReader for JSON.
+      class JSONAnimationReader < AbstractAnimationReader
+        private
+
+        # Read parameter from animation information file.
+        def read_parameter(path)
+          open(path) do |file|
+            JSON.load(file).each do |key, val|
+              case key
+              when 'frames'         then  read_frame_infos(val)
+              when 'delays'         then  val.each { |delay| add_delay(delay) }
+              else                        set_parameter(key, val)
+              end
+            end
+          end
+        end
+
+        # Read frame informations
+        def read_frame_infos(value)
+          value.each do |frame_info|
+            if frame_info.instance_of?(Hash)
+              frame_info.each do |name, delay|
+                add_frame_info(name, delay)
+              end
+            else
+              add_frame_info(frame_info)
+            end
+          end
+        end
+      end # class JSONAnimationReader < AbstractAnimationReader
+    end # module Parser
+  end # module SVG
+end # module Phantom

data/lib/phantom/parser/raster.rb

@@ -0,0 +1,115 @@
+
+require 'rapngasm'
+require 'gdk3'
+require 'rsvg2'
+require 'tmpdir'
+require 'cairo'
+
+require_relative '../frame.rb'
+
+module Phantom
+  module SVG
+    module Parser
+      module Raster
+        def load_raster(path, id)
+          apngasm = APNGAsm.new
+          apngasm.disassemble(path)
+
+          if apngasm.frame_count == 1 
+            @frames << create_frame_from_png(path, id)
+          else
+            create_frame_from_apng(apngasm, id)
+          end
+
+          apngasm.reset
+        end
+
+        def create_frame_from_png(path, id, duration = nil)
+          pixbuf = Gdk::Pixbuf.new(path)
+
+          frame = Phantom::SVG::Frame.new
+          frame.width = "#{pixbuf.width}px"
+          frame.height = "#{pixbuf.height}px"
+          frame.surfaces = create_surfaces(path, pixbuf.width, pixbuf.height)
+          frame.duration = duration unless duration.nil?
+          frame.namespaces = {
+            'xmlns' => 'http://www.w3.org/2000/svg',
+            'xlink' => 'http://www.w3.org/1999/xlink'
+          }
+
+          frame
+        end
+
+        def create_frame_from_apng(apngasm, id)
+          png_frames = apngasm.get_frames
+          width = 0
+          height = 0
+          Dir::mktmpdir(nil, File.dirname(__FILE__)) do |dir|
+            apngasm.save_pngs(dir)
+            png_frames.each_with_index do |png_frame, i|
+              width = png_frame.width if width < png_frame.width
+              height = png_frame.height if height < png_frame.height
+              duration = png_frame.delay_numerator.to_f / png_frame.delay_denominator.to_f
+              @frames << create_frame_from_png("#{dir}/#{i}.png", id, duration)
+            end
+          end
+          @width = "#{width}px"
+          @height = "#{height}px"
+          @loops = apngasm.get_loops
+          @skip_first = apngasm.is_skip_first
+        end
+
+        def create_surfaces(path, width, height)
+          bin = File.binread(path)
+          base64 = [bin].pack('m')
+
+          image = REXML::Element.new('image')
+          image.add_attributes(
+            'width' => width,
+            'height' => height,
+            'xlink:href' => "data:image/png;base64,#{base64}"
+          )
+
+          [image]
+        end
+
+        def save_rasterized(path)
+          set_size if @width.to_i == 0 || @height.to_i == 0
+
+          apngasm = APNGAsm.new
+          apngasm.set_loops(@loops)
+          apngasm.set_skip_first(@skip_first)
+
+          Dir::mktmpdir(nil, File.dirname(__FILE__)) do |dir|
+            @frames.each_with_index do |frame, i|
+              create_tmp_file("#{dir}/tmp#{i}", frame)
+              apngasm.add_frame_file("#{dir}/tmp#{i}.png", frame.duration.to_f * 1000, 1000)
+            end
+          end
+
+          result = apngasm.assemble(path)
+          apngasm.reset
+
+          result
+        end
+
+        def create_tmp_file(path, frame)
+          save_svg_frame("#{path}.svg", frame, @width, @height)
+          convert_to_png(path, frame)
+        end
+
+        def convert_to_png(path, frame)
+          handle = RSVG::Handle.new_from_file("#{path}.svg")
+
+          surface = Cairo::ImageSurface.new(Cairo::FORMAT_ARGB32, @width, @height)
+          context = Cairo::Context.new(surface)
+          context.scale(@width / handle.dimensions.width, @height / handle.dimensions.height)
+          context.render_rsvg_handle(handle)
+
+          surface.write_to_png("#{path}.png")
+          surface.finish
+        end
+      end
+    end
+  end
+end

data/lib/phantom/parser/svg_reader.rb

@@ -0,0 +1,131 @@
+
+require 'rexml/document'
+
+require_relative '../frame.rb'
+
+module Phantom
+  module SVG
+    module Parser
+      # SVG reader.
+      class SVGReader
+        attr_reader :frames, :width, :height, :loops, :skip_first, :has_animation
+        alias_method :has_animation?, :has_animation
+
+        # Construct SVGReader object.
+        def initialize(path = nil, options = {})
+          read(path, options)
+        end
+
+        # Read svg file from path.
+        def read(path, options = {})
+          reset
+
+          return if path.nil? || path.empty?
+
+          @root = REXML::Document.new(open(path))
+
+          if @root.elements['svg'].attributes['id'] == 'phantom_svg'
+            read_animation_svg(options)
+            @has_animation = true
+          else
+            read_svg(options)
+            @has_animation = false
+          end
+        end
+
+        private
+
+        # Reset SVGReader object.
+        def reset
+          @frames = []
+          @width = nil
+          @height = nil
+          @loops = nil
+          @skip_first = nil
+          @has_animation = false
+        end
+
+        # Read no animation svg.
+        def read_svg(options)
+          read_images(@root, options)
+        end
+
+        # Read animation svg.
+        def read_animation_svg(options)
+          svg = @root.elements['svg']
+          defs = svg.elements['defs']
+
+          read_size(svg, self, options)
+          read_images(defs, options)
+          read_skip_first
+          read_durations(options)
+          read_loops
+        end
+
+        # Read size from node to dest.
+        def read_size(node, dest, options = {})
+          node.attributes.each do |key, val|
+            case key
+            when 'width'
+              dest.instance_variable_set(:@width, choice_value(val, options[:width]))
+            when 'height'
+              dest.instance_variable_set(:@height, choice_value(val, options[:height]))
+            when 'viewBox'
+              dest.viewbox.set_from_text(choice_value(val, options[:viewbox]).to_s)
+            end
+          end
+        end
+
+        # Read images from svg.
+        def read_images(parent_node, options)
+          parent_node.elements.each('svg') do |svg|
+            new_frame = Phantom::SVG::Frame.new
+
+            # Read namespaces.
+            new_frame.namespaces = svg.namespaces.clone
+            new_frame.namespaces.merge!(options[:namespaces]) unless options[:namespaces].nil?
+
+            # Read image size.
+            read_size(svg, new_frame, options)
+
+            # Read image surfaces.
+            new_frame.surfaces = choice_value(svg.elements.to_a, options[:surfaces])
+
+            # Read frame duration.
+            new_frame.duration = choice_value(new_frame.duration, options[:duration])
+
+            # Add frame to array.
+            @frames << new_frame
+          end
+        end
+
+        # Read skip_first.
+        def read_skip_first
+          @skip_first = @root.elements['svg/defs/symbol/use'].attributes['xlink:href'] != '#frame0'
+        end
+
+        # Read frame durations.
+        def read_durations(options)
+          i = @skip_first ? 1 : 0
+          @root.elements['svg/defs/symbol'].elements.each('use') do |use|
+            duration = use.elements['set'].attributes['dur'].to_f
+            @frames[i].duration = choice_value(duration, options[:duration])
+            i += 1
+          end
+        end
+
+        # Read animation loop count.
+        def read_loops
+          @loops = @root.elements['svg/animate'].attributes['repeatCount'].to_i
+        end
+
+        # Helper method.
+        # Return val if override is nil.
+        # Return override if override is not nil.
+        def choice_value(val, override)
+          override.nil? ? val : override
+        end
+      end # class SVGReader
+    end # module Parser
+  end # module SVG
+end # module Phantom

data/lib/phantom/parser/svg_writer.rb

@@ -0,0 +1,163 @@
+
+require 'rexml/document'
+
+module Phantom
+  module SVG
+    module Parser
+      # SVG writer.
+      class SVGWriter
+        # Construct SVGWriter object.
+        def initialize(path = nil, object = nil)
+          write(path, object)
+        end
+
+        # Write svg file from object to path.
+        # Return write size.
+        def write(path, object)
+          return 0 if path.nil? || path.empty? || object.nil?
+
+          reset
+
+          # Parse object.
+          if object.is_a?(Base)     then  write_animation_svg(object)
+          elsif object.is_a?(Frame) then  write_svg(object)
+          else                            return 0
+          end
+
+          # Add svg version.
+          @root.elements['svg'].add_attribute('version', '1.1')
+
+          # Write to file.
+          File.open(path, 'w') { |file| @root.write(file, 2) }
+        end
+
+        private
+
+        # Reset SVGWriter object.
+        def reset
+          @root = REXML::Document.new
+          @root << REXML::XMLDecl.new('1.0', 'UTF-8')
+          @root << REXML::Comment.new(' Generated by phantom_svg. ')
+        end
+
+        # Write no animation svg.
+        def write_svg(frame)
+          write_image(frame, @root)
+        end
+
+        # Write animation svg.
+        def write_animation_svg(base)
+          svg = @root.add_element('svg', 'id' => 'phantom_svg')
+          defs = svg.add_element('defs')
+
+          # Header.
+          write_size(base, svg)
+          svg.add_namespace('http://www.w3.org/2000/svg')
+          svg.add_namespace('xlink', 'http://www.w3.org/1999/xlink')
+
+          # Images.
+          write_images(base.frames, defs)
+
+          # Animation.
+          write_animation(base, defs)
+
+          # Show control.
+          write_show_control(base, svg)
+        end
+
+        # Write image size.
+        def write_size(s, d)
+          d.add_attribute('width', s.width.is_a?(String) ? s.width : "#{s.width.to_i}px")
+          d.add_attribute('height', s.height.is_a?(String) ? s.height : "#{s.height.to_i}px")
+          d.add_attribute('viewBox', s.viewbox.to_s) if s.instance_variable_defined?(:@viewbox)
+        end
+
+        # Write namespaces from src to dest.
+        def write_namespaces(src, dest)
+          src.namespaces.each do |key, val|
+            if key == 'xmlns' then  dest.add_namespace(val)
+            else                    dest.add_namespace(key, val)
+            end
+          end
+        end
+
+        # Write surfaces to dest.
+        def write_surfaces(surfaces, dest)
+          surfaces.each { |surface| dest.add_element(surface) }
+        end
+
+        # Write image.
+        def write_image(frame, parent_node, id = nil)
+          svg = parent_node.add_element('svg')
+          svg.add_attribute('id', id) unless id.nil?
+          write_size(frame, svg)
+          write_namespaces(frame, svg)
+          write_surfaces(frame.surfaces, svg)
+        end
+
+        # Write images.
+        def write_images(frames, parent_node)
+          REXML::Comment.new(' Images. ', parent_node)
+          frames.each_with_index { |frame, i| write_image(frame, parent_node, "frame#{i}") }
+        end
+
+        # Write animation.
+        def write_animation(base, parent_node)
+          REXML::Comment.new(' Animation. ', parent_node)
+          symbol = parent_node.add_element('symbol', 'id' => 'animation')
+
+          begin_text = "0s;frame#{base.frames.length - 1}_anim.end"
+          base.frames.each_with_index do |frame, i|
+            next if i == 0 && base.skip_first
+
+            write_animation_frame(frame, "frame#{i}", begin_text, symbol)
+
+            begin_text = "frame#{i}_anim.end"
+          end
+        end
+
+        def write_animation_frame(frame, id, begin_text, parent)
+          use = parent.add_element('use', 'xlink:href' => "##{id}",
+                                          'visibility' => 'hidden')
+
+          use.add_element('set',  'id' => "#{id}_anim",
+                                  'attributeName' => 'visibility',
+                                  'to' => 'visible',
+                                  'begin' => begin_text,
+                                  'dur' => "#{frame.duration}s")
+        end
+
+        # Write show control.
+        def write_show_control(base, parent_node)
+          REXML::Comment.new(' Main control. ', parent_node)
+
+          write_show_control_header(base, parent_node)
+          write_show_control_main(base, parent_node)
+        end
+
+        # Write show control header.
+        def write_show_control_header(base, parent_node)
+          repeat_count = base.loops.to_i == 0 ? 'indefinite' : base.loops.to_i.to_s
+
+          parent_node.add_element('animate',  'id' => 'controller',
+                                              'begin' => '0s',
+                                              'dur' => "#{base.total_duration}s",
+                                              'repeatCount' => repeat_count)
+        end
+
+        # Write show control main.
+        def write_show_control_main(base, parent_node)
+          use = parent_node.add_element('use', 'xlink:href' => '#frame0')
+
+          use.add_element('set',  'attributeName' => 'xlink:href',
+                                  'to' => '#animation',
+                                  'begin' => 'controller.begin')
+
+          use.add_element('set',  'attributeName' => 'xlink:href',
+                                  'to' => "#frame#{base.frames.length - 1}",
+                                  'begin' => 'controller.end')
+        end
+      end # class SVGWriter
+    end # module Parser
+  end # module SVG
+end # module Phantom