Class: RGeo::Cartesian::Factory

Inherits:
Object
  • Object
show all
Includes:
Feature::Factory::Instance, ImplHelper::Utils
Defined in:
lib/rgeo/cartesian/factory.rb

Overview

This class implements the factory for the simple cartesian implementation.

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(opts = {}) ⇒ Factory

Create a new simple cartesian factory.

See RGeo::Cartesian.simple_factory for a list of supported options.


22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
# File 'lib/rgeo/cartesian/factory.rb', line 22

def initialize(opts = {})
  @has_z = opts[:has_z_coordinate] ? true : false
  @has_m = opts[:has_m_coordinate] ? true : false
  @coordinate_dimension = 2
  @coordinate_dimension += 1 if @has_z
  @coordinate_dimension += 1 if @has_m
  @spatial_dimension = @has_z ? 3 : 2

  @proj4 = opts[:proj4]
  if @proj4 && CoordSys.check!(:proj4)
    if @proj4.is_a?(String) || @proj4.is_a?(Hash)
      @proj4 = CoordSys::Proj4.create(@proj4)
    end
  end
  srid = opts[:srid]
  @coord_sys = opts[:coord_sys]
  if @coord_sys.is_a?(String)
    @coord_sys = CoordSys::CS.create_from_wkt(@coord_sys)
  end
  srid ||= @coord_sys.authority_code if @coord_sys
  @srid = srid.to_i
  @buffer_resolution = opts[:buffer_resolution].to_i
  @buffer_resolution = 1 if @buffer_resolution < 1

  wkt_generator = opts[:wkt_generator]
  case wkt_generator
  when Hash
    @wkt_generator = WKRep::WKTGenerator.new(wkt_generator)
  else
    @wkt_generator = WKRep::WKTGenerator.new(convert_case: :upper)
  end
  wkb_generator = opts[:wkb_generator]
  case wkb_generator
  when Hash
    @wkb_generator = WKRep::WKBGenerator.new(wkb_generator)
  else
    @wkb_generator = WKRep::WKBGenerator.new
  end
  wkt_parser = opts[:wkt_parser]
  case wkt_parser
  when Hash
    @wkt_parser = WKRep::WKTParser.new(self, wkt_parser)
  else
    @wkt_parser = WKRep::WKTParser.new(self)
  end
  wkb_parser = opts[:wkb_parser]
  case wkb_parser
  when Hash
    @wkb_parser = WKRep::WKBParser.new(self, wkb_parser)
  else
    @wkb_parser = WKRep::WKBParser.new(self)
  end
end

Instance Attribute Details

#coord_sysObject (readonly)

See RGeo::Feature::Factory#coord_sys


275
276
277
# File 'lib/rgeo/cartesian/factory.rb', line 275

def coord_sys
  @coord_sys
end

#coordinate_dimensionObject (readonly)

Returns the value of attribute coordinate_dimension.


75
76
77
# File 'lib/rgeo/cartesian/factory.rb', line 75

def coordinate_dimension
  @coordinate_dimension
end

#proj4Object (readonly)

See RGeo::Feature::Factory#proj4


271
272
273
# File 'lib/rgeo/cartesian/factory.rb', line 271

def proj4
  @proj4
end

#spatial_dimensionObject (readonly)

Returns the value of attribute spatial_dimension.


75
76
77
# File 'lib/rgeo/cartesian/factory.rb', line 75

def spatial_dimension
  @spatial_dimension
end

#sridObject (readonly)

Returns the SRID.


186
187
188
# File 'lib/rgeo/cartesian/factory.rb', line 186

def srid
  @srid
end

Instance Method Details

#collection(elems) ⇒ Object

See RGeo::Feature::Factory#collection


247
248
249
# File 'lib/rgeo/cartesian/factory.rb', line 247

def collection(elems)
  GeometryCollectionImpl.new(self, elems)
end

#encode_with(coder) ⇒ Object

Psych support


139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
# File 'lib/rgeo/cartesian/factory.rb', line 139

def encode_with(coder) # :nodoc:
  coder["has_z_coordinate"] = @has_z
  coder["has_m_coordinate"] = @has_m
  coder["srid"] = @srid
  coder["buffer_resolution"] = @buffer_resolution
  coder["wkt_generator"] = @wkt_generator.properties
  coder["wkb_generator"] = @wkb_generator.properties
  coder["wkt_parser"] = @wkt_parser.properties
  coder["wkb_parser"] = @wkb_parser.properties
  if @proj4
    str = @proj4.original_str || @proj4.canonical_str
    coder["proj4"] = @proj4.radians? ? { "proj4" => str, "radians" => true } : str
  end
  coder["coord_sys"] = @coord_sys.to_wkt if @coord_sys
end

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

Equivalence test.

Returns:

  • (Boolean)

79
80
81
82
83
84
# File 'lib/rgeo/cartesian/factory.rb', line 79

def eql?(rhs)
  rhs.is_a?(self.class) && @srid == rhs.srid &&
    @has_z == rhs.property(:has_z_coordinate) &&
    @has_m == rhs.property(:has_m_coordinate) &&
    @proj4.eql?(rhs.proj4)
end

#generate_wkb(obj) ⇒ Object


281
282
283
# File 'lib/rgeo/cartesian/factory.rb', line 281

def generate_wkb(obj)
  @wkb_generator.generate(obj)
end

#generate_wkt(obj) ⇒ Object


277
278
279
# File 'lib/rgeo/cartesian/factory.rb', line 277

def generate_wkt(obj)
  @wkt_generator.generate(obj)
end

#hashObject

Standard hash code


89
90
91
# File 'lib/rgeo/cartesian/factory.rb', line 89

def hash
  @hash ||= [@srid, @has_z, @has_m, @proj4].hash
end

#init_with(coder) ⇒ Object

:nodoc:


155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
# File 'lib/rgeo/cartesian/factory.rb', line 155

def init_with(coder) # :nodoc:
  if (proj4_data = coder["proj4"]) && CoordSys.check!(:proj4)
    if proj4_data.is_a?(Hash)
      proj4 = CoordSys::Proj4.create(proj4_data["proj4"], radians: proj4_data["radians"])
    else
      proj4 = CoordSys::Proj4.create(proj4_data.to_s)
    end
  else
    proj4 = nil
  end
  if (coord_sys_data = coder["cs"])
    coord_sys = CoordSys::CS.create_from_wkt(coord_sys_data.to_s)
  else
    coord_sys = nil
  end
  initialize(
    has_z_coordinate: coder["has_z_coordinate"],
    has_m_coordinate: coder["has_m_coordinate"],
    srid: coder["srid"],
    wkt_generator: symbolize_hash(coder["wkt_generator"]),
    wkb_generator: symbolize_hash(coder["wkb_generator"]),
    wkt_parser: symbolize_hash(coder["wkt_parser"]),
    wkb_parser: symbolize_hash(coder["wkb_parser"]),
    buffer_resolution: coder["buffer_resolution"],
    proj4: proj4,
    coord_sys: coord_sys
  )
end

#line(start, stop) ⇒ Object

See RGeo::Feature::Factory#line


229
230
231
# File 'lib/rgeo/cartesian/factory.rb', line 229

def line(start, stop)
  LineImpl.new(self, start, stop)
end

#line_string(points) ⇒ Object

See RGeo::Feature::Factory#line_string


223
224
225
# File 'lib/rgeo/cartesian/factory.rb', line 223

def line_string(points)
  LineStringImpl.new(self, points)
end

#linear_ring(points) ⇒ Object

See RGeo::Feature::Factory#linear_ring


235
236
237
# File 'lib/rgeo/cartesian/factory.rb', line 235

def linear_ring(points)
  LinearRingImpl.new(self, points)
end

#marshal_dumpObject

Marshal support


95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
# File 'lib/rgeo/cartesian/factory.rb', line 95

def marshal_dump # :nodoc:
  hash_ = {
    "hasz" => @has_z,
    "hasm" => @has_m,
    "srid" => @srid,
    "wktg" => @wkt_generator.properties,
    "wkbg" => @wkb_generator.properties,
    "wktp" => @wkt_parser.properties,
    "wkbp" => @wkb_parser.properties,
    "bufr" => @buffer_resolution
  }
  hash_["proj4"] = @proj4.marshal_dump if @proj4
  hash_["cs"] = @coord_sys.to_wkt if @coord_sys
  hash_
end

#marshal_load(data) ⇒ Object

:nodoc:


111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
# File 'lib/rgeo/cartesian/factory.rb', line 111

def marshal_load(data) # :nodoc:
  if (proj4_data = data["proj4"]) && CoordSys.check!(:proj4)
    proj4 = CoordSys::Proj4.allocate
    proj4.marshal_load(proj4_data)
  else
    proj4 = nil
  end
  if (coord_sys_data = data["cs"])
    coord_sys = CoordSys::CS.create_from_wkt(coord_sys_data)
  else
    coord_sys = nil
  end
  initialize(
    has_z_coordinate: data["hasz"],
    has_m_coordinate: data["hasm"],
    srid: data["srid"],
    wkt_generator: symbolize_hash(data["wktg"]),
    wkb_generator: symbolize_hash(data["wkbg"]),
    wkt_parser: symbolize_hash(data["wktp"]),
    wkb_parser: symbolize_hash(data["wkbp"]),
    buffer_resolution: data["bufr"],
    proj4: proj4,
    coord_sys: coord_sys
  )
end

#marshal_wkb_generatorObject


285
286
287
# File 'lib/rgeo/cartesian/factory.rb', line 285

def marshal_wkb_generator
  @marshal_wkb_generator ||= RGeo::WKRep::WKBGenerator.new(type_format: :wkb12)
end

#marshal_wkb_parserObject


289
290
291
# File 'lib/rgeo/cartesian/factory.rb', line 289

def marshal_wkb_parser
  @marshal_wkb_parser ||= RGeo::WKRep::WKBParser.new(self, support_wkb12: true)
end

#multi_line_string(elems) ⇒ Object

See RGeo::Feature::Factory#multi_line_string


259
260
261
# File 'lib/rgeo/cartesian/factory.rb', line 259

def multi_line_string(elems)
  MultiLineStringImpl.new(self, elems)
end

#multi_point(elems) ⇒ Object

See RGeo::Feature::Factory#multi_point


253
254
255
# File 'lib/rgeo/cartesian/factory.rb', line 253

def multi_point(elems)
  MultiPointImpl.new(self, elems)
end

#multi_polygon(elems) ⇒ Object

See RGeo::Feature::Factory#multi_polygon


265
266
267
# File 'lib/rgeo/cartesian/factory.rb', line 265

def multi_polygon(elems)
  MultiPolygonImpl.new(self, elems)
end

#parse_wkb(str) ⇒ Object

See RGeo::Feature::Factory#parse_wkb


211
212
213
# File 'lib/rgeo/cartesian/factory.rb', line 211

def parse_wkb(str)
  @wkb_parser.parse(str)
end

#parse_wkt(str) ⇒ Object

See RGeo::Feature::Factory#parse_wkt


205
206
207
# File 'lib/rgeo/cartesian/factory.rb', line 205

def parse_wkt(str)
  @wkt_parser.parse(str)
end

#point(x, y, *extra) ⇒ Object

See RGeo::Feature::Factory#point


217
218
219
# File 'lib/rgeo/cartesian/factory.rb', line 217

def point(x, y, *extra)
  PointImpl.new(self, x, y, *extra)
end

#polygon(outer_ring, inner_rings = nil) ⇒ Object

See RGeo::Feature::Factory#polygon


241
242
243
# File 'lib/rgeo/cartesian/factory.rb', line 241

def polygon(outer_ring, inner_rings = nil)
  PolygonImpl.new(self, outer_ring, inner_rings)
end

#property(name) ⇒ Object

See RGeo::Feature::Factory#property


190
191
192
193
194
195
196
197
198
199
200
201
# File 'lib/rgeo/cartesian/factory.rb', line 190

def property(name)
  case name
  when :has_z_coordinate
    @has_z
  when :has_m_coordinate
    @has_m
  when :buffer_resolution
    @buffer_resolution
  when :is_cartesian
    true
  end
end

#psych_wkt_generatorObject


293
294
295
# File 'lib/rgeo/cartesian/factory.rb', line 293

def psych_wkt_generator
  @psych_wkt_generator ||= RGeo::WKRep::WKTGenerator.new(tag_format: :wkt12)
end

#psych_wkt_parserObject


297
298
299
# File 'lib/rgeo/cartesian/factory.rb', line 297

def psych_wkt_parser
  @psych_wkt_parser ||= RGeo::WKRep::WKTParser.new(self, support_wkt12: true, support_ewkt: true)
end