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:



105
106
107
108
109
 
# File 'lib/ogr/geometry.rb', line 105

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:



113
114
115
116
117
 
# File 'lib/ogr/geometry.rb', line 113

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:



87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
# File 'lib/ogr/geometry.rb', line 87

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:



65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
 
# File 'lib/ogr/geometry.rb', line 65

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

def factory(geometry)
  geometry =
    if geometry.is_a?(OGR::Geometry)
      geometry
    else
      OGR::UnknownGeometry.new(geometry)
    end

  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.



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

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

#release(pointer) ⇒ Object

Parameters:

  • pointer (FFI::Pointer) 


143
144
145
146
147
 
# File 'lib/ogr/geometry.rb', line 143

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:



123
124
125
126
127
128
 
# File 'lib/ogr/geometry.rb', line 123

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

  name
end