dxf 0.2 → 0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2645909e4268c3367196986f86b48822419a8299
+  data.tar.gz: ef973d3d48e9f3cdbb0079d21e97eed21ec19706
+SHA512:
+  metadata.gz: 3a3f3a3582ba79bfc5b8d19227dae5c3ee874cb0fbe3f30c1da21cb46de86e386b51d519578b0094183202b2967cc83d78f6753462f5c8251185f300c791f26e
+  data.tar.gz: 7d3307bc5e85f8e66ab9d582c1511d47ff646fddebeef222daa189f92b87d802d3014ecceb072b8972a146325698717e5f6d97db72b8f7bf9d9691118b7b4fd3

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+rvm:
+- 2.0.0
+deploy:
+  provider: rubygems
+  api_key:
+    secure: S0O4Y3l92qkVXey7ZqIQnRt+81UflIXtsRLOlqONmk2eJ+OLWF8PnQf2PHLuCN39xtaNRPRmjzXxq5SqIvZdJNveAWhTMR+JerW6itGEa1pDEeqtbLsZ42uzfoUdw4kuw/tr2cB8FaNujtRndbzsqRsEinfJ/zlPO606C3CdodI=
+  gem: dxf
+  on:
+    tags: true
+    repo: bfoz/dxf-ruby

data/Gemfile

@@ -1,4 +1,10 @@
 source 'https://rubygems.org'
 
-# Specify your gem's dependencies in dxf.gemspec
 gemspec
+
+gem 'sketch', github: 'bfoz/sketch'
+gem 'units', github: 'bfoz/units-ruby'
+
+group :test do
+    gem 'rake'
+end

data/README.markdown

@@ -1,5 +1,7 @@
 # DXF
 
+[![Build Status](https://travis-ci.org/bfoz/dxf-ruby.png)](https://travis-ci.org/bfoz/dxf-ruby)
+
 Tools for working with the popular DXF file format
 
 ## Installation
@@ -28,4 +30,4 @@ DXF.write('filename.dxf', my_sketch, :inches)
 License
 -------
 
-Copyright 2012-2013 Brandon Fosdick <bfoz@bfoz.net> and released under the BSD license.
+Copyright 2012-2014 Brandon Fosdick <bfoz@bfoz.net> and released under the BSD license.

data/Rakefile

@@ -1,6 +1,8 @@
 require "bundler/gem_tasks"
 require 'rake/testtask'
 
+task :default => :test
+
 Rake::TestTask.new do |t|
     t.libs.push "lib"
     t.test_files = FileList['test/**/*.rb']

data/dxf.gemspec

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |gem|
   gem.name          = "dxf"
-  gem.version       = '0.2'
+  gem.version       = '0.3'
   gem.authors       = ["Brandon Fosdick"]
   gem.email         = ["bfoz@bfoz.net"]
   gem.description   = %q{Read and write DXF files using Ruby}
@@ -16,6 +16,9 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_dependency  'sketch'
-    gem.add_dependency	'units', '~> 2.1'
+    gem.add_dependency	'geometry', '~> 6.4'
+    gem.add_dependency  'sketch', '~> 0.4'
+    gem.add_dependency	'units', '~> 2.4'
+
+    gem.required_ruby_version = '>= 2.0'
 end

data/lib/dxf.rb

@@ -1,6 +1,5 @@
-require 'geometry'
-require 'sketch'
-require 'units'
+require_relative 'dxf/parser'
+require_relative 'dxf/unparser'
 
 module DXF
 =begin
@@ -9,101 +8,18 @@ Reading and writing of files using AutoCAD's {http://en.wikipedia.org/wiki/AutoC
     {http://usa.autodesk.com/adsk/servlet/item?siteID=123112&id=12272454&linkID=10809853 DXF Specifications}
 =end
 
-    class Builder
-	attr_accessor :container
-
-	# Initialize with a Sketch
-	# @param [String,Symbol] units	The units to convert length values to (:inches or :millimeters)
-	def initialize(units=:mm)
-	    @units = units
-	end
-
-	# Convert the given value to the correct units and return it as a formatted string
-	# @return [String]
-	def format_value(value)
-	    if value.is_a? Units::Literal
-		"%g" % value.send("to_#{@units}".to_sym)
-	    else
-		"%g" % value
-	    end
-	end
-
-	def to_s
-	    from_sketch(container)
-	end
-
-	# Convert a {Geometry::Line} into an entity array
-	# @overload line(Line, layer=0)
-	# @overload line(Point, Point, layer=0)
-	def line(*args)
-	    if args[0].is_a?(Geometry::Line)
-		first, last = args[0].first, args[0].last
-		layer = args[1] ||= 0
-	    else
-		first = args[0]
-		last = args[1]
-		layer = args[2] ||= 0
-	    end
-	    first = Point[first] unless first.is_a?(Geometry::Point)
-	    last = Point[last] unless last.is_a?(Geometry::Point)
-	    [ 0, 'LINE',
-	      8, layer,
-	     10, format_value(first.x),
-	     20, format_value(first.y),
-	     11, format_value(last.x),
-	     21, format_value(last.y)]
-	end
-
-	def section(name)
-	    [0, 'SECTION', 2, name]
-	end
-
-	# Build a DXF from a Sketch
-	# @return   [Array]	Array of bytes to be written to a file
-	def from_sketch(sketch)
-	    bytes = []
-	    bytes.push section('HEADER')
-	    bytes.push 0, 'ENDSEC'
-	    bytes.push section('ENTITIES')
-
-	    sketch.geometry.map do |element|
-		case element
-		    when Geometry::Arc
-			bytes.push 0, 'ARC'
-			bytes.push 10, format_value(element.center.x)
-			bytes.push 20, format_value(element.center.y)
-			bytes.push 40, format_value(element.radius)
-			bytes.push 50, format_value(element.start_angle)
-			bytes.push 51, format_value(element.end_angle)
-		    when Geometry::Circle
-			bytes.push 0, 'CIRCLE'
-			bytes.push 10, format_value(element.center.x)
-			bytes.push 20, format_value(element.center.y)
-			bytes.push 40, format_value(element.radius)
-		    when Geometry::Line
-			bytes.push line(element.first, element.last)
-		    when Geometry::Polyline
-			element.edges.map {|edge| bytes.push line(edge.first, edge.last) }
-		    when Geometry::Rectangle
-			element.edges.map {|edge| bytes.push line(edge.first, edge.last) }
-		    when Geometry::Square
-			points = element.points
-			points.each_cons(2) {|p1,p2| bytes.push line(p1,p2) }
-			bytes.push line(points.last, point.first)
-		end
-	    end
-
-	    bytes.push 0, 'ENDSEC'
-	    bytes.push 0, 'EOF'
-	    bytes.join "\n"
-	end
-    end
-
     # Export a {Sketch} to a DXF file
     # @param [String] filename	The path to write to
     # @param [Sketch] sketch	The {Sketch} to export
     # @param [Symbol] units	Convert all values to the specified units (:inches or :mm)
     def self.write(filename, sketch, units=:mm)
-	File.write(filename, Builder.new(units).from_sketch(sketch))
+	File.open(filename, 'w') {|f| Unparser.new(units).unparse(f, sketch)}
+    end
+
+    # Read a DXF file
+    # @param [String] filename	The path to the file to read
+    # @return [DXF] the resulting {DXF} object
+    def self.read(filename)
+	File.open(filename, 'r') {|f| DXF::Parser.new.parse(f) }
     end
 end

data/lib/dxf/cluster_factory.rb

@@ -0,0 +1,15 @@
+# Include this module in the base class of a class cluster to handle swizzling
+# of ::new
+module ClusterFactory
+    def self.included(parent)
+	class << parent
+	    alias :original_new :new
+
+	    def inherited(subclass)
+		class << subclass
+		    alias :new :original_new
+		end
+	    end
+	end
+    end
+end

data/lib/dxf/entity.rb

@@ -0,0 +1,169 @@
+require 'geometry'
+
+require_relative 'cluster_factory'
+
+module DXF
+    Point = Geometry::Point
+
+    # {Entity} is the base class for everything that can live in the ENTITIES block
+    class Entity
+	TypeError = Class.new(StandardError)
+
+	include ClusterFactory
+
+	attr_accessor :handle
+	attr_accessor :layer
+
+	def self.new(type)
+	    case type
+		when 'CIRCLE'	then Circle.new
+		when 'LINE'	then Line.new
+		when 'SPLINE'	then Spline.new
+		else
+		    raise TypeError, "Unrecognized entity type '#{type}'"
+	    end
+	end
+
+	def parse_pair(code, value)
+	    # Handle group codes that are common to all entities
+	    #  These are from the table that starts on page 70 of specification
+	    case code
+		when '5'
+		    handle = value
+		when '8'
+		    layer = value
+		else
+		    p "Unrecognized entity group code: #{code} #{value}"
+	    end
+	end
+
+	private
+
+	def point_from_values(*args)
+	    Geometry::Point[args.flatten.reverse.drop_while {|a| not a }.reverse]
+	end
+    end
+
+    class Circle < Entity
+	attr_accessor :x, :y, :z
+	attr_accessor :radius
+
+	def parse_pair(code, value)
+	    case code
+		when '10'   then self.x = value.to_f
+		when '20'   then self.y = value.to_f
+		when '30'   then self.z = value.to_f
+		when '40'   then self.radius = value.to_f
+		else
+		    super   # Handle common and unrecognized codes
+	    end
+	end
+
+	# @!attribute [r] center
+	#   @return [Point]  the composed center of the {Circle}
+	def center
+	    a = [x, y, z]
+	    a.pop until a.last
+	    Geometry::Point[*a]
+	end
+    end
+
+    class Line < Entity
+	attr_reader :first, :last
+	attr_accessor :x1, :y1, :z1
+	attr_accessor :x2, :y2, :z2
+
+	def parse_pair(code, value)
+	    case code
+		when '10'   then self.x1 = value.to_f
+		when '20'   then self.y1 = value.to_f
+		when '30'   then self.z1 = value.to_f
+		when '11'   then self.x2 = value.to_f
+		when '21'   then self.y2 = value.to_f
+		when '31'   then self.z2 = value.to_f
+		else
+		    super   # Handle common and unrecognized codes
+	    end
+	end
+
+	def initialize(*args)
+	    @first, @last = *args
+	end
+
+	# @!attribute [r] first
+	#   @return [Point]  the starting point of the {Line}
+	def first
+	    @first ||= point_from_values(x1, y1, z1)
+	end
+
+	# @!attribute [r] last
+	#   @return [Point]  the end point of the {Line}
+	def last
+	    @last ||= point_from_values(x2, y2, z2)
+	end
+    end
+
+    class LWPolyline < Entity
+	# @!attribute points
+	#   @return [Array<Point>]  The points that make up the polyline
+	attr_reader :points
+
+	def initialize(*points)
+	    @points = points.map {|a| Point[a]}
+	end
+
+	# Return the individual line segments
+	def lines
+	    points.each_cons(2).map {|a,b| Line.new a, b}
+	end
+    end
+
+    class Spline < Entity
+	attr_reader :degree
+	attr_reader :knots
+	attr_reader :points
+
+	def initialize(degree:nil, knots:[], points:nil)
+	    @degree = degree
+	    @knots = knots || []
+	    @points = points || []
+	end
+    end
+
+    class Bezier < Spline
+	# @!attribute degree
+	#   @return [Number]  The degree of the curve
+	def degree
+	    points.length - 1
+	end
+
+	# @!attribute points
+	#   @return [Array<Point>]  The control points for the Bézier curve
+	attr_reader :points
+
+	def initialize(*points)
+	    @points = points.map {|v| Geometry::Point[v]}
+	end
+
+	# http://en.wikipedia.org/wiki/Binomial_coefficient
+	# http://rosettacode.org/wiki/Evaluate_binomial_coefficients#Ruby
+	def binomial_coefficient(k)
+	    (0...k).inject(1) {|m,i| (m * (degree - i)) / (i + 1) }
+	end
+
+	# @param t [Float]  the input parameter
+	def [](t)
+	    return nil unless (0..1).include?(t)
+	    result = Geometry::Point.zero(points.first.size)
+	    points.each_with_index do |v, i|
+		result += v * binomial_coefficient(i) * ((1 - t) ** (degree - i)) * (t ** i)
+	    end
+	    result
+	end
+
+	# Convert the {Bezier} into the given number of line segments
+	def lines(count=20)
+	    (0..1).step(1.0/count).map {|t| self[t]}.each_cons(2).map {|a,b| Line.new a, b}
+	end
+    end
+end

data/lib/dxf/parser.rb

@@ -0,0 +1,248 @@
+require_relative 'entity'
+
+module DXF
+    class Parser
+	ParseError = Class.new(StandardError)
+
+	# @!attribute entities
+	#   @return [Array]  the entities that comprise the drawing
+	attr_accessor :entities
+
+	# @!attribute header
+	#   @return [Hash]  the header variables
+	attr_accessor :header
+
+	def initialize(units=:mm)
+	    @entities = []
+	    @header = {}
+	end
+
+	def parse(io)
+	    parse_pairs io do |code, value|
+		next if '999' == code
+		raise ParseError, "DXF files must begin with group code 0, not #{code}" unless '0' == code
+		raise ParseError, "Expecting a SECTION, not #{value}" unless 'SECTION' == value
+		parse_section(io)
+	    end
+	    self
+	end
+
+	private
+
+	def read_pair(io)
+	    code = io.gets.strip
+	    value = io.gets.strip
+	    value = case code.to_i
+		when 1..9
+		    value.to_s
+		when 10..18, 20..28, 30..37, 40..49
+		    value.to_f
+		when 50..58
+		    value.to_f	# degrees
+		when 70..78, 90..99, 270..289
+		    value.to_i
+		else
+		    value
+	    end
+
+	    [code, value]
+	end
+
+	def parse_pairs(io, &block)
+	    while not io.eof?
+		code, value = read_pair(io)
+		case [code, value]
+		    when ['0', 'ENDSEC']
+			yield code, value   # Allow the handler a chance to clean up
+			return
+		    when ['0', 'EOF']	    then return
+		    else
+			yield code, value
+		end
+	    end
+	end
+
+	def parse_section(io)
+	    code, value = read_pair(io)
+	    raise ParseError, 'SECTION must be followed by a section type' unless '2' == code
+
+	    case value
+		when 'BLOCKS' then parse_pairs(io) {|code, value|}  # Ignore until implemented
+		when 'CLASSES' then parse_pairs(io) {|code, value|}  # Ignore until implemented
+		when 'ENTITIES'
+		    parse_entities(io)
+		when 'HEADER'
+		    parse_header(io)
+		when 'OBJECTS' then parse_pairs(io) {|code, value|}  # Ignore until implemented
+		when 'TABLES' then parse_pairs(io) {|code, value|}  # Ignore until implemented
+#		when 'THUMBNAILIMAGE'
+		else
+		    raise ParseError, "Unrecognized section type '#{value}'"
+	    end
+	end
+
+	# Parse the ENTITIES section
+	def parse_entities(io)
+	    parser = nil
+	    parse_pairs io do |code, value|
+		if 0 == code.to_i
+		    if parser
+			entities.push parser.to_entity
+			parser = nil
+		    end
+
+		    # Nothing to do
+		    next if 'ENDSEC' == value
+
+		    if 'LWPOLYLINE' == value
+			parser = EntityParser.new(value)
+		    elsif 'SPLINE' == value
+			parser = SplineParser.new
+		    else
+			entities.push Entity.new(value)
+		    end
+		elsif parser
+		    parser.parse_pair(code.to_i, value)
+		else
+		    entities.last.parse_pair(code, value)
+		end
+	    end
+	end
+
+	# Parse the HEADER section
+	def parse_header(io)
+	    variable_name = nil
+	    parse_pairs io do |code, value|
+		case code
+		    when '0' then next
+		    when '9'
+			variable_name = value
+		    else
+			header[variable_name] = value
+		end
+	    end
+	end
+
+# @group Helpers
+	def self.code_to_symbol(code)
+	    case code
+		when 10..13 then :x
+		when 20..23 then :y
+		when 30..33 then :z
+	    end
+	end
+
+	def self.update_point(point, x:nil, y:nil, z:nil)
+	    a = point ? point.to_a : []
+	    a[0] = x if x
+	    a[1] = y if y
+	    a[2] = z if z
+	    Geometry::Point[a]
+	end
+# @endgroup
+    end
+
+    class EntityParser
+	# @!attribute points
+	#   @return [Array]  points
+	attr_accessor :points
+
+	attr_reader :handle
+	attr_reader :layer
+
+	def initialize(type_name)
+	    @flags = nil
+	    @points = Array.new { Point.new }
+	    @type_name = type_name
+
+	    @point_index = Hash.new {|h,k| h[k] = 0}
+	end
+
+	def parse_pair(code, value)
+	    case code
+		when 5 then	@handle = value		# Fixed
+		when 8 then	@layer = value		# Fixed
+		when 62 then	@color_number = value   # Fixed
+		when 10, 20, 30
+		    k = Parser.code_to_symbol(code)
+		    i = @point_index[k]
+		    @points[i] = Parser.update_point(@points[i], k => value)
+		    @point_index[k] += 1
+		when 70	then	@flags = value
+	    end
+	end
+
+	def to_entity
+	    case @type_name
+		when 'LWPOLYLINE' then LWPolyline.new(*points)
+	    end
+	end
+    end
+
+    class SplineParser < EntityParser
+	# @!attribute points
+	#   @return [Array]  points
+	attr_accessor :points
+
+	attr_reader :closed, :periodic, :rational, :planar, :linear
+	attr_reader :degree
+	attr_reader :knots
+
+	def initialize
+	    super 'SPLINE'
+	    @fit_points = []
+	    @knots = []
+	    @weights = []
+
+	    @fit_point_index = Hash.new {|h,k| h[k] = 0}
+	end
+
+	def parse_pair(code, value)
+	    case code
+		when 11, 21, 31
+		    k = Parser.code_to_symbol(code)
+		    i = @fit_point_index[k]
+		    @fit_points[i] = Parser.update_point(@fit_points[i], k => value)
+		    @fit_point_index[k] += 1
+		when 12, 22, 32 then    @start_tangent = update_point(@start_tangent, Parser.code_to_symbol(code) => value)
+		when 13, 23, 33 then    @end_tangent = update_point(@end_tangent, Parser.code_to_symbol(code) => value)
+		when 40 then    knots.push value.to_f
+		when 41 then    @weights.push value
+		when 42 then    @knot_tolerance = value
+		when 43 then    @control_tolerance = value
+		when 44 then    @fit_tolerance = value
+		when 70
+		    value = value.to_i
+		    @closed = value[0].zero? ? nil : true
+		    @periodic = value[1].zero? ? nil : true
+		    @rational = value[2].zero? ? nil : true
+		    @planar = value[3].zero? ? nil : true
+		    @linear = value[4].zero? ? nil : true
+		when 71 then    @degree = value
+		when 72 then    @num_knots = value
+		when 73 then    @num_control_points = value
+		when 74 then    @num_fit_points = value
+		else
+		    super
+	    end
+	end
+
+	def to_entity
+	    raise ParseError, "Wrong number of control points" unless points.size == @num_control_points
+
+	    # If all of the points lie in the XY plane, remove the Z component from each point
+	    if planar && points.all? {|a| a.z.zero?}
+		@points.map! {|a| Geometry::Point[a[0, 2]]}
+	    end
+
+	    if knots.size == 2*points.size
+		# Bezier?
+		if knots[0,points.size].all?(&:zero?) && (knots[-points.size,points.size].uniq.size==1)
+		    Bezier.new *points
+		end
+	    else
+		Spline.new degree:degree, knots:knots, points:points
+	    end
+	end
+    end
+end