› › ›

Тип поля Shape

Тип данных shape позволяет индексировать и осуществлять поиск с использованием произвольных x, y декартовых фигур, таких как прямоугольники и многоугольники. Он может использоваться для индексации и запросов геометрий, координаты которых попадают в 2-мерную плоскую систему координат.

Вы можете запрашивать документы с использованием этого типа с помощью запроса формы.

Параметры сопоставления

Как и тип поля geo_shape, сопоставление поля shape преобразует объекты геометрии GeoJSON или Well-Known Text (WKT) в тип формы. Для его включения пользователи должны явно сопоставить поля с типом формы.

Параметр	Описание	Значение по умолчанию
`orientation`	Необязательно задайте, как интерпретировать порядок вершин для многоугольников/множественных многоугольников. Этот параметр определяет одно из двух правил системы координат (правостороннее или левостороннее), каждое из которых может быть задано тремя различными способами. 1. Правило правой руки: `right`, `ccw`, `counterclockwise`, 2. Правило левой руки: `left`, `cw`, `clockwise`. По умолчанию (`counterclockwise`) используется стандарт OGC, который определяет вершины внешней окружности в порядке против часовой стрелки, а вершины внутренней окружности (дыры) — по часовой стрелке. Установка этого параметра в сопоставлении `geo_shape` явно задаёт порядок вершин для списка координат поля `geo_shape`, но может быть переопределён в каждом отдельном документе GeoJSON или WKT.	`ccw`
`ignore_malformed`	Если значение true, некорректные геометрии GeoJSON или WKT игнорируются. Если значение false (по умолчанию), некорректные геометрии GeoJSON и WKT генерируют исключение и отбрасывают весь документ.	`false`
`ignore_z_value`	Если значение `true` (по умолчанию), трёхмерные точки будут приниматься (хранятся в источнике), но будут индексироваться только значения широты и долготы; третья размерность игнорируется. Если `false`, геоточки, содержащие больше, чем широта и долгота (две размерности) значения, генерируют исключение и отклоняют весь документ.	`true`
`coerce`	Если `true` незамкнутые линейные кольца в многоугольниках будут автоматически закрываться.	`false`

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

Как и geo_shape, тип поля shape индексируется путём разбиения геометрий на треугольную сетку и индексирования каждого треугольника как точки 7-мерности в дереве BKD. Координаты, предоставляемые индексатору, — это одноточные значения с плавающей точкой, поэтому поле гарантирует такую же точность, как и у виртуальной машины Java (обычно 1E-38). Для многоугольников/множественных многоугольников производительность триангулятора в первую очередь зависит от количества вершин, определяющих геометрию.

ВАЖНЫЕ ПРИМЕЧАНИЯ

CONTAINS запрос отношения - shape запросы с relation определёнными как contains поддерживаются для индексов, созданных с ElasticSearch 7.5.0 или выше.

Пример

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

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

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

PUT /example
{
  "mappings": {
    "properties": {
      "geometry": {
        "type": "shape"
      }
    }
  }
}

Это определение сопоставления сопоставляет поле геометрии с типом формы. Индексатор использует одноточные значения с плавающей точкой для значений вершин, поэтому точность гарантируется до такой же точности, как и у float значений, предоставляемых виртуальной машиной Java (приблизительно, обычно 1E-38).

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

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

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

Для всех типов обязательны поля type и coordinates.

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

Точка

Точка — это одна координата в декартовом x, y пространстве. Она может представлять местоположение элемента, представляющего интерес, в виртуальном мире или спроецированном пространстве. Следующий пример точки в формате GeoJSON.

resp = client.index(
    index="example",
    document={
        "location": {
            "type": "point",
            "coordinates": [
                -377.03653,
                389.897676
            ]
        }
    },
)
print(resp)

response = client.index(
  index: 'example',
  body: {
    location: {
      type: 'point',
      coordinates: [
        -377.03653,
        389.897676
      ]
    }
  }
)
puts response

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

POST /example/_doc
{
  "location" : {
    "type" : "point",
    "coordinates" : [-377.03653, 389.897676]
  }
}

Следующий пример точки в формате WKT:

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

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

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

POST /example/_doc
{
  "location" : "POINT (-377.03653 389.897676)"
}

Линейная строка

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

resp = client.index(
    index="example",
    document={
        "location": {
            "type": "linestring",
            "coordinates": [
                [
                    -377.03653,
                    389.897676
                ],
                [
                    -377.009051,
                    389.889939
                ]
            ]
        }
    },
)
print(resp)

response = client.index(
  index: 'example',
  body: {
    location: {
      type: 'linestring',
      coordinates: [
        [
          -377.03653,
          389.897676
        ],
        [
          -377.009051,
          389.889939
        ]
      ]
    }
  }
)
puts response

const response = await client.index({
  index: "example",
  document: {
    location: {
      type: "linestring",
      coordinates: [
        [-377.03653, 389.897676],
        [-377.009051, 389.889939],
      ],
    },
  },
});
console.log(response);

POST /example/_doc
{
  "location" : {
    "type" : "linestring",
    "coordinates" : [[-377.03653, 389.897676], [-377.009051, 389.889939]]
  }
}

Следующий пример линейной строки в формате WKT:

resp = client.index(
    index="example",
    document={
        "location": "LINESTRING (-377.03653 389.897676, -377.009051 389.889939)"
    },
)
print(resp)

response = client.index(
  index: 'example',
  body: {
    location: 'LINESTRING (-377.03653 389.897676, -377.009051 389.889939)'
  }
)
puts response

const response = await client.index({
  index: "example",
  document: {
    location: "LINESTRING (-377.03653 389.897676, -377.009051 389.889939)",
  },
});
console.log(response);

POST /example/_doc
{
  "location" : "LINESTRING (-377.03653 389.897676, -377.009051 389.889939)"
}

Многоугольник

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

resp = client.index(
    index="example",
    document={
        "location": {
            "type": "polygon",
            "coordinates": [
                [
                    [
                        1000,
                        -1001
                    ],
                    [
                        1001,
                        -1001
                    ],
                    [
                        1001,
                        -1000
                    ],
                    [
                        1000,
                        -1000
                    ],
                    [
                        1000,
                        -1001
                    ]
                ]
            ]
        }
    },
)
print(resp)

response = client.index(
  index: 'example',
  body: {
    location: {
      type: 'polygon',
      coordinates: [
        [
          [
            1000,
            -1001
          ],
          [
            1001,
            -1001
          ],
          [
            1001,
            -1000
          ],
          [
            1000,
            -1000
          ],
          [
            1000,
            -1001
          ]
        ]
      ]
    }
  }
)
puts response

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

POST /example/_doc
{
  "location" : {
    "type" : "polygon",
    "coordinates" : [
      [ [1000.0, -1001.0], [1001.0, -1001.0], [1001.0, -1000.0], [1000.0, -1000.0], [1000.0, -1001.0] ]
    ]
  }
}

Вот пример многоугольника в формате WKT:

resp = client.index(
    index="example",
    document={
        "location": "POLYGON ((1000.0 -1001.0, 1001.0 -1001.0, 1001.0 -1000.0, 1000.0 -1000.0, 1000.0 -1001.0))"
    },
)
print(resp)

response = client.index(
  index: 'example',
  body: {
    location: 'POLYGON ((1000.0 -1001.0, 1001.0 -1001.0, 1001.0 -1000.0, 1000.0 -1000.0, 1000.0 -1001.0))'
  }
)
puts response

const response = await client.index({
  index: "example",
  document: {
    location:
      "POLYGON ((1000.0 -1001.0, 1001.0 -1001.0, 1001.0 -1000.0, 1000.0 -1000.0, 1000.0 -1001.0))",
  },
});
console.log(response);

POST /example/_doc
{
  "location" : "POLYGON ((1000.0 -1001.0, 1001.0 -1001.0, 1001.0 -1000.0, 1000.0 -1000.0, 1000.0 -1001.0))"
}

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

resp = client.index(
    index="example",
    document={
        "location": {
            "type": "polygon",
            "coordinates": [
                [
                    [
                        1000,
                        -1001
                    ],
                    [
                        1001,
                        -1001
                    ],
                    [
                        1001,
                        -1000
                    ],
                    [
                        1000,
                        -1000
                    ],
                    [
                        1000,
                        -1001
                    ]
                ],
                [
                    [
                        1000.2,
                        -1001.2
                    ],
                    [
                        1000.8,
                        -1001.2
                    ],
                    [
                        1000.8,
                        -1001.8
                    ],
                    [
                        1000.2,
                        -1001.8
                    ],
                    [
                        1000.2,
                        -1001.2
                    ]
                ]
            ]
        }
    },
)
print(resp)

response = client.index(
  index: 'example',
  body: {
    location: {
      type: 'polygon',
      coordinates: [
        [
          [
            1000,
            -1001
          ],
          [
            1001,
            -1001
          ],
          [
            1001,
            -1000
          ],
          [
            1000,
            -1000
          ],
          [
            1000,
            -1001
          ]
        ],
        [
          [
            1000.2,
            -1001.2
          ],
          [
            1000.8,
            -1001.2
          ],
          [
            1000.8,
            -1001.8
          ],
          [
            1000.2,
            -1001.8
          ],
          [
            1000.2,
            -1001.2
          ]
        ]
      ]
    }
  }
)
puts response

const response = await client.index({
  index: "example",
  document: {
    location: {
      type: "polygon",
      coordinates: [
        [
          [1000, -1001],
          [1001, -1001],
          [1001, -1000],
          [1000, -1000],
          [1000, -1001],
        ],
        [
          [1000.2, -1001.2],
          [1000.8, -1001.2],
          [1000.8, -1001.8],
          [1000.2, -1001.8],
          [1000.2, -1001.2],
        ],
      ],
    },
  },
});
console.log(response);

POST /example/_doc
{
  "location" : {
    "type" : "polygon",
    "coordinates" : [
      [ [1000.0, -1001.0], [1001.0, -1001.0], [1001.0, -1000.0], [1000.0, -1000.0], [1000.0, -1001.0] ],
      [ [1000.2, -1001.2], [1000.8, -1001.2], [1000.8, -1001.8], [1000.2, -1001.8], [1000.2, -1001.2] ]
    ]
  }
}

Следующий пример многоугольника с дырой в формате WKT:

resp = client.index(
    index="example",
    document={
        "location": "POLYGON ((1000.0 1000.0, 1001.0 1000.0, 1001.0 1001.0, 1000.0 1001.0, 1000.0 1000.0), (1000.2 1000.2, 1000.8 1000.2, 1000.8 1000.8, 1000.2 1000.8, 1000.2 1000.2))"
    },
)
print(resp)

response = client.index(
  index: 'example',
  body: {
    location: 'POLYGON ((1000.0 1000.0, 1001.0 1000.0, 1001.0 1001.0, 1000.0 1001.0, 1000.0 1000.0), (1000.2 1000.2, 1000.8 1000.2, 1000.8 1000.8, 1000.2 1000.8, 1000.2 1000.2))'
  }
)
puts response

const response = await client.index({
  index: "example",
  document: {
    location:
      "POLYGON ((1000.0 1000.0, 1001.0 1000.0, 1001.0 1001.0, 1000.0 1001.0, 1000.0 1000.0), (1000.2 1000.2, 1000.8 1000.2, 1000.8 1000.8, 1000.2 1000.8, 1000.2 1000.2))",
  },
});
console.log(response);

POST /example/_doc
{
  "location" : "POLYGON ((1000.0 1000.0, 1001.0 1000.0, 1001.0 1001.0, 1000.0 1001.0, 1000.0 1000.0), (1000.2 1000.2, 1000.8 1000.2, 1000.8 1000.8, 1000.2 1000.8, 1000.2 1000.2))"
}

ВАЖНОЕ ПРИМЕЧАНИЕ: WKT не накладывает ограничений на порядок вершин. GeoJSON предписывает, что внешний многоугольник должен быть задан против часовой стрелки, а внутренние фигуры — по часовой стрелке, что соответствует спецификации доступа к простым объектам (Simple Feature Access) Консорциума по открытым геопространственным стандартам (OGC) Simple Feature Access для порядка вершин.

По умолчанию Elasticsearch ожидает вершины в порядке против часовой стрелки (правило правой руки). Если данные предоставлены в порядке по часовой стрелке (правило левой руки), пользователь может изменить параметр orientation либо в описании поля, либо в качестве параметра документа.

Следующий пример переопределения параметров orientation в документе:

resp = client.index(
    index="example",
    document={
        "location": {
            "type": "polygon",
            "orientation": "clockwise",
            "coordinates": [
                [
                    [
                        1000,
                        1000
                    ],
                    [
                        1000,
                        1001
                    ],
                    [
                        1001,
                        1001
                    ],
                    [
                        1001,
                        1000
                    ],
                    [
                        1000,
                        1000
                    ]
                ]
            ]
        }
    },
)
print(resp)

response = client.index(
  index: 'example',
  body: {
    location: {
      type: 'polygon',
      orientation: 'clockwise',
      coordinates: [
        [
          [
            1000,
            1000
          ],
          [
            1000,
            1001
          ],
          [
            1001,
            1001
          ],
          [
            1001,
            1000
          ],
          [
            1000,
            1000
          ]
        ]
      ]
    }
  }
)
puts response

const response = await client.index({
  index: "example",
  document: {
    location: {
      type: "polygon",
      orientation: "clockwise",
      coordinates: [
        [
          [1000, 1000],
          [1000, 1001],
          [1001, 1001],
          [1001, 1000],
          [1000, 1000],
        ],
      ],
    },
  },
});
console.log(response);

POST /example/_doc
{
  "location" : {
    "type" : "polygon",
    "orientation" : "clockwise",
    "coordinates" : [
      [ [1000.0, 1000.0], [1000.0, 1001.0], [1001.0, 1001.0], [1001.0, 1000.0], [1000.0, 1000.0] ]
    ]
  }
}

MultiPoint

Следующий пример списка точек GeoJSON:

resp = client.index(
    index="example",
    document={
        "location": {
            "type": "multipoint",
            "coordinates": [
                [
                    1002,
                    1002
                ],
                [
                    1003,
                    2000
                ]
            ]
        }
    },
)
print(resp)

response = client.index(
  index: 'example',
  body: {
    location: {
      type: 'multipoint',
      coordinates: [
        [
          1002,
          1002
        ],
        [
          1003,
          2000
        ]
      ]
    }
  }
)
puts response

const response = await client.index({
  index: "example",
  document: {
    location: {
      type: "multipoint",
      coordinates: [
        [1002, 1002],
        [1003, 2000],
      ],
    },
  },
});
console.log(response);

POST /example/_doc
{
  "location" : {
    "type" : "multipoint",
    "coordinates" : [
      [1002.0, 1002.0], [1003.0, 2000.0]
    ]
  }
}

Следующий пример списка точек WKT:

resp = client.index(
    index="example",
    document={
        "location": "MULTIPOINT (1002.0 2000.0, 1003.0 2000.0)"
    },
)
print(resp)

response = client.index(
  index: 'example',
  body: {
    location: 'MULTIPOINT (1002.0 2000.0, 1003.0 2000.0)'
  }
)
puts response

const response = await client.index({
  index: "example",
  document: {
    location: "MULTIPOINT (1002.0 2000.0, 1003.0 2000.0)",
  },
});
console.log(response);

POST /example/_doc
{
  "location" : "MULTIPOINT (1002.0 2000.0, 1003.0 2000.0)"
}

MultiLineString

Следующий пример списка линий GeoJSON:

resp = client.index(
    index="example",
    document={
        "location": {
            "type": "multilinestring",
            "coordinates": [
                [
                    [
                        1002,
                        200
                    ],
                    [
                        1003,
                        200
                    ],
                    [
                        1003,
                        300
                    ],
                    [
                        1002,
                        300
                    ]
                ],
                [
                    [
                        1000,
                        100
                    ],
                    [
                        1001,
                        100
                    ],
                    [
                        1001,
                        100
                    ],
                    [
                        1000,
                        100
                    ]
                ],
                [
                    [
                        1000.2,
                        100.2
                    ],
                    [
                        1000.8,
                        100.2
                    ],
                    [
                        1000.8,
                        100.8
                    ],
                    [
                        1000.2,
                        100.8
                    ]
                ]
            ]
        }
    },
)
print(resp)

response = client.index(
  index: 'example',
  body: {
    location: {
      type: 'multilinestring',
      coordinates: [
        [
          [
            1002,
            200
          ],
          [
            1003,
            200
          ],
          [
            1003,
            300
          ],
          [
            1002,
            300
          ]
        ],
        [
          [
            1000,
            100
          ],
          [
            1001,
            100
          ],
          [
            1001,
            100
          ],
          [
            1000,
            100
          ]
        ],
        [
          [
            1000.2,
            100.2
          ],
          [
            1000.8,
            100.2
          ],
          [
            1000.8,
            100.8
          ],
          [
            1000.2,
            100.8
          ]
        ]
      ]
    }
  }
)
puts response

const response = await client.index({
  index: "example",
  document: {
    location: {
      type: "multilinestring",
      coordinates: [
        [
          [1002, 200],
          [1003, 200],
          [1003, 300],
          [1002, 300],
        ],
        [
          [1000, 100],
          [1001, 100],
          [1001, 100],
          [1000, 100],
        ],
        [
          [1000.2, 100.2],
          [1000.8, 100.2],
          [1000.8, 100.8],
          [1000.2, 100.8],
        ],
      ],
    },
  },
});
console.log(response);

POST /example/_doc
{
  "location" : {
    "type" : "multilinestring",
    "coordinates" : [
      [ [1002.0, 200.0], [1003.0, 200.0], [1003.0, 300.0], [1002.0, 300.0] ],
      [ [1000.0, 100.0], [1001.0, 100.0], [1001.0, 100.0], [1000.0, 100.0] ],
      [ [1000.2, 100.2], [1000.8, 100.2], [1000.8, 100.8], [1000.2, 100.8] ]
    ]
  }
}

Следующий пример списка линий WKT:

resp = client.index(
    index="example",
    document={
        "location": "MULTILINESTRING ((1002.0 200.0, 1003.0 200.0, 1003.0 300.0, 1002.0 300.0), (1000.0 100.0, 1001.0 100.0, 1001.0 100.0, 1000.0 100.0), (1000.2 0.2, 1000.8 100.2, 1000.8 100.8, 1000.2 100.8))"
    },
)
print(resp)

response = client.index(
  index: 'example',
  body: {
    location: 'MULTILINESTRING ((1002.0 200.0, 1003.0 200.0, 1003.0 300.0, 1002.0 300.0), (1000.0 100.0, 1001.0 100.0, 1001.0 100.0, 1000.0 100.0), (1000.2 0.2, 1000.8 100.2, 1000.8 100.8, 1000.2 100.8))'
  }
)
puts response

const response = await client.index({
  index: "example",
  document: {
    location:
      "MULTILINESTRING ((1002.0 200.0, 1003.0 200.0, 1003.0 300.0, 1002.0 300.0), (1000.0 100.0, 1001.0 100.0, 1001.0 100.0, 1000.0 100.0), (1000.2 0.2, 1000.8 100.2, 1000.8 100.8, 1000.2 100.8))",
  },
});
console.log(response);

POST /example/_doc
{
  "location" : "MULTILINESTRING ((1002.0 200.0, 1003.0 200.0, 1003.0 300.0, 1002.0 300.0), (1000.0 100.0, 1001.0 100.0, 1001.0 100.0, 1000.0 100.0), (1000.2 0.2, 1000.8 100.2, 1000.8 100.8, 1000.2 100.8))"
}

MultiPolygon

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

resp = client.index(
    index="example",
    document={
        "location": {
            "type": "multipolygon",
            "coordinates": [
                [
                    [
                        [
                            1002,
                            200
                        ],
                        [
                            1003,
                            200
                        ],
                        [
                            1003,
                            300
                        ],
                        [
                            1002,
                            300
                        ],
                        [
                            1002,
                            200
                        ]
                    ]
                ],
                [
                    [
                        [
                            1000,
                            200
                        ],
                        [
                            1001,
                            100
                        ],
                        [
                            1001,
                            100
                        ],
                        [
                            1000,
                            100
                        ],
                        [
                            1000,
                            100
                        ]
                    ],
                    [
                        [
                            1000.2,
                            200.2
                        ],
                        [
                            1000.8,
                            100.2
                        ],
                        [
                            1000.8,
                            100.8
                        ],
                        [
                            1000.2,
                            100.8
                        ],
                        [
                            1000.2,
                            100.2
                        ]
                    ]
                ]
            ]
        }
    },
)
print(resp)

const response = await client.index({
  index: "example",
  document: {
    location: {
      type: "multipolygon",
      coordinates: [
        [
          [
            [1002, 200],
            [1003, 200],
            [1003, 300],
            [1002, 300],
            [1002, 200],
          ],
        ],
        [
          [
            [1000, 200],
            [1001, 100],
            [1001, 100],
            [1000, 100],
            [1000, 100],
          ],
          [
            [1000.2, 200.2],
            [1000.8, 100.2],
            [1000.8, 100.8],
            [1000.2, 100.8],
            [1000.2, 100.2],
          ],
        ],
      ],
    },
  },
});
console.log(response);

POST /example/_doc
{
  "location" : {
    "type" : "multipolygon",
    "coordinates" : [
      [ [[1002.0, 200.0], [1003.0, 200.0], [1003.0, 300.0], [1002.0, 300.0], [1002.0, 200.0]] ],
      [ [[1000.0, 200.0], [1001.0, 100.0], [1001.0, 100.0], [1000.0, 100.0], [1000.0, 100.0]],
        [[1000.2, 200.2], [1000.8, 100.2], [1000.8, 100.8], [1000.2, 100.8], [1000.2, 100.2]] ]
    ]
  }
}

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

resp = client.index(
    index="example",
    document={
        "location": "MULTIPOLYGON (((1002.0 200.0, 1003.0 200.0, 1003.0 300.0, 1002.0 300.0, 102.0 200.0)), ((1000.0 100.0, 1001.0 100.0, 1001.0 100.0, 1000.0 100.0, 1000.0 100.0), (1000.2 100.2, 1000.8 100.2, 1000.8 100.8, 1000.2 100.8, 1000.2 100.2)))"
    },
)
print(resp)

const response = await client.index({
  index: "example",
  document: {
    location:
      "MULTIPOLYGON (((1002.0 200.0, 1003.0 200.0, 1003.0 300.0, 1002.0 300.0, 102.0 200.0)), ((1000.0 100.0, 1001.0 100.0, 1001.0 100.0, 1000.0 100.0, 1000.0 100.0), (1000.2 100.2, 1000.8 100.2, 1000.8 100.8, 1000.2 100.8, 1000.2 100.2)))",
  },
});
console.log(response);

POST /example/_doc
{
  "location" : "MULTIPOLYGON (((1002.0 200.0, 1003.0 200.0, 1003.0 300.0, 1002.0 300.0, 102.0 200.0)), ((1000.0 100.0, 1001.0 100.0, 1001.0 100.0, 1000.0 100.0, 1000.0 100.0), (1000.2 100.2, 1000.8 100.2, 1000.8 100.8, 1000.2 100.8, 1000.2 100.2)))"
}

Geometry Collection

Следующий пример коллекции геометрических объектов GeoJSON:

resp = client.index(
    index="example",
    document={
        "location": {
            "type": "geometrycollection",
            "geometries": [
                {
                    "type": "point",
                    "coordinates": [
                        1000,
                        100
                    ]
                },
                {
                    "type": "linestring",
                    "coordinates": [
                        [
                            1001,
                            100
                        ],
                        [
                            1002,
                            100
                        ]
                    ]
                }
            ]
        }
    },
)
print(resp)

response = client.index(
  index: 'example',
  body: {
    location: {
      type: 'geometrycollection',
      geometries: [
        {
          type: 'point',
          coordinates: [
            1000,
            100
          ]
        },
        {
          type: 'linestring',
          coordinates: [
            [
              1001,
              100
            ],
            [
              1002,
              100
            ]
          ]
        }
      ]
    }
  }
)
puts response

const response = await client.index({
  index: "example",
  document: {
    location: {
      type: "geometrycollection",
      geometries: [
        {
          type: "point",
          coordinates: [1000, 100],
        },
        {
          type: "linestring",
          coordinates: [
            [1001, 100],
            [1002, 100],
          ],
        },
      ],
    },
  },
});
console.log(response);

POST /example/_doc
{
  "location" : {
    "type": "geometrycollection",
    "geometries": [
      {
        "type": "point",
        "coordinates": [1000.0, 100.0]
      },
      {
        "type": "linestring",
        "coordinates": [ [1001.0, 100.0], [1002.0, 100.0] ]
      }
    ]
  }
}

Следующий пример коллекции геометрических объектов WKT:

resp = client.index(
    index="example",
    document={
        "location": "GEOMETRYCOLLECTION (POINT (1000.0 100.0), LINESTRING (1001.0 100.0, 1002.0 100.0))"
    },
)
print(resp)

response = client.index(
  index: 'example',
  body: {
    location: 'GEOMETRYCOLLECTION (POINT (1000.0 100.0), LINESTRING (1001.0 100.0, 1002.0 100.0))'
  }
)
puts response

const response = await client.index({
  index: "example",
  document: {
    location:
      "GEOMETRYCOLLECTION (POINT (1000.0 100.0), LINESTRING (1001.0 100.0, 1002.0 100.0))",
  },
});
console.log(response);

POST /example/_doc
{
  "location" : "GEOMETRYCOLLECTION (POINT (1000.0 100.0), LINESTRING (1001.0 100.0, 1002.0 100.0))"
}

Огибающая

Elasticsearch поддерживает тип envelope, который состоит из координат верхних левого и нижнего правого углов фигуры, представляющих прямоугольник в формате [[minX, maxY], [maxX, minY]]:

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

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

POST /example/_doc
{
  "location" : {
    "type" : "envelope",
    "coordinates" : [ [1000.0, 100.0], [1001.0, 100.0] ]
  }
}

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

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

resp = client.index(
    index="example",
    document={
        "location": "BBOX (1000.0, 1002.0, 2000.0, 1000.0)"
    },
)
print(resp)

const response = await client.index({
  index: "example",
  document: {
    location: "BBOX (1000.0, 1002.0, 2000.0, 1000.0)",
  },
});
console.log(response);

POST /example/_doc
{
  "location" : "BBOX (1000.0, 1002.0, 2000.0, 1000.0)"
}

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

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

© 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/shape.html