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

Parameters:

Returns:



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

Parameters:

Returns:



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

Parameters:

Returns:



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

Parameters:

  • wkt_data (String)
  • spatial_ref (FFI::Pointer) (defaults to: nil) —

    Optional spatial reference to assign to the new geometry.

Returns:



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.

Parameters:

Returns:



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.

Parameters:

  • main (FFI::OGR::WKBGeometryType)
  • extra (FFI::OGR::WKBGeometryType)

Returns:

  • (FFI::OGR::WKBGeometryType) —

    Returns :wkbUnknown when there is no type in common.



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

Parameters:

  • pointer (FFI::Pointer) 


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.

Parameters:

  • type (FFI::OGR::WKBGeometryType)

Returns:



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