public GridData(eState[,] tileStates)
{
_tileStates = (eState[, ])tileStates.Clone();
_winningLine = null;
_width = tileStates.GetLength(0);
_height = tileStates.GetLength(1);
}
private CompResult ComputeParallelLines(double width, List <MyPoint3D> cartPolygon, LineDefinition lineDef, List <MyPoint3D> intersections, bool addLinesToMap)
{
CompResult result = new CompResult();
while (intersections.Count > 1)
{
intersections = intersections.Distinct(new MyPoint3D.MyPoint3D_EqualityComparer()).ToList();
if (intersections.Min(p => p.Y) == intersections.Max(p => p.Y))
{
intersections.Sort(new MyPoint3D.MyPoint3D_ComparerByX());
}
else
{
intersections.Sort(new MyPoint3D.MyPoint3D_ComparerByY());
}
for (int i = 0; i < intersections.Count - 1; i += 2)
{
var p1 = intersections[i + 1];
var p2 = intersections[i];
result.LinesLength += (p1 - p2).Norm;
result.LinesCount++;
if (addLinesToMap)
{
AddLineToMap(p1, p2);
AddSwathToMap(p1, p2, width);
}
}
lineDef = LineDefinition.GetParallelLine(lineDef, width);
intersections = Utility.GetHeadlandIntersections(cartPolygon, lineDef, width);
}
return(result);
}
/// <summary>
/// Gets the value of PWL for given time.
/// </summary>
/// <param name="time">Time.</param>
/// <returns>
/// PWL's value for given time.
/// </returns>
protected double GetLineValue(double time)
{
while (_currentLineIndex < _pwlPoints)
{
if (Times[_currentLineIndex] >= time)
{
long prevLineIndex = _currentLineIndex - 1;
if (prevLineIndex >= 0)
{
if (_lineDefinition == null)
{
_lineDefinition = CreateLineParameters(Times[prevLineIndex], Times[_currentLineIndex], Voltages[prevLineIndex], Voltages[_currentLineIndex]);
_breakPointAdded = false;
}
return((_lineDefinition.A * time) + _lineDefinition.B);
}
else
{
return(Voltages[0]);
}
}
_breakPointAdded = false;
_lineDefinition = null;
_currentLineIndex++;
}
return(Voltages[_pwlPoints - 1]);
}
public void IncrementScore(int winner, LineDefinition winningLine)
{
if(winner > -1)
{
++_scores[winner];
}
}
public GridData(eState[,] tileStates)
{
_tileStates = (eState[,])tileStates.Clone();
_winningLine = null;
_width = tileStates.GetLength(0);
_height = tileStates.GetLength(1);
}
public void IncrementScore(int winner, LineDefinition winningLine)
{
if (winner > -1)
{
++_scores[winner];
}
}
public void HighlightWinningLine(int winner, LineDefinition winningLine)
{
if(winningLine != null)
{
StartCoroutine(_gridDisplay.FlashWinningTiles(winningLine, _gameManager.ResetScene));
}
}
public void HighlightWinningLine(int winner, LineDefinition winningLine)
{
if (winningLine != null)
{
StartCoroutine(_gridDisplay.FlashWinningTiles(winningLine, _gameManager.ResetScene));
}
}
public GridData(int width, int height)
{
_tileStates = null;
_winningLine = null;
_width = width;
_height = height;
_tileStates = new eState[width, height];
}
public GridData(int width, int height)
{
_tileStates = null;
_winningLine = null;
_width = width;
_height = height;
_tileStates = new eState[width, height];
}
void doAllFields()
{
if (selectedField == null)
{
if (Fields.Count > 0)
{
selectedField = Fields.First();
}
}
GuidanceLines.Clear();
Swathes.Clear();
AnalysisResult.Clear();
foreach (var poly in Fields)
{
PointExtension.LocalLatitude = poly.Locations.Min(p => p.Latitude);
var geoPolygon = new List <GeoPoint>();
foreach (var p in poly.Locations)
{
geoPolygon.Add(p.ToGeoPoint());
}
List <MyPoint3D> cartPolygon = new List <MyPoint3D>();
foreach (var p in poly.Locations)
{
cartPolygon.Add(p.ToGeoPoint().ToCart());
}
var lineDef = LineDefinition.GetBestLine(cartPolygon);
var res = AnalyzeFieldAndShowSwaths(poly, lineDef);
if (double.IsNaN(res.AppliedArea))
{
continue;
}
res.AppliedArea = res.AppliedArea / 10000;
res.FieldArea = res.FieldArea / 10000;
//res.Savings = (res.AppliedArea - res.FieldArea) * CostHa;
res.SectionSaving = (res.AppliedArea - res.FieldArea) * CostHa * (1 - 1.0 / NumberOfSections);
res.SectionLoss = (res.AppliedArea - res.FieldArea) * CostHa - res.SectionSaving;
res.FieldName = (AnalysisResult.Count + 1).ToString();
AnalysisResult.Add(res);
}
AppliedArea = AnalysisResult.Sum(r => r.AppliedArea);
FieldArea = AnalysisResult.Sum(r => r.FieldArea);
SectionSaving = AnalysisResult.Sum(r => r.SectionSaving);
SectionLoss = AnalysisResult.Sum(r => r.SectionLoss);
double totalNozzleSaving = (AppliedArea - FieldArea) * CostHa * (1 - 1.0 / NumberOfNozzles);
NozzleSaving = totalNozzleSaving - SectionSaving;
NozzleLoss = (AppliedArea - FieldArea) * CostHa - totalNozzleSaving;
SectionPaybackHa = SectionControlPrice / (SectionSaving / AppliedArea);
NozzlePaybackHa = (NozzleControlPrice - SectionControlPrice) / (NozzleSaving / AppliedArea);
}
private void FindWinningLine(Move move)
{
List <LineDefinition> lines = GetLines(move);
foreach (LineDefinition line in lines)
{
if (IsWinningLine(line))
{
_winningLine = line;
}
}
}
public IEnumerator FlashWinningTiles(LineDefinition winningLine, PostFlashRoutine postFlashRoutine)
{
for(int flashCount = 0; flashCount < 6; ++flashCount)
{
yield return new WaitForSeconds(0.15f);
bool flashOn = flashCount%2 == 0;
for(int tileCount = 0; tileCount < 3; ++tileCount)
{
Move tilePosition = winningLine.GetMove(tileCount);
TileDisplay tileDisplay = GetTileDisplay(tilePosition);
tileDisplay.SetWinningFlashMaterial(flashOn);
}
}
postFlashRoutine();
}
public static LineDefinitionList XmlToLineDefinitionsList(string body)
{
var lineList = new LineDefinitionList();
var doc = XDocument.Parse(body);
// Handle all LINES
var lines = from node in doc.Descendants(NS + "line")
select new
{
object_type = node.Attribute(MOVENS + "object-type").Value,
name = (node.Attribute("title") == null) ? null : node.Attribute("title").Value,
active = (node.Attribute(MOVENS + "active") == null) ? null : node.Attribute(MOVENS + "active").Value,
id = (node.Attribute(MOVENS + "id") == null) ? null : node.Attribute(MOVENS + "id").Value,
stroke = (node.Attribute("stroke") == null) ? null : node.Attribute("stroke").Value,
used = ((node.Attribute(MOVENS + "used") != null) ? (node.Attribute(MOVENS + "used").Value.ToLower() == "true") : false),
x1 = node.Attribute("x1").Value,
y1 = node.Attribute("y1").Value,
x2 = node.Attribute("x2").Value,
y2 = node.Attribute("y2").Value,
events = ((node.Attribute("name") == null) ? null : node.Attribute("name").Value)
};
foreach (var line in lines)
{
if (line.object_type.ToUpper() != LINE)
{
continue;
}
var newLine = new LineDefinition();
newLine.Id = int.Parse(line.id);
newLine.Name = line.name;
newLine.Active = (line.active.ToLower() == "true");
newLine.Used = line.used;
newLine.Color = line.stroke;
newLine.LeftName = LeftName(line.events);
newLine.RightName = RightName(line.events);
newLine.Initial.X = (int)Convert.ToDouble(line.x1);
newLine.Initial.Y = (int)Convert.ToDouble(line.y1);
newLine.Terminal.X = (int)Convert.ToDouble(line.x2);
newLine.Terminal.Y = (int)Convert.ToDouble(line.y2);
lineList.LineDefinitions.Add(newLine);
}
return(lineList);
}
public IEnumerator FlashWinningTiles(LineDefinition winningLine, PostFlashRoutine postFlashRoutine)
{
for (int flashCount = 0; flashCount < 6; ++flashCount)
{
yield return(new WaitForSeconds(0.15f));
bool flashOn = flashCount % 2 == 0;
for (int tileCount = 0; tileCount < 3; ++tileCount)
{
Move tilePosition = winningLine.GetMove(tileCount);
TileDisplay tileDisplay = GetTileDisplay(tilePosition);
tileDisplay.SetWinningFlashMaterial(flashOn);
}
}
postFlashRoutine();
}
public static bool LinesIntersection3d(LineDefinition lineA, LineDefinition lineB, out Vector3d closestPointA, out Vector3d closestPointB)
{
closestPointA = Vector3d.Zero;
closestPointB = Vector3d.Zero;
var dirProjection = lineA.UnitDirection.Dot(lineB.UnitDirection);
if (Math.Abs(Math.Abs(dirProjection) - 1.0) < 0.00001)
{
return(false); // parallel sides
}
var sepProjection1 = (lineB.Point - lineA.Point).Dot(lineA.UnitDirection);
var sepProjection2 = (lineB.Point - lineA.Point).Dot(lineB.UnitDirection);
var d1 = (sepProjection1 - dirProjection * sepProjection2) / (1 - dirProjection * dirProjection);
var d2 = (dirProjection * sepProjection1 - sepProjection2) / (1 - dirProjection * dirProjection);
closestPointA = lineA.Point + d1 * lineA.UnitDirection;
closestPointB = lineB.Point + d2 * lineB.UnitDirection;
return(true);
}
private bool IsWinningLine(LineDefinition lineDefinition)
{
Move firstMove = lineDefinition.GetMove(0);
eState firstState = _tileStates[firstMove._column, firstMove._row];
if (firstState == eState.empty)
{
return(false);
}
for (int tileCount = 1; tileCount < 3; ++tileCount)
{
Move move = lineDefinition.GetMove(tileCount);
if (_tileStates[move._column, move._row] != firstState)
{
return(false);
}
}
return(true);
}
void processField()
{
PointExtension.LocalLatitude = selectedField.Locations.Min(p => p.Latitude);
LineDefinition lineDef_AB = LineDefinition.GetLineDefinition(flagA.Location.ToGeoPoint().ToCart(), flagB.Location.ToGeoPoint().ToCart());
GuidanceLines.Clear();
Swathes.Clear();
AnalysisResult res = AnalyzeFieldAndShowSwaths(selectedField, lineDef_AB);
AppliedArea = res.AppliedArea / 10000;
FieldArea = res.FieldArea / 10000;
//Savings = (res.AppliedArea - res.FieldArea) / 10000 * CostHa;
SectionSaving = (res.AppliedArea - res.FieldArea) / 10000 * CostHa * (1 - 1.0 / NumberOfSections);
SectionLoss = (res.AppliedArea - res.FieldArea) / 10000 * CostHa - SectionSaving;
double totalNozzleSaving = (res.AppliedArea - res.FieldArea) / 10000 * CostHa * (1 - 1.0 / NumberOfNozzles);
NozzleSaving = totalNozzleSaving - SectionSaving;
NozzleLoss = (res.AppliedArea - res.FieldArea) / 10000 * CostHa - totalNozzleSaving;
SectionPaybackHa = SectionControlPrice / (SectionSaving / AppliedArea);
NozzlePaybackHa = (NozzleControlPrice - SectionControlPrice) / (NozzleSaving / AppliedArea);
}
private void FindWinningLine(Move move)
{
List<LineDefinition> lines = GetLines(move);
foreach(LineDefinition line in lines)
{
if(IsWinningLine(line))
{
_winningLine = line;
}
}
}
public static void OnGameWonEvent(int winningPlayer, LineDefinition winningLine)
{
OnGameWon(winningPlayer, winningLine);
}
public bool Equals(LineDefinition other)
{
return this.LineParams.IsSameLine(other.LineParams);
}
private bool IsWinningLine(LineDefinition lineDefinition)
{
Move firstMove = lineDefinition.GetMove(0);
eState firstState = _tileStates[firstMove._column, firstMove._row];
if(firstState == eState.empty)
{
return false;
}
for(int tileCount = 1; tileCount < 3; ++tileCount)
{
Move move = lineDefinition.GetMove(tileCount);
if(_tileStates[move._column, move._row] != firstState)
{
return false;
}
}
return true;
}
public void TestChooseHeadlandInterstion()
{
List <MyPoint3D> headland = new List <MyPoint3D>();
//headland.Add(new MyPoint3D());
headland.Add(new MyPoint3D()
{
X = 10
});
headland.Add(new MyPoint3D()
{
Y = 10
});
headland.Add(new MyPoint3D()
{
X = -10
});
headland.Add(new MyPoint3D()
{
Y = -10
});
headland.Add(new MyPoint3D()
{
X = 10
});
//headland.Add(new MyPoint3D());
LineDefinition line = new LineDefinition()
{
k = 1
};
LineDefinition headlandLine = new LineDefinition()
{
k = -1, b = 10
};
var intersection = Utility.ChooseHeadlandIntersection(headland, line, 2, headlandLine, new MyPoint3D()
{
X = 5, Y = 5
});
Assert.AreEqual(5 - Math.Sqrt(2) / 2, intersection.X);
Assert.AreEqual(5 - Math.Sqrt(2) / 2, intersection.Y);
line = new LineDefinition()
{
k = -1
};
headlandLine = new LineDefinition()
{
k = 1, b = -10
};
intersection = Utility.ChooseHeadlandIntersection(headland, line, 2, headlandLine, new MyPoint3D()
{
X = 5, Y = -5
});
Assert.AreEqual(true, Math.Abs(5 - Math.Sqrt(2) / 2 - intersection.X) < 0.00000001);
Assert.AreEqual(true, Math.Abs(-5 + Math.Sqrt(2) / 2 - intersection.Y) < 0.00000001);
line = new LineDefinition()
{
k = -1
};
headlandLine = new LineDefinition()
{
k = 1, b = 10
};
intersection = Utility.ChooseHeadlandIntersection(headland, line, 2, headlandLine, new MyPoint3D()
{
X = -5, Y = 5
});
Assert.AreEqual(true, Math.Abs(-5 + Math.Sqrt(2) / 2 - intersection.X) < 0.00000001);
Assert.AreEqual(true, Math.Abs(5 - Math.Sqrt(2) / 2 - intersection.Y) < 0.00000001);
line = new LineDefinition()
{
k = 1
};
headlandLine = new LineDefinition()
{
k = -1, b = -10
};
intersection = Utility.ChooseHeadlandIntersection(headland, line, 2, headlandLine, new MyPoint3D()
{
X = -5, Y = -5
});
Assert.AreEqual(true, Math.Abs(-5 + Math.Sqrt(2) / 2 - intersection.X) < 0.00000001);
Assert.AreEqual(true, Math.Abs(-5 + Math.Sqrt(2) / 2 - intersection.Y) < 0.00000001);
headland = new List <MyPoint3D>();
headland.Add(new MyPoint3D()
{
X = 25.0 / 3
});
headland.Add(new MyPoint3D()
{
Y = 25.0 / 4
});
headland.Add(new MyPoint3D()
{
X = -25.0 / 3
});
headland.Add(new MyPoint3D()
{
Y = -25.0 / 4
});
headland.Add(new MyPoint3D()
{
X = 25.0 / 3
});
line = new LineDefinition()
{
k = 4.0 / 3
};
headlandLine = new LineDefinition()
{
k = -3.0 / 4, b = 25.0 / 4
};
intersection = Utility.ChooseHeadlandIntersection(headland, line, 2, headlandLine, new MyPoint3D()
{
X = 3, Y = 4
});
Assert.AreEqual(true, Math.Abs(3 - 3.0 / 5 - intersection.X) < 0.00000001);
Assert.AreEqual(true, Math.Abs(4 - 4.0 / 5 - intersection.Y) < 0.00000001);
line = new LineDefinition()
{
k = 4.0 / 3
};
headlandLine = new LineDefinition()
{
k = -3.0 / 4, b = -25.0 / 4
};
intersection = Utility.ChooseHeadlandIntersection(headland, line, 2, headlandLine, new MyPoint3D()
{
X = -3, Y = -4
});
Assert.AreEqual(true, Math.Abs(-3 + 3.0 / 5 - intersection.X) < 0.00000001);
Assert.AreEqual(true, Math.Abs(-4 + 4.0 / 5 - intersection.Y) < 0.00000001);
headland = new List <MyPoint3D>();
headland.Add(new MyPoint3D()
{
X = 90, Y = 10
});
headland.Add(new MyPoint3D()
{
X = -30, Y = 90
});
headland.Add(new MyPoint3D()
{
X = 70, Y = 125
});
headland.Add(new MyPoint3D()
{
X = 90, Y = 10
});
line = LineDefinition.GetLineDefinition(new MyPoint3D(), new MyPoint3D()
{
X = 15, Y = 60
});
headlandLine = LineDefinition.GetLineDefinition(new MyPoint3D()
{
X = 90, Y = 10
}, new MyPoint3D()
{
X = -30, Y = 90
});
intersection = Utility.ChooseHeadlandIntersection(headland, line, 10, headlandLine, new MyPoint3D()
{
X = 15, Y = 60
});
}
public static void OnGameWonEvent(int winningPlayer, LineDefinition winningLine)
{
OnGameWon(winningPlayer, winningLine);
}
private AnalysisResult AnalyzeFieldAndShowSwaths(FieldVM polygon, LineDefinition lineDef)
{
double processedArea = 0;
double width = ImplementWidth;
var geoPolygon = new List <GeoPoint>();
foreach (var p in polygon.Locations)
{
geoPolygon.Add(p.ToGeoPoint());
}
List <MyPoint3D> cartPolygon = new List <MyPoint3D>();
foreach (var p in polygon.Locations)
{
cartPolygon.Add(p.ToGeoPoint().ToCart());
}
double length = width / 2.0;
if (Utility.CalculateArea(geoPolygon, false) < 0)
{
length = -length;
}
List <MyPoint3D> boundary = new List <MyPoint3D>();
MyPoint3D prevP = cartPolygon[0];
boundary.Add(cartPolygon[0]);
for (int i = 1; i < cartPolygon.Count; i++)
{
if ((prevP - cartPolygon[i]).Norm < 3)
{
continue;
}
prevP = cartPolygon[i];
boundary.Add(cartPolygon[i]);
}
if ((boundary.First() - boundary.Last()).Norm < 3)
{
boundary.Remove(boundary.Last());
}
length = -length;
List <MyPoint3D> headLand = Utility.ShiftBoundary(length, boundary);
headLand.Add(headLand.First());
List <MyPoint3D> innerBoundary = Utility.ShiftBoundary(2 * length, boundary);
AddHeadLandToMap(headLand);
AddOuterSwathToMap(boundary, innerBoundary);
var intersections = Utility.GetHeadlandIntersections(headLand, lineDef, width);
processedArea += width * ComputeParallelLines(width, headLand, lineDef, intersections, true).LinesLength;
lineDef = LineDefinition.GetParallelLine(lineDef, -width);
intersections = Utility.GetHeadlandIntersections(headLand, lineDef, width);
processedArea += width * ComputeParallelLines(-width, headLand, lineDef, intersections, true).LinesLength;
for (int i = 1; i < headLand.Count; i++)
{
processedArea += width * (headLand[i - 1] - headLand[i]).Norm;
}
AnalysisResult res = new AnalysisResult();
res.AppliedArea = processedArea;
res.FieldArea = Utility.CalculateArea(geoPolygon);
return(res);
}
