/// <summary>
/// Inserts the given value into each intersecting bin.
/// </summary>
/// <param name="box"></param>
/// <param name="value"></param>
public void Insert(Interval3d box, T value)
{
box.MakeIncreasing();
var key0 = ToKey(box.A);
var key1 = ToKey(box.B);
for (int k = key0.K; k <= key1.K; k++)
{
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, k));
// sync bin if necessary
if (bin.Version != _version)
{
bin.Version = _version;
bin.Clear();
}
bin.Add(value);
_count++;
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="countX"></param>
/// <param name="countY"></param>
/// <param name="origin"></param>
/// <param name="scale"></param>
public GridField3d <T> Create(int countX, int countY, int countZ, Interval3d bounds)
{
var result = Create(countX, countY, countZ);
result.Bounds = bounds;
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="args"></param>
public static void Start()
{
var random = new Random(0);
var box = new Interval3d(new Vec3d(0.0), new Vec3d(10.0)); // create a interval between the (0,0,0) and (10,10,10)
// create particles
var particles = new Particle[] {
new Particle(random.NextVec3d(box)),
new Particle(random.NextVec3d(box)),
new Particle(random.NextVec3d(box)),
new Particle(random.NextVec3d(box))
};
// create constraints
var constraints = new IConstraint[] {
new PlanarQuad(0, 1, 2, 3)
};
// create solver
var solver = new ConstraintSolver();
// wait for keypress to start the solver
Console.WriteLine("Press return to start the solver.");
Console.ReadLine();
// step the solver until converged
while (!solver.IsConverged)
{
solver.Step(particles, constraints);
Console.WriteLine($" step {solver.StepCount}");
}
Console.WriteLine("\nSolver converged! Press return to exit.");
Console.ReadLine();
}
/// <summary>
/// Returns each intersecting bin.
/// </summary>
private IEnumerable <Bin> SearchImpl(Interval3d box)
{
box.MakeIncreasing();
var key0 = ToKey(box.A);
var key1 = ToKey(box.B);
for (int k = key0.K; k <= key1.K; k++)
{
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, k), out Bin bin))
{
continue;
}
// skip bin if not synced
if (bin.LastVersion != _version)
{
continue;
}
yield return(bin);
}
}
}
}
/// <summary>
/// Returns each intersecting bin.
/// </summary>
private IEnumerable <Bin> SearchImpl(Interval3d box)
{
box.MakeIncreasing();
(int i0, int j0, int k0) = IndicesAt(box.A);
(int i1, int j1, int k1) = IndicesAt(box.B);
var currQuery = NextQuery;
for (int k = k0; k <= k1; k++)
{
for (int j = j0; j <= j1; j++)
{
for (int i = i0; i <= i1; i++)
{
var bin = GetBin(i, j, k);
// skip bin if not synced or already visited
if (bin.LastVersion != _currVersion || bin.LastQuery == currQuery)
{
continue;
}
bin.LastQuery = currQuery;
yield return(bin);
}
}
}
}
/// <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(Interval3d box, Stack <IEnumerable <T> > result)
{
foreach (var bin in SearchImpl(box))
{
result.Push(bin);
}
}
/// <summary>
///
/// </summary>
/// <param name="interval"></param>
/// <returns></returns>
public static BoundingBox ToBoundingBox(this Interval3d interval)
{
var x = interval.X;
var y = interval.Y;
var z = interval.Z;
return(new BoundingBox(x.A, y.A, z.A, x.B, y.B, z.B));
}
/// <summary>
///
/// </summary>
/// <param name="bounds"></param>
/// <param name="countX"></param>
/// <param name="countY"></param>
/// <param name="countZ"></param>
/// <param name="wrapModeX"></param>
/// <param name="wrapModeY"></param>
/// <param name="wrapModeZ"></param>
public Grid3d(Interval3d bounds, int countX, int countY, int countZ, WrapMode wrapModeX, WrapMode wrapModeY, WrapMode wrapModeZ)
: this(countX, countY, countZ)
{
Bounds = bounds;
_wrapModeX = wrapModeX;
_wrapModeY = wrapModeY;
_wrapModeZ = wrapModeZ;
}
/// <summary>
///
/// </summary>
/// <param name="interval"></param>
/// <returns></returns>
public static BoundingBox ToBoundingBox(this Interval3d interval)
{
Interval1d x = interval.X;
Interval1d y = interval.Y;
Interval1d z = interval.Z;
return(new BoundingBox(x.A, y.A, z.A, x.B, y.B, z.B));
}
/// <summary>
///
/// </summary>
public static void Evaluate(this IDiscreteField <Vec3d> field, Interval3d interval, IDiscreteField <Vec3d> 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 <Vec3d> field, Interval3d from, Interval3d to, IDiscreteField <Vec3d> 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 <Vector3d> field, Interval3d from, Interval3d to, ISampledField <Vector3d> 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 <Vector3d> field, Interval3d interval, ISampledField <Vector3d> 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(Interval3d 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 InitVector(IGH_DataAccess DA, int nx, int ny, int nz, Interval3d bounds)
{
var f = GridField3d.Vector3d.Create(nx, ny, nz, 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 => (Vector3d)x.Value), f.CountXYZ));
}
DA.SetData(0, new GH_ObjectWrapper(f));
}
/// <summary>
/// Returns the contents of all intersecting bins.
/// </summary>
public void Search(Interval3d box, List <T> result)
{
box.MakeIncreasing();
var key0 = ToKey(box.A);
var key1 = ToKey(box.B);
for (int k = key0.K; k <= key1.K; k++)
{
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, k), out Bin bin) && bin.Version == _version)
{
result.AddRange(bin);
}
}
}
}
}
/// <summary>
/// Returns each intersecting bin.
/// </summary>
private IEnumerable <Bin> SearchImpl(Interval3d box)
{
box.MakeIncreasing();
var key0 = ToKey(box.A);
var key1 = ToKey(box.B);
for (int k = key0.K; k <= key1.K; k++)
{
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, k), out Bin bin) && bin.Version == _version)
{
yield return(bin);
}
}
}
}
}
/// <summary>
/// Inserts the given value into each intersecting bin.
/// </summary>
/// <param name="box"></param>
/// <param name="value"></param>
public void Insert(Interval3d box, T value)
{
box.MakeIncreasing();
(int i0, int j0, int k0) = IndicesAt(box.A);
(int i1, int j1, int k1) = IndicesAt(box.B);
var currQuery = NextQuery;
for (int k = k0; k <= k1; k++)
{
for (int j = j0; j <= j1; j++)
{
for (int i = i0; i <= i1; i++)
{
var bin = GetBin(i, j, k);
// 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="bitmaps"></param>
/// <param name="mapper"></param>
/// <param name="interval"></param>
/// <returns></returns>
public static GridVectorField3d CreateFromImageStack(IList <Bitmap> bitmaps, Func <Color, Vec3d> mapper, Interval3d interval)
{
var bmp0 = bitmaps[0];
int nx = bmp0.Width;
int ny = bmp0.Height;
int nz = bitmaps.Count;
var result = new GridVectorField3d(interval, nx, ny, nz);
FieldIO.ReadFromImageStack(bitmaps, result, mapper);
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="interval"></param>
/// <param name="weight"></param>
public InsideInterval(Interval3d interval, double weight = 1.0, int capacity = DefaultCapacity)
: base(weight, capacity)
{
Interval = interval;
}
/// <summary>
///
/// </summary>
/// <param name="indices"></param>
/// <param name="interval"></param>
/// <param name="weight"></param>
public InsideInterval(IEnumerable <int> indices, Interval3d interval, double weight = 1.0, int capacity = DefaultCapacity)
: base(weight, capacity)
{
Handles.AddRange(indices.Select(i => new H(i)));
Interval = interval;
}
/// <summary>
///
/// </summary>
/// <param name="indices"></param>
/// <param name="interval"></param>
/// <param name="weight"></param>
public InsideInterval(IEnumerable <int> indices, Interval3d interval, double weight = 1.0)
: base(weight)
{
Handles.AddRange(indices.Select(i => new H(i)));
Interval = interval;
}
/// <summary>
///
/// </summary>
/// <param name="interval"></param>
/// <param name="capacity"></param>
/// <param name="weight"></param>
public InsideInterval(Interval3d interval, int capacity, double weight = 1.0)
: base(capacity, weight)
{
Interval = interval;
}
/// <summary>
///
/// </summary>
/// <param name="interval"></param>
/// <param name="weight"></param>
public InsideInterval(Interval3d interval, double weight = 1.0)
: base(weight)
{
Interval = interval;
}
/// <summary>
///
/// </summary>
/// <param name="interval"></param>
/// <param name="countX"></param>
/// <param name="countY"></param>
/// <param name="countZ"></param>
/// <param name="wrapModeX"></param>
/// <param name="wrapModeY"></param>
/// <param name="wrapModeZ"></param>
/// <param name="sampleMode"></param>
public GridField3d(Interval3d interval, int countX, int countY, int countZ, WrapMode wrapModeX, WrapMode wrapModeY, WrapMode wrapModeZ, SampleMode sampleMode = SampleMode.Linear)
: base(interval, countX, countY, countZ, wrapModeX, wrapModeY, wrapModeZ)
{
_values = new T[Count];
SampleMode = sampleMode;
}
/// <summary>
///
/// </summary>
/// <param name="interval"></param>
/// <param name="countX"></param>
/// <param name="countY"></param>
/// <param name="countZ"></param>
/// <param name="wrapMode"></param>
/// <param name="sampleMode"></param>
public GridScalarField3d(Interval3d interval, int countX, int countY, int countZ, WrapMode wrapMode = WrapMode.Clamp, SampleMode sampleMode = SampleMode.Linear)
: base(interval, countX, countY, countZ, wrapMode, sampleMode)
{
}
/// <summary>
/// Returns the contents of all intersecting bins.
/// </summary>
public IEnumerable <T> Search(Interval3d box)
{
return(SearchImpl(box).SelectMany(x => x));
}
/// <summary>
///
/// </summary>
/// <param name="bounds"></param>
/// <param name="weight"></param>
public InsideBounds(int index, Interval3d bounds, double weight = 1.0)
{
_handle.Index = index;
_bounds = bounds;
Weight = weight;
}
/// <summary>
///
/// </summary>
/// <param name="interval"></param>
/// <param name="countX"></param>
/// <param name="countY"></param>
/// <param name="countZ"></param>
/// <param name="wrapModeX"></param>
/// <param name="wrapModeY"></param>
/// <param name="wrapModeZ"></param>
/// <param name="sampleMode"></param>
public GridVectorField3d(Interval3d interval, int countX, int countY, int countZ, WrapMode wrapModeX, WrapMode wrapModeY, WrapMode wrapModeZ, SampleMode sampleMode = SampleMode.Linear)
: base(interval, countX, countY, countZ, wrapModeX, wrapModeY, wrapModeZ, sampleMode)
{
}
/// <summary>
///
/// </summary>
/// <param name="bounds"></param>
/// <param name="countX"></param>
/// <param name="countY"></param>
/// <param name="countZ"></param>
/// <param name="wrapMode"></param>
public Grid3d(Interval3d bounds, int countX, int countY, int countZ, WrapMode wrapMode = WrapMode.Clamp)
: this(countX, countY, countZ)
{
Bounds = bounds;
_wrapModeX = _wrapModeY = _wrapModeZ = wrapMode;
}
