Filter Results Inside a Polygon

Dataset

The dataset contains 3000+ of the biggest airports in the world.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
[
 {
    "objectID": "3797",
    "name": "John F Kennedy Intl",
    "city": "New York",
    "country": "United States",
    "iata_code": "JFK",
    "_geoloc": {
      "lat": 40.639751,
      "lng": -73.778925
    },
    "links_count": 911
  }
]

To tell Algolia where each record is located, we need to have the latitude and longitude stored in the _geoloc attribute.

You can download the dataset here. Have look at how to import it in Algolia here

Initialize the client

1
2
3
4
5
6
7
8
9
10
11
12
// composer autoload
require __DIR__ . '/vendor/autoload.php';

// if you are not using composer
// require_once 'path/to/algoliasearch.php';

$client = \Algolia\AlgoliaSearch\SearchClient::create(
  'YourApplicationID',
  'YourAdminAPIKey'
);

$index = $client->initIndex('your_index_name');

1
2
3
4
5
6
require 'rubygems'
require 'algoliasearch'

Algolia.init(application_id: 'YourApplicationID',
             api_key:        'YourAdminAPIKey')
index = Algolia::Index.new('your_index_name')

1
2
3
4
5
6
7
8
9
10
11
// const algoliasearch = require('algoliasearch');
// const algoliasearch = require('algoliasearch/reactnative');
// const algoliasearch = require('algoliasearch/lite');
// import algoliasearch from 'algoliasearch';
//
// or just use algoliasearch if you are using a <script> tag
// if you are using AMD module loader, algoliasearch will not be defined in window,
// but in the AMD modules of the page

const client = algoliasearch('YourApplicationID', 'YourAdminAPIKey');
const index = client.initIndex('your_index_name');

1
2
3
4
from algoliasearch.search_client import SearchClient

client = SearchClient.create('YourApplicationID', 'YourAdminAPIKey')
index = client.init_index('your_index_name')

1
2
let client = Client(appID: "YourApplicationID", apiKey: "YourAdminAPIKey")
let index = client.index(withName: "your_index_name")

1
2
Client client = new Client("YourApplicationID", "YourAdminAPIKey");
Index index = client.getIndex("your_index_name");

1
2
SearchClient client = new SearchClient("YourApplicationID", "YourAdminAPIKey");
SearchIndex index = client.InitIndex("your_index_name");

1
2
3
4
SearchClient client = 
DefaultSearchClient.create("YourApplicationID", "YourAdminAPIKey");

SearchIndex index = client.InitIndex("your_index_name");

1
2
3
4
5
6
7
8
package main

import "github.com/algolia/algoliasearch-client-go/algolia/search"

func main() {
  client := search.NewClient("YourApplicationID", "YourAdminAPIKey")
  index := client.InitIndex("your_index_name")
}

1
2
// No initIndex
val client = new AlgoliaClient("YourApplicationID", "YourAdminAPIKey")

1
2
3
4
5
6
7
val client = ClientSearch(
    applicationID = ApplicationID("latency"),
    apiKey = APIKey("YourAdminAPIKey")
)
val indexName = IndexName("your_index_name")

client.initIndex(indexName)

Configure Index Settings

Even if we want to sort by distance to a location, we need the textual relevance to be good in case we refine the search with a query.

For that let’s configure the index.

1
2
3
4
5
6
7
8
9
10
11
$index->setSettings({
  'searchableAttributes' => [
    'name',
    'city',
    'country',
    'iata_code'
  ],
  'customRanking': [
    'desc(links_count)'
  ]
});

1
2
3
4
5
6
7
8
9
10
11
index.set_settings(
  searchableAttributes: [
    'name',
    'city',
    'country',
    'iata_code'
  ],
  customRanking: [
    'desc(links_count)'
  ]
)

1
2
3
4
index.setSettings(new IndexSettings()
    .setSearchableAttributes(Arrays.asList("name", "city", "country", "iata_code"))
    .setCustomRanking(Collections.singletonList("desc(links_count"))
);

1
2
3
4
5
6
7
8
9
res, err := index.SetSettings(search.Settings{
  SearchableAttributes: opt.SearchableAttributes(
    "name",
    "city",
    "country",
    "iata_code",
  ),
  CustomRanking: opt.CustomRanking("desc(links_count)"),
})

1
2
3
4
5
6
7
8
9
10
11
12
13
val settings = settings {
    searchableAttributes {
        +"name"
        +"city"
        +"country"
        +"iata_code"
    }
    customRanking {
        +Desc("links_count")
    }
}

index.setSettings(settings)

Searchable attributes

We’re going to search in our 4 textual attributes: name, city, country and iata_code.

Custom Ranking

We will use the number of other connected airports to any airport as a ranking metric - the more connection the better.

Filtering inside a polygonal area

Let’s filter inside the United State of America.

USA can be considered as a polygon:

To filter inside this polygon we need the latitude and longitude of all the points:

• 42.01,-124.31,
• 48.835509470063045,-124.40453125000005
• 45.01082951668149,-65.95726562500005
• 31.247243545293433,-81.06578125000004
• 25.924152577235226,-97.68234374999997
• 32.300311895879545,-117.54828125

We are going to use the insidePolygon parameter:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
$polygon = [
  42.01,
  -124.31,

  48.835509470063045,
  -124.40453125000005,

  45.01082951668149,
  -65.95726562500005,

  31.247243545293433,
  -81.06578125000004,

  25.924152577235226,
  -97.68234374999997,

  32.300311895879545,
  -117.54828125
];

$results = $index->search('', [
  'insidePolygon' => [$polygon]
]);

1
2
3
4
5
6
7
8
9
10
polygon = [
  42.01,-124.31,
  48.835509470063045,-124.40453125000005,
  45.01082951668149,-65.95726562500005,
  31.247243545293433,-81.06578125000004,
  25.924152577235226,-97.68234374999997,
  32.300311895879545,-117.54828125
]

results = index.search('', insidePolygon: [ polygon ])

1
2
3
4
5
6
7
8
9
index.search(new Query().setInsidePolygon(
      Arrays.asList(
              Arrays.asList(42.01f, -124.31f),
              Arrays.asList(48.835509470063045f, -124.40453125000005f),
              Arrays.asList(45.01082951668149f, -65.95726562500005f),
              Arrays.asList(31.247243545293433f, -81.06578125000004f),
              Arrays.asList(25.924152577235226f, -97.68234374999997f),
              Arrays.asList(32.300311895879545f, -117.54828125f)
      )));

1
2
3
4
5
6
7
8
9
10
11
12
polygons := [][]float64{
  {
    42.01, -124.31,
    48.835509470063045, -124.40453125000005,
    45.01082951668149, -65.95726562500005,
    31.247243545293433, -81.06578125000004,
    25.924152577235226, -97.68234374999997,
    32.300311895879545, -117.54828125,
  },
}

res, err := index.Search("", opt.InsidePolygon(polygons))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
val query = query {
    insidePolygon {
        +Polygon(
            Point(42.01f, -124.31f),
            Point(48.835509470063045f, -124.40453125000005f),
            Point(45.01082951668149f, -65.95726562500005f),
            Point(31.247243545293433f, -81.06578125000004f),
            Point(25.924152577235226f, -97.68234374999997f),
            Point(32.300311895879545f, -117.54828125f)
        )
    }
}

index.search(query)

We are using the empty query ('') because we want all airports.