› › ›

Тип поля геоформы

Тип данных geo_shape облегчает индексацию и поиск с произвольными геофигурами, такими как прямоугольники, линии и многоугольники. Если индексируемые данные содержат фигуры, отличные от точек, необходимо использовать это отображение. Если данные содержат только точки, их можно индексировать как geo_point или geo_shape.

Документы, использующие этот тип, могут быть использованы:

для поиска геофигуры внутри:
- прямоугольника
- на определённом расстоянии от центральной точки
- запрос по геофигуре (например, пересечение многоугольников).
для агрегирования документов по географическим сеткам:
- либо geo_hash
- либо geo_tile
- либо geo_hex

Параметры отображения

Отображение geo_shape отображает объекты геометрии GeoJSON или WKT в тип geo_shape. Чтобы его включить, пользователи должны явно отобразить поля в тип geo_shape.

В GeoJSON и WKT, и, следовательно, в Elasticsearch, правильный порядок координат — долгота, широта (X, Y) внутри массивов координат. Это отличается от многих геопространственных API (например, Google Maps), которые обычно используют широту, долготу (Y, X).

Параметр	Описание	По умолчанию
`orientation`	Необязательно. Значение ориентации по умолчанию для WKT-многоугольников поля. Этот параметр устанавливает и возвращает только значение `RIGHT` (против часовой стрелки) или `LEFT` (по часовой стрелке). Однако вы можете указать любое значение несколькими способами. Для установки `RIGHT` используйте одно из следующих аргументов или его заглавную версию: `right` `counterclockwise` `ccw` Для установки `LEFT` используйте одно из следующих аргументов или его заглавную версию: `left` `clockwise` `cw`	`RIGHT`
`ignore_malformed`	Если значение true, некорректные геометрии GeoJSON или WKT игнорируются. Если false (по умолчанию), некорректные GeoJSON и WKT фигуры вызывают исключение и отклоняют весь документ.	`false`
`ignore_z_value`	Если `true` (по умолчанию), трёхмерные точки будут приниматься (хранятся в источнике), но индексироваться будут только значения широты и долготы; третья размерность игнорируется. Если `false`, геоточки, содержащие более чем два измерения (широта и долгота), вызывают исключение и отклоняют весь документ.	`true`
`coerce`	Если `true`, незамкнутые линейные кольца в многоугольниках будут автоматически закрываться.	`false`
`index`	Нужно ли быстро выполнять поиск по полю? Принимает `true` (по умолчанию) и `false`. Поля, для которых включен только `doc_values`, по-прежнему могут быть запрошены, хотя и медленнее.	`true`
`doc_values`	Следует ли хранить поле на диске в столбце-строке, чтобы оно затем могло быть использовано для агрегаций или сценариев?	`true`

Подход к индексированию

Типы геофигуры индексируются путём разбиения фигуры на треугольную сетку, и индексирование каждого треугольника как точки в 7 измерениях в дереве BKD. Это обеспечивает почти идеальное пространственное разрешение (до 1e-7 десятичных градусов) поскольку все пространственные отношения вычисляются с использованием закодированного векторного представления исходной фигуры. Производительность разбивателя в первую очередь зависит от числа вершин, определяющих многоугольник/множество многоугольников.

Пример

resp = client.indices.create(
    index="example",
    mappings={
        "properties": {
            "location": {
                "type": "geo_shape"
            }
        }
    },
)
print(resp)

response = client.indices.create(
  index: 'example',
  body: {
    mappings: {
      properties: {
        location: {
          type: 'geo_shape'
        }
      }
    }
  }
)
puts response

const response = await client.indices.create({
  index: "example",
  mappings: {
    properties: {
      location: {
        type: "geo_shape",
      },
    },
  },
});
console.log(response);

PUT /example
{
  "mappings": {
    "properties": {
      "location": {
        "type": "geo_shape"
      }
    }
  }
}

Структура входных данных

Фигуры могут быть представлены в формате GeoJSON или Well-Known Text (WKT). В следующей таблице показано отображение GeoJSON и WKT в типы Elasticsearch:

Тип GeoJSON	Тип WKT	Тип Elasticsearch	Описание
`Point`	`POINT`	`point`	Одна географическая координата. Примечание: Elasticsearch использует только координаты WGS-84.
`LineString`	`LINESTRING`	`linestring`	Произвольная линия, заданная двумя или более точками.
`Polygon`	`POLYGON`	`polygon`	Закрытый многоугольник, у которого первая и последняя точки должны совпадать, что требует `n + 1` вершин для создания `n`-стороннего многоугольника и минимально `4` вершин.
`MultiPoint`	`MULTIPOINT`	`multipoint`	Массив несвязанных, но, вероятно, связанных точек.
`MultiLineString`	`MULTILINESTRING`	`multilinestring`	Массив отдельных линий.
`MultiPolygon`	`MULTIPOLYGON`	`multipolygon`	Массив отдельных многоугольников.
`GeometryCollection`	`GEOMETRYCOLLECTION`	`geometrycollection`	Геофигура GeoJSON, аналогичная `multi*` фигурам, за исключением того, что несколько типов могут сосуществовать (например, точка и линия).
`N/A`	`BBOX`	`envelope`	Прямоугольник огибающей, заданный только двумя точками (верхний левый и нижний правый).

Для всех типов необходимы поля type и coordinates.

Точка

Точка — это одна географическая координата, например, расположение здания или текущие координаты, предоставленные API геолокации смартфона. Ниже приведен пример точки в формате GeoJSON.

resp = client.index(
    index="example",
    document={
        "location": {
            "type": "Point",
            "coordinates": [
                -77.03653,
                38.897676
            ]
        }
    },
)
print(resp)

response = client.index(
  index: 'example',
  body: {
    location: {
      type: 'Point',
      coordinates: [
        -77.03653,
        38.897676
      ]
    }
  }
)
puts response

const response = await client.index({
  index: "example",
  document: {
    location: {
      type: "Point",
      coordinates: [-77.03653, 38.897676],
    },
  },
});
console.log(response);

POST /example/_doc
{
  "location" : {
    "type" : "Point",
    "coordinates" : [-77.03653, 38.897676]
  }
}

Ниже приведен пример точки в формате WKT:

resp = client.index(
    index="example",
    document={
        "location": "POINT (-77.03653 38.897676)"
    },
)
print(resp)

response = client.index(
  index: 'example',
  body: {
    location: 'POINT (-77.03653 38.897676)'
  }
)
puts response

const response = await client.index({
  index: "example",
  document: {
    location: "POINT (-77.03653 38.897676)",
  },
});
console.log(response);

POST /example/_doc
{
  "location" : "POINT (-77.03653 38.897676)"
}

LineString

Линия, определяемая массивом из двух или более позиций. Указав только две точки, линия будет представлять прямую линию. Указание более двух точек создаёт произвольную траекторию. Ниже приведён пример линии в формате GeoJSON.

resp = client.index(
    index="example",
    document={
        "location": {
            "type": "LineString",
            "coordinates": [
                [
                    -77.03653,
                    38.897676
                ],
                [
                    -77.009051,
                    38.889939
                ]
            ]
        }
    },
)
print(resp)

response = client.index(
  index: 'example',
  body: {
    location: {
      type: 'LineString',
      coordinates: [
        [
          -77.03653,
          38.897676
        ],
        [
          -77.009051,
          38.889939
        ]
      ]
    }
  }
)
puts response

const response = await client.index({
  index: "example",
  document: {
    location: {
      type: "LineString",
      coordinates: [
        [-77.03653, 38.897676],
        [-77.009051, 38.889939],
      ],
    },
  },
});
console.log(response);

POST /example/_doc
{
  "location" : {
    "type" : "LineString",
    "coordinates" : [[-77.03653, 38.897676], [-77.009051, 38.889939]]
  }
}

Ниже приведён пример линии в формате WKT:

resp = client.index(
    index="example",
    document={
        "location": "LINESTRING (-77.03653 38.897676, -77.009051 38.889939)"
    },
)
print(resp)

response = client.index(
  index: 'example',
  body: {
    location: 'LINESTRING (-77.03653 38.897676, -77.009051 38.889939)'
  }
)
puts response

const response = await client.index({
  index: "example",
  document: {
    location: "LINESTRING (-77.03653 38.897676, -77.009051 38.889939)",
  },
});
console.log(response);

POST /example/_doc
{
  "location" : "LINESTRING (-77.03653 38.897676, -77.009051 38.889939)"
}

Вышеприведённая линия изобразит прямую линию, начинающуюся у Белого дома и проходящую к зданию Капитолия США.

Polygon

Многоугольник определяется списком списков точек. Первая и последняя точки в каждом (внешнем) списке должны быть одинаковыми (многоугольник должен быть замкнутым). Ниже приведён пример многоугольника в формате GeoJSON.

resp = client.index(
    index="example",
    document={
        "location": {
            "type": "Polygon",
            "coordinates": [
                [
                    [
                        100,
                        0
                    ],
                    [
                        101,
                        0
                    ],
                    [
                        101,
                        1
                    ],
                    [
                        100,
                        1
                    ],
                    [
                        100,
                        0
                    ]
                ]
            ]
        }
    },
)
print(resp)

response = client.index(
  index: 'example',
  body: {
    location: {
      type: 'Polygon',
      coordinates: [
        [
          [
            100,
            0
          ],
          [
            101,
            0
          ],
          [
            101,
            1
          ],
          [
            100,
            1
          ],
          [
            100,
            0
          ]
        ]
      ]
    }
  }
)
puts response

const response = await client.index({
  index: "example",
  document: {
    location: {
      type: "Polygon",
      coordinates: [
        [
          [100, 0],
          [101, 0],
          [101, 1],
          [100, 1],
          [100, 0],
        ],
      ],
    },
  },
});
console.log(response);

POST /example/_doc
{
  "location" : {
    "type" : "Polygon",
    "coordinates" : [
      [ [100.0, 0.0], [101.0, 0.0], [101.0, 1.0], [100.0, 1.0], [100.0, 0.0] ]
    ]
  }
}

Ниже приведён пример многоугольника в формате WKT:

resp = client.index(
    index="example",
    document={
        "location": "POLYGON ((100.0 0.0, 101.0 0.0, 101.0 1.0, 100.0 1.0, 100.0 0.0))"
    },
)
print(resp)

response = client.index(
  index: 'example',
  body: {
    location: 'POLYGON ((100.0 0.0, 101.0 0.0, 101.0 1.0, 100.0 1.0, 100.0 0.0))'
  }
)
puts response

const response = await client.index({
  index: "example",
  document: {
    location:
      "POLYGON ((100.0 0.0, 101.0 0.0, 101.0 1.0, 100.0 1.0, 100.0 0.0))",
  },
});
console.log(response);

POST /example/_doc
{
  "location" : "POLYGON ((100.0 0.0, 101.0 0.0, 101.0 1.0, 100.0 1.0, 100.0 0.0))"
}

Первый массив представляет собой внешнюю границу многоугольника, остальные массивы представляют собой внутренние фигуры («дыры»). Ниже приведён пример GeoJSON-многоугольника с дырой:

resp = client.index(
    index="example",
    document={
        "location": {
            "type": "Polygon",
            "coordinates": [
                [
                    [
                        100,
                        0
                    ],
                    [
                        101,
                        0
                    ],
                    [
                        101,
                        1
                    ],
                    [
                        100,
                        1
                    ],
                    [
                        100,
                        0
                    ]
                ],
                [
                    [
                        100.2,
                        0.2
                    ],
                    [
                        100.8,
                        0.2
                    ],
                    [
                        100.8,
                        0.8
                    ],
                    [
                        100.2,
                        0.8
                    ],
                    [
                        100.2,
                        0.2
                    ]
                ]
            ]
        }
    },
)
print(resp)

response = client.index(
  index: 'example',
  body: {
    location: {
      type: 'Polygon',
      coordinates: [
        [
          [
            100,
            0
          ],
          [
            101,
            0
          ],
          [
            101,
            1
          ],
          [
            100,
            1
          ],
          [
            100,
            0
          ]
        ],
        [
          [
            100.2,
            0.2
          ],
          [
            100.8,
            0.2
          ],
          [
            100.8,
            0.8
          ],
          [
            100.2,
            0.8
          ],
          [
            100.2,
            0.2
          ]
        ]
      ]
    }
  }
)
puts response

const response = await client.index({
  index: "example",
  document: {
    location: {
      type: "Polygon",
      coordinates: [
        [
          [100, 0],
          [101, 0],
          [101, 1],
          [100, 1],
          [100, 0],
        ],
        [
          [100.2, 0.2],
          [100.8, 0.2],
          [100.8, 0.8],
          [100.2, 0.8],
          [100.2, 0.2],
        ],
      ],
    },
  },
});
console.log(response);

POST /example/_doc
{
  "location" : {
    "type" : "Polygon",
    "coordinates" : [
      [ [100.0, 0.0], [101.0, 0.0], [101.0, 1.0], [100.0, 1.0], [100.0, 0.0] ],
      [ [100.2, 0.2], [100.8, 0.2], [100.8, 0.8], [100.2, 0.8], [100.2, 0.2] ]
    ]
  }
}

Ниже приведён пример многоугольника с дырой в формате WKT:

resp = client.index(
    index="example",
    document={
        "location": "POLYGON ((100.0 0.0, 101.0 0.0, 101.0 1.0, 100.0 1.0, 100.0 0.0), (100.2 0.2, 100.8 0.2, 100.8 0.8, 100.2 0.8, 100.2 0.2))"
    },
)
print(resp)

response = client.index(
  index: 'example',
  body: {
    location: 'POLYGON ((100.0 0.0, 101.0 0.0, 101.0 1.0, 100.0 1.0, 100.0 0.0), (100.2 0.2, 100.8 0.2, 100.8 0.8, 100.2 0.8, 100.2 0.2))'
  }
)
puts response

const response = await client.index({
  index: "example",
  document: {
    location:
      "POLYGON ((100.0 0.0, 101.0 0.0, 101.0 1.0, 100.0 1.0, 100.0 0.0), (100.2 0.2, 100.8 0.2, 100.8 0.8, 100.2 0.8, 100.2 0.2))",
  },
});
console.log(response);

POST /example/_doc
{
  "location" : "POLYGON ((100.0 0.0, 101.0 0.0, 101.0 1.0, 100.0 1.0, 100.0 0.0), (100.2 0.2, 100.8 0.2, 100.8 0.8, 100.2 0.8, 100.2 0.2))"
}

Ориентация многоугольника

Ориентация многоугольника указывает порядок его вершин: RIGHT (против часовой стрелки) или LEFT (по часовой стрелке). Elasticsearch использует ориентацию многоугольника для определения того, пересекает ли он международную дату (+/-180° долгота).

Вы можете установить стандартную ориентацию для WKT-многоугольников, используя параметр orientation. Это связано с тем, что спецификация WKT не указывает или не навязывает стандартную ориентацию.

GeoJSON-многоугольники используют стандартную ориентацию RIGHT, независимо от значения параметра сопоставления orientation. Это связано с тем, что спецификация GeoJSON обязательно требует, чтобы внешний многоугольник использовал ориентацию против часовой стрелки, а внутренние фигуры — по часовой стрелке.

Вы можете переопределить стандартную ориентацию для GeoJSON-многоугольников, используя параметр orientation уровня документа. Например, следующий запрос индексирования указывает значение orientation уровня документа как LEFT.

resp = client.index(
    index="example",
    document={
        "location": {
            "type": "Polygon",
            "orientation": "LEFT",
            "coordinates": [
                [
                    [
                        -177,
                        10
                    ],
                    [
                        176,
                        15
                    ],
                    [
                        172,
                        0
                    ],
                    [
                        176,
                        -15
                    ],
                    [
                        -177,
                        -10
                    ],
                    [
                        -177,
                        10
                    ]
                ]
            ]
        }
    },
)
print(resp)

response = client.index(
  index: 'example',
  body: {
    location: {
      type: 'Polygon',
      orientation: 'LEFT',
      coordinates: [
        [
          [
            -177,
            10
          ],
          [
            176,
            15
          ],
          [
            172,
            0
          ],
          [
            176,
            -15
          ],
          [
            -177,
            -10
          ],
          [
            -177,
            10
          ]
        ]
      ]
    }
  }
)
puts response

const response = await client.index({
  index: "example",
  document: {
    location: {
      type: "Polygon",
      orientation: "LEFT",
      coordinates: [
        [
          [-177, 10],
          [176, 15],
          [172, 0],
          [176, -15],
          [-177, -10],
          [-177, 10],
        ],
      ],
    },
  },
});
console.log(response);

POST /example/_doc
{
  "location" : {
    "type" : "Polygon",
    "orientation" : "LEFT",
    "coordinates" : [
      [ [-177.0, 10.0], [176.0, 15.0], [172.0, 0.0], [176.0, -15.0], [-177.0, -10.0], [-177.0, 10.0] ]
    ]
  }
}

Elasticsearch использует ориентацию многоугольника только для определения того, пересекает ли он международную дату. Если разность между минимальной и максимальной долготой многоугольника меньше 180°, многоугольник не пересекает дату, и его ориентация не имеет значения.

Если разность между минимальной и максимальной долготой многоугольника составляет 180° или больше, Elasticsearch проверяет, отличается ли значение orientation документа многоугольника от стандартной ориентации. Если ориентация отличается, Elasticsearch рассматривает многоугольник как пересекающий международную дату и разбивает многоугольник по дате.

MultiPoint

Ниже приведён пример списка точек GeoJSON:

resp = client.index(
    index="example",
    document={
        "location": {
            "type": "MultiPoint",
            "coordinates": [
                [
                    102,
                    2
                ],
                [
                    103,
                    2
                ]
            ]
        }
    },
)
print(resp)

response = client.index(
  index: 'example',
  body: {
    location: {
      type: 'MultiPoint',
      coordinates: [
        [
          102,
          2
        ],
        [
          103,
          2
        ]
      ]
    }
  }
)
puts response

const response = await client.index({
  index: "example",
  document: {
    location: {
      type: "MultiPoint",
      coordinates: [
        [102, 2],
        [103, 2],
      ],
    },
  },
});
console.log(response);

POST /example/_doc
{
  "location" : {
    "type" : "MultiPoint",
    "coordinates" : [
      [102.0, 2.0], [103.0, 2.0]
    ]
  }
}

Ниже приведён пример списка точек WKT:

resp = client.index(
    index="example",
    document={
        "location": "MULTIPOINT (102.0 2.0, 103.0 2.0)"
    },
)
print(resp)

response = client.index(
  index: 'example',
  body: {
    location: 'MULTIPOINT (102.0 2.0, 103.0 2.0)'
  }
)
puts response

const response = await client.index({
  index: "example",
  document: {
    location: "MULTIPOINT (102.0 2.0, 103.0 2.0)",
  },
});
console.log(response);

POST /example/_doc
{
  "location" : "MULTIPOINT (102.0 2.0, 103.0 2.0)"
}

MultiLineString

Ниже приведён пример списка линий GeoJSON:

resp = client.index(
    index="example",
    document={
        "location": {
            "type": "MultiLineString",
            "coordinates": [
                [
                    [
                        102,
                        2
                    ],
                    [
                        103,
                        2
                    ],
                    [
                        103,
                        3
                    ],
                    [
                        102,
                        3
                    ]
                ],
                [
                    [
                        100,
                        0
                    ],
                    [
                        101,
                        0
                    ],
                    [
                        101,
                        1
                    ],
                    [
                        100,
                        1
                    ]
                ],
                [
                    [
                        100.2,
                        0.2
                    ],
                    [
                        100.8,
                        0.2
                    ],
                    [
                        100.8,
                        0.8
                    ],
                    [
                        100.2,
                        0.8
                    ]
                ]
            ]
        }
    },
)
print(resp)

response = client.index(
  index: 'example',
  body: {
    location: {
      type: 'MultiLineString',
      coordinates: [
        [
          [
            102,
            2
          ],
          [
            103,
            2
          ],
          [
            103,
            3
          ],
          [
            102,
            3
          ]
        ],
        [
          [
            100,
            0
          ],
          [
            101,
            0
          ],
          [
            101,
            1
          ],
          [
            100,
            1
          ]
        ],
        [
          [
            100.2,
            0.2
          ],
          [
            100.8,
            0.2
          ],
          [
            100.8,
            0.8
          ],
          [
            100.2,
            0.8
          ]
        ]
      ]
    }
  }
)
puts response

const response = await client.index({
  index: "example",
  document: {
    location: {
      type: "MultiLineString",
      coordinates: [
        [
          [102, 2],
          [103, 2],
          [103, 3],
          [102, 3],
        ],
        [
          [100, 0],
          [101, 0],
          [101, 1],
          [100, 1],
        ],
        [
          [100.2, 0.2],
          [100.8, 0.2],
          [100.8, 0.8],
          [100.2, 0.8],
        ],
      ],
    },
  },
});
console.log(response);

POST /example/_doc
{
  "location" : {
    "type" : "MultiLineString",
    "coordinates" : [
      [ [102.0, 2.0], [103.0, 2.0], [103.0, 3.0], [102.0, 3.0] ],
      [ [100.0, 0.0], [101.0, 0.0], [101.0, 1.0], [100.0, 1.0] ],
      [ [100.2, 0.2], [100.8, 0.2], [100.8, 0.8], [100.2, 0.8] ]
    ]
  }
}

Ниже приведён пример списка линий WKT:

resp = client.index(
    index="example",
    document={
        "location": "MULTILINESTRING ((102.0 2.0, 103.0 2.0, 103.0 3.0, 102.0 3.0), (100.0 0.0, 101.0 0.0, 101.0 1.0, 100.0 1.0), (100.2 0.2, 100.8 0.2, 100.8 0.8, 100.2 0.8))"
    },
)
print(resp)

response = client.index(
  index: 'example',
  body: {
    location: 'MULTILINESTRING ((102.0 2.0, 103.0 2.0, 103.0 3.0, 102.0 3.0), (100.0 0.0, 101.0 0.0, 101.0 1.0, 100.0 1.0), (100.2 0.2, 100.8 0.2, 100.8 0.8, 100.2 0.8))'
  }
)
puts response

const response = await client.index({
  index: "example",
  document: {
    location:
      "MULTILINESTRING ((102.0 2.0, 103.0 2.0, 103.0 3.0, 102.0 3.0), (100.0 0.0, 101.0 0.0, 101.0 1.0, 100.0 1.0), (100.2 0.2, 100.8 0.2, 100.8 0.8, 100.2 0.8))",
  },
});
console.log(response);

POST /example/_doc
{
  "location" : "MULTILINESTRING ((102.0 2.0, 103.0 2.0, 103.0 3.0, 102.0 3.0), (100.0 0.0, 101.0 0.0, 101.0 1.0, 100.0 1.0), (100.2 0.2, 100.8 0.2, 100.8 0.8, 100.2 0.8))"
}

MultiPolygon

Ниже приведён пример списка многоугольников GeoJSON (второй многоугольник содержит дыру):

resp = client.index(
    index="example",
    document={
        "location": {
            "type": "MultiPolygon",
            "coordinates": [
                [
                    [
                        [
                            102,
                            2
                        ],
                        [
                            103,
                            2
                        ],
                        [
                            103,
                            3
                        ],
                        [
                            102,
                            3
                        ],
                        [
                            102,
                            2
                        ]
                    ]
                ],
                [
                    [
                        [
                            100,
                            0
                        ],
                        [
                            101,
                            0
                        ],
                        [
                            101,
                            1
                        ],
                        [
                            100,
                            1
                        ],
                        [
                            100,
                            0
                        ]
                    ],
                    [
                        [
                            100.2,
                            0.2
                        ],
                        [
                            100.8,
                            0.2
                        ],
                        [
                            100.8,
                            0.8
                        ],
                        [
                            100.2,
                            0.8
                        ],
                        [
                            100.2,
                            0.2
                        ]
                    ]
                ]
            ]
        }
    },
)
print(resp)

response = client.index(
  index: 'example',
  body: {
    location: {
      type: 'MultiPolygon',
      coordinates: [
        [
          [
            [
              102,
              2
            ],
            [
              103,
              2
            ],
            [
              103,
              3
            ],
            [
              102,
              3
            ],
            [
              102,
              2
            ]
          ]
        ],
        [
          [
            [
              100,
              0
            ],
            [
              101,
              0
            ],
            [
              101,
              1
            ],
            [
              100,
              1
            ],
            [
              100,
              0
            ]
          ],
          [
            [
              100.2,
              0.2
            ],
            [
              100.8,
              0.2
            ],
            [
              100.8,
              0.8
            ],
            [
              100.2,
              0.8
            ],
            [
              100.2,
              0.2
            ]
          ]
        ]
      ]
    }
  }
)
puts response

const response = await client.index({
  index: "example",
  document: {
    location: {
      type: "MultiPolygon",
      coordinates: [
        [
          [
            [102, 2],
            [103, 2],
            [103, 3],
            [102, 3],
            [102, 2],
          ],
        ],
        [
          [
            [100, 0],
            [101, 0],
            [101, 1],
            [100, 1],
            [100, 0],
          ],
          [
            [100.2, 0.2],
            [100.8, 0.2],
            [100.8, 0.8],
            [100.2, 0.8],
            [100.2, 0.2],
          ],
        ],
      ],
    },
  },
});
console.log(response);

POST /example/_doc
{
  "location" : {
    "type" : "MultiPolygon",
    "coordinates" : [
      [ [[102.0, 2.0], [103.0, 2.0], [103.0, 3.0], [102.0, 3.0], [102.0, 2.0]] ],
      [ [[100.0, 0.0], [101.0, 0.0], [101.0, 1.0], [100.0, 1.0], [100.0, 0.0]],
        [[100.2, 0.2], [100.8, 0.2], [100.8, 0.8], [100.2, 0.8], [100.2, 0.2]] ]
    ]
  }
}

Ниже приведён пример списка многоугольников WKT (второй многоугольник содержит дыру):

resp = client.index(
    index="example",
    document={
        "location": "MULTIPOLYGON (((102.0 2.0, 103.0 2.0, 103.0 3.0, 102.0 3.0, 102.0 2.0)), ((100.0 0.0, 101.0 0.0, 101.0 1.0, 100.0 1.0, 100.0 0.0), (100.2 0.2, 100.8 0.2, 100.8 0.8, 100.2 0.8, 100.2 0.2)))"
    },
)
print(resp)

response = client.index(
  index: 'example',
  body: {
    location: 'MULTIPOLYGON (((102.0 2.0, 103.0 2.0, 103.0 3.0, 102.0 3.0, 102.0 2.0)), ((100.0 0.0, 101.0 0.0, 101.0 1.0, 100.0 1.0, 100.0 0.0), (100.2 0.2, 100.8 0.2, 100.8 0.8, 100.2 0.8, 100.2 0.2)))'
  }
)
puts response

const response = await client.index({
  index: "example",
  document: {
    location:
      "MULTIPOLYGON (((102.0 2.0, 103.0 2.0, 103.0 3.0, 102.0 3.0, 102.0 2.0)), ((100.0 0.0, 101.0 0.0, 101.0 1.0, 100.0 1.0, 100.0 0.0), (100.2 0.2, 100.8 0.2, 100.8 0.8, 100.2 0.8, 100.2 0.2)))",
  },
});
console.log(response);

POST /example/_doc
{
  "location" : "MULTIPOLYGON (((102.0 2.0, 103.0 2.0, 103.0 3.0, 102.0 3.0, 102.0 2.0)), ((100.0 0.0, 101.0 0.0, 101.0 1.0, 100.0 1.0, 100.0 0.0), (100.2 0.2, 100.8 0.2, 100.8 0.8, 100.2 0.8, 100.2 0.2)))"
}

Geometry Collection

Ниже приведён пример коллекции геометрических объектов GeoJSON:

resp = client.index(
    index="example",
    document={
        "location": {
            "type": "GeometryCollection",
            "geometries": [
                {
                    "type": "Point",
                    "coordinates": [
                        100,
                        0
                    ]
                },
                {
                    "type": "LineString",
                    "coordinates": [
                        [
                            101,
                            0
                        ],
                        [
                            102,
                            1
                        ]
                    ]
                }
            ]
        }
    },
)
print(resp)

response = client.index(
  index: 'example',
  body: {
    location: {
      type: 'GeometryCollection',
      geometries: [
        {
          type: 'Point',
          coordinates: [
            100,
            0
          ]
        },
        {
          type: 'LineString',
          coordinates: [
            [
              101,
              0
            ],
            [
              102,
              1
            ]
          ]
        }
      ]
    }
  }
)
puts response

const response = await client.index({
  index: "example",
  document: {
    location: {
      type: "GeometryCollection",
      geometries: [
        {
          type: "Point",
          coordinates: [100, 0],
        },
        {
          type: "LineString",
          coordinates: [
            [101, 0],
            [102, 1],
          ],
        },
      ],
    },
  },
});
console.log(response);

POST /example/_doc
{
  "location" : {
    "type": "GeometryCollection",
    "geometries": [
      {
        "type": "Point",
        "coordinates": [100.0, 0.0]
      },
      {
        "type": "LineString",
        "coordinates": [ [101.0, 0.0], [102.0, 1.0] ]
      }
    ]
  }
}

Ниже приведён пример коллекции геометрических объектов WKT:

resp = client.index(
    index="example",
    document={
        "location": "GEOMETRYCOLLECTION (POINT (100.0 0.0), LINESTRING (101.0 0.0, 102.0 1.0))"
    },
)
print(resp)

response = client.index(
  index: 'example',
  body: {
    location: 'GEOMETRYCOLLECTION (POINT (100.0 0.0), LINESTRING (101.0 0.0, 102.0 1.0))'
  }
)
puts response

const response = await client.index({
  index: "example",
  document: {
    location:
      "GEOMETRYCOLLECTION (POINT (100.0 0.0), LINESTRING (101.0 0.0, 102.0 1.0))",
  },
});
console.log(response);

POST /example/_doc
{
  "location" : "GEOMETRYCOLLECTION (POINT (100.0 0.0), LINESTRING (101.0 0.0, 102.0 1.0))"
}

Огибающая

Elasticsearch поддерживает тип envelope, который содержит координаты верхней левой и нижней правой точек фигуры, представляющей прямоугольник ограничивающей рамки в формате [[minLon, maxLat], [maxLon, minLat]]:

resp = client.index(
    index="example",
    document={
        "location": {
            "type": "envelope",
            "coordinates": [
                [
                    100,
                    1
                ],
                [
                    101,
                    0
                ]
            ]
        }
    },
)
print(resp)

response = client.index(
  index: 'example',
  body: {
    location: {
      type: 'envelope',
      coordinates: [
        [
          100,
          1
        ],
        [
          101,
          0
        ]
      ]
    }
  }
)
puts response

const response = await client.index({
  index: "example",
  document: {
    location: {
      type: "envelope",
      coordinates: [
        [100, 1],
        [101, 0],
      ],
    },
  },
});
console.log(response);

POST /example/_doc
{
  "location" : {
    "type" : "envelope",
    "coordinates" : [ [100.0, 1.0], [101.0, 0.0] ]
  }
}

Ниже приведён пример огибающей, использующей формат WKT BBOX:

ПРИМЕЧАНИЕ: В спецификации WKT ожидается следующий порядок: minLon, maxLon, maxLat, minLat.

resp = client.index(
    index="example",
    document={
        "location": "BBOX (100.0, 102.0, 2.0, 0.0)"
    },
)
print(resp)

response = client.index(
  index: 'example',
  body: {
    location: 'BBOX (100.0, 102.0, 2.0, 0.0)'
  }
)
puts response

const response = await client.index({
  index: "example",
  document: {
    location: "BBOX (100.0, 102.0, 2.0, 0.0)",
  },
});
console.log(response);

POST /example/_doc
{
  "location" : "BBOX (100.0, 102.0, 2.0, 0.0)"
}

Окружность

Ни GeoJSON, ни WKT не поддерживают тип окружности точка-радиус. Вместо этого используйте процессор ingests окружности для приближения окружности в виде polygon.

Сортировка и извлечение фигур индекса

Из-за сложной структуры входных данных и представления фигур в индексе в настоящее время невозможно сортировать фигуры или извлекать их поля напрямую. Значение geo_shape можно получить только через поле _source.

Синтетический источник

Синтетический _source доступен в общем доступе только для индексов TSDB (индексы, у которых index.mode установлено в time_series). Для других индексов синтетический _source находится в техническом предварительном просмотре. Функции в техническом предварительном просмотре могут быть изменены или удалены в будущих выпусках. Elastic будет работать над устранением любых проблем, но функции в техническом предварительном просмотре не подпадают под SLA поддержки официальных функций GA.

© 2023-2025 Elasticsearch
As of September 2024, Elasticsearch is available under a choice of three licenses: the Server Side Public License (SSPL), the Elastic License, or the AGPLv3 (OSI approved).
Elasticsearch and the Elasticsearch logo are trademarks of Elasticsearch B.V., registered in the U.S. and in other countries.
https://www.elastic.co/guide/en/elasticsearch/reference/8.17/geo-shape.html