/// <summary> /// Reads the TAG file schema dictionary from the TAG file data using the TAG file reader /// </summary> /// <param name="reader"></param> /// <returns></returns> public bool Read(TAGReader reader) { string fieldName; while ((fieldName = reader.ReadANSIString()) != string.Empty) { uint tempFieldType = reader.ReadUnSignedIntegerValue(1); // If field type is 15, then read an extra var int to determine extended data type if (tempFieldType == 15) { if (!reader.ReadVarInt(out short tempFieldTypeExtended)) { return(false); } tempFieldType += (uint)tempFieldTypeExtended; } var fieldType = (TAGDataType)tempFieldType; if (!reader.ReadVarInt(out var id)) { return(false); } Entries.Add(id, new TAGDictionaryItem(fieldName, fieldType, id)); } if (Entries.Count > DEFAULT_TAG_FILE_SCHEMA_DICTIONARY_CAPACITY) { Log.LogInformation($"TAG file schema dictionary final size of {Entries.Count} exceeds default capacity for dictionary of {DEFAULT_TAG_FILE_SCHEMA_DICTIONARY_CAPACITY}. Consider increasing it."); } return(true); }
public void Test_TAGReader_Creation() { using (var reader = new TAGReader(new MemoryStream(Consts.TREX_DEFAULT_MEMORY_STREAM_CAPACITY_ON_CREATION))) { Assert.NotNull(reader); } }
/// <summary> /// Execute the pre-scan operation on the TAG file, returning a boolean success result. /// Sets up local state detailing the pre-scan fields retried from the ATG file /// </summary> public bool Execute(Stream TAGData) { try { Initialise(); using (var Processor = new TAGProcessorPreScanState()) { var Sink = new TAGVisionLinkPrerequisitesValueSink(Processor); using (var Reader = new TAGReader(TAGData)) { var TagFile = new TAGFile(); ReadResult = TagFile.Read(Reader, Sink); } if (ReadResult != TAGReadResult.NoError) { return(false); } IsCSIBCoordSystemTypeOnly = Processor.IsCSIBCoordSystemTypeOnly; SetPublishedState(Processor); } } catch // (Exception E) // make sure any exception is trapped to return correct response to caller { return(false); } return(true); }
} // This is a byte offset /// <summary> /// Reads the contents of the TAG file header using the provided reader /// </summary> /// <param name="reader"></param> public void Read(TAGReader reader) { MajorVer = reader.ReadUnSignedIntegerValue(1); MinorVer = reader.ReadUnSignedIntegerValue(1); DictionaryID = reader.ReadUnSignedIntegerValue(4); DictionaryMajorVer = reader.ReadUnSignedIntegerValue(1); DictionaryMinorVer = reader.ReadUnSignedIntegerValue(1); FieldAndTypeTableOffset = reader.ReadUnSignedIntegerValue(8); }
/// <summary> /// Read the content of a TAG file and routes it to the provided sink /// </summary> /// <param name="fileName"></param> /// <param name="sink"></param> /// <returns></returns> public TAGReadResult Read(string fileName, TAGValueSinkBase sink) { using (var fs = new FileStream(fileName, FileMode.Open, FileAccess.Read)) { using (var reader = new TAGReader(fs)) { return(Read(reader, sink)); } } }
/// <summary> /// Execute the pre-scan operation on the TAG file, returning a boolean success result. /// Sets up local state detailing the pre-scan fields retried from the ATG file /// </summary> public bool Execute(Stream TAGData, ref List <UTMCoordPointPair> aCSBladePositions, ref List <UTMCoordPointPair> aCSRearAxlePositions, ref List <UTMCoordPointPair> aCSTrackPositions, ref List <UTMCoordPointPair> aCSWheelPositions) { try { Initialise(); using (var processor = new TAGProcessorPreScanACSState()) { var Sink = new TAGVisionLinkPrerequisitesValueSink(processor); using (var Reader = new TAGReader(TAGData)) { var TagFile = new TAGFile(); ReadResult = TagFile.Read(Reader, Sink); } if (ReadResult != TAGReadResult.NoError) { return(false); } IsCSIBCoordSystemTypeOnly = processor.IsCSIBCoordSystemTypeOnly; if (!IsCSIBCoordSystemTypeOnly) { if (processor.HaveReceivedValidTipPositions) { aCSBladePositions.AddRange(processor.BladePositions); } if (processor.HaveReceivedValidRearPositions) { aCSRearAxlePositions.AddRange(processor.RearAxlePositions); } if (processor.HaveReceivedValidTrackPositions) { aCSTrackPositions.AddRange(processor.TrackPositions); } if (processor.HaveReceivedValidWheelPositions) { aCSWheelPositions.AddRange(processor.WheelPositions); } } SetPublishedState(processor); } } catch { return(false); } return(true); }
public void Test_TAGFile_Read_Stream() { // Create the TAG file and reader classes TAGFile file = new TAGFile(); using (var reader = new TAGReader(new FileStream( Path.Combine("TestData", "TAGFiles", "TestTAGFile-TAGFile-Read-Stream.tag"), FileMode.Open, FileAccess.Read))) { // Create the state and sink TAGProcessorStateBase stateBase = new TAGProcessorStateBase(); // Derivatives to construct later TAGValueSink sink = new TAGValueSink(stateBase); //Read the TAG file TAGReadResult result = file.Read(reader, sink); Assert.Equal(TAGReadResult.NoError, result); } }
private static void ProcessTagFiles(string directoryToProcess, string[] dataList) { if (dataList == null) { Console.WriteLine($"No specific tag attributes requested, using defaults of {DEFAULT_DATA_LIST}"); } var files = new List <string>(); CollectTagFilesInFolder(directoryToProcess, files); TAGReader reader = null; FileStream fs = null; CSVTAGProcessor stateBase = null; foreach (var filename in files) { // Create the TAG file and reader classes var file = new TAGFile(); try { fs = new FileStream(Path.GetFullPath(filename), FileMode.Open, FileAccess.Read); reader = new TAGReader(fs); // Create the state and sink stateBase = new CSVTAGProcessor(dataList ?? DEFAULT_DATA_LIST, Path.GetFullPath(filename)); var sink = new TAGValueSink(stateBase); //Read the TAG file var result = file.Read(reader, sink); Console.WriteLine($"File {filename} processed with result {result}"); } finally { fs?.Dispose(); reader?.Dispose(); stateBase?.Dispose(); } } Console.WriteLine("Complete"); }
public void Test_TAGHeader_Read() { using (var reader = new TAGReader(new FileStream(Path.Combine("TestData", "TAGFiles", "TestTAGFile-TAG-Header-Read.tag"), FileMode.Open))) { Assert.NotNull(reader); TAGHeader header = new TAGHeader(); //Read the header header.Read(reader); Assert.Equal(1U, header.DictionaryID); Assert.Equal(1U, header.DictionaryMajorVer); Assert.Equal(4U, header.DictionaryMinorVer); Assert.Equal(1U, header.MajorVer); Assert.Equal(0U, header.MinorVer); Assert.True( header.FieldAndTypeTableOffset > 0 && header.FieldAndTypeTableOffset < reader.StreamSizeInNybbles / 2, "Field and type table offset read from header is invalid"); } }
/// <summary> /// Reads the context of a TAG file using the provided reader and sink /// </summary> /// <param name="reader"></param> /// <param name="sink"></param> /// <returns></returns> public TAGReadResult Read(TAGReader reader, TAGValueSinkBase sink) { try { if (reader.StreamSizeInNybbles == 0) { return(TAGReadResult.ZeroLengthFile); } try { Header.Read(reader); } catch (Exception E) { Log.LogError(E, "Invalid tag file. Exception in TTagFile.ReadStream - Header.LoadFromStream:"); return(TAGReadResult.InvalidDictionary); } // If the offset to the dictionary is zero, then it follows immediately after the header long DataEndPos; try { if (Header.FieldAndTypeTableOffset != 0) { long StreamPos = reader.NybblePosition; reader.NybblePosition = Header.FieldAndTypeTableOffset * 2; // FieldAndTypeTableOffset is in bytes if (!Dictionary.Read(reader)) { return(TAGReadResult.InvalidDictionary); } reader.NybblePosition = StreamPos; DataEndPos = Header.FieldAndTypeTableOffset * 2; // FieldAndTypeTableOffset is in bytes } else { if (!Dictionary.Read(reader)) { return(TAGReadResult.InvalidDictionary); } DataEndPos = reader.StreamSizeInNybbles; } } catch (Exception E) { Log.LogWarning(E, "Exception in TagFile.ReadFile:"); return(TAGReadResult.InvalidDictionary); } // Now read in the data from the file if (!sink.Starting()) { return(TAGReadResult.SinkStartingFailure); } while (!sink.Aborting() && reader.NybblePosition < DataEndPos) { if (!reader.ReadVarInt(out short ValueTypeID)) { if (reader.NybblePosition >= DataEndPos) { break; // We have finished } return(TAGReadResult.InvalidValueTypeID); // This is an invalid tag file } if (Dictionary.Entries.Keys.Count == 0) { return(TAGReadResult.InvalidDictionary); } if (!Dictionary.Entries.TryGetValue(ValueTypeID, out TAGDictionaryItem DictionaryEntry)) { return(TAGReadResult.InvalidValueTypeID); } try { switch (DictionaryEntry.Type) { case TAGDataType.t4bitInt: case TAGDataType.t8bitInt: case TAGDataType.t12bitInt: case TAGDataType.t16bitInt: case TAGDataType.t32bitInt: sink.ReadIntegerValue(DictionaryEntry, reader.ReadSignedIntegerValue(IntegerNybbleSizes.Nybbles[(byte)DictionaryEntry.Type])); break; case TAGDataType.t4bitUInt: case TAGDataType.t8bitUInt: case TAGDataType.t12bitUInt: case TAGDataType.t16bitUInt: case TAGDataType.t32bitUInt: sink.ReadUnsignedIntegerValue(DictionaryEntry, reader.ReadUnSignedIntegerValue(IntegerNybbleSizes.Nybbles[(byte)DictionaryEntry.Type])); break; case TAGDataType.tIEEESingle: sink.ReadIEEESingleValue(DictionaryEntry, reader.ReadSinglePrecisionIEEEValue()); break; case TAGDataType.tIEEEDouble: sink.ReadIEEEDoubleValue(DictionaryEntry, reader.ReadDoublePrecisionIEEEValue()); break; case TAGDataType.tANSIString: sink.ReadANSIStringValue(DictionaryEntry, reader.ReadANSIString()); break; case TAGDataType.tUnicodeString: sink.ReadUnicodeStringValue(DictionaryEntry, reader.ReadUnicodeString()); break; case TAGDataType.tEmptyType: sink.ReadEmptyValue(DictionaryEntry); break; } } catch (Exception E) { Log.LogError(E, "Exception in TagFile.ReadFile while reading field value:"); return(TAGReadResult.InvalidValue); } } if (!sink.Finishing()) { return(TAGReadResult.SinkFinishingFailure); } } catch (IOException E) { Log.LogDebug(E, "Exception in TagFile.ReadFile:"); return(TAGReadResult.CouldNotOpenFile); } return(TAGReadResult.NoError); }
/// <summary> /// Execute the conversion operation on the TAG file, returning a boolean success result. /// Sets up local state detailing the pre-scan fields retrieved from the TAG file /// </summary> public bool ExecuteLegacyTAGFile(string filename, Stream tagData, Guid assetUid, bool isJohnDoe) { Log.LogInformation($"In {nameof(ExecuteLegacyTAGFile)}: reading file {filename} for asset {assetUid}, JohnDoe: {isJohnDoe}"); ReadResult = TAGReadResult.NoError; List <UTMCoordPointPair> aCSBladePositions = null; List <UTMCoordPointPair> ACSRearAxlePositions = null; List <UTMCoordPointPair> ACSTrackPositions = null; List <UTMCoordPointPair> ACSWheelPositions = null; try { Processor?.Dispose(); // Locate the machine in the local set of machines, adding one if necessary Machine = Machines.Locate(assetUid, isJohnDoe); var machineType = MachineType.Unknown; var machineHardwareId = string.Empty; var machineId = string.Empty; //Prescan to get all relevant information necessary for processing the tag file. e.g. Machinetype for swather, Type of coordinate system (ACS) var tagFilePreScan = new TAGFilePreScan(); tagFilePreScan.Execute(tagData); tagData.Position = 0; // reset if (tagFilePreScan.ReadResult == TAGReadResult.NoError) { machineType = tagFilePreScan.MachineType; // used in creation of swather machineHardwareId = tagFilePreScan.HardwareID; machineId = tagFilePreScan.MachineID; IsUTMCoordinateSystem = !tagFilePreScan.IsCSIBCoordSystemTypeOnly; // do we need to convert UTM coordinates to project coordinates if (IsUTMCoordinateSystem && tagFilePreScan.ProcessedEpochCount > 0) { Log.LogInformation($"{nameof(ExecuteLegacyTAGFile)}: ACS coordinate system detected. {filename}"); aCSBladePositions = new List <UTMCoordPointPair>(); ACSRearAxlePositions = new List <UTMCoordPointPair>(); ACSTrackPositions = new List <UTMCoordPointPair>(); ACSWheelPositions = new List <UTMCoordPointPair>(); if (!CollectAndConvertBladePostions(_targetSiteModel, ref tagData, ref aCSBladePositions, ref ACSRearAxlePositions, ref ACSTrackPositions, ref ACSWheelPositions)) { Log.LogError($"{nameof(ExecuteLegacyTAGFile)}: Failed to collect and convert blade positions for tagfile processing with ACS. TAG FILE:{filename}"); ReadResult = TAGReadResult.CoordinateConversionFailure; return(false); } } } else { Log.LogError($"Unsuccessful prescan of tagfile. {tagFilePreScan.ReadResult}"); return(false); } if (Machine == null) { // Now we know more about the machine have another go finding it Machine = Machines.Locate(assetUid, machineId, isJohnDoe); } if (Machine == null) { Log.LogDebug($"Creating new machine in common converter for AssetUid = {assetUid}, JohnDoe = {isJohnDoe}, machineId = {machineId}, machineHardwareId = {machineHardwareId}"); Machine = Machines.CreateNew(machineId, machineHardwareId, machineType, DeviceTypeEnum.MANUALDEVICE, isJohnDoe, assetUid); } if (Machine.MachineType == MachineType.Unknown && machineType != MachineType.Unknown) { Machine.MachineType = machineType; } var holdMachineType = Machine.MachineType; // Locate the aggregator, adding one if necessary var machineTargetValueChangesAggregator = MachinesTargetValueChangesAggregator[Machine.InternalSiteModelMachineIndex] as ProductionEventLists; if (machineTargetValueChangesAggregator == null) { machineTargetValueChangesAggregator = new ProductionEventLists(SiteModel, Machine.InternalSiteModelMachineIndex); MachinesTargetValueChangesAggregator.Add(machineTargetValueChangesAggregator); } Processor = new TAGProcessor(SiteModel, Machine, SiteModelGridAggregator, machineTargetValueChangesAggregator); // If ACS coordinate system populate converted UTM coordinates if (IsUTMCoordinateSystem && tagFilePreScan.ProcessedEpochCount > 0) { if (aCSBladePositions != null && aCSBladePositions.Count > 0) { Processor.ConvertedBladePositions.AddRange(aCSBladePositions); } if (ACSRearAxlePositions != null && ACSRearAxlePositions.Count > 0) { Processor.ConvertedRearAxlePositions.AddRange(ACSRearAxlePositions); } if (ACSTrackPositions != null && ACSTrackPositions.Count > 0) { Processor.ConvertedTrackPositions.AddRange(ACSTrackPositions); } if (ACSWheelPositions != null && ACSWheelPositions.Count > 0) { Processor.ConvertedWheelPositions.AddRange(ACSWheelPositions); } } var sink = new TAGValueSink(Processor); using (var reader = new TAGReader(tagData)) { var tagFile = new TAGFile(); ReadResult = tagFile.Read(reader, sink); // Notify the processor that all reading operations have completed for the file Processor.DoPostProcessFileAction(ReadResult == TAGReadResult.NoError); SetPublishedState(Processor); Machine.MachineType = holdMachineType; if (ReadResult != TAGReadResult.NoError) { return(false); } } } catch (Exception e) // make sure any exception is trapped to return correct response to caller { Log.LogError(e, "Exception occurred while converting a TAG file"); return(false); } return(true); }