Module: OGR::Geometry::ClassMethods

Included in:
OGR::Geometry
Defined in:
lib/ogr/geometry.rb

Instance Method Summary collapse

Instance Method Details

#create(type) ⇒ Object 



9
10
11
12
13
14
15
16
 
# File 'lib/ogr/geometry.rb', line 9

def create(type)
  geometry_pointer = FFI::OGR::API.OGR_G_CreateGeometry(type)
  return if geometry_pointer.null?

  geometry_pointer.autorelease = false

  factory(geometry_pointer)
end

#create_from_gml(gml_data) ⇒ OGR::Geometry 



100
101
102
103
104
 
# File 'lib/ogr/geometry.rb', line 100

def create_from_gml(gml_data)
  geometry_pointer = FFI::OGR::API.OGR_G_CreateFromGML(gml_data)

  _ = factory(geometry_pointer)
end

#create_from_json(json_data) ⇒ OGR::Geometry 



108
109
110
111
112
 
# File 'lib/ogr/geometry.rb', line 108

def create_from_json(json_data)
  geometry_pointer = FFI::OGR::API.OGR_G_CreateGeometryFromJson(json_data)

  factory(geometry_pointer)
end

#create_from_wkb(wkb_data, spatial_ref = nil) ⇒ OGR::Geometry 



82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
 
# File 'lib/ogr/geometry.rb', line 82

def create_from_wkb(wkb_data, spatial_ref = nil)
  wkb_data_pointer = FFI::MemoryPointer.new(:char, wkb_data.length)
  wkb_data_pointer.put_bytes(0, wkb_data)

  spatial_ref_pointer = GDAL._pointer(OGR::SpatialReference, spatial_ref) if spatial_ref

  geometry_ptr_ptr = GDAL._pointer_pointer(:pointer)

  byte_count = wkb_data.length
  FFI::OGR::API.OGR_G_CreateFromWkb(wkb_data_pointer, spatial_ref_pointer, geometry_ptr_ptr, byte_count)

  return if geometry_ptr_ptr.null? || geometry_ptr_ptr.read_pointer.null?

  factory(geometry_ptr_ptr.read_pointer)
end

#create_from_wkt(wkt_data, spatial_ref = nil) ⇒ OGR::Geometry 



60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/ogr/geometry.rb', line 60

def create_from_wkt(wkt_data, spatial_ref = nil)
  wkt_data_pointer = FFI::MemoryPointer.from_string(wkt_data)
  wkt_pointer_pointer = FFI::MemoryPointer.new(:pointer)
  wkt_pointer_pointer.write_pointer(wkt_data_pointer)

  spatial_ref_pointer = GDAL._pointer(OGR::SpatialReference, spatial_ref) if spatial_ref

  geometry_ptr = FFI::MemoryPointer.new(:pointer)
  geometry_ptr_ptr = FFI::MemoryPointer.new(:pointer)
  geometry_ptr_ptr.write_pointer(geometry_ptr)

  FFI::OGR::API.OGR_G_CreateFromWkt(wkt_pointer_pointer,
                                    spatial_ref_pointer, geometry_ptr_ptr)

  return if geometry_ptr_ptr.null? || geometry_ptr_ptr.read_pointer.null?

  factory(geometry_ptr_ptr.read_pointer)
end

#factory(geometry) ⇒ OGR::Geometry

Creates a new Geometry using the class of the geometry that the type represents.



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
 
# File 'lib/ogr/geometry.rb', line 23

def factory(geometry)
  geometry = OGR::UnknownGeometry.new(geometry) unless geometry.is_a?(OGR::Geometry)

  new_pointer = geometry.c_pointer
  return if new_pointer.nil? || new_pointer.null?

  case geometry.type
  when :wkbPoint then OGR::Point.new(new_pointer)
  when :wkbPoint25D then OGR::Point25D.new(new_pointer)
  when :wkbLineString
    if /^LINEARRING/.match?(geometry.to_wkt)
      OGR::LinearRing.new(new_pointer)
    else
      OGR::LineString.new(new_pointer)
    end
  when :wkbLineString25D then OGR::LineString25D.new(new_pointer)
  when :wkbLinearRing then OGR::LinearRing.new(new_pointer)
  when :wkbPolygon then OGR::Polygon.new(new_pointer)
  when :wkbPolygon25D then OGR::Polygon25D.new(new_pointer)
  when :wkbMultiPoint then OGR::MultiPoint.new(new_pointer)
  when :wkbMultiPoint25D then OGR::MultiPoint25D.new(new_pointer)
  when :wkbMultiLineString then OGR::MultiLineString.new(new_pointer)
  when :wkbMultiLineString25D then OGR::MultiLineString25D.new(new_pointer)
  when :wkbMultiPolygon then OGR::MultiPolygon.new(new_pointer)
  when :wkbMultiPolygon25D then OGR::MultiPolygon25D.new(new_pointer)
  when :wkbGeometryCollection then OGR::GeometryCollection.new(new_pointer)
  when :wkbGeometryCollection25D then OGR::GeometryCollection25D.new(new_pointer)
  when :wkbNone then OGR::NoneGeometry.new(new_pointer)
  else
    geometry
  end
end

#merge_geometry_types(main, extra) ⇒ FFI::OGR::WKBGeometryType

Finds the most specific common geometry type from the two given types. Useful when trying to figure out what geometry type to report for an entire layer, when the layer uses multiple types.



133
134
135
 
# File 'lib/ogr/geometry.rb', line 133

def merge_geometry_types(main, extra)
  FFI::OGR::Core.OGRMergeGeometryTypes(main, extra)
end

#release(pointer) ⇒ Object 



138
139
140
141
142
 
# File 'lib/ogr/geometry.rb', line 138

def release(pointer)
  return unless pointer && !pointer.null?

  FFI::OGR::API.OGR_G_DestroyGeometry(pointer)
end

#type_to_name(type) ⇒ String

The human-readable string for the geometry type.



118
119
120
121
122
123
 
# File 'lib/ogr/geometry.rb', line 118

def type_to_name(type)
  name, ptr = FFI::OGR::Core.OGRGeometryTypeToName(type)
  ptr.autorelease = false

  name
end