Class: HexaPDF::Content::TransformationMatrix

Inherits:
Object
  • Object
show all
Includes:
Utils::MathHelpers
Defined in:
lib/hexapdf/content/transformation_matrix.rb

Overview

A TransformationMatrix is a matrix used in PDF graphics operations to specify the relationship between different coordinate systems.

All matrix operations modify the matrix in place. So if the original matrix should be preserved, duplicate it before the operation.

It is important to note that the matrix transforms from the new coordinate system to the untransformed coordinate system. This means that after the transformation all coordinates are specified in the new, transformed coordinate system and to get the untransformed coordinates the matrix needs to be applied.

Although all operations are done in 2D space the transformation matrix is a 3x3 matrix because homogeneous coordinates are used. This, however, also means that only six entries are actually used that are named like in the following graphic:

a b 0
c d 0
e f 1

Here is a simple transformation matrix to translate all coordinates by 5 units horizontally and 10 units vertically:

1  0 0
0  1 0
5 10 1

Details and some examples can be found in the PDF reference.

See: PDF2.0 s8.3

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Utils::MathHelpers

deg_to_rad, rad_to_deg

Constructor Details

#initialize(a = 1, b = 0, c = 0, d = 1, e = 0, f = 0) ⇒ TransformationMatrix

Initializes the transformation matrix with the given values.



94
95
96
97
98
99
100
101
 
# File 'lib/hexapdf/content/transformation_matrix.rb', line 94

def initialize(a = 1, b = 0, c = 0, d = 1, e = 0, f = 0)
  @a = a
  @b = b
  @c = c
  @d = d
  @e = e
  @f = f
end

Instance Attribute Details

#a ⇒ Object (readonly)

The value at the position (1,1) in the matrix.



76
77
78
 
# File 'lib/hexapdf/content/transformation_matrix.rb', line 76

def a
  @a
end

#b ⇒ Object (readonly)

The value at the position (1,2) in the matrix.



79
80
81
 
# File 'lib/hexapdf/content/transformation_matrix.rb', line 79

def b
  @b
end

#c ⇒ Object (readonly)

The value at the position (2,1) in the matrix.



82
83
84
 
# File 'lib/hexapdf/content/transformation_matrix.rb', line 82

def c
  @c
end

#d ⇒ Object (readonly)

The value at the position (2,2) in the matrix.



85
86
87
 
# File 'lib/hexapdf/content/transformation_matrix.rb', line 85

def d
  @d
end

#e ⇒ Object (readonly)

The value at the position (3,1) in the matrix.



88
89
90
 
# File 'lib/hexapdf/content/transformation_matrix.rb', line 88

def e
  @e
end

#f ⇒ Object (readonly)

The value at the position (3,2) in the matrix.



91
92
93
 
# File 'lib/hexapdf/content/transformation_matrix.rb', line 91

def f
  @f
end

Instance Method Details

#==(other) ⇒ Object

Returns true if the other object is a transformation matrix with the same values.



162
163
164
165
 
# File 'lib/hexapdf/content/transformation_matrix.rb', line 162

def ==(other)
  other.kind_of?(self.class) && @a == other.a && @b == other.b && @c == other.c &&
    @d == other.d && @e == other.e && @f == other.f
end

#evaluate(x, y) ⇒ Object

Returns the untransformed coordinates of the given point.



104
105
106
 
# File 'lib/hexapdf/content/transformation_matrix.rb', line 104

def evaluate(x, y)
  [@a * x + @c * y + @e, @b * x + @d * y + @f]
end

#premultiply(a, b, c, d, e, f) ⇒ Object

Transforms this matrix by premultiplying it with the given one (ie. given*this) and returns it.



147
148
149
150
151
152
153
154
155
156
157
158
159
 
# File 'lib/hexapdf/content/transformation_matrix.rb', line 147

def premultiply(a, b, c, d, e, f)
  a1 = a * @a + b * @c
  b1 = a * @b + b * @d
  c1 = c * @a + d * @c
  d1 = c * @b + d * @d
  @e = e * @a + f * @c + @e
  @f = e * @b + f * @d + @f
  @a = a1
  @b = b1
  @c = c1
  @d = d1
  self
end

#rotate(q) ⇒ Object

Rotates this matrix by an angle of q degrees and returns it.

This equal to premultiply(cos(rad(q)), sin(rad(q)), -sin(rad(q)), cos(rad(q)), x, y).



131
132
133
134
135
 
# File 'lib/hexapdf/content/transformation_matrix.rb', line 131

def rotate(q)
  cq = Math.cos(deg_to_rad(q))
  sq = Math.sin(deg_to_rad(q))
  premultiply(cq, sq, -sq, cq, 0, 0)
end

#scale(sx, sy) ⇒ Object

Scales this matrix by sx units horizontally and y units vertically and returns it.

This is equal to premultiply(sx, 0, 0, sy, 0, 0).



120
121
122
123
124
125
126
 
# File 'lib/hexapdf/content/transformation_matrix.rb', line 120

def scale(sx, sy)
  @a = sx * @a
  @b = sx * @b
  @c = sy * @c
  @d = sy * @d
  self
end

#skew(a, b) ⇒ Object

Skews this matrix by an angle of a degrees for the x axis and by an angle of b degrees for the y axis and returns it.

This is equal to premultiply(1, tan(rad(a)), tan(rad(b)), 1, x, y).



141
142
143
 
# File 'lib/hexapdf/content/transformation_matrix.rb', line 141

def skew(a, b)
  premultiply(1, Math.tan(deg_to_rad(a)), Math.tan(deg_to_rad(b)), 1, 0, 0)
end

#to_a ⇒ Object

Creates an array [a, b, c, d, e, f] from the transformation matrix.



168
169
170
 
# File 'lib/hexapdf/content/transformation_matrix.rb', line 168

def to_a
  [@a, @b, @c, @d, @e, @f]
end

#translate(x, y) ⇒ Object

Translates this matrix by x units horizontally and y units vertically and returns it.

This is equal to premultiply(1, 0, 0, 1, x, y).



111
112
113
114
115
 
# File 'lib/hexapdf/content/transformation_matrix.rb', line 111

def translate(x, y)
  @e = x * @a + y * @c + @e
  @f = x * @b + y * @d + @f
  self
end