Module: RGeo::Geos::FFIGeometryMethods

Includes:
Feature::Instance
Included in:
FFIGeometryCollectionImpl, FFIGeometryImpl, FFILineImpl, FFILineStringImpl, FFILinearRingImpl, FFIMultiLineStringImpl, FFIMultiPointImpl, FFIMultiPolygonImpl, FFIPointImpl, FFIPolygonImpl
Defined in:
lib/rgeo/geos/ffi_feature_methods.rb

Overview

:nodoc:

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#_klasses ⇒ Object (readonly)

:nodoc:


60
61
62
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 60

def _klasses
  @_klasses
end

#factory ⇒ Object (readonly)

Returns the value of attribute factory.


57
58
59
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 57

def factory
  @factory
end

#fg_geom ⇒ Object (readonly)

Returns the value of attribute fg_geom.


58
59
60
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 58

def fg_geom
  @fg_geom
end

Instance Method Details

#as_binary ⇒ Object 


112
113
114
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 112

def as_binary
  @factory.generate_wkb(self)
end

#as_text ⇒ Object Also known as: to_s 


105
106
107
108
109
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 105

def as_text
  str = @factory.generate_wkt(self)
  str.force_encoding("US-ASCII") if str.respond_to?(:force_encoding)
  str
end

#boundary ⇒ Object 


97
98
99
100
101
102
103
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 97

def boundary
  if self.class == FFIGeometryCollectionImpl
    nil
  else
    @factory.wrap_fg_geom(@fg_geom.boundary, nil)
  end
end

#buffer(distance) ⇒ Object 


230
231
232
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 230

def buffer(distance)
  @factory.wrap_fg_geom(@fg_geom.buffer(distance, @factory.buffer_resolution), nil)
end

#contains?(rhs) ⇒ Boolean

Returns:

  • (Boolean) 

199
200
201
202
203
204
205
206
207
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 199

def contains?(rhs)
  fg = factory.convert_to_fg_geometry(rhs)
  if fg
    prep = request_prepared if Utils.ffi_supports_prepared_level_1
    prep ? prep.contains?(fg) : @fg_geom.contains?(fg)
  else
    false
  end
end

#convex_hull ⇒ Object 


234
235
236
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 234

def convex_hull
  @factory.wrap_fg_geom(@fg_geom.convex_hull, nil)
end

#crosses?(rhs) ⇒ Boolean

Returns:

  • (Boolean) 

179
180
181
182
183
184
185
186
187
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 179

def crosses?(rhs)
  fg = factory.convert_to_fg_geometry(rhs)
  if fg
    prep = request_prepared if Utils.ffi_supports_prepared_level_2
    prep ? prep.crosses?(fg) : @fg_geom.crosses?(fg)
  else
    false
  end
end

#detach_fg_geom ⇒ Object 


273
274
275
276
277
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 273

def detach_fg_geom
  fg = @fg_geom
  @fg_geom = nil
  fg
end

#difference(rhs) ⇒ Object Also known as: - 


257
258
259
260
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 257

def difference(rhs)
  fg = factory.convert_to_fg_geometry(rhs)
  fg ? @factory.wrap_fg_geom(@fg_geom.difference(fg), nil) : nil
end

#dimension ⇒ Object 


74
75
76
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 74

def dimension
  Utils.ffi_compute_dimension(@fg_geom)
end

#disjoint?(rhs) ⇒ Boolean

Returns:

  • (Boolean) 

149
150
151
152
153
154
155
156
157
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 149

def disjoint?(rhs)
  fg = factory.convert_to_fg_geometry(rhs)
  if fg
    prep = request_prepared if Utils.ffi_supports_prepared_level_2
    prep ? prep.disjoint?(fg) : @fg_geom.disjoint?(fg)
  else
    false
  end
end

#distance(rhs) ⇒ Object 


225
226
227
228
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 225

def distance(rhs)
  fg = factory.convert_to_fg_geometry(rhs)
  fg ? @fg_geom.distance(fg) : nil
end

#empty? ⇒ Boolean

Returns:

  • (Boolean) 

116
117
118
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 116

def empty?
  @fg_geom.empty?
end

#encode_with(coder) ⇒ Object

Psych support


42
43
44
45
46
47
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 42

def encode_with(coder) # :nodoc:
  coder["factory"] = @factory
  str = @factory.write_for_psych(self)
  str = str.encode("US-ASCII") if str.respond_to?(:encode)
  coder["wkt"] = str
end

#envelope ⇒ Object 


93
94
95
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 93

def envelope
  @factory.wrap_fg_geom(@fg_geom.envelope, nil)
end

#eql?(rhs) ⇒ Boolean

Returns:

  • (Boolean) 

269
270
271
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 269

def eql?(rhs)
  rep_equals?(rhs)
end

#equals?(rhs) ⇒ Boolean Also known as: ==

Returns:

  • (Boolean) 

134
135
136
137
138
139
140
141
142
143
144
145
146
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 134

def equals?(rhs)
  return false unless rhs.is_a?(RGeo::Feature::Instance)
  fg = factory.convert_to_fg_geometry(rhs)
  if !fg
    false
  # GEOS has a bug where empty geometries are not spatially equal
  # to each other. Work around this case first.
  elsif fg.empty? && @fg_geom.empty?
    true
  else
    @fg_geom.eql?(fg)
  end
end

#geometry_type ⇒ Object 


78
79
80
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 78

def geometry_type
  Feature::Geometry
end

#init_with(coder) ⇒ Object

:nodoc:


49
50
51
52
53
54
55
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 49

def init_with(coder) # :nodoc:
  @factory = coder["factory"]
  @fg_geom = @factory.read_for_psych(coder["wkt"])
  @fg_geom.srid = @factory.srid
  @_fg_prep = @factory._auto_prepare ? 1 : 0
  @_klasses = nil
end

#initialize(factory, fg_geom, klasses) ⇒ Object 


14
15
16
17
18
19
20
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 14

def initialize(factory, fg_geom, klasses)
  @factory = factory
  @fg_geom = fg_geom
  @_fg_prep = factory._auto_prepare ? 1 : 0
  @_klasses = klasses
  fg_geom.srid = factory.srid
end

#initialize_copy(orig) ⇒ Object 


62
63
64
65
66
67
68
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 62

def initialize_copy(orig)
  @factory = orig.factory
  @fg_geom = orig.fg_geom.clone
  @fg_geom.srid = orig.fg_geom.srid
  @_fg_prep = @factory._auto_prepare ? 1 : 0
  @_klasses = orig._klasses
end

#inspect ⇒ Object 


22
23
24
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 22

def inspect
  "#<#{self.class}:0x#{object_id.to_s(16)} #{as_text.inspect}>"
end

#intersection(rhs) ⇒ Object Also known as: * 


238
239
240
241
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 238

def intersection(rhs)
  fg = factory.convert_to_fg_geometry(rhs)
  fg ? @factory.wrap_fg_geom(@fg_geom.intersection(fg), nil) : nil
end

#intersects?(rhs) ⇒ Boolean

Returns:

  • (Boolean) 

159
160
161
162
163
164
165
166
167
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 159

def intersects?(rhs)
  fg = factory.convert_to_fg_geometry(rhs)
  if fg
    prep = request_prepared if Utils.ffi_supports_prepared_level_1
    prep ? prep.intersects?(fg) : @fg_geom.intersects?(fg)
  else
    false
  end
end

#is_empty? ⇒ Boolean

Returns:

  • (Boolean) 

120
121
122
123
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 120

def is_empty?
  warn "The is_empty? method is deprecated, please use the empty? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
  empty?
end

#is_simple? ⇒ Boolean

Returns:

  • (Boolean) 

129
130
131
132
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 129

def is_simple?
  warn "The is_simple? method is deprecated, please use the simple? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
  simple?
end

#marshal_dump ⇒ Object

Marshal support


28
29
30
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 28

def marshal_dump # :nodoc:
  [@factory, @factory.write_for_marshal(self)]
end

#marshal_load(data) ⇒ Object

:nodoc:


32
33
34
35
36
37
38
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 32

def marshal_load(data) # :nodoc:
  @factory = data[0]
  @fg_geom = @factory.read_for_marshal(data[1])
  @fg_geom.srid = @factory.srid
  @_fg_prep = @factory._auto_prepare ? 1 : 0
  @_klasses = nil
end

#overlaps?(rhs) ⇒ Boolean

Returns:

  • (Boolean) 

209
210
211
212
213
214
215
216
217
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 209

def overlaps?(rhs)
  fg = factory.convert_to_fg_geometry(rhs)
  if fg
    prep = request_prepared if Utils.ffi_supports_prepared_level_2
    prep ? prep.overlaps?(fg) : @fg_geom.overlaps?(fg)
  else
    false
  end
end

#point_on_surface ⇒ Object 


279
280
281
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 279

def point_on_surface
  @factory.wrap_fg_geom(@fg_geom.point_on_surface, FFIPointImpl)
end

#prepare! ⇒ Object 


86
87
88
89
90
91
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 86

def prepare!
  if @_fg_prep.is_a?(Integer)
    @_fg_prep = ::Geos::PreparedGeometry.new(@fg_geom)
  end
  self
end

#prepared? ⇒ Boolean

Returns:

  • (Boolean) 

82
83
84
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 82

def prepared?
  !@_fg_prep.is_a?(Integer)
end

#relate?(rhs, pattern) ⇒ Boolean Also known as: relate

Returns:

  • (Boolean) 

219
220
221
222
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 219

def relate?(rhs, pattern)
  fg = factory.convert_to_fg_geometry(rhs)
  fg ? @fg_geom.relate_pattern(fg, pattern) : nil
end

#simple? ⇒ Boolean

Returns:

  • (Boolean) 

125
126
127
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 125

def simple?
  @fg_geom.simple?
end

#srid ⇒ Object 


70
71
72
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 70

def srid
  @fg_geom.srid
end

#sym_difference(rhs) ⇒ Object 


264
265
266
267
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 264

def sym_difference(rhs)
  fg = factory.convert_to_fg_geometry(rhs)
  fg ? @factory.wrap_fg_geom(@fg_geom.sym_difference(fg), nil) : nil
end

#touches?(rhs) ⇒ Boolean

Returns:

  • (Boolean) 

169
170
171
172
173
174
175
176
177
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 169

def touches?(rhs)
  fg = factory.convert_to_fg_geometry(rhs)
  if fg
    prep = request_prepared if Utils.ffi_supports_prepared_level_2
    prep ? prep.touches?(fg) : @fg_geom.touches?(fg)
  else
    false
  end
end

#unary_union ⇒ Object 


252
253
254
255
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 252

def unary_union
  return unless @fg_geom.respond_to?(:unary_union)
  @factory.wrap_fg_geom(@fg_geom.unary_union)
end

#union(rhs) ⇒ Object Also known as: + 


245
246
247
248
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 245

def union(rhs)
  fg = factory.convert_to_fg_geometry(rhs)
  fg ? @factory.wrap_fg_geom(@fg_geom.union(fg), nil) : nil
end

#within?(rhs) ⇒ Boolean

Returns:

  • (Boolean) 

189
190
191
192
193
194
195
196
197
 
# File 'lib/rgeo/geos/ffi_feature_methods.rb', line 189

def within?(rhs)
  fg = factory.convert_to_fg_geometry(rhs)
  if fg
    prep = request_prepared if Utils.ffi_supports_prepared_level_2
    prep ? prep.within?(fg) : @fg_geom.within?(fg)
  else
    false
  end
end