Esempio n. 1
0
 private static List <RawVariable> ReadRawVariables(byte[] bytes, SubsystemData subsystemData)
 {
     using var stream = new MemoryStream(bytes);
     using var reader = new BinaryReader(stream);
     reader.ReadBytes(8);
     return(MatFileReader.ReadRawVariables(reader, -1, subsystemData));
 }
        /// <summary>
        /// Read subsystem data from a given byte array.
        /// </summary>
        /// <param name="bytes">Byte array with the data.</param>
        /// <param name="subsystemData">
        /// Link to the existing subsystem data; this will be put in nested OpaqueLink objects
        /// and later replaced with the subsystem data that we are currently reading.</param>
        /// <returns>Subsystem data read.</returns>
        public static SubsystemData Read(byte[] bytes, SubsystemData subsystemData)
        {
            List <RawVariable> rawVariables = null;

            using (var stream = new MemoryStream(bytes))
            {
                using (var reader = new BinaryReader(stream))
                {
                    reader.ReadBytes(8);
                    rawVariables = MatFileReader.ReadRawVariables(reader, -1, subsystemData);
                }
            }

            // Parse subsystem data.
            var mainVariable = rawVariables[0].DataElement as IStructureArray;
            var mcosData     = mainVariable["MCOS", 0] as Opaque;
            var opaqueData   = mcosData.RawData as ICellArray;
            var info         = (opaqueData[0] as IArrayOf <byte>).Data;

            var(offsets, position) = ReadOffsets(info, 0);
            var fieldNames      = ReadFieldNames(info, position, offsets[1]);
            var numberOfClasses = ((offsets[3] - offsets[2]) / 16) - 1;
            Dictionary <int, string> classIdToName = null;

            using (var stream = new MemoryStream(info, offsets[2], offsets[3] - offsets[2]))
            {
                using (var reader = new BinaryReader(stream))
                {
                    classIdToName = ReadClassNames(reader, fieldNames, numberOfClasses);
                }
            }

            var numberOfObjects = ((offsets[5] - offsets[4]) / 24) - 1;
            Dictionary <int, (int, int)> objectClasses = null;

            using (var stream = new MemoryStream(info, offsets[4], offsets[5] - offsets[4]))
            {
                using (var reader = new BinaryReader(stream))
                {
                    objectClasses = ReadObjectClasses(reader, numberOfObjects);
                }
            }

            Dictionary <int, Dictionary <int, int> > objectToFields = null;

            using (var stream = new MemoryStream(info, offsets[5], offsets[6] - offsets[5]))
            {
                using (var reader = new BinaryReader(stream))
                {
                    objectToFields = ReadObjectToFieldsMapping(reader, numberOfObjects);
                }
            }

            var(classInformation, objectInformation) =
                GatherClassAndObjectInformation(
                    classIdToName,
                    fieldNames,
                    objectClasses,
                    objectToFields);

            var allFields = objectInformation.Values.SelectMany(obj => obj.FieldLinks.Values);
            var data      = new Dictionary <int, IArray>();

            foreach (var i in allFields)
            {
                data[i] = TransformOpaqueData(opaqueData[i + 2], subsystemData);
            }
            return(new SubsystemData(classInformation, objectInformation, data));
        }