/// <summary>
/// Inserts the given value into each intersecting bin.
/// </summary>
/// <param name="box"></param>
/// <param name="value"></param>
public void Insert(Interval2d box, T value)
{
box.MakeIncreasing();
var key0 = ToKey(box.A);
var key1 = ToKey(box.B);
for (int j = key0.J; j <= key1.J; j++)
{
for (int i = key0.I; i <= key1.I; i++)
{
var bin = GetBin(new BinKey(i, j));
// sync bin if necessary
if (bin.LastVersion != _version)
{
bin.LastVersion = _version;
bin.Clear();
}
bin.Push(value);
_count++;
}
}
}
/// <summary>
///
/// </summary>
/// <param name="countX"></param>
/// <param name="countY"></param>
/// <param name="origin"></param>
/// <param name="scale"></param>
public GridField2d <T> Create(int countX, int countY, Interval2d bounds)
{
var result = Create(countX, countY);
result.Bounds = bounds;
return(result);
}
/// <summary>
/// Returns each intersecting bin.
/// </summary>
private IEnumerable <Bin> SearchImpl(Interval2d box)
{
box.MakeIncreasing();
var key0 = ToKey(box.A);
var key1 = ToKey(box.B);
for (int j = key0.J; j <= key1.J; j++)
{
for (int i = key0.I; i <= key1.I; i++)
{
// skip if no bin at key
if (!_bins.TryGetValue(new BinKey(i, j), out Bin bin))
{
continue;
}
// skip bin if not synced
if (bin.LastVersion != _version)
{
continue;
}
yield return(bin);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="bounds"></param>
/// <param name="countX"></param>
/// <param name="countY"></param>
/// <param name="wrapModeX"></param>
/// <param name="wrapModeY"></param>
public Grid2d(Interval2d bounds, int countX, int countY, WrapMode wrapModeX, WrapMode wrapModeY)
: this(countX, countY)
{
Bounds = bounds;
_wrapX = wrapModeX;
_wrapY = wrapModeY;
}
/// <summary>
/// Adds the contents of each intersecting bin to the given stack.
/// This implementation separates the the collection of bins (not threadsafe) from the processing of their contents (potentially threadsafe) making it better suited to concurrent applications.
/// </summary>
/// <param name="box"></param>
/// <param name="result"></param>
public void Search(Interval2d box, Stack <IEnumerable <T> > result)
{
foreach (var bin in SearchImpl(box))
{
result.Push(bin);
}
}
/// <summary>
/// Returns each intersecting bin.
/// </summary>
private IEnumerable <Bin> SearchImpl(Interval2d box)
{
box.MakeIncreasing();
(int i0, int j0) = IndicesAt(box.A);
(int i1, int j1) = IndicesAt(box.B);
var currQuery = NextQuery;
for (int j = j0; j <= j1; j++)
{
for (int i = i0; i <= i1; i++)
{
var bin = GetBin(i, j);
// skip bin if not synced or already visited
if (bin.LastVersion != _currVersion || bin.LastQuery == currQuery)
{
continue;
}
bin.LastQuery = currQuery;
yield return(bin);
}
}
}
/// <summary>
/// Inserts the given value into each intersecting bin.
/// </summary>
/// <param name="box"></param>
/// <param name="value"></param>
public void Insert(Interval2d box, T value)
{
box.MakeIncreasing();
(int i0, int j0) = IndicesAt(box.A);
(int i1, int j1) = IndicesAt(box.B);
var currQuery = NextQuery;
for (int j = j0; j <= j1; j++)
{
for (int i = i0; i <= i1; i++)
{
var bin = GetBin(i, j);
// skip bin if already visited
if (bin.LastQuery == currQuery)
{
continue;
}
bin.LastQuery = currQuery;
// sync bin if necessary
if (bin.LastVersion != _currVersion)
{
bin.LastVersion = _currVersion;
bin.Clear();
}
bin.Add(value);
_count++;
}
}
}
/// <summary>
///
/// </summary>
/// <param name="interval"></param>
/// <returns></returns>
public static BoundingBox ToBoundingBox(this Interval2d interval)
{
var x = interval.X;
var y = interval.Y;
return(new BoundingBox(x.A, y.A, 0.0, x.B, y.B, 0.0));
}
/// <summary>
///
/// </summary>
public static void Evaluate(this IDiscreteField <Vec2d> field, Interval2d interval, IDiscreteField <Vec2d> result, bool parallel = false)
{
if (parallel)
{
ArrayMath.EvaluateParallel(field.Values, interval, result.Values);
}
else
{
ArrayMath.Evaluate(field.Values, interval, result.Values);
}
}
/// <summary>
///
/// </summary>
public static void Remap(this IDiscreteField <Vec2d> field, Interval2d from, Interval2d to, IDiscreteField <Vec2d> result, bool parallel = false)
{
if (parallel)
{
ArrayMath.RemapParallel(field.Values, from, to, result.Values);
}
else
{
ArrayMath.Remap(field.Values, from, to, result.Values);
}
}
/// <summary>
///
/// </summary>
public static void Remap(this ISampledField <Vector2d> field, Interval2d from, Interval2d to, ISampledField <Vector2d> result, bool parallel = false)
{
if (parallel)
{
Matrix.Parallel.RemapColumns(field.Values, from, to, result.Values);
}
else
{
Matrix.RemapColumns(field.Values, from, to, result.Values);
}
}
/// <summary>
///
/// </summary>
public static void Evaluate(this ISampledField <Vector2d> field, Interval2d interval, ISampledField <Vector2d> result, bool parallel = false)
{
if (parallel)
{
Matrix.Parallel.EvaluateColumns(field.Values, interval, result.Values);
}
else
{
Matrix.EvaluateColumns(field.Values, interval, result.Values);
}
}
/// <summary>
/// Calls the given delegate on each value within each intersecting bin.
/// The search can be aborted by returning false from the given callback.
/// If aborted, this function will also return false.
/// </summary>
public bool Search(Interval2d box, Func <T, bool> callback)
{
foreach (var bin in SearchImpl(box))
{
foreach (var value in bin)
{
if (!callback(value))
{
return(false);
}
}
}
return(true);
}
/// <summary>
///
/// </summary>
private void InitScalar(IGH_DataAccess DA, int nx, int ny, Interval2d bounds)
{
var f = GridField2d.Double.Create(nx, ny, bounds);
f.WrapMode = _wrapMode;
f.SampleMode = _sampleMode;
List <GH_Number> vals = new List <GH_Number>();
if (DA.GetDataList(4, vals))
{
f.Set(LongestList(vals.Select(x => x.Value), f.CountXY));
}
DA.SetData(0, new GH_ObjectWrapper(f));
}
/// <summary>
/// Returns the contents of all intersecting bin.
/// </summary>
public void Search(Interval2d box, List <T> result)
{
box.MakeIncreasing();
var key0 = ToKey(box.A);
var key1 = ToKey(box.B);
for (int j = key0.J; j <= key1.J; j++)
{
for (int i = key0.I; i <= key1.I; i++)
{
if (_bins.TryGetValue(new BinKey(i, j), out Bin bin) && bin.Version == _version)
{
result.AddRange(bin);
}
}
}
}
/// <summary>
/// Returns each intersecting bin.
/// </summary>
private IEnumerable <Bin> SearchImpl(Interval2d box)
{
box.MakeIncreasing();
var key0 = ToKey(box.A);
var key1 = ToKey(box.B);
for (int j = key0.J; j <= key1.J; j++)
{
for (int i = key0.I; i <= key1.I; i++)
{
if (_bins.TryGetValue(new BinKey(i, j), out Bin bin) && bin.Version == _version)
{
yield return(bin);
}
}
}
}
/// <summary>
///
/// </summary>
private void InitVector(IGH_DataAccess DA, int nx, int ny, Interval2d bounds)
{
var f = GridField2d.Vec2d.Create(nx, ny, bounds);
f.WrapMode = _wrapMode;
f.SampleMode = _sampleMode;
List <GH_Vector> vals = new List <GH_Vector>();
if (DA.GetDataList(4, vals))
{
f.Set(LongestList(vals.Select(x => ToVec2d(x.Value)), f.Count));
}
DA.SetData(0, new GH_ObjectWrapper(f));
Vec2d ToVec2d(Vector3d v)
{
return(new Vec2d(v.X, v.Y));
}
}
/// <summary>
///
/// </summary>
/// <param name="interval"></param>
/// <param name="countX"></param>
/// <param name="countY"></param>
/// <param name="wrapMode"></param>
/// <param name="sampleMode"></param>
public GridVectorField2d(Interval2d interval, int countX, int countY, WrapMode wrapMode = WrapMode.Clamp, SampleMode sampleMode = SampleMode.Linear)
: base(interval, countX, countY, wrapMode, sampleMode)
{
}
/// <summary>
///
/// </summary>
/// <param name="bounds"></param>
/// <param name="countX"></param>
/// <param name="countY"></param>
/// <param name="wrapMode"></param>
public Grid2d(Interval2d bounds, int countX, int countY, WrapMode wrapMode = WrapMode.Clamp)
: this(countX, countY)
{
Bounds = bounds;
_wrapX = _wrapY = wrapMode;
}
/// <summary>
///
/// </summary>
/// <param name="interval"></param>
/// <param name="countX"></param>
/// <param name="countY"></param>
/// <param name="wrapModeX"></param>
/// <param name="wrapModeY"></param>
/// <param name="sampleMode"></param>
public GridField2d(Interval2d interval, int countX, int countY, WrapMode wrapModeX, WrapMode wrapModeY, SampleMode sampleMode = SampleMode.Linear)
: base(interval, countX, countY, wrapModeX, wrapModeY)
{
_values = new T[Count];
SampleMode = sampleMode;
}
public UVInterval Interval2dToNative(Interval2d interval)
{
return(new UVInterval(IntervalToNative(interval.u), IntervalToNative(interval.v)));
}
/// <summary>
///
/// </summary>
/// <param name="bitmap"></param>
/// <param name="mapper"></param>
/// <param name="interval"></param>
/// <returns></returns>
public static GridScalarField2d CreateFromImage(Bitmap bitmap, Func <Color, double> mapper, Interval2d interval)
{
int nx = bitmap.Width;
int ny = bitmap.Height;
var result = new GridScalarField2d(interval, nx, ny);
FieldIO.ReadFromImage(bitmap, result, mapper);
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="interval"></param>
/// <param name="countX"></param>
/// <param name="countY"></param>
/// <param name="wrapModeX"></param>
/// <param name="wrapModeY"></param>
/// <param name="sampleMode"></param>
public GridScalarField2d(Interval2d interval, int countX, int countY, WrapMode wrapModeX, WrapMode wrapModeY, SampleMode sampleMode = SampleMode.Linear)
: base(interval, countX, countY, wrapModeX, wrapModeY, sampleMode)
{
}
/// <summary>
/// Returns the contents of all intersecting bins.
/// </summary>
public IEnumerable <T> Search(Interval2d box)
{
return(SearchImpl(box).SelectMany(x => x));
}