fdc 0.0.1

data/bin/fdc

@@ -0,0 +1,114 @@
+#!/usr/bin/env ruby
+
+require 'fdc'
+require 'optparse'
+
+ERROR_MISSING_ARGUMENT = -1
+ERROR_INVALID_OPTION = -2
+ERROR_FILE_EXPORT = -3
+ERROR_INCOMPATIBLE_RUBY_VERSION = -4
+
+# Lock out older and knowingly incompatible ruby versions
+if RUBY_VERSION[0..2].to_f < 1.9 then 
+  STDERR.puts <<-EOS 
+Incompatible Ruby version: #{RUBY_VERSION} (at least 1.9.1 required)
+Get the latest version from ruby-lang.org!
+EOS
+  exit(ERROR_INCOMPATIBLE_RUBY_VERSION)
+end
+
+options = {}
+
+optparse = OptionParser.new do |opts|
+  opts.banner = "Usage: fdc [options] <file>..."
+  
+  opts.separator ""
+  opts.separator "Options:"
+  
+  # Define alternative destination directory
+  options[:dest] = nil
+  opts.on( "-d", "--destination DEST", String, "Alternative destination directory" ) do |dest| 
+   options[:dest] = dest
+  end
+  
+  # Define alternative destination directory
+  options[:stdout] = false
+  opts.on( "-s", "--stdout", String, "Print converted KML to STDOUT" ) do
+   options[:stdout] = true
+  end
+
+  # Clamp track to ground and ignore altitude information
+  options[:clamp] = false
+  opts.on( "-c", "--clamp", "Clamp track to ground") do
+    options[:clamp] = true
+  end
+  
+  # Extrude track to ground to emphasize absolute height
+  options[:extrude] = false
+  opts.on( "-e", "--extrude", "Extrude track to ground") do
+    options[:extrude] = true
+  end
+  
+  # Extrude track to ground to emphasize absolute height
+  options[:gps] = false
+  opts.on( "-g", "--gps-alt", "Use gps instead of barometric altitude") do
+    options[:gps] = true
+  end
+  
+  # UTF-8 input file encoding
+  options[:utf] = "ISO-8859-1"
+  opts.on( "-u", "--utf8", "Set input file encoding to UTF-8") do
+    options[:utf] = "UTF-8"
+  end
+
+  # Verbose output
+  options[:verbose] = false
+  opts.on( "-v", "--verbose", "Verbose output") do
+    options[:verbose] = true
+  end
+  
+  # Define help
+  opts.on_tail( "-h", "--help", "Display this help screen" ) do
+    STDERR.puts opts
+    exit
+  end
+
+end
+
+begin
+  optparse.parse!
+rescue OptionParser::MissingArgument => e
+  STDERR.puts e.message
+  exit(ERROR_MISSING_ARGUMENT)
+rescue OptionParser::InvalidOption => e
+  STDERR.puts e.message
+  exit(ERROR_INVALID_OPTION)
+end
+
+STDERR.puts optparse if ARGV.empty?
+
+@converter = Fdc::Converter.new
+
+ARGV.each do |file|
+  
+  begin
+      @converter.parse(file, encoding=options[:utf])
+  rescue Fdc::FileReadError => e
+    STDERR.puts e.message
+    next
+  end
+  
+  @converter.compile(clamp=options[:clamp], extrude=options[:extrude], gps=options[:gps])
+  
+  if options[:stdout] 
+    STDOUT.puts @converter.kml
+  else
+    begin
+      options[:dest] ? @converter.export(options[:dest]) : @converter.export
+      STDERR.puts "Successfully converted file: #{file}" if options[:verbose]
+    rescue Fdc::FileWriteError => e
+      STDERR.puts e.message
+      exit(ERROR_FILE_EXPORT)
+    end
+  end
+end

data/lib/fdc/converter.rb

@@ -0,0 +1,284 @@
+require 'date'
+require 'pathname'
+require 'builder'
+require 'fdc/utilities'
+require 'fdc/exceptions'
+
+module Fdc
+
+  # Class to convert IGC files to KML.
+  # 
+  # @!attribute [r] kml
+  #   @return [String] The KML document
+  # 
+  # @example
+  #   converter = Converter.new
+  #   converter.parse(path/to/file.igc)
+  #   converter.compile
+  #   converter.export(output/dir)
+  class Converter
+  
+    # The compiled KML document
+    attr_accessor :kml
+  
+    # Load and parse an IGC file from the supplied path.
+    # 
+    # @param [String] file The path to the IGC file
+    # @param [String] encoding The encoding of the input file
+    # @raise [Fdc::FileReadError] If file could not be loaded
+    # @raise [Fdc::FileFormatError] If the file format is invalid
+    def parse(file, encoding="ISO-8859-1")
+    
+      # Update state
+      @path = Pathname.new(file)
+      @encoding = encoding
+    
+      # Do work
+      load_file
+      parse_file
+    
+    end
+  
+    # Compile the KML document from the parsed IGC file.
+    # 
+    # @param [Boolean] clamp Whether the track should be clamped to the ground
+    # @param [Boolean] extrude Whether the track should be extruded to the ground
+    # @param [Boolean] gps Whether GPS altitude information should be used
+    # @raise [RuntimeError] If {#parse} was not called before
+    def compile(clamp=false, extrude=false, gps=false)
+    
+      # State assertion
+      raise RuntimeError, "Cannot compile before successfull parse" if @igc.nil? or @date.nil?
+    
+      # Build HTML for balloon description
+      html = Builder::XmlMarkup.new(:indent => 2)
+      html.div :style => "width: 250;" do
+        html.p do
+          unless @a_records[3].nil? then 
+            html.strong "Device:"
+            html.dfn @a_records[3].strip
+            html.br 
+          end
+        end
+        html.p do
+          @h_records.each do |h|
+            if h.include? "PLT" and not h[2].strip.empty? then 
+              html.strong "Pilot:"
+              html.dfn h[2].strip
+              html.br
+            end
+            if h.include? "CID" and not h[2].strip.empty? then 
+              html.strong "Competition ID:"
+              html.dfn h[2].strip
+              html.br
+            end
+            if h.include? "GTY" and not h[2].strip.empty? then 
+              html.strong "Glider:"
+              html.dfn h[2].strip
+              html.br
+            end
+            if h.include? "GID" and not h[2].strip.empty? then
+              html.strong "Glider ID:"
+              html.dfn h[2].strip
+              html.br
+            end
+            if h.include? "CCL" and not h[2].strip.empty? then 
+              html.strong "Competition class:"
+              html.dfn h[2].strip
+              html.br 
+            end
+            if h.include? "SIT" and not h[2].strip.empty? then 
+              html.strong "Site:"
+              html.dfn h[2].strip
+              html.br
+            end
+          end
+        
+          html.strong "Date:"
+          html.dfn @date[3..5].join(".")
+          html.br
+        end
+      
+        # Manufacturer-dependent L records
+        case @a_records[1]
+        when "XSX"
+          @l_records.each do |l|
+            if matches = l[1].scan(/(\w*):(-?\d+.?\d+)/) then 
+              html.p do
+                matches.each do |match|
+                  case match[0]
+                  when "MC"
+                    html.strong "Max. climb:"
+                    html.dfn match[1] << " m/s"
+                    html.br
+                  when "MS"
+                    html.strong "Max. sink:"
+                    html.dfn match[1] << " m/s"
+                    html.br
+                  when "MSP"
+                    html.strong "Max. speed:"
+                    html.dfn match[1] << " km/h"
+                    html.br
+                  when "Dist"
+                    html.strong "Track distance:"
+                    html.dfn match[1] << " km"
+                    html.br
+                  end
+                end
+              end
+            end
+          end
+        end
+      
+      end
+    
+      # Build KML
+      xml = Builder::XmlMarkup.new(:indent => 2)
+      xml.instruct!
+      xml.kml "xmlns" => "http://www.opengis.net/kml/2.2", "xmlns:gx" => "http://www.google.com/kml/ext/2.2" do
+        xml.Placemark {
+          xml.name @path.basename(@path.extname)
+          xml.Snippet :maxLines => "2" do
+            xml.text! snippet
+          end
+          xml.description do
+            xml.cdata! html.target!
+          end
+          xml.Style do
+            xml.IconStyle do
+              xml.Icon do 
+                xml.href "http://earth.google.com/images/kml-icons/track-directional/track-0.png"
+              end
+            end
+            xml.LineStyle do
+              xml.color "99ffac59"
+              xml.width "4"
+            end
+          end
+          xml.gx:Track do
+          
+            clamp ? xml.altitudeMode("clampToGround") : xml.altitudeMode("absolute")
+            extrude ? xml.extrude("1") : xml.extrude("0")
+          
+            @b_records.each do |b_record|
+               time = DateTime.new(2000 + @date[5].to_i, @date[4].to_i, @date[3].to_i, 
+                b_record[1].to_i, b_record[2].to_i, b_record[3].to_i)
+               xml.when time
+            end
+            @b_records.each do |b_record|
+              coords = Fdc::GeoLocation.to_dec(b_record[5], b_record[4])
+              gps ? coords << b_record[8].to_f : coords << b_record[7].to_f
+              xml.gx :coord, coords.join(" ")
+            end
+          end
+        }
+      end
+    
+      @kml = xml.target!
+    end
+  
+    # Export the compiled KML document
+    # 
+    # @param [String] dir The alternative output directory. 
+    #   If nothing is supplied the files are written to the same location 
+    #   as the IGC input file.
+    # @raise [RuntimeError] If {#parse} and {#compile} were not called before
+    # @raise [Fdc::FileWriteError] If dirname is not a directory or write protected
+    def export(dir = nil)
+    
+      # Assert state
+      raise RuntimeError, "Cannot export before compile was called" unless @kml
+    
+      dir = @path.dirname.to_s unless dir
+    
+      # Create Pathname for easier handling
+      dest = Pathname.new(dir)
+    
+      # Create output file name
+      dest += @path.basename(@path.extname)
+    
+      begin
+        file = File.new(dest.to_s << ".kml", "w:UTF-8")
+      rescue Errno::EACCES => e
+        raise Fdc::FileWriteError, "Destination is write-protected: #{dir.to_s}"
+      rescue Errno::ENOTDIR => e
+        raise Fdc::FileWriteError, "Destination is not a directory: #{dir.to_s}"
+      rescue Errno::ENOENT => e
+        raise Fdc::FileWriteError, "Destination does not exist: #{dir.to_s}"
+      end
+    
+      file.write(@kml)
+      file.close
+    
+    end
+  
+    private
+  
+    # Load igc file from supplied path
+    def load_file
+
+      raise Fdc::FileReadError, "Invalid file extension: #{@path.to_s}" unless @path.extname == ".igc"
+
+      # Load file
+      begin
+       file = File.new(@path, "r", :encoding => @encoding)
+      rescue Errno::EISDIR => e
+       raise Fdc::FileReadError, "Input file is a directory: #{@path.to_s}"
+      rescue Errno::ENOENT => e
+       raise Fdc::FileReadError, "Input file does not exist: #{@path.to_s}"
+      end
+
+      @igc = file.read
+      file.close
+
+    end
+  
+    # Regular expressions for file parsing
+    REGEX_A = /^[a]([a-z\d]{3})([a-z\d]{3})?(.*)$/i
+    REGEX_H = /^[h][f|o|p]([\w]{3})(.*):(.*)$/i
+    REGEX_H_DTE = /^hf(dte)((\d{2})(\d{2})(\d{2}))/i
+    REGEX_B = /^(B)(\d{2})(\d{2})(\d{2})(\d{7}[NS])(\d{8}[EW])([AV])(\d{5})(\d{5})/
+    REGEX_L = /^l([a-z0-9]{3}|[plt]|[pfc])(.*)/i
+  
+    # Parse igc file content
+    def parse_file
+    
+      begin
+    
+        # parse utc date
+        @date = @igc.match(REGEX_H_DTE)
+        raise Fdc::FileFormatError, "Invalid file format - header date is missing: #{@path.to_s}" unless @date
+    
+        # parse a records
+        @a_records = @igc.match(REGEX_A)
+        raise Fdc::FileFormatError, "Invalid file format: #{@path.to_s}" unless @a_records
+    
+        # parse h records
+        @h_records = @igc.scan(REGEX_H)
+    
+        # parse b records
+        @b_records = @igc.scan(REGEX_B)
+    
+        # parse l records
+        @l_records = @igc.scan(REGEX_L)
+    
+      rescue ArgumentError => e
+        raise Fdc::FileFormatError, "Wrong file encoding: #{e.message}"
+      end
+    
+    end
+  
+    # Generate Snippet tag content
+    def snippet
+      summary = "Flight"
+      @h_records.each do |h|
+        if h.include? "SIT" and not h[2].strip.empty? then 
+          summary << " from #{h[2].strip}" 
+        end
+      end
+      summary << " on #{@date[3..5].join(".")}"
+    end
+  
+  end
+  
+end

data/lib/fdc/exceptions.rb

@@ -0,0 +1,12 @@
+module Fdc
+
+  # Exception caused by invalid input file format
+  class FileFormatError < StandardError; end
+  
+  # Exception that is raised when a file cannot be read
+  class FileReadError < StandardError; end
+  
+  # Exception that is raised when a files cannot be written
+  class FileWriteError < StandardError; end
+
+end

data/lib/fdc/utilities.rb

@@ -0,0 +1,32 @@
+# Utility classes used by {IGCConverter}
+module Fdc
+  
+   # Module with helper functions for geocoordinate conversion
+   module GeoLocation
+
+     # Convert geocoordinates from mindec notation of IGC to dec notation
+     # 
+     # @param [String] long The longitude from the igc file
+     # @param [String] lat  The Latitude from the igc file
+     # @return [Float, Float] Longitude and Latitude in decimal notation
+     # @example Convert a pair of coordinates
+     #   GeoLocation.to_dec("01343272E", "4722676N")  #=>[13.7212,47.37793333333333]
+     def GeoLocation.to_dec(long, lat)
+
+       long_m = long.match(/^(\d{3})((\d{2})(\d{3}))(E|W)/)
+       lat_m = lat.match(/^(\d{2})((\d{2})(\d{3}))(N|S)/)
+
+       # Convert minutes to decimal
+       long_dec = long_m[1].to_f + (long_m[2].to_f / 1000 / 60)
+       lat_dec = lat_m[1].to_f + (lat_m[2].to_f / 1000 / 60)
+
+       # Change signs according to direction
+       long_dec *= (-1) if long_m[5] == "W"
+       lat_dec *= (-1) if lat_m[5] == "S"
+
+       return long_dec, lat_dec
+     end
+     
+   end
+  
+end

data/lib/fdc.rb

@@ -0,0 +1,11 @@
+# Ruby stdlib
+require 'date'
+require 'pathname'
+
+# Gems
+require 'builder'
+
+# Fdc
+require 'fdc/utilities'
+require 'fdc/converter'
+require 'fdc/exceptions'

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: fdc
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Tobias Noiges
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: builder
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+description: Convert files in the avionics flight recorder data format (IGC) to the
+  keyhole markup language (KML) for display in Applications such as Google Earth.
+email: tobias@noig.es
+executables:
+- fdc
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/fdc/converter.rb
+- lib/fdc/exceptions.rb
+- lib/fdc/utilities.rb
+- lib/fdc.rb
+- bin/fdc
+homepage: https://github.com/nokinen/igc-kml
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Convert flight data format files (IGC) to keyhole markup language (KML)
+test_files: []