private static List <WorkingData> CreateMeters(out SpatialRecord spatialRecord, int startSection)
{
var meters = new List <WorkingData>();
for (int i = startSection; i < startSection + 16; i++)
{
meters.Add(new ISOEnumeratedMeter {
DeviceElementUseId = i
});
}
spatialRecord = new SpatialRecord();
for (var i = 0; i < 16; i++)
{
if (i % 2 == 0)
{
spatialRecord.SetMeterValue(meters[i],
new EnumeratedValue
{
Value = DefinedTypeEnumerationInstanceList.dtiRecordingStatusOff.ToModelEnumMember()
});
}
else
{
spatialRecord.SetMeterValue(meters[i],
new EnumeratedValue
{
Value = DefinedTypeEnumerationInstanceList.dtiRecordingStatusOn.ToModelEnumMember()
});
}
}
return(meters);
}
public static void AreEqual(ISOSpatialRow isoSpatialRow, SpatialRecord adaptSpatialRecord, IEnumerable <WorkingData> meters)
{
foreach (var meter in meters)
{
var isoValue = isoSpatialRow.SpatialValues.SingleOrDefault(v => v.Id == meter.Id.FindIntIsoId());
if (isoValue == null)
{
continue;
}
if (meter is NumericWorkingData)
{
var numericMeter = meter as NumericWorkingData;
var numericRepresentationValue = (NumericRepresentationValue)adaptSpatialRecord.GetMeterValue(numericMeter);
if (isoValue != null)
{
Assert.AreEqual(isoValue.Value, numericRepresentationValue.Value.Value);
}
}
if (meter is EnumeratedWorkingData)
{
var isoEnumeratedMeter = meter as ISOEnumeratedMeter;
var enumeratedValue = isoEnumeratedMeter.GetEnumeratedValue(isoValue, isoEnumeratedMeter);
Assert.AreEqual(enumeratedValue.Representation.Description, meter.Representation.Description);
}
}
}
public SpatialRecord Map(ISOSpatialRow isoSpatialRow, List <WorkingData> meters, Dictionary <string, List <ISOProductAllocation> > productAllocations)
{
var spatialRecord = new SpatialRecord();
spatialRecord.Geometry = new ApplicationDataModel.Shapes.Point
{
X = Convert.ToDouble(isoSpatialRow.EastPosition * CoordinateMultiplier),
Y = Convert.ToDouble(isoSpatialRow.NorthPosition * CoordinateMultiplier),
Z = Convert.ToDouble(isoSpatialRow.Elevation.GetValueOrDefault() * ZMultiplier)
};
spatialRecord.Timestamp = isoSpatialRow.TimeStart;
foreach (var meter in meters.OfType <NumericWorkingData>())
{
SetNumericMeterValue(isoSpatialRow, meter, spatialRecord, productAllocations);
}
foreach (var meter in meters.OfType <EnumeratedWorkingData>())
{
SetEnumeratedMeterValue(isoSpatialRow, meter, spatialRecord);
}
return(spatialRecord);
}
public void Setup()
{
_dataPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
Directory.CreateDirectory(_dataPath);
_fileName = "test.bin";
_meters = new List <WorkingData>();
_spatialRecord = new SpatialRecord {
Geometry = new Point {
X = 93.6208, Y = 41.5908
}
};
_spatialRecords = new List <SpatialRecord> {
_spatialRecord
};
_numericMeter = new NumericWorkingData
{
Representation = RepresentationInstanceList.vrAvgHarvestMoisture.ToModelRepresentation(),
UnitOfMeasure = UnitSystemManager.GetUnitOfMeasure("prcnt"),
DeviceElementUseId = 1
};
_enumeratedMeter = new ISOEnumeratedMeter
{
Representation = RepresentationInstanceList.dtSkyCondition.ToModelRepresentation(),
DeviceElementUseId = 1,
ValueCodes = new List <int> {
0, 1, 2
}
};
_numericValueMapperMock = new Mock <INumericValueMapper>();
_enumeratedMeterMapperMock = new Mock <IEnumeratedValueMapper>();
_binaryWriter = new BinaryWriter(_enumeratedMeterMapperMock.Object, _numericValueMapperMock.Object);
}
public void GivenOperationDataWithSpatialRecordDataWithNumericRepValueWhenProcessOperationDAtaThenRowsAreAdded()
{
var harvestMoistureMeter = new NumericWorkingData {
Representation = RepresentationInstanceList.vrHarvestMoisture.ToModelRepresentation()
};
_workingDatas.Add(harvestMoistureMeter);
_deviceElementUses.Add(0, new List <DeviceElementUse>
{
new DeviceElementUse
{
Depth = 0,
GetWorkingDatas = () => _workingDatas,
}
});
var spatialRecord = new SpatialRecord();
var numericRepresentation = new NumericRepresentationValue(RepresentationInstanceList.vrHarvestMoisture.ToModelRepresentation(), UnitSystemManager.GetUnitOfMeasure("prcnt"), new NumericValue(UnitSystemManager.GetUnitOfMeasure("prcnt"), 3.0));
spatialRecord.SetMeterValue(harvestMoistureMeter, numericRepresentation);
_spatialRecords.Add(spatialRecord);
var dataTable = _operationDataProcessor.ProcessOperationData(_operationData);
Assert.AreEqual(1, dataTable.Rows.Count);
Assert.AreEqual(numericRepresentation.Value.Value.ToString(), dataTable.Rows[0][0]);
}
public void GivenOperationDataWithSpatialRecordDataWithEnumeratedValueWhenProcessOperationDataThenRowsAreAdded()
{
var meter = new EnumeratedWorkingData {
Representation = RepresentationInstanceList.dtRecordingStatus.ToModelRepresentation()
};
_workingDatas.Add(meter);
_deviceElementUses.Add(0, new List <DeviceElementUse>
{
new DeviceElementUse
{
Depth = 0,
GetWorkingDatas = () => _workingDatas,
}
});
var spatialRecord = new SpatialRecord();
var enumeratedValue = new EnumeratedValue {
Value = DefinedTypeEnumerationInstanceList.dtiRecordingStatusOn.ToModelEnumMember()
};
spatialRecord.SetMeterValue(meter, enumeratedValue);
_spatialRecords.Add(spatialRecord);
var dataTable = _operationDataProcessor.ProcessOperationData(_operationData);
Assert.AreEqual(1, dataTable.Rows.Count);
Assert.AreEqual(enumeratedValue.Value.Value, dataTable.Rows[0][0]);
}
public void GivenOperationDataWithSpatialRecordDataWithNullMeterWhenProcessOperationDataThenRowsAreAdded()
{
var meter = new EnumeratedWorkingData {
Representation = RepresentationInstanceList.dtRecordingStatus.ToModelRepresentation()
};
_workingDatas.Add(meter);
_deviceElementUses.Add(0, new List <DeviceElementUse>
{
new DeviceElementUse
{
Depth = 0,
GetWorkingDatas = () => _workingDatas,
}
});
var spatialRecord = new SpatialRecord();
_spatialRecords.Add(spatialRecord);
var dataTable = _operationDataProcessor.ProcessOperationData(_operationData);
Assert.AreEqual(1, dataTable.Rows.Count);
Assert.AreEqual("", dataTable.Rows[0][0]);
}
public void GivenOperationDataWithSpatialRecordDataWithNumericRepValueWhenProcessOperationDataThenColumnNamesContainUom()
{
var harvestMoistureMeter = new NumericWorkingData {
Representation = RepresentationInstanceList.vrHarvestMoisture.ToModelRepresentation()
};
_workingDatas.Add(harvestMoistureMeter);
_deviceElementUses.Add(0, new List <DeviceElementUse>
{
new DeviceElementUse
{
Depth = 0,
GetWorkingDatas = () => _workingDatas,
}
});
var spatialRecord = new SpatialRecord();
var numericRepresentation = new NumericRepresentationValue(RepresentationInstanceList.vrHarvestMoisture.ToModelRepresentation(), UnitSystemManager.GetUnitOfMeasure("prcnt"), new NumericValue(UnitSystemManager.GetUnitOfMeasure("prcnt"), 3.0));
spatialRecord.SetMeterValue(harvestMoistureMeter, numericRepresentation);
_spatialRecords.Add(spatialRecord);
var dataTable = _operationDataProcessor.ProcessOperationData(_operationData);
var expectedColumnName = _workingDatas.First().Representation.Code + "-" + _workingDatas.First().Id.ReferenceId + "-0-" + numericRepresentation.Value.UnitOfMeasure.Code;
Assert.AreEqual(expectedColumnName, dataTable.Columns[0].ColumnName);
}
private void WriteMeterValues(SpatialRecord spatialRecord, List <WorkingData> meters, MemoryStream memoryStream, Dictionary <WorkingData, int> metersByIsoIds)
{
var dlvOrders = metersByIsoIds.Values.Distinct();
Dictionary <int, uint> dlvsToWrite;
if (dlvOrders.Contains(-1))
{
dlvsToWrite = GetMeterValuesAndAssignDlvNumbers(spatialRecord, meters);
}
else
{
dlvsToWrite = GetMeterValues(spatialRecord, meters, metersByIsoIds);
}
var numberOfMeters = (byte)dlvsToWrite.Count;
var numberOfMetersStream = new MemoryStream();
numberOfMetersStream.WriteByte(numberOfMeters);
numberOfMetersStream.WriteTo(memoryStream);
foreach (var key in dlvsToWrite.Keys)
{
var order = (byte)key;
var value = dlvsToWrite[key];
memoryStream.WriteByte(order);
var valueStream = new MemoryStream(BitConverter.GetBytes(value));
valueStream.WriteTo(memoryStream);
}
}
private SpatialRecord AddSpatialRecord()
{
var record = new SpatialRecord();
_spatialRecords.Add(record);
return(record);
}
public override UInt32 GetMetersValue(List <WorkingData> meters, SpatialRecord spatialRecord)
{
var returnValue = new UInt32();
for (int i = 0; i < meters.Count; i++)
{
var sectionId = ((DDI - StartingDdi) * 16) + (i + 1);
var meter = (ISOEnumeratedMeter)meters.SingleOrDefault(x => x.DeviceElementUseId == sectionId);
var value = (EnumeratedValue)spatialRecord.GetMeterValue(meter);
int meterInt;
if (value.Value.Code == DefinedTypeEnumerationInstanceList.dtiPrescriptionUsed.ToModelEnumMember().Code)
{
meterInt = 0;
}
else if (value.Value.Code == DefinedTypeEnumerationInstanceList.dtiPrescriptionOverridden.ToModelEnumMember().Code)
{
meterInt = 1;
}
else
{
meterInt = 3;
}
returnValue |= Convert.ToUInt32(meterInt << (i * 2));
}
return(returnValue);
}
public override void OpenRecord(BaseTask task)
{
task.RecordIndex = RecordList.Count;
SpatialRecord prevRecord = (RecordList.Count == 0) ? null : RecordList[RecordList.Count - 1] as SpatialRecord;
RecordList.Add(new SpatialRecord(prevRecord, task as SpatialTask));
}
public SpatialRecord Map(ISOSpatialRow isoSpatialRow, List <WorkingData> meters)
{
var spatialRecord = new SpatialRecord();
foreach (var meter in meters.OfType <NumericWorkingData>())
{
SetNumericMeterValue(isoSpatialRow, meter, spatialRecord);
}
foreach (var meter in meters.OfType <EnumeratedWorkingData>())
{
SetEnumeratedMeterValue(isoSpatialRow, meter, spatialRecord);
}
spatialRecord.Geometry = new ApplicationDataModel.Shapes.Point
{
X = Convert.ToDouble(isoSpatialRow.EastPosition * CoordinateMultiplier),
Y = Convert.ToDouble(isoSpatialRow.NorthPosition * CoordinateMultiplier),
Z = isoSpatialRow.Elevation
};
spatialRecord.Timestamp = isoSpatialRow.TimeStart;
return(spatialRecord);
}
private void CreateHavestMoistureSpatialRecord(WorkingData workingData, double value)
{
var spatialRecord = new SpatialRecord();
var meter1Value1 = CreateHarvestMoisture(value);
spatialRecord.SetMeterValue(workingData, meter1Value1);
_spatialRecords.Add(spatialRecord);
}
public void Setup()
{
_meter = new NumericMeter();
_spatialRecord = new SpatialRecord();
_representationMapperMock = new Mock <IRepresentationMapper>();
_mapper = new NumericValueMapper(_representationMapperMock.Object);
}
public static void SetNumericMeterValue(this SpatialRecord record, NumericWorkingData workingData, double value)
{
var numericRepresentation = workingData.Representation as NumericRepresentation;
var numericValue = new NumericValue(workingData.UnitOfMeasure, value);
var representationValue = new NumericRepresentationValue(numericRepresentation, workingData.UnitOfMeasure, numericValue);
record.SetMeterValue(workingData, representationValue);
}
private static void CreateNumericMeterCell(SpatialRecord spatialRecord, WorkingData workingData, int depth, DataRow dataRow)
{
var numericRepresentationValue = spatialRecord.GetMeterValue(workingData) as NumericRepresentationValue;
var value = numericRepresentationValue != null
? numericRepresentationValue.Value.Value.ToString(CultureInfo.InvariantCulture)
: "";
dataRow[GetColumnName(workingData, depth)] = value;
}
public UInt32 GetMetersValue(List <WorkingData> meters, SpatialRecord spatialRecord)
{
var section1Meter = (ISOEnumeratedMeter)meters.SingleOrDefault(x => x.DeviceElementUseId == 1);
var section1Value = (EnumeratedValue)spatialRecord.GetMeterValue(section1Meter);
var sectionOneIsoValue = ConvertToIsoValue(section1Value);
var section2Meter = (ISOEnumeratedMeter)meters.SingleOrDefault(x => x.DeviceElementUseId == 2);
var section2Value = (EnumeratedValue)spatialRecord.GetMeterValue(section2Meter);
var sectionTwoIsoValue = ConvertToIsoValue(section2Value);
return(Convert.ToUInt32(sectionOneIsoValue | (sectionTwoIsoValue << 8)));
}
public override void CloseRecord(int taskIndex)
{
// fill in error
SpatialTask task = TaskList[taskIndex] as SpatialTask;
SpatialRecord rec = RecordList[task.RecordIndex] as SpatialRecord;
// record task result
rec.CloseRecord(task);
ActivateNextTask();
}
public IEnumerable <SpatialRecord> ReadSpatialRecords(string path)
{
using (var fileStream = File.OpenRead(path))
{
while (!IsEndOfStream(fileStream))
{
var spatialRecord = new SpatialRecord();
_model.DeserializeWithLengthPrefix(fileStream, spatialRecord, typeof(SpatialRecord), PrefixStyle.Base128, 1);
yield return(spatialRecord);
}
}
}
private static void AreEqual(SpatialRecord adaptSpatialRecord, ISOSpatialRow isoSpatialRow, List <WorkingData> meters)
{
Assert.AreEqual(adaptSpatialRecord.Timestamp, isoSpatialRow.TimeStart);
var point = (Point)adaptSpatialRecord.Geometry;
Assert.AreEqual((int)(point.X / CoordinateMultiplier), isoSpatialRow.EastPosition, CoordinateMultiplier);
Assert.AreEqual((int)(point.Y / CoordinateMultiplier), isoSpatialRow.NorthPosition, CoordinateMultiplier);
Assert.AreEqual(point.Z, isoSpatialRow.Elevation);
SpatialValueAssert.AreEqual(isoSpatialRow, adaptSpatialRecord, meters);
}
private static void AreEqual(ISOSpatialRow isoSpatialRow, SpatialRecord adaptSpatialRecord, IEnumerable <WorkingData> meters)
{
Assert.AreEqual(isoSpatialRow.TimeStart, adaptSpatialRecord.Timestamp);
var point = adaptSpatialRecord.Geometry as Point;
Assert.AreEqual(isoSpatialRow.EastPosition * CoordinateMultiplier, point.X, 0.000001);
Assert.AreEqual(isoSpatialRow.NorthPosition * CoordinateMultiplier, point.Y, 0.000001);
Assert.AreEqual(isoSpatialRow.Elevation, point.Z);
SpatialValueAssert.AreEqual(isoSpatialRow, adaptSpatialRecord, meters);
}
public uint Map(NumericWorkingData meter, SpatialRecord spatialRecord)
{
var value = (NumericRepresentationValue)spatialRecord.GetMeterValue(meter);
if (value == null)
{
return(0);
}
var resolution = GetResolution(value);
return((UInt32)(value.Value.Value / resolution));
}
private Dictionary <int, uint> GetMeterValues(SpatialRecord spatialRecord, List <WorkingData> workingDatas)
{
var dlvsToWrite = new Dictionary <int, uint>();
var workingDatasWithValues = workingDatas.Where(x => spatialRecord.GetMeterValue(x) != null);
foreach (WorkingData workingData in workingDatasWithValues)
{
int order = _dlvOrdersByWorkingDataID[workingData.Id.ReferenceId];
UInt32?value = null;
if (workingData is NumericWorkingData)
{
NumericWorkingData numericMeter = workingData as NumericWorkingData;
if (numericMeter != null && spatialRecord.GetMeterValue(numericMeter) != null)
{
value = _numericValueMapper.Map(numericMeter, spatialRecord);
}
}
else if (workingData is EnumeratedWorkingData)
{
EnumeratedWorkingData enumeratedMeter = workingData as EnumeratedWorkingData;
if (enumeratedMeter != null && spatialRecord.GetMeterValue(enumeratedMeter) != null)
{
value = _enumeratedValueMapper.Map(enumeratedMeter, new List <WorkingData>()
{
workingData
}, spatialRecord);
}
}
if (value == null)
{
continue;
}
if (_previousDlvs.ContainsKey(order) && _previousDlvs[order] != value)
{
_previousDlvs[order] = value.Value;
dlvsToWrite.Add(order, value.Value);
}
else if (!_previousDlvs.ContainsKey(order))
{
_previousDlvs.Add(order, value.Value);
dlvsToWrite.Add(order, value.Value);
}
}
return(dlvsToWrite);
}
private static double GetActiveWidthFt(SpatialRecord spatialRecord, List <RowConfiguration> rows)
{
double activeWidthIn = 0;
foreach (RowConfiguration row in rows)
{
EnumeratedValue rowStatus = spatialRecord.GetMeterValue(row.statusMeter) as EnumeratedValue;
if (rowStatus.Value.Value == "On")
{
activeWidthIn += row.widthIn;
}
}
return(activeWidthIn / 12.0);
}
private void WriteSpatialRecord(SpatialRecord spatialRecord, List <WorkingData> meters, MemoryStream memoryStream)
{
//Start Time
var millisecondsSinceMidnight = (UInt32) new TimeSpan(0, spatialRecord.Timestamp.Hour, spatialRecord.Timestamp.Minute, spatialRecord.Timestamp.Second, spatialRecord.Timestamp.Millisecond).TotalMilliseconds;
memoryStream.Write(BitConverter.GetBytes(millisecondsSinceMidnight), 0, 4);
var daysSinceJanOne1980 = (UInt16)(spatialRecord.Timestamp - (_januaryFirst1980)).TotalDays;
memoryStream.Write(BitConverter.GetBytes(daysSinceJanOne1980), 0, 2);
//Position
var north = Int32.MaxValue; //"Not available" value for the Timelog
var east = Int32.MaxValue;
var up = Int32.MaxValue;
if (spatialRecord.Geometry != null)
{
Point location = spatialRecord.Geometry as Point;
if (location != null)
{
north = (Int32)(location.Y / CoordinateMultiplier);
east = (Int32)(location.X / CoordinateMultiplier);
up = (Int32)(location.Z.GetValueOrDefault());
}
}
memoryStream.Write(BitConverter.GetBytes(north), 0, 4);
memoryStream.Write(BitConverter.GetBytes(east), 0, 4);
memoryStream.Write(BitConverter.GetBytes(up), 0, 4);
memoryStream.WriteByte((byte)ISOPositionStatus.NotAvailable);
//Values
Dictionary <int, uint> dlvsToWrite = GetMeterValues(spatialRecord, meters);
byte numberOfMeters = (byte)dlvsToWrite.Count;
memoryStream.WriteByte(numberOfMeters);
foreach (var key in dlvsToWrite.Keys)
{
byte order = (byte)key;
uint value = dlvsToWrite[key];
memoryStream.WriteByte(order);
memoryStream.Write(BitConverter.GetBytes(value), 0, 4);
}
}
public UInt32 GetMetersValue(List <WorkingData> meters, SpatialRecord spatialRecord)
{
var meter = (ISOEnumeratedMeter)meters.SingleOrDefault();
var value = (EnumeratedValue)spatialRecord.GetMeterValue(meter);
if (value.Value.Code == DefinedTypeEnumerationInstanceList.dtiWeightUnStable.ToModelEnumMember().Code)
{
return(0);
}
if (value.Value.Code == DefinedTypeEnumerationInstanceList.dtiWeightStable.ToModelEnumMember().Code)
{
return(1);
}
return(2);
}
public UInt32 GetMetersValue(List <WorkingData> meters, SpatialRecord spatialRecord)
{
var meter = meters.SingleOrDefault();
var value = (EnumeratedValue)spatialRecord.GetMeterValue(meter);
if (value.Value.Code == DefinedTypeEnumerationInstanceList.dtiRecordingStatusOn.ToModelEnumMember().Code)
{
return(1);
}
if (value.Value.Code == DefinedTypeEnumerationInstanceList.dtiRecordingStatusOff.ToModelEnumMember().Code)
{
return(0);
}
return(3);
}
public void GivenMetersWithAutoOnWhenGetMetersValueThenOne()
{
var enumeratedMeter = new ISOEnumeratedMeter();
var meters = new List <WorkingData> {
enumeratedMeter
};
var spatialRecord = new SpatialRecord();
spatialRecord.SetMeterValue(enumeratedMeter, new EnumeratedValue {
Value = DefinedTypeEnumerationInstanceList.dtiSCMasterAutoOn.ToModelEnumMember()
});
var result = _creator.GetMetersValue(meters, spatialRecord);
Assert.AreEqual(0x01, result);
}
public void GivenOperationDataFileWhenReadSpatialRecordsThenSpatialRecordsAreReturned()
{
var meter = new NumericWorkingData();
_meters.Add(meter);
var numericRepValue = new NumericRepresentationValue(RepresentationInstanceList.vrABLineHeading.ToModelRepresentation(), new NumericValue(UnitSystemManager.GetUnitOfMeasure("m"), 21.2));
var spatialRecord1 = new SpatialRecord {
Timestamp = DateTime.Now, Geometry = new Point {
X = 45.123456, Y = -65.456789
}
};
spatialRecord1.SetMeterValue(meter, numericRepValue);
spatialRecord1.SetAppliedLatency(meter, 2);
_spatialRecords.Add(spatialRecord1);
var spatialRecord2 = new SpatialRecord {
Timestamp = DateTime.Now, Geometry = new Point {
X = 85.654875, Y = -65.3456212
}
};
spatialRecord2.SetMeterValue(meter, numericRepValue);
spatialRecord2.SetAppliedLatency(meter, 2);
_spatialRecords.Add(spatialRecord2);
var filePath = Path.Combine(_testCardPath, "OperationData-1.adm");
_protobufSerializer.WriteSpatialRecords(filePath, _spatialRecords);
var spatialRecords = _protobufSerializer.ReadSpatialRecords(filePath).ToList();
Assert.AreEqual(spatialRecord1.Timestamp, spatialRecords[0].Timestamp);
Assert.AreEqual(spatialRecord1.Geometry.Id, spatialRecords[0].Geometry.Id);
Assert.AreEqual(numericRepValue.Value.Value, ((NumericRepresentationValue)spatialRecords[0].GetMeterValue(meter)).Value.Value);
Assert.AreEqual(numericRepValue.Representation.Code, ((NumericRepresentationValue)spatialRecords[0].GetMeterValue(meter)).Representation.Code);
Assert.AreEqual(numericRepValue.Value.UnitOfMeasure.Code, ((NumericRepresentationValue)spatialRecords[0].GetMeterValue(meter)).Value.UnitOfMeasure.Code);
Assert.AreEqual(spatialRecord2.Timestamp, spatialRecords[1].Timestamp);
Assert.AreEqual(spatialRecord2.Geometry.Id, spatialRecords[1].Geometry.Id);
Assert.AreEqual(numericRepValue.Value.Value, ((NumericRepresentationValue)spatialRecords[1].GetMeterValue(meter)).Value.Value);
Assert.AreEqual(numericRepValue.Representation.Code, ((NumericRepresentationValue)spatialRecords[1].GetMeterValue(meter)).Representation.Code);
Assert.AreEqual(numericRepValue.Value.UnitOfMeasure.Code, ((NumericRepresentationValue)spatialRecords[1].GetMeterValue(meter)).Value.UnitOfMeasure.Code);
}
