using System.Collections.Generic;
using System.Linq;
using System.Xml.Linq;
using global::Sitecore.ContentSearch.SolrProvider.Pipelines.PopulateSolrSchema;
using SolrNet.Schema;

public class CustomPopulateHelper : SchemaPopulateHelper
{
  public CustomPopulateHelper(SolrSchema schema) : base(schema)
  {
  }

  public override IEnumerable<XElement> GetAllFields()
  {
      return base.GetAllFields().Union(GetAddCustomFields());
  }

  public override IEnumerable<XElement> GetAllFieldTypes()
  {
      return base.GetAllFieldTypes().Union(GetAddCustomFieldTypes());
  }

  private IEnumerable<XElement> GetAddCustomFields()
  {
      yield return CreateField("*_grpt",
          "geojson_rpt",
          isDynamic: true,
          required: false,
          indexed: true,
          stored: true,
          multiValued: false,
          omitNorms: false,
          termOffsets: false,
          termPositions: false,
          termVectors: false);
  }

  private IEnumerable<XElement> GetAddCustomFieldTypes()
  {
      yield return CreateFieldType("geojson_rpt", "solr.SpatialRecursivePrefixTreeFieldType",
          new Dictionary<string, string>
          {
              { "indexed", "true" },
              { "spatialContextFactory", "JTS" },
              { "geo", "true" },
              { "format", "GeoJSON" },
              { "autoIndex", "true" },
              { "validationRule", "repairBuffer0" },
              { "distErrPct", "0.025" },
              { "maxDistErr", "0.001" },
              { "distanceUnits", "kilometers" }
          });
  }
}

  <field fieldName="polygon" returnType="geojsonrptgeom">Custom.Indexes.Polygon, Custom.Assembly</field>

using Sitecore.ContentSearch;
using Sitecore.ContentSearch.ComputedFields;
using Sitecore.Diagnostics;
using System;

  public class Polygon : IComputedIndexField
  {
      public string Parameters { get; set; }
      public string FieldName { get; set; }
      public string ReturnType { get; set; }

      public object ComputeFieldValue(IIndexable indexable)
      {
          Assert.ArgumentNotNull(indexable, "indexable");
          try
          {
              if (!(indexable is SitecoreIndexableItem indexableItem))
              {
                  Log.Warn(string.Format("{0} : unsupported IIndexable type : {1}", this, indexable.GetType()), this);
                  return null;
              }
              if (indexableItem.Item?.TemplateID != Templates.Templates.Global.RegionPolygonData)
              {
                  return null;
              }
              return indexableItem.Item?.Fields["polygongeom"]?.Value;
          }
          catch (Exception ex)
          {
              Log.Error("Error while indexing Polygon", ex, this);
              return null;
          }
      }
  }

  public async Task<IEnumerable<LocationSearchResultName>> GetRegionNames(double lat, double lng)
  {
      var regionNames = new List<LocationSearchResultName>();
      var geoFieldName = "polygon_grpt";

      using (var client = new HttpClient())
        {
            var query = $"{YourIndexName}/select?fl=location_t%20and%20_group%20and%20_name&q={geoFieldName}%3A\"Intersects({lng}%20{lat})\"&wt=json";

            //Set basic auth authorization header if user info exists in uri
            var uri = new Uri(Sitecore.Configuration.Settings.GetConnectionString("solr.search"));
            if (!string.IsNullOrEmpty(uri.UserInfo))
            {
                var byteArray = Encoding.ASCII.GetBytes(uri.UserInfo);
                client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", System.Convert.ToBase64String(byteArray));
            }

            var response = await client.GetAsync($"{Sitecore.Configuration.Settings.GetConnectionString("solr.search")}/{query}");

            var responseContent = await response.Content.ReadAsStringAsync();
            if (!response.IsSuccessStatusCode)
            {
                MyLogger.Log.Warn($"{responseContent}");
            }

            var docs = JObject.Parse(responseContent);

            regionNames = docs["response"]["docs"].ToObject<List<LocationSearchResultName>>();
        }

      return regionNames;
  }

using Newtonsoft.Json;

public class LocationSearchResultName
{
  [JsonProperty("location_t")]
  public string LocationName { get; set; }

  [JsonProperty("_name")]
  public string Name { get; set; }

  [JsonProperty("_group")]
  public string ItemId { get; set; }
}