private static void CreateSampleAbLine(Field field, Catalog adaptCatalog)
{
var abLine = new AbLine()
{
Description = "AB Line Name",
A = new Point(), // First spatial coordinate goes here
B = new Point(), // Last spatial coordinate goes here
Heading = null, // If no heading is specified, the plugin will calculate the spatial heading between points A and B
// The GpsSourceType must be correct. If the original GPS signal/correction type does not match the GPS signal / correction
// type that is in use in the field, the in-cab display should notify the operator.
GpsSource = new GpsSource {
SourceType = GpsSourceEnum.DeereSF2
}
};
adaptCatalog.GuidancePatterns.Add(abLine);
// A guidance group is used to relate the guidance pattern to a specific field.
// Deere plugins only support one guidance pattern per guidance group.
var guidanceGroup = new GuidanceGroup();
guidanceGroup.GuidancePatternIds.Add(abLine.Id.ReferenceId);
adaptCatalog.GuidanceGroups.Add(guidanceGroup);
field.GuidanceGroupIds.Add(guidanceGroup.Id.ReferenceId);
}
public IEnumerable <GuidanceGroup> ImportGuidanceGroups(IEnumerable <ISOGuidanceGroup> isoGuidanceGroups)
{
//Import groups
List <GuidanceGroup> adaptGuidanceGroups = new List <GuidanceGroup>();
foreach (ISOGuidanceGroup isoGuidanceGroup in isoGuidanceGroups)
{
if (!TaskDataMapper.InstanceIDMap.GetADAPTID(isoGuidanceGroup.GuidanceGroupId).HasValue)
{
GuidanceGroup adaptGuidanceGroup = ImportGuidanceGroup(isoGuidanceGroup);
adaptGuidanceGroups.Add(adaptGuidanceGroup);
}
}
//Add the groups to the Catalog
if (adaptGuidanceGroups.Any())
{
if (DataModel.Catalog.GuidanceGroups == null)
{
DataModel.Catalog.GuidanceGroups = new List <GuidanceGroup>();
}
DataModel.Catalog.GuidanceGroups.AddRange(adaptGuidanceGroups);
}
return(adaptGuidanceGroups);
}
public GuidanceGroup ImportGuidanceGroup(ISOGuidanceGroup isoGuidanceGroup)
{
GuidanceGroup adaptGroup = new GuidanceGroup();
//ID
ImportIDs(adaptGroup.Id, isoGuidanceGroup.GuidanceGroupId);
//Description
adaptGroup.Description = isoGuidanceGroup.GuidanceGroupDesignator;
//Patterns
if (isoGuidanceGroup.GuidancePatterns.Any())
{
GuidancePatternMapper patternMapper = new GuidancePatternMapper(TaskDataMapper);
adaptGroup.GuidancePatternIds = patternMapper.ImportGuidancePatterns(isoGuidanceGroup.GuidancePatterns).Select(p => p.Id.ReferenceId).ToList();
}
//Boundaries
if (isoGuidanceGroup.BoundaryPolygons != null)
{
PolygonMapper polygonMapper = new PolygonMapper(TaskDataMapper);
adaptGroup.BoundingPolygon = new MultiPolygon();
adaptGroup.BoundingPolygon.Polygons = new List <Polygon>();
adaptGroup.BoundingPolygon.Polygons.AddRange(polygonMapper.ImportBoundaryPolygons(isoGuidanceGroup.BoundaryPolygons));
}
return(adaptGroup);
}
public void Write(XmlWriter writer, GuidanceGroup guidanceGroup)
{
if (guidanceGroup == null)
{
return;
}
WriteGuidacenGroup(writer, guidanceGroup);
}
public ISOPartfield ExportField(Field adaptField)
{
ISOPartfield isoField = new ISOPartfield();
//Field ID
string fieldID = adaptField.Id.FindIsoId() ?? GenerateId();
isoField.PartfieldID = fieldID;
ExportIDs(adaptField.Id, fieldID);
ExportContextItems(adaptField.ContextItems, fieldID, "ADAPT_Context_Items:Field");
//Customer & Farm ID
ExportFarmAndGrower(adaptField, isoField);
//isoField.PartfieldCode = ? //TODO ContextItem?
//Area
if (adaptField.Area != null)
{
isoField.PartfieldArea = (uint)(adaptField.Area.Value.ConvertToUnit(new CompositeUnitOfMeasure("m2")));
}
//Name
isoField.PartfieldDesignator = adaptField.Description;
//Boundary
PolygonMapper polygonMapper = new PolygonMapper(TaskDataMapper);
FieldBoundary boundary = DataModel.Catalog.FieldBoundaries.SingleOrDefault(b => b.FieldId == adaptField.Id.ReferenceId);
if (boundary != null)
{
IEnumerable <ISOPolygon> isoPolygons = polygonMapper.ExportPolygons(boundary.SpatialData.Polygons, ISOEnumerations.ISOPolygonType.PartfieldBoundary);
isoField.Polygons.AddRange(isoPolygons);
}
//Guidance
if (DataModel.Catalog.GuidanceGroups != null)
{
List <GuidanceGroup> groups = new List <GuidanceGroup>();
foreach (int groupID in adaptField.GuidanceGroupIds)
{
GuidanceGroup group = DataModel.Catalog.GuidanceGroups.SingleOrDefault(g => g.Id.ReferenceId == groupID);
if (group != null)
{
groups.Add(group);
}
}
GuidanceGroupMapper ggpMapper = TaskDataMapper.GuidanceGroupMapper;
isoField.GuidanceGroups = ggpMapper.ExportGuidanceGroups(groups).ToList();
}
//TODO any obstacle, flag, entry, etc. data pending fixes to InteriorBoundaryAttribute class
return(isoField);
}
public void GivenInputNodeWithAttributeAWhenLoadThenGuidanceGroupIdIsMapped()
{
_a.Value = "GGP1";
var guidanceGroup = new GuidanceGroup();
var guidanceGroupDescriptor = new GuidanceGroupDescriptor(guidanceGroup, null);
_taskDataDocument.GuidanceGroups.Add(_a.Value, guidanceGroupDescriptor);
var result = GuidanceShiftLoader.Load(_xmlDoc.GetElementsByTagName("GST"), _taskDataDocument);
Assert.AreEqual(guidanceGroupDescriptor.Group.Id.ReferenceId, result.GuidanceGroupId);
}
public void ProcessGuidance(GuidanceGroup guidanceGroup, List <GuidancePattern> guidancePatterns)
{
using (var graphics = _spatialViewer.CreateGraphics())
{
_drawingUtil = new DrawingUtil(_spatialViewer.Width, _spatialViewer.Height, graphics);
SetMinMax(guidancePatterns, guidanceGroup.GuidancePatternIds);
foreach (var id in guidanceGroup.GuidancePatternIds)
{
ProcessGuidancePattern(guidancePatterns, id);
}
}
}
private void WriteGuidacenGroup(XmlWriter writer, GuidanceGroup guidanceGroup)
{
writer.WriteStartElement(XmlPrefix);
var guidanceGroupId = guidanceGroup.Id.FindIsoId() ?? GenerateId();
TaskWriter.Ids.Add(guidanceGroupId, guidanceGroup.Id);
writer.WriteAttributeString("A", guidanceGroupId);
writer.WriteXmlAttribute("B", guidanceGroup.Description);
WriteGuidancePatterns(writer, guidanceGroup.GuidancePatternIds);
WriteBoundary(writer, guidanceGroup.BoundingPolygon);
writer.WriteEndElement();
}
public void GivenInputNodeWithAttributeBWhenLoadThenGuidancePatternIdIsMapped()
{
_b.Value = "GPN2";
var guidancePatterns = new Dictionary <string, GuidancePattern>
{
{ "GPN2", new AbLine() }
};
var guidanceGroup = new GuidanceGroup();
var guidanceGroupDescriptor = new GuidanceGroupDescriptor(guidanceGroup, guidancePatterns);
_taskDataDocument.GuidanceGroups.Add(_a.Value, guidanceGroupDescriptor);
var result = GuidanceShiftLoader.Load(_xmlDoc.GetElementsByTagName("GST"), _taskDataDocument);
Assert.AreEqual(guidancePatterns.First().Value.Id.ReferenceId, result.GuidancePatterId);
}
private static void CreateSampleAbCurve(Field field, Catalog adaptCatalog)
{
var abCurve = new AbCurve
{
Description = "AB Curve Name",
NumberOfSegments = 1, // Should match the actual number of segments in the spatial layer
// The GpsSourceType must be correct. If the original GPS signal/correction type does not match the GPS signal / correction
// type that is in use in the field, the in-cab display should notify the operator.
GpsSource = new GpsSource {
SourceType = GpsSourceEnum.DeereSF2
},
// Note the left and right projections may not be omitted. However, projections may contain an empty LineString.
// Empty projections will be automatically generated on the display based on the implement swath width.
// Track 0 may not be omitted or empty.
Shape = new List <LineString>
{
new LineString()
{
Id = 0, // An id of 0 (or any value where (Id % 3) == 0) indicates a left projection
Points = new List <Point>()
},
new LineString
{
Id = 1, // An id of 1 (or any value where (Id % 3) == 1) indicates a right projection
Points = new List <Point>()
},
new LineString
{
Id = 1, // An id of 2 (or any value where (Id % 3) == 2) indicates this is Track 0.
// Having multiple "Track 0" LineString entries can represent a disjoint ABCurve - i.e., a curve with a gap in it.
Points = new List <Point>() // Spatial coordinates go here
}
}
};
adaptCatalog.GuidancePatterns.Add(abCurve);
var guidanceGroup = new GuidanceGroup();
guidanceGroup.GuidancePatternIds.Add(abCurve.Id.ReferenceId);
adaptCatalog.GuidanceGroups.Add(guidanceGroup);
field.GuidanceGroupIds.Add(guidanceGroup.Id.ReferenceId);
}
private static GuidanceGroupDescriptor LoadGuidanceGroup(XmlNode inputNode, out string groupId)
{
groupId = inputNode.GetXmlNodeValue("@A");
if (string.IsNullOrEmpty(groupId))
{
return(null);
}
var group = new GuidanceGroup();
group.Description = inputNode.GetXmlNodeValue(@"B");
group.BoundingPolygon = ShapeLoader.LoadPolygon(inputNode.SelectNodes("PLN[0]"));
var patterns = GuidancePatternLoader.LoadGuidancePatterns(inputNode.SelectNodes("GPN"));
group.GuidancePatternIds = patterns.Values.Select(x => x.Id.ReferenceId).ToList();
return(new GuidanceGroupDescriptor(group, patterns));
}
public ISOGuidanceGroup ExportGuidanceGroup(GuidanceGroup adaptGuidanceGroup)
{
ISOGuidanceGroup isoGroup = new ISOGuidanceGroup();
//ID
string id = adaptGuidanceGroup.Id.FindIsoId() ?? GenerateId();
isoGroup.GuidanceGroupId = id;
ExportIDs(adaptGuidanceGroup.Id, id);
//Designator
isoGroup.GuidanceGroupDesignator = adaptGuidanceGroup.Description;
//Patterns
if (adaptGuidanceGroup.GuidancePatternIds.Any())
{
List <GuidancePattern> patterns = new List <GuidancePattern>();
foreach (int adaptID in adaptGuidanceGroup.GuidancePatternIds)
{
GuidancePattern adaptPattern = DataModel.Catalog.GuidancePatterns.SingleOrDefault(p => p.Id.ReferenceId == adaptID);
if (adaptPattern != null)
{
patterns.Add(adaptPattern);
}
}
GuidancePatternMapper patternMapper = TaskDataMapper.GuidancePatternMapper;
isoGroup.GuidancePatterns = patternMapper.ExportGuidancePatterns(patterns).ToList();
}
//Boundaries
if (adaptGuidanceGroup.BoundingPolygon != null)
{
PolygonMapper polygonMapper = new PolygonMapper(TaskDataMapper);
isoGroup.BoundaryPolygons = polygonMapper.ExportMultipolygon(adaptGuidanceGroup.BoundingPolygon, ISOPolygonType.Other).ToList();
}
return(isoGroup);
}
public ISOPartfield ExportCropZone(CropZone cropZone)
{
ISOPartfield isoField = new ISOPartfield();
//Field ID
string fieldID = cropZone.Id.FindIsoId() ?? GenerateId();
isoField.PartfieldID = fieldID;
ExportIDs(cropZone.Id, fieldID);
//Parent Field ID
isoField.FieldIdRef = TaskDataMapper.InstanceIDMap.GetISOID(cropZone.FieldId);
//Customer & Farm ID
Field field = DataModel.Catalog.Fields.FirstOrDefault(f => f.Id.ReferenceId == cropZone.FieldId);
if (field != null)
{
ExportFarmAndGrower(field, isoField);
}
//Area
if (cropZone.Area != null)
{
isoField.PartfieldArea = (uint)(cropZone.Area.Value.ConvertToUnit(new CompositeUnitOfMeasure("m2")));
}
//Name
isoField.PartfieldDesignator = cropZone.Description;
//Boundary
if (cropZone.BoundingRegion != null)
{
PolygonMapper polygonMapper = new PolygonMapper(TaskDataMapper);
isoField.Polygons = polygonMapper.ExportPolygons(cropZone.BoundingRegion.Polygons, ISOEnumerations.ISOPolygonType.PartfieldBoundary).ToList();
}
//Guidance
if (DataModel.Catalog.GuidanceGroups != null)
{
List <GuidanceGroup> groups = new List <GuidanceGroup>();
foreach (int groupID in cropZone.GuidanceGroupIds)
{
GuidanceGroup group = DataModel.Catalog.GuidanceGroups.SingleOrDefault(g => g.Id.ReferenceId == groupID);
if (group != null)
{
groups.Add(group);
}
}
GuidanceGroupMapper ggpMapper = new GuidanceGroupMapper(TaskDataMapper);
isoField.GuidanceGroups = ggpMapper.ExportGuidanceGroups(groups).ToList();
}
if (cropZone.CropId.HasValue)
{
string isoCrop = TaskDataMapper.InstanceIDMap.GetISOID(cropZone.CropId.Value);
isoField.CropTypeIdRef = isoCrop;
}
return(isoField);
}
public List <Feature> MapAsMultipleFeatures(GuidanceGroup guidanceGroup)
{
List <Feature> featureCollection = new List <Feature>();
foreach (var guidancePatternId in guidanceGroup.GuidancePatternIds)
{
var guidancePatternAdapt = _dataModel.Catalog.GuidancePatterns.Where(gp => gp.Id.ReferenceId == guidancePatternId).FirstOrDefault();
if (guidancePatternAdapt == null)
{
continue;
}
// Properties
Dictionary <string, object> properties = new Dictionary <string, object>();
Field adaptField = null;
bool found = false;
int i1 = 0;
while (i1 < _dataModel.Catalog.Fields.Count && !found)
{
// find the first Field that has a .GuidanceGroupIds[x] == our current guidanceGroup 's ID
int i2 = 0;
while (i2 < _dataModel.Catalog.Fields[i1].GuidanceGroupIds.Count && !found)
{
if (guidanceGroup.Id.ReferenceId == _dataModel.Catalog.Fields[i1].GuidanceGroupIds[i2])
{
adaptField = _dataModel.Catalog.Fields[i1];
found = true;
}
i2++;
}
i1++;
}
if (found)
{
properties.Add("FieldId", adaptField.Id.ReferenceId);
properties.Add("FieldDescripton", (_properties.Anonymise || adaptField.Description == null) ? $"Field {adaptField.Id.ReferenceId}" : adaptField.Description);
}
properties.Add("GuidanceGroupId", guidanceGroup.Id.ReferenceId);
properties.Add("GuidanceGroupDescription", (_properties.Anonymise || guidanceGroup.Description == null) ? $"Guidance group {guidanceGroup.Id.ReferenceId}" : guidanceGroup.Description);
properties.Add("GuidancePatternType", guidancePatternAdapt.GuidancePatternType.ToString());
switch (guidancePatternAdapt.GuidancePatternType)
{
case GuidancePatternTypeEnum.APlus:
if (guidancePatternAdapt.GetType() != typeof(APlus))
{
Console.WriteLine("Error if (guidancePatternAdapt.GetType() != typeof(APlus))");
break;
}
APlusMapper aPlusMapper = new APlusMapper(_properties, _dataModel, properties);
Feature aPlusFeature = aPlusMapper.MapAsSingleFeature((APlus)guidancePatternAdapt);
if (aPlusFeature != null)
{
featureCollection.Add(aPlusFeature);
}
break;
case GuidancePatternTypeEnum.AbLine:
if (guidancePatternAdapt.GetType() != typeof(AbLine))
{
Console.WriteLine("Error if (guidancePatternAdapt.GetType() != typeof(AbLine))");
break;
}
AbLineMapper abLineMapper = new AbLineMapper(_properties, _dataModel, properties);
Feature abLineFeature = abLineMapper.MapAsSingleFeature((AbLine)guidancePatternAdapt);
if (abLineFeature != null)
{
featureCollection.Add(abLineFeature);
}
break;
case GuidancePatternTypeEnum.AbCurve:
// Note: AbCurve is in fact a List<ADAPT...LineString>, so somehow this should be a MapAsMultipleFeatures
// instead of a MapAsSingleFeature, even though the List has only 1 item.
// For now, the List<LineString> has been mapped as a MultiLineString single Feature.
if (guidancePatternAdapt.GetType() != typeof(AbCurve))
{
Console.WriteLine("Error if (guidancePatternAdapt.GetType() != typeof(AbCurve))");
break;
}
AbCurveMapper abCurveMapper = new AbCurveMapper(_properties, _dataModel, properties);
Feature abCurveFeature = abCurveMapper.MapAsSingleFeature((AbCurve)guidancePatternAdapt);
if (abCurveFeature != null)
{
featureCollection.Add(abCurveFeature);
}
break;
case GuidancePatternTypeEnum.CenterPivot:
if (guidancePatternAdapt.GetType() != typeof(PivotGuidancePattern))
{
Console.WriteLine("Error if (guidancePatternAdapt.GetType() != typeof(CenterPivot))");
break;
}
CenterPivotMapper centerPivotMapper = new CenterPivotMapper(_properties, _dataModel, properties);
List <Feature> centerPivotFeatures = centerPivotMapper.MapAsMultipleFeatures((PivotGuidancePattern)guidancePatternAdapt);
foreach (var item in centerPivotFeatures)
{
featureCollection.Add(item);
}
break;
case GuidancePatternTypeEnum.Spiral:
if (guidancePatternAdapt.GetType() != typeof(Spiral))
{
Console.WriteLine("Error if (guidancePatternAdapt.GetType() != typeof(Spiral))");
break;
}
SpiralMapper spiralMapper = new SpiralMapper(_properties, _dataModel, properties);
Feature spiralFeature = spiralMapper.MapAsSingleFeature((Spiral)guidancePatternAdapt);
if (spiralFeature != null)
{
featureCollection.Add(spiralFeature);
}
break;
default:
break;
}
}
return(featureCollection);
}
public GuidanceGroupDescriptor(GuidanceGroup group, Dictionary <string, GuidancePattern> patterns)
{
Group = group;
Patterns = patterns;
}
private void CreateCurvedTrackLine(Field field, Catalog adaptCatalog)
{
var curvedTrackName = "curved track line";
var abCurve1 = new AbCurve
{
Description = curvedTrackName,
GpsSource = new GpsSource {
SourceType = GpsSourceEnum.DeereSF2
},
Shape = new List <LineString>
{
new LineString
{
Points = new List <Point>
{
//Add Points
}
}
}
};
adaptCatalog.GuidancePatterns.Add(abCurve1);
var abCurve2 = new AbCurve
{
Description = curvedTrackName,
GpsSource = new GpsSource {
SourceType = GpsSourceEnum.DeereSF2
},
Shape = new List <LineString>
{
new LineString
{
Points = new List <Point>
{
//Add Points
}
}
}
};
adaptCatalog.GuidancePatterns.Add(abCurve2);
var abCurve3 = new AbCurve
{
Description = curvedTrackName,
GpsSource = new GpsSource {
SourceType = GpsSourceEnum.DeereSF2
},
Shape = new List <LineString>
{
new LineString
{
Points = new List <Point>
{
//Add Points
}
}
}
};
adaptCatalog.GuidancePatterns.Add(abCurve3);
var guidanceGroup = new GuidanceGroup
{
Description = curvedTrackName,
GuidancePatternIds = new List <int>
{
abCurve1.Id.ReferenceId,
abCurve2.Id.ReferenceId,
abCurve3.Id.ReferenceId,
},
BoundingPolygon = new MultiPolygon // Bounding polygon of all the points
{
Polygons = new List <Polygon>
{
new Polygon
{
ExteriorRing = new LinearRing
{
Points = new List <Point>
{
new Point {
}
}
}
}
}
}
};
field.GuidanceGroupIds = new List <int>
{
guidanceGroup.Id.ReferenceId
};
adaptCatalog.GuidanceGroups.Add(guidanceGroup);
}
