public float SelectFloatValue(Func <double> random, INamedDataCollection data)
{
Contract.Requires(random != null);
Contract.Requires(data != null);
return(default(float));
}
protected override float GenerateFloatValue(Func <double> random, INamedDataCollection data)
{
Contract.Requires(random != null);
Contract.Requires(data != null);
return(default(float));
}
public override ITerminationRule Rule(Func <double> random, INamedDataCollection metadata)
{
Contract.Requires(random != null);
Contract.Requires(metadata != null);
return(default(ITerminationRule));
}
public override IReadOnlyList <Vector2> Apply(Func <double> random, INamedDataCollection metadata, IReadOnlyList <Vector2> footprint, IReadOnlyList <Vector2> basis, IReadOnlyList <Vector2> lot)
{
var center = footprint.Aggregate((a, b) => a + b) / footprint.Count;
var radians = _angle.SelectFloatValue(random, metadata).ToRadians();
return(footprint.Select(a => Vector3.Transform((a - center).X_Y(0), Quaternion.CreateFromAxisAngle(Vector3.UnitY, radians)).XZ() + center).ToArray());
}
public void Build(TracingConfiguration config, Func <double> random, INamedDataCollection metadata, Region region)
{
Contract.Requires(config != null);
Contract.Requires(random != null);
Contract.Requires(metadata != null);
Contract.Requires(region != null);
//var extent = region.Max - region.Min;
//var eigens = config.TensorField.Presample(new Vector2(region.Min.X, region.Min.Y), new Vector2(region.Max.X, region.Max.Y), (int)Math.Max(extent.X, extent.Y));
var ex = _max - _min;
var eigens = config.TensorField.Presample(_min, _max, (uint)Math.Max(ex.X, ex.Y));
var seeds = SeedsAlongEdge(region, config.SeparationField, eigens.MajorEigenVectors, eigens.MinorEigenVectors);
Build(seeds, region.Min, region.Max,
config.SeparationField,
true, true,
config.MergeDistance,
config.SegmentLength,
config.CosineSearchConeAngle,
p => !region.PointInPolygon(p), e => e.Streamline.Region == region,
s => {
s.Width = (uint)config.RoadWidth.SelectIntValue(random, metadata);
s.Region = region;
LinearReduction(s);
});
}
/// <summary>
/// Get the sidewalk width, or if one has not been generated, generate one based off MinimumSidewalkWidthName and MaximumSidewalkWidthName value
/// </summary>
/// <param name="provider">The provider to get and put value from/to</param>
/// <param name="random">A random number generator (generating values from 0 to 1)</param>
/// <param name="min">The minimum allowable value</param>
/// <param name="max">The maximum allowable value</param>
/// <returns></returns>
public static float RoadSidewalkWidth(this INamedDataCollection provider, Func <double> random, float?min = null, float?max = null)
{
Contract.Requires(provider != null);
Contract.Requires(random != null);
return(provider.DetermineHierarchicalValue(random, MathHelper.Lerp, RoadSidewalkWidthName, MinimumSidewalkWidthName, MaximumSidewalkWidthName, min, max));
}
public override void Subdivide(Prism bounds, ISubdivisionGeometry geometry, INamedDataCollection hierarchicalParameters)
{
//Select external building parameters
var externals = SelectExternals().ToArray();
//Create things
_floors = CreateFloors(SelectFloors().ToArray(), Footprints(externals));
_verticals = SelectVerticals().ToArray();
_facades = CreateFacades(geometry, externals, hierarchicalParameters);
//Setup relationship between floors (floor PrerequisiteOf floor-further-from-ground)
foreach (var keyValuePair in _floors)
{
//Ground floor has no prerequisites
if (keyValuePair.Key == 0)
{
continue;
}
//Work out the index of the prerequisite
var prereqIndex = keyValuePair.Key < 0 ? keyValuePair.Key + 1 : keyValuePair.Key - 1;
//Try to find it (this *shouldn't* ever fail, if we have a continuous run of floors)
IFloor prereq;
if (_floors.TryGetValue(prereqIndex, out prereq))
{
keyValuePair.Value.AddPrerequisite(prereq);
}
}
}
/// <summary>
/// Get the sidewalk material, or if one has not been generated, generate one based off DefaultSidewalkMaterial
/// </summary>
/// <param name="provider"></param>
/// <param name="random"></param>
/// <param name="defaultMaterial"></param>
/// <returns></returns>
public static string RoadSidewalkMaterial(this INamedDataCollection provider, Func <double> random, string defaultMaterial = null)
{
Contract.Requires(provider != null);
Contract.Requires(random != null);
return(provider.DefaultMaterial(random, RoadSidewalkMaterialName, defaultMaterial ?? provider.GetValue(DefaultSidewalkMaterialName)));
}
/// <summary>
/// Get the standard ceiling height, or if one has not been generated, generate one based off MinimumStandardCeilingHeightName and MaximumStandardCeilingHeightName value
/// </summary>
/// <param name="provider">The provider to get and put value from/to</param>
/// <param name="random">A random number generator (generating values from 0 to 1)</param>
/// <param name="min">The minimum allowable value</param>
/// <param name="max">The maximum allowable value</param>
/// <returns></returns>
public static float StandardCeilingHeight(this INamedDataCollection provider, Func <double> random, float?min = null, float?max = null)
{
Contract.Requires(provider != null);
Contract.Requires(random != null);
return(provider.DetermineHierarchicalValue(random, MathHelper.Lerp, StandardCeilingHeightName, MinimumStandardCeilingHeightName, MaximumStandardCeilingHeightName, min, max));
}
/// <summary>
/// Determine a value by deriving it from a previously calculated value and then store the result
/// </summary>
/// <typeparam name="T">The type of the value</typeparam>
/// <param name="provider">Provider for previously defined value as well as the target to store the new value in</param>
/// <param name="name">The name of the value</param>
/// <param name="update">Function to derive a new value from an old one</param>
/// <param name="generate">Function to generate a new value if no old one existed</param>
/// <returns>The determined value</returns>
public static T DetermineHierarchicalValue <T>(this INamedDataCollection provider, TypedName <T> name, Func <T, T> update, Func <T> generate) where T : IEquatable <T>
{
Contract.Requires(provider != null);
Contract.Requires(update != null);
Contract.Requires(generate != null);
T value;
if (provider.TryGetValue <T>(name, out value))
{
var oldValue = value;
value = update(oldValue);
if (!EqualityComparer <T> .Default.Equals(oldValue, value))
{
provider.Set <T>(name, value);
}
}
else
{
value = generate();
provider.Set <T>(name, value);
}
return(value);
}
public void Build(TracingConfiguration config, Func <double> random, INamedDataCollection metadata, Vector2 min, Vector2 max)
{
Contract.Requires(config != null);
Contract.Requires(random != null);
Contract.Requires(metadata != null);
if (!_begun)
{
Begin(min, max);
AddBoundary(min, max);
}
var extent = max - min;
var eigens = config.TensorField.Presample(min, max, (uint)Math.Max(extent.X, extent.Y));
var count = (int)((extent.X * extent.Y) / 2500);
Func <Vector2, bool> isOutOfBounds = v => v.X > max.X || v.X <min.X || v.Y> max.Y || v.Y < min.Y;
var seeds = RandomSeedsInBounds(random, count, eigens.MajorEigenVectors, eigens.MinorEigenVectors, min, max, isOutOfBounds);
Build(seeds, min, max, config.SeparationField, true, true, config.SegmentLength, config.MergeDistance, config.CosineSearchConeAngle, isOutOfBounds, null, s =>
{
s.Width = (uint)config.RoadWidth.SelectIntValue(random, metadata);
LinearReduction(s);
});
}
public override IReadOnlyList <Vector2> Apply(Func <double> random, INamedDataCollection metadata, IReadOnlyList <Vector2> footprint, IReadOnlyList <Vector2> basis, IReadOnlyList <Vector2> lot)
{
var c = new Clipper();
const int SCALE = 1000;
c.AddPath(footprint.Select(a => new IntPoint((int)(a.X * SCALE), (int)(a.Y * SCALE))).ToList(), PolyType.ptSubject, true);
var clip = _lot ? lot : basis;
c.AddPath(clip.Select(a => new IntPoint((int)(a.X * SCALE), (int)(a.Y * SCALE))).ToList(), PolyType.ptClip, true);
var solutions = new List <List <IntPoint> >();
c.Execute(ClipType.ctIntersection, solutions);
var clipperSolution = solutions.Single();
Contract.Assume(clipperSolution != null);
if (Clipper.Orientation(clipperSolution))
{
clipperSolution.Reverse();
}
return(clipperSolution.Select(a => new Vector2(a.X / (float)SCALE, a.Y / (float)SCALE)).ToArray());
}
public static string DefaultMaterial(this INamedDataCollection provider, Func <double> random, TypedName <string> name, params string[] possibilities)
{
Contract.Requires(provider != null);
Contract.Requires(random != null);
Contract.Requires(possibilities != null);
//Select a random value from the possibilities
var generated = possibilities.Length == 0 ? null : possibilities[random.RandomInteger(0, possibilities.Length - 1)];
return(provider.DetermineHierarchicalValue(name, oldValue =>
{
//If no possibilities were provided, everything is valid!
if (possibilities.Length == 0)
{
return oldValue;
}
//Use the old value if it is one of the allowed possibilities
if (((IList <string>)possibilities).Contains(oldValue))
{
return oldValue;
}
//Otherwise generate a new value (from the range of allowed possibilities)
return generated;
}, () => generated));
}
public static float ExternalWallThickness(this INamedDataCollection provider, Func <double> random, float?min = null, float?max = null)
{
Contract.Requires(provider != null);
Contract.Requires(random != null);
return(provider.DetermineHierarchicalValue(random, MathHelper.Lerp, ExternalWallThicknessName, MinimumExternalWallThicknessName, MaximumExternalWallThicknessName, min, max));
}
public override void Subdivide(Prism bounds, ISubdivisionGeometry geometry, INamedDataCollection hierarchicalParameters)
{
//Create land parcels
var nodes = CreateParcelNodes(GenerateParcels(bounds.Footprint).ToArray(), bounds.Height).ToArray();
//Set ground height (for nodes which care)
foreach (var grounded in nodes.Select(node => node.Value).OfType <IGrounded>())
{
grounded.GroundHeight = GroundHeight;
}
//Build neighbour set
var neighbours = new NeighbourSet <ISubdivisionContext>();
foreach (var keyValuePair in nodes)
{
foreach (var edge in keyValuePair.Key.Edges)
{
neighbours.Add(new LineSegment2(edge.Start, edge.End), keyValuePair.Value);
}
}
//Associate node with their neighbours (for nodes which care)
foreach (var neighbour in nodes.Where(node => node.Value is INeighbour))
{
((INeighbour)neighbour.Value).Neighbours = CalculateNeighbours(neighbour, neighbours).ToArray();
}
}
public override ITerminationRule Rule(Func <double> random, INamedDataCollection metadata)
{
return(new AccessRule(
_resource,
TerminationChance.SelectFloatValue(random, metadata)
));
}
/// <summary>
/// Evaluate this building design spec to create a set of building internals (floors and vertical elements)
/// </summary>
/// <param name="random"></param>
/// <param name="metadata"></param>
/// <param name="finder"></param>
/// <returns></returns>
public Internals Internals(Func <double> random, INamedDataCollection metadata, Func <KeyValuePair <string, string>[], Type[], ScriptReference> finder)
{
Contract.Requires(random != null);
Contract.Requires(metadata != null);
Contract.Requires(finder != null);
Contract.Ensures(Contract.Result <Internals>() != null);
var ground = _floorSelectors.OfType <GroundMarker>().Single();
var aboveGround = _floorSelectors.TakeWhile(a => !(a is GroundMarker)).Append(ground).ToArray();
var belowGround = _floorSelectors.SkipWhile(a => !(a is GroundMarker)).Skip(1).ToArray();
List <FootprintSelection> footprints = new List <FootprintSelection>();
//Select above ground floors, then assign indices
var above = SelectFloors(random, metadata, finder, aboveGround, ground, aboveGround: true);
int index = 0;
float compoundHeight = 0;
foreach (var run in above.Reverse())
{
if (run.Selection.Count > 0)
{
footprints.Add(new FootprintSelection(run.Marker, index));
foreach (var floor in run.Selection.Reverse())
{
floor.Index = index++;
floor.CompoundHeight = compoundHeight;
compoundHeight += floor.Height;
}
}
}
//Select below ground floors, then assign indices
var below = SelectFloors(random, metadata, finder, belowGround, ground, aboveGround: false);
index = 0;
compoundHeight = 0;
foreach (var run in below)
{
foreach (var floor in run.Selection)
{
floor.Index = --index;
floor.CompoundHeight = compoundHeight;
compoundHeight -= floor.Height;
}
footprints.Add(new FootprintSelection(run.Marker, index));
}
//Create result object (with floors)
var internals = new Internals(this, above.Select(a => a.Selection.ToArray()).ToArray(), below.Select(a => a.Selection.ToArray()).ToArray(), footprints.ToArray());
//Select vertical elements for floors and add to result
internals.Verticals = SelectVerticals(random, finder, _verticalSelectors, internals.Floors).ToArray();
//return result
return(internals);
}
public override bool Check(Parcel parcel, Func <double> random, INamedDataCollection metadata)
{
var min = _min.SelectFloatValue(random, metadata);
var max = _max.SelectFloatValue(random, metadata);
var ratio = parcel.AspectRatio();
return(ratio >= min && ratio <= max);
}
public override bool Check(Parcel parcel, Func <double> random, INamedDataCollection metadata)
{
var min = _min.SelectFloatValue(random, metadata);
var max = _max.SelectFloatValue(random, metadata);
var area = parcel.Area();
return(area >= min && area <= max);
}
public bool Check(Parcel parcel, Func <double> random, INamedDataCollection metadata)
{
Contract.Requires(parcel != null);
Contract.Requires(random != null);
Contract.Requires(metadata != null);
return(_constraints.All(constraint => constraint.Check(parcel, random, metadata)));
}
public override bool Check(Parcel parcel, Func <double> random, INamedDataCollection metadata)
{
Contract.Requires(parcel != null);
Contract.Requires(random != null);
Contract.Requires(metadata != null);
return(default(bool));
}
public ITensorField Unwrap(Func <double> random, INamedDataCollection metadata)
{
Contract.Requires(random != null);
Contract.Requires(metadata != null);
Contract.Ensures(Contract.Result <ITensorField>() != null);
return(default(ITensorField));
}
public TracingConfiguration Minor(Func <double> random, INamedDataCollection metadata)
{
Contract.Requires(random != null);
Contract.Requires(metadata != null);
Contract.Ensures(Contract.Result <TracingConfiguration>() != null);
return(_minor.Unwrap(random, metadata));
}
public static string DefaultMaterial(this INamedDataCollection provider, Func <double> random, params string[] possibilities)
{
Contract.Requires(provider != null);
Contract.Requires(random != null);
Contract.Requires(possibilities != null);
return(DefaultMaterial(provider, random, DefaultMaterialName, possibilities));
}
public override void Subdivide(Prism bounds, ISubdivisionGeometry geometry, INamedDataCollection hierarchicalParameters)
{
//Generate a topological map of city roads
var m = GenerateBlockMesh();
//Materialize the topological map into a topographical one
MaterializeMesh(m);
}
public override ITerminationRule Rule(Func <double> random, INamedDataCollection metadata)
{
return(new AreaRule(
_min.SelectFloatValue(random, metadata),
_max.SelectFloatValue(random, metadata),
TerminationChance.SelectFloatValue(random, metadata)
));
}
public ITensorField Unwrap(Func <double> random, INamedDataCollection metadata)
{
var tensors = Tensors;
Contract.Assume(tensors != null);
return(new Addition(tensors.Select(a => a.Unwrap(random, metadata)).ToArray()));
}
public override void Subdivide(Prism bounds, ISubdivisionGeometry geometry, INamedDataCollection hierarchicalParameters)
{
if (!_deleted)
{
base.Subdivide(bounds, geometry, _parameters ?? hierarchicalParameters);
}
IsSubdivided = true;
}
public IEnumerable <ISpec> Expand(Func <double> random, INamedDataCollection metadata)
{
var count = Count.SelectIntValue(random, metadata);
for (var i = 0; i < count; i++)
{
yield return(Space);
}
}
public override IEnumerable <FloorRun> Select(Func <double> random, INamedDataCollection metadata, Func <KeyValuePair <string, string>[], Type[], ScriptReference> finder)
{
Contract.Requires(random != null);
Contract.Requires(metadata != null);
Contract.Requires(finder != null);
Contract.Ensures(Contract.Result <IEnumerable <FloorRun> >() != null);
return(default(IEnumerable <FloorRun>));
}
