/***************************************************/
private static Polyline ClipActivityArea(Plane clipping, ActivityArea activityArea)
{
List <Point> control = new List <Point>();
foreach (Line seg in activityArea.PlayingArea.SubParts())
{
//is start infront or behind plane?
Point s = seg.StartPoint();
Point e = clipping.Origin;
Vector v = Geometry.Create.Vector(e) - Geometry.Create.Vector(s);
double d = Geometry.Query.DotProduct(clipping.Normal, v);
if (d < 0)//infront
{
control.Add(s);
}
Point p = seg.PlaneIntersection(clipping, false);
if (p != null)
{
control.Add(p);
}
}
//close the polyline
control.Add(control[0]);
Polyline clippedPoly = Geometry.Create.Polyline(control);
return(clippedPoly);
}
private void SetLastAreaFocus(ActivityArea area)
{
switch (area)
{
case ActivityArea.CG:
HomeIlhasHelper.previousHomeFocus = HomeIlhasHelper.PreviousHomeFocus.IVulcan;
break;
case ActivityArea.EF:
HomeIlhasHelper.previousHomeFocus = HomeIlhasHelper.PreviousHomeFocus.IBeach;
break;
case ActivityArea.EO:
HomeIlhasHelper.previousHomeFocus = HomeIlhasHelper.PreviousHomeFocus.IGlacius;
break;
case ActivityArea.ET:
HomeIlhasHelper.previousHomeFocus = HomeIlhasHelper.PreviousHomeFocus.ITech;
break;
case ActivityArea.TS:
HomeIlhasHelper.previousHomeFocus = HomeIlhasHelper.PreviousHomeFocus.IForest;
break;
default:
break;
}
}
public async Task <IActionResult> AddJobActivityArea(string name)
{
if (!String.IsNullOrEmpty(name))
{
try
{
var activityArea = new ActivityArea
{
Name = name,
};
await _dbContext.ActivityAreas.AddAsync(activityArea);
await _dbContext.SaveChangesAsync();
return(Json(activityArea));
}
catch (Exception)
{
return(Json("fail"));
}
}
return(Json("fail"));
}
/***************************************************/
/**** Private Methods ****/
/***************************************************/
private static List <Evalue> EvaluateEvalue(Audience audience, EvalueSettings settings, ActivityArea activityArea)
{
List <Evalue> results = new List <Evalue>();
KDTree <Spectator> spectatorTree = SetKDTree(audience);
foreach (Spectator s in audience.Spectators)
{
Vector rowVector = Geometry.Query.CrossProduct(Vector.ZAxis, s.Head.PairOfEyes.ViewDirection);
Vector viewVector = s.Head.PairOfEyes.ViewDirection;
if (settings.ViewType == EvalueViewEnum.ToPoint)
{
viewVector = activityArea.ActivityFocalPoint - s.Head.PairOfEyes.ReferenceLocation;
}
results.Add(EvalueResult(s, rowVector, viewVector, activityArea.PlayingArea, settings));
}
return(results);
}
public static List <List <Evalue> > EvalueAnalysis(List <Audience> audience, EvalueSettings settings, ActivityArea activityArea)
{
List <List <Evalue> > results = new List <List <Evalue> >();
foreach (Audience a in audience)
{
results.Add(EvaluateEvalue(a, settings, activityArea));
}
return(results);
}
public static List <Evalue> EvalueAnalysis(Audience audience, EvalueSettings settings, ActivityArea activityArea)
{
List <Evalue> results = EvaluateEvalue(audience, settings, activityArea);
return(results);
}
public static StadiaParameters StadiaParameters(double structBayWidth = 7.5, double cornerRadius = 10.0, double sideBound = 6.7,
double endBound = 7.8, double sideRadius = 240.0, double endRadius = 200.0, double theatronRadius = 100.0, int numCornerBays = 7,
StadiaType typeOfBowl = StadiaType.EightArc, double cornerFraction = 0.5, ActivityArea activityArea = null, double pitchLength = 90, double pitchWidth = 45)
{
if (activityArea == null)
{
activityArea = Create.ActivityArea(1);
}
return(new StadiaParameters
{
StructBayWidth = structBayWidth,
CornerRadius = cornerRadius,
SideBound = sideBound,
EndBound = endBound,
SideRadius = sideRadius,
EndRadius = endRadius,
TheatronRadius = theatronRadius,
NumCornerBays = numCornerBays,
TypeOfBowl = typeOfBowl,
CornerFraction = cornerFraction,
ActivityArea = activityArea,
PitchLength = pitchLength,
PitchWidth = pitchWidth,
});
}
/***************************************************/
/**** Private Methods ****/
/***************************************************/
private static List <Avalue> EvaluateAvalue(Audience audience, AvalueSettings settings, ActivityArea activityArea)
{
List <Avalue> results = new List <Avalue>();
KDTree <Spectator> spectatorTree = null;
if (settings.CalculateOcclusion)
{
spectatorTree = SetKDTree(audience);
}
foreach (Spectator s in audience.Spectators)
{
Vector rowVector = Geometry.Query.CrossProduct(Vector.ZAxis, s.Head.PairOfEyes.ViewDirection);
Vector viewVect = activityArea.ActivityFocalPoint - s.Head.PairOfEyes.ReferenceLocation;
results.Add(ClipView(s, rowVector, viewVect, settings, activityArea, spectatorTree));
}
return(results);
}
public static List <List <Evalue> > EvalueAnalysis(this List <Audience> audience, EvalueSettings settings, ActivityArea activityArea)
{
List <List <Evalue> > results = new List <List <Evalue> >();
if (audience == null || settings == null || activityArea == null)
{
BH.Engine.Reflection.Compute.RecordError("Cannot query the EvalueAnalysis if the audience, settings, or activity area are null.");
return(results);
}
foreach (Audience a in audience)
{
results.Add(EvaluateEvalue(a, settings, activityArea));
}
return(results);
}
/***************************************************/
private static Avalue ClipView(Spectator spectator, Vector rowV, Vector viewVect, AvalueSettings settings, ActivityArea activityArea, KDTree <Spectator> tree)
{
Avalue result = new Avalue();
Vector viewY = Geometry.Query.CrossProduct(viewVect, rowV);
Vector viewX = Geometry.Query.CrossProduct(viewVect, viewY);
viewVect = viewVect.Normalise();
Vector shift = viewVect * settings.EyeFrameDist;
Point shiftOrigin = spectator.Head.PairOfEyes.ReferenceLocation + shift;
Point viewClipOrigin = spectator.Head.PairOfEyes.ReferenceLocation + 2 * shift;
//planes need orientation
Plane viewPlane = Geometry.Create.Plane(shiftOrigin, viewVect);
Plane viewClip = Geometry.Create.Plane(viewClipOrigin, viewVect);
//get the view cone
result.ViewCone = Create.ViewCone(viewY, viewX, shiftOrigin, 1, settings.ConeType);
//find part of activity area to project
Polyline clippedArea = ClipActivityArea(viewClip, activityArea);
//project the pitch
result.FullActivityArea = ProjectPolylineToPlane(viewPlane, clippedArea, spectator.Head.PairOfEyes.ReferenceLocation);
//clip the pitch against the viewcone
result.ClippedActivityArea = ClipActivityArea(result.FullActivityArea, result.ViewCone, spectator, viewPlane);
//calculate the avalue
result.AValue = result.ClippedActivityArea.Sum(x => x.Area()) / result.ViewCone.ConeArea * 100;
//clip heads infront
if (settings.CalculateOcclusion)
{
List <Spectator> occludingSpectators = GetPotentialOcclusion(spectator, tree, 3);
if (occludingSpectators.Count > 0)
{
List <Polyline> occludingClippedHeads = ClipHeads(occludingSpectators, spectator, viewPlane, result.ClippedActivityArea);
if (occludingClippedHeads.Count > 0)
{
result.Heads = occludingClippedHeads;
result.Occulsion = occludingClippedHeads.Sum(x => x.Area()) / result.ViewCone.ConeArea * 100;
CheckPolylineGeo(occludingClippedHeads);
}
}
}
return(result);
}
public static List <Evalue> EvalueAnalysis(this Audience audience, EvalueSettings settings, ActivityArea activityArea)
{
if (audience == null || settings == null || activityArea == null)
{
BH.Engine.Reflection.Compute.RecordError("Cannot query the EvalueAnalysis if the audience, settings, or activity area are null.");
return(new List <Evalue>());
}
List <Evalue> results = EvaluateEvalue(audience, settings, activityArea);
return(results);
}
public void EValueAnanlysisTest(TheatronGeometry bowl, ActivityArea activityArea)
{
var settings = BH.Engine.Humans.ViewQuality.Create.EvalueSettings(EvalueViewEnum.ToPoint);
var results = BH.Engine.Humans.ViewQuality.Query.EvalueAnalysis(bowl.Audience, settings, activityArea);
}
public void CValueAnanlysisTest(TheatronGeometry bowl, ActivityArea activityArea)
{
var settings = BH.Engine.Humans.ViewQuality.Create.CvalueSettings(CvalueFocalMethodEnum.Perpendicular);
var results = BH.Engine.Humans.ViewQuality.Query.CvalueAnalysis(bowl.Audience, settings, activityArea.PlayingArea);
}
public void AValueAnalysisTest(TheatronGeometry bowl, ActivityArea activityArea)
{
var settings = BH.Engine.Humans.ViewQuality.Create.AvalueSettings(ViewConeEnum.DynamicConeArea, true);
var results = BH.Engine.Humans.ViewQuality.Query.AvalueAnalysis(bowl.Tiers3d[0].TierBlocks[0].Audience, settings, activityArea);
}
public void TestAnalysis(TheatronGeometry theatronGeometry, ActivityArea activityArea)
{
AValueAnalysisTest(theatronGeometry, activityArea);
CValueAnanlysisTest(theatronGeometry, activityArea);
EValueAnanlysisTest(theatronGeometry, activityArea);
}
