public SpatialField(string fieldName, SpatialOptions options)
{
this.options = options;
ntsContext = CreateNtsContext(options);
shapeStringReadWriter = new ShapeStringReadWriter(options, ntsContext);
strategy = CreateStrategy(fieldName, options, ntsContext);
}
public SpatialField(string fieldName, SpatialOptions options)
{
_options = options ?? throw new ArgumentNullException(nameof(options));
_ntsContext = CreateNtsContext(options);
_shapeStringReadWriter = new ShapeStringReadWriter(options, _ntsContext);
Strategy = CreateStrategy(fieldName, options, _ntsContext);
}
private NtsShapeReadWriter CreateNtsShapeReadWriter(SpatialOptions opt, NtsSpatialContext ntsContext)
{
if (opt.Type == SpatialFieldType.Cartesian)
{
return(new NtsShapeReadWriter(ntsContext, false));
}
return(geoShapeReadWriter ?? (geoShapeReadWriter = new NtsShapeReadWriter(ntsContext, false)));
}
private static NtsSpatialContext CreateNtsContext(SpatialOptions options)
{
if (options.Type == SpatialFieldType.Cartesian)
{
var nts = new NtsSpatialContext(new GeometryFactory(), false, new CartesianDistCalc(), null);
nts.GetWorldBounds().Reset(options.MinX, options.MaxX, options.MinY, options.MaxY);
return nts;
}
return GeoContext;
}
internal SpatialOptions(SpatialOptions options)
{
Type = options.Type;
Strategy = options.Strategy;
MaxTreeLevel = options.MaxTreeLevel;
MinX = options.MinX;
MaxX = options.MaxX;
MinY = options.MinY;
MaxY = options.MaxY;
Units = options.Units;
}
private static NtsSpatialContext CreateNtsContext(SpatialOptions options)
{
if (options.Type == SpatialFieldType.Cartesian)
{
var nts = new NtsSpatialContext(new NtsSpatialContextFactory {
geo = false, distCalc = new CartesianDistCalc(), worldBounds = null
});
nts.WorldBounds.Reset(options.MinX, options.MaxX, options.MinY, options.MaxY);
return(nts);
}
return(GeoContext);
}
private static SpatialStrategy CreateStrategy(string fieldName, SpatialOptions opt, NtsSpatialContext context)
{
switch (opt.Strategy)
{
case SpatialSearchStrategy.GeohashPrefixTree:
return new RecursivePrefixTreeStrategyThatSupportsWithin(new GeohashPrefixTree(context, opt.MaxTreeLevel), fieldName);
case SpatialSearchStrategy.QuadPrefixTree:
return new RecursivePrefixTreeStrategyThatSupportsWithin(new QuadPrefixTree(context, opt.MaxTreeLevel), fieldName);
case SpatialSearchStrategy.BoundingBox:
return new BBoxStrategyThatSupportsAllShapes(context, fieldName);
}
return null;
}
public Circle(ICircle circle, SpatialUnits units, SpatialOptions options)
: base(SpatialShapeType.Circle)
{
if (circle == null)
{
throw new ArgumentNullException(nameof(circle));
}
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
Center = new Coordinates(circle.Center);
Radius = ShapeStringReadWriter.TranslateDegreesToRadius(circle.Radius, units, options);
Units = units;
}
public void UpdateFromSpatialOptions(SpatialOptions spatialOptions)
{
Type = spatialOptions.Type;
ResetToDefaults();
Strategy = spatialOptions.Strategy;
MaxTreeLevel = spatialOptions.MaxTreeLevel;
if (spatialOptions.Type == SpatialFieldType.Geography)
{
Units = spatialOptions.Units;
}
else
{
MinX = spatialOptions.MinX;
MaxX = spatialOptions.MaxX;
MinY = spatialOptions.MinY;
MaxY = spatialOptions.MaxY;
}
}
protected bool Equals(SpatialOptions other)
{
var result = Type == other.Type && Strategy == other.Strategy;
if (Type == SpatialFieldType.Geography)
{
result = result && Units == other.Units;
}
if (Strategy != SpatialSearchStrategy.BoundingBox)
{
result = result && MaxTreeLevel == other.MaxTreeLevel;
if (Type == SpatialFieldType.Cartesian)
{
result = result &&
MinX.Equals(other.MinX) &&
MaxX.Equals(other.MaxX) &&
MinY.Equals(other.MinY) &&
MaxY.Equals(other.MaxY);
}
}
return(result);
}
protected bool Equals(SpatialOptions other)
{
var result = Type == other.Type && Strategy == other.Strategy;
if (Type == SpatialFieldType.Geography)
{
result = result && Units == other.Units;
}
if (Strategy != SpatialSearchStrategy.BoundingBox)
{
result = result && MaxTreeLevel == other.MaxTreeLevel;
if (Type == SpatialFieldType.Cartesian)
{
result = result
&& MinX.Equals(other.MinX)
&& MaxX.Equals(other.MaxX)
&& MinY.Equals(other.MinY)
&& MaxY.Equals(other.MaxY);
}
}
return result;
}
public ShapeStringReadWriter(SpatialOptions options, NtsSpatialContext context)
{
this.options = options;
this.ntsShapeReadWriter = CreateNtsShapeReadWriter(options, context);
this.shapeStringConverter = new ShapeStringConverter(options);
}
public ShapeStringConverter(SpatialOptions options)
{
this.options = options;
}
public static double TranslateDegreesToRadius(double degrees, SpatialUnits units, SpatialOptions options)
{
if (options.Type == SpatialFieldType.Cartesian)
{
return(degrees);
}
var radius = (degrees * Constants.Documents.Indexing.Spatial.EarthMeanRadiusKm) / RadiansToDegrees;
if (units == SpatialUnits.Miles)
{
radius /= Constants.Documents.Indexing.Spatial.MilesToKm;
}
return(radius);
}
public ShapeStringReadWriter(SpatialOptions options, NtsSpatialContext context)
{
_options = options;
_context = context;
_shapeStringConverter = new ShapeStringConverter(options);
}
public IndexSettings()
{
Spatial = new SpatialOptions();
Search = new SearchOptions();
}