System.IO.BinaryReader.ReadSingle()

Here are the examples of the csharp api System.IO.BinaryReader.ReadSingle() taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

929 Examples 7

19 Source : WorldModel.cs
with GNU General Public License v3.0
from CypherCore

public static WmoLiquid ReadFromFile(BinaryReader reader)
        {
            WmoLiquid liquid = new();

            liquid.iTilesX = reader.ReadUInt32();
            liquid.iTilesY = reader.ReadUInt32();
            liquid.iCorner = reader.Read<Vector3>();
            liquid.iType = reader.ReadUInt32();

            if (liquid.iTilesX != 0 && liquid.iTilesY != 0)
            {
                uint size = (liquid.iTilesX + 1) * (liquid.iTilesY + 1);
                liquid.iHeight = reader.ReadArray<float>(size);

                size = liquid.iTilesX * liquid.iTilesY;
                liquid.iFlags = reader.ReadArray<byte>(size);
            }
            else
            {
                liquid.iHeight = new float[1];
                liquid.iHeight[0] = reader.ReadSingle();
            }

            return liquid;
        }

19 Source : ByteBuffer.cs
with GNU General Public License v3.0
from CypherCore

public float ReadFloat()
        {
            ResetBitPos();
            return readStream.ReadSingle();
        }

19 Source : Model.cs
with GNU General Public License v3.0
from CypherCore

public static bool ReadFromFile(BinaryReader reader, out ModelSpawn spawn)
        {
            spawn = new ModelSpawn();
            spawn.flags = reader.ReadUInt32();
            spawn.adtId = reader.ReadUInt16();
            spawn.ID = reader.ReadUInt32();
            spawn.iPos = reader.ReadVector3();
            spawn.iRot = reader.ReadVector3();
            spawn.iScale = reader.ReadSingle();

            if ((spawn.flags & ModelFlags.HasBound) != 0) // only WMOs have bound in MPQ, only available after computation
            {
                Vector3 bLow = reader.ReadVector3();
                Vector3 bHigh = reader.ReadVector3();
                spawn.iBound = new AxisAlignedBox(bLow, bHigh);
            }

            int nameLen = reader.ReadInt32();
            spawn.name = reader.ReadString(nameLen);
            return true;
        }

19 Source : WorldModel.cs
with GNU General Public License v3.0
from CypherCore

public static WmoLiquid ReadFromFile(BinaryReader reader)
        {
            WmoLiquid liquid = new();

            liquid.iTilesX = reader.ReadUInt32();
            liquid.iTilesY = reader.ReadUInt32();
            liquid.iCorner = reader.Read<Vector3>();
            liquid.iType = reader.ReadUInt32();

            if (liquid.iTilesX != 0 && liquid.iTilesY != 0)
            {
                uint size = (liquid.iTilesX + 1) * (liquid.iTilesY + 1);
                liquid.iHeight = new float[size];
                for (var i = 0; i < size; i++)
                    liquid.iHeight[i] = reader.ReadSingle();

                size = liquid.iTilesX * liquid.iTilesY;
                liquid.iFlags = new byte[size];
                for (var i = 0; i < size; i++)
                    liquid.iFlags[i] = reader.ReadByte();
            }
            else
            {
                liquid.iHeight = new float[1];
                liquid.iHeight[0] = reader.ReadSingle();
            }

            return liquid;
        }

19 Source : Extensions.cs
with GNU General Public License v3.0
from CypherCore

public static Vector3 ReadVector3(this BinaryReader reader)
        {
            return new Vector3(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
        }

19 Source : Wmo.cs
with GNU General Public License v3.0
from CypherCore

public bool Open(uint fileId, WMORoot rootWmo)
        {
            Stream stream = Program.CascHandler.OpenFile((int)fileId);
            if (stream == null)
            {
                Console.WriteLine("No such file.");
                return false;
            }

            using (BinaryReader reader = new(stream))
            {
                long fileLength = reader.BaseStream.Length;
                while (reader.BaseStream.Position < fileLength)
                {
                    string fourcc = reader.ReadStringFromChars(4, true);
                    uint size = reader.ReadUInt32();

                    if (fourcc == "MOGP")//Fix sizeoff = Data size.
                        size = 68;

                    long nextpos = reader.BaseStream.Position + size;

                    if (fourcc == "MOGP")//header
                    {
                        groupName = reader.ReadInt32();
                        descGroupName = reader.ReadInt32();
                        mogpFlags = reader.ReadInt32();

                        for (var i = 0; i < 3; ++i)
                            bbcorn1[i] = reader.ReadSingle();

                        for (var i = 0; i < 3; ++i)
                            bbcorn2[i] = reader.ReadSingle();

                        moprIdx = reader.ReadUInt16();
                        moprNItems = reader.ReadUInt16();
                        nBatchA = reader.ReadUInt16();
                        nBatchB = reader.ReadUInt16();
                        nBatchC = reader.ReadUInt32();
                        fogIdx = reader.ReadUInt32();
                        groupLiquid = reader.ReadUInt32();
                        groupWMOID = reader.ReadUInt32();

                        // according to WoW.Dev Wiki:
                        if (Convert.ToBoolean(rootWmo.flags & 4))
                            groupLiquid = GetLiquidTypeId(groupLiquid);
                        else if (groupLiquid == 15)
                            groupLiquid = 0;
                        else
                            groupLiquid = GetLiquidTypeId(groupLiquid + 1);

                        if (groupLiquid != 0)
                            liquflags |= 2;
                    }
                    else if (fourcc == "MOPY")
                    {
                        mopy_size = (int)size;
                        nTriangles = (int)size / 2;
                        MOPY = reader.ReadString((int)size);
                    }
                    else if (fourcc == "MOVI")
                    {
                        MOVI = new ushort[size / 2];
                        for (var i = 0; i < size / 2; ++i)
                            MOVI[i] = reader.ReadUInt16();
                    }
                    else if (fourcc == "MOVT")
                    {
                        MOVT = new float[size / 4];
                        for (var i = 0; i < size / 4; ++i)
                            MOVT[i] = reader.ReadSingle();

                        nVertices = size / 12;
                    }
                    else if (fourcc == "MONR")
                    {
                    }
                    else if (fourcc == "MOTV")
                    {
                    }
                    else if (fourcc == "MOBA")
                    {
                        MOBA = new ushort[size / 2];
                        moba_size = (int)(size / 2);

                        for (var i = 0; i < size / 2; ++i)
                            MOBA[i] = reader.ReadUInt16();
                    }
                    else if (fourcc == "MODR")
                    {
                        for (var i = 0; i < size / 2; ++i)
                            DoodadReferences.Add(reader.Read<ushort>());
                    }
                    else if (fourcc == "MLIQ")
                    {
                        liquflags |= 1;
                        hlq = reader.Read<WMOLiquidHeader>();
                        LiquEx_size = 8 * hlq.xverts * hlq.yverts;
                        LiquEx = new WMOLiquidVert[hlq.xverts * hlq.yverts];
                        for (var i = 0; i < hlq.xverts * hlq.yverts; ++i)
                            LiquEx[i] = reader.Read<WMOLiquidVert>();

                        int nLiquBytes = hlq.xtiles * hlq.ytiles;
                        LiquBytes = reader.ReadBytes(nLiquBytes);

                        // Determine legacy liquid type
                        if (groupLiquid == 0)
                        {
                            for (int i = 0; i < hlq.xtiles * hlq.ytiles; ++i)
                            {
                                if ((LiquBytes[i] & 0xF) != 15)
                                {
                                    groupLiquid = GetLiquidTypeId((uint)(LiquBytes[i] & 0xF) + 1);
                                    break;
                                }
                            }
                        }

                        /* std::ofstream llog("Buildings/liquid.log", ios_base::out | ios_base::app);
                        llog << filename;
                        llog << "\nbbox: " << bbcorn1[0] << ", " << bbcorn1[1] << ", " << bbcorn1[2] << " | " << bbcorn2[0] << ", " << bbcorn2[1] << ", " << bbcorn2[2];
                        llog << "\nlpos: " << hlq->pos_x << ", " << hlq->pos_y << ", " << hlq->pos_z;
                        llog << "\nx-/yvert: " << hlq->xverts << "/" << hlq->yverts << " size: " << size << " expected size: " << 30 + hlq->xverts*hlq->yverts*8 + hlq->xtiles*hlq->ytiles << std::endl;
                        llog.close(); */
                    }
                    reader.BaseStream.Seek((int)nextpos, SeekOrigin.Begin);
                }
            }

            return true;
        }

19 Source : TileAssembler.cs
with GNU General Public License v3.0
from CypherCore

public bool Read(BinaryReader reader)
        {
            mogpflags = reader.ReadUInt32();
            GroupWMOID = reader.ReadUInt32();

            Vector3 vec1 = reader.Read<Vector3>();
            Vector3 vec2 = reader.Read<Vector3>();
            bounds = new AxisAlignedBox(vec1, vec2);

            liquidflags = reader.ReadUInt32();

            string blockId = new(reader.ReadChars(4));
            if (blockId != "GRP ")
            {
                Console.WriteLine($"Error: {blockId} != GRP {reader.BaseStream.Position}");
                return false;
            }

            int blocksize = reader.ReadInt32();
            uint branches = reader.ReadUInt32();
            for (int i = 0; i < branches; ++i)
                reader.ReadUInt32();

            // ---- indexes
            blockId = new(reader.ReadChars(4));
            if (blockId != "INDX")
            {
                Console.WriteLine($"Error: {blockId} != INDX");
                return false;
            }

            blocksize = reader.ReadInt32();
            uint nindexes = reader.ReadUInt32();
            if (nindexes > 0)
            {
                ushort[] indexarray = new ushort[nindexes];
                for (var i = 0; i < nindexes; ++i)
                    indexarray[i] = reader.ReadUInt16();

                for (uint i = 0; i < nindexes; i += 3)
                    triangles.Add(new MeshTriangle(indexarray[i], indexarray[i + 1], indexarray[i + 2]));
            }

            // ---- vectors
            blockId = new(reader.ReadChars(4));
            if (blockId != "VERT")
            {
                Console.WriteLine($"Error: {blockId} != VERT");
                return false;
            }
            blocksize = reader.ReadInt32();

            uint nvectors = reader.ReadUInt32();
            if (nvectors > 0)
            {
                float[] vectorarray = new float[nvectors * 3];
                for (var i = 0; i < nvectors * 3; ++i)
                    vectorarray[i] = reader.ReadSingle();

                vertexArray = new List<Vector3>();
                for (uint i = 0; i < nvectors; ++i)
                    vertexArray.Add(new Vector3(vectorarray[3 * i], vectorarray[3 * i + 1], vectorarray[3 * i + 2]));
            }

            // ----- liquid
            liquid = null;
            if (Convert.ToBoolean(liquidflags & 3))
            {
                blockId = reader.ReadStringFromChars(4);
                if (blockId != "LIQU")
                {
                    Console.WriteLine($"Error: {blockId} != LIQU");
                    return false;
                }
                blocksize = reader.ReadInt32();
                uint liquidType = reader.ReadUInt32();
                if (Convert.ToBoolean(liquidflags & 1))
                {
                    WMOLiquidHeader hlq = reader.Read<WMOLiquidHeader>();
                    liquid = new WmoLiquid((uint)hlq.xtiles, (uint)hlq.ytiles, new Vector3(hlq.pos_x, hlq.pos_y, hlq.pos_z), liquidType);
                    int size = hlq.xverts * hlq.yverts;
                    liquid.iHeight = new float[size];
                    for (var i = 0; i < size; ++i)
                        liquid.iHeight[i] = reader.ReadSingle();

                    size = hlq.xtiles * hlq.ytiles;
                    liquid.iFlags = new byte[size];
                    for (var i = 0; i < size; ++i)
                        liquid.iFlags[i] = reader.ReadByte();
                }
                else
                {
                    liquid = new WmoLiquid(0, 0, Vector3.Zero, liquidType);
                    liquid.iHeight[0] = bounds.Hi.Z;
                }
            }

            return true;
        }

19 Source : Wmo.cs
with GNU General Public License v3.0
from CypherCore

public bool Read(Stream stream)
        {
            if (stream == null)
            {
                Console.WriteLine("No such file.");
                return false;
            }

            using (BinaryReader reader = new(stream))
            {
                long fileLength = reader.BaseStream.Length;
                while (reader.BaseStream.Position < fileLength)
                {
                    string fourcc = reader.ReadStringFromChars(4, true);
                    uint size = reader.ReadUInt32();

                    int nextpos = (int)(reader.BaseStream.Position + size);
                    if (fourcc == "MOHD") // header
                    {
                        nTextures = reader.ReadUInt32();
                        nGroups = reader.ReadUInt32();
                        nPortals = reader.ReadUInt32();
                        nLights = reader.ReadUInt32();
                        nDoodadNames = reader.ReadUInt32();
                        nDoodadDefs = reader.ReadUInt32();
                        nDoodadSets = reader.ReadUInt32();
                        color = reader.ReadUInt32();
                        RootWMOID = reader.ReadUInt32();

                        for (var i = 0; i < 3; ++i)
                            bbcorn1[i] = reader.ReadSingle();

                        for (var i = 0; i < 3; ++i)
                            bbcorn2[i] = reader.ReadSingle();

                        flags = reader.ReadUInt16();
                        numLod = reader.ReadUInt16();
                    }
                    else if (fourcc == "MODS")
                    {
                        for (var i = 0; i < size / 32; ++i)
                            DoodadData.Sets.Add(reader.ReadStruct<MODS>());
                    }
                    else if (fourcc == "MODN")
                    {
                        DoodadData.Paths = reader.ReadBytes((int)size);

                        using BinaryReader doodadReader = new(new MemoryStream(DoodadData.Paths));
                        int index = 0;
                        long endIndex = doodadReader.BaseStream.Length;
                        while (doodadReader.BaseStream.Position < endIndex)
                        {
                            string path = doodadReader.ReadCString();
                            if (VmapFile.ExtractSingleModel(path))
                                ValidDoodadNames.Add((uint)index);

                            index += path.Length + 1;
                        }
                    }
                    else if (fourcc == "MODI")
                    {
                        uint fileDataIdCount = size / 4;
                        DoodadData.FileDataIds = new uint[size / 4];

                        Buffer.BlockCopy(reader.ReadBytes((int)size), 0, DoodadData.FileDataIds, 0, DoodadData.FileDataIds.Length);
                        for (uint i = 0; i < fileDataIdCount; ++i)
                        {
                            if (DoodadData.FileDataIds[i] == 0)
                                continue;

                            string path = $"FILE{DoodadData.FileDataIds[i]:X8}.xxx";
                            if (VmapFile.ExtractSingleModel(path))
                                ValidDoodadNames.Add(i);
                        }
                    }
                    else if (fourcc == "MODD")
                    {
                        for (var i = 0; i < size / 40; ++i)
                            DoodadData.Spawns.Add(reader.Read<MODD>());
                    }
                    else if (fourcc == "GFID")
                    {
                        for (uint gp = 0; gp < nGroups; ++gp)
                        {
                            uint fileDataId = reader.ReadUInt32();
                            if (fileDataId != 0)
                                groupFileDataIDs.Add(fileDataId);
                        }
                    }

                    reader.BaseStream.Seek(nextpos, SeekOrigin.Begin);
                }
            }
            return true;
        }

19 Source : SimpleJSON.cs
with GNU General Public License v3.0
from Cytoid

public static JSONNode Deserialize(System.IO.BinaryReader aReader)
        {
            JSONBinaryTag type = (JSONBinaryTag)aReader.ReadByte();
            switch(type)
            {
            case JSONBinaryTag.Array:
            {
                int count = aReader.ReadInt32();
                JSONArray tmp = new JSONArray();
                for(int i = 0; i < count; i++)
                    tmp.Add(Deserialize(aReader));
                return tmp;
            }
            case JSONBinaryTag.Clreplaced:
            {
                int count = aReader.ReadInt32();                
                JSONClreplaced tmp = new JSONClreplaced();
                for(int i = 0; i < count; i++)
                {
                    string key = aReader.ReadString();
                    var val = Deserialize(aReader);
                    tmp.Add(key, val);
                }
                return tmp;
            }
            case JSONBinaryTag.Value:
            {
                return new JSONData(aReader.ReadString());
            }
            case JSONBinaryTag.IntValue:
            {
                return new JSONData(aReader.ReadInt32());
            }
            case JSONBinaryTag.DoubleValue:
            {
                return new JSONData(aReader.ReadDouble());
            }
            case JSONBinaryTag.BoolValue:
            {
                return new JSONData(aReader.ReadBoolean());
            }
            case JSONBinaryTag.FloatValue:
            {
                return new JSONData(aReader.ReadSingle());
            }
 
            default:
            {
                throw new Exception("Error deserializing JSON. Unknown tag: " + type);
            }
            }
        }

19 Source : ImageInput.xaml.cs
with MIT License
from czh098tom

private static void ReadHGEFormat(BinaryReader sr, StringBuilder sb)
        {
            sb.Append("Default index: ");
            sb.Append(sr.ReadByte());
            sr.ReadByte();
            sb.Append("\nBlend mode: ");
            sb.Append(sr.ReadByte());
            sr.ReadByte();
            sb.Append("\nEmission: ");
            sb.Append(sr.ReadInt32());
            sb.Append(" p/sec\nSystem life time: ");
            float f = sr.ReadSingle();
            sb.Append(f == -1 ? "infinite" : f.ToString());
            sb.Append(" sec\n\nParticle life time: ");
            sb.Append(sr.ReadSingle());
            sb.Append(" ~ ");
            sb.Append(sr.ReadSingle());
            sb.Append(" sec\n\nDirection: ");
            sb.Append(sr.ReadSingle());
            sb.Append(" deg\nSpread: ");
            sb.Append(sr.ReadSingle());
            sb.Append(" deg\nIs relative: ");
            sb.Append(sr.ReadBoolean());
            sr.ReadByte();
            sr.ReadByte();
            sr.ReadByte();
            sb.Append("\n\nSpeed Range: ");
            sb.Append(sr.ReadSingle());
            sb.Append(" ~ ");
            sb.Append(sr.ReadSingle());
            sb.Append("\nGravity Range: ");
            sb.Append(sr.ReadSingle());
            sb.Append(" ~ ");
            sb.Append(sr.ReadSingle());
            sb.Append("\nRadial Acceleration Range: ");
            sb.Append(sr.ReadSingle());
            sb.Append(" ~ ");
            sb.Append(sr.ReadSingle());
            sb.Append("\nTangential Acceleration Range: ");
            sb.Append(sr.ReadSingle());
            sb.Append(" ~ ");
            sb.Append(sr.ReadSingle());
            sb.Append("\n\nSize: ");
            sb.Append(sr.ReadSingle());
            sb.Append(" -> ");
            sb.Append(sr.ReadSingle());
            sb.Append(" variation: ");
            sb.Append(sr.ReadSingle());
            sb.Append("\nSpin: ");
            sb.Append(sr.ReadSingle());
            sb.Append(" -> ");
            sb.Append(sr.ReadSingle());
            sb.Append(" variation: ");
            sb.Append(sr.ReadSingle());
            sb.Append("\nColor: ");
            sb.Append(Convert.ToInt32(sr.ReadSingle() * 255));
            sb.Append(" ");
            sb.Append(Convert.ToInt32(sr.ReadSingle() * 255));
            sb.Append(" ");
            sb.Append(Convert.ToInt32(sr.ReadSingle() * 255));
            sb.Append(" -> ");
            sb.Append(Convert.ToInt32(sr.ReadSingle() * 255));
            sb.Append(" ");
            sb.Append(Convert.ToInt32(sr.ReadSingle() * 255));
            sb.Append(" ");
            sb.Append(Convert.ToInt32(sr.ReadSingle() * 255));
            sb.Append("\ncolor variation: ");
            sb.Append(sr.ReadSingle());
            sb.Append("\nalpha variation: ");
            sb.Append(sr.ReadSingle());
        }

19 Source : Wire.cs
with Apache License 2.0
from danielcrenna

private static object ReadValue(this Type type, BinaryReader br, ITypeResolver typeResolver)
		{
			while (true)
			{
				readValue:

				if (type == null)
					throw new NullReferenceException();

				if (type == typeof(string))
					return br.ReadIsNull() ? default : br.ReadString();
				if (type == typeof(bool))
					return BuiltIns.ReadBoolean(br);
				if (type == typeof(int))
					return br.ReadInt32();
				if (type == typeof(long))
					return br.ReadInt64();
				if (type == typeof(float))
					return br.ReadSingle();
				if (type == typeof(double))
					return br.ReadDouble();
				if (type == typeof(decimal))
					return br.ReadDecimal();
				if (type == typeof(short))
					return br.ReadInt16();
				if (type == typeof(uint))
					return br.ReadUInt32();
				if (type == typeof(ulong))
					return br.ReadUInt64();
				if (type == typeof(ushort))
					return br.ReadUInt16();
				if (type == typeof(byte))
					return br.ReadByte();
				if (type == typeof(sbyte))
					return br.ReadSByte();
				if (type == typeof(char))
					return br.ReadChar();

				if (type == typeof(byte?))
					return br.ReadIsNull() ? default : br.ReadByte();
				if (type == typeof(sbyte?))
					return br.ReadIsNull() ? default : br.ReadSByte();
				if (type == typeof(bool?))
					return br.ReadIsNull() ? default : br.ReadBoolean();
				if (type == typeof(short?))
					return br.ReadIsNull() ? default : br.ReadInt16();
				if (type == typeof(ushort?))
					return br.ReadIsNull() ? default : br.ReadUInt16();
				if (type == typeof(int?))
					return br.ReadIsNull() ? default : br.ReadInt32();
				if (type == typeof(uint?))
					return br.ReadIsNull() ? default : br.ReadUInt32();
				if (type == typeof(long?))
					return br.ReadIsNull() ? default : br.ReadInt64();
				if (type == typeof(ulong?))
					return br.ReadIsNull() ? default : br.ReadUInt64();
				if (type == typeof(float?))
					return br.ReadIsNull() ? default : br.ReadSingle();
				if (type == typeof(double?))
					return br.ReadIsNull() ? default : br.ReadDouble();
				if (type == typeof(decimal?))
					return br.ReadIsNull() ? default : br.ReadDecimal();
				if (type == typeof(char?))
					return br.ReadIsNull() ? default : br.ReadChar();

				if (type == typeof(char[]))
					return br.ReadIsNull() ? null : ReadCharArray(br);
				if (type == typeof(byte[]))
					return br.ReadIsNull() ? null : ReadByteArray(br);

				if (type == typeof(TimeSpan))
					return br.ReadTimeSpan();
				if (type == typeof(DateTimeOffset))
					return br.ReadDateTimeOffset();
				if (type == typeof(DateTime))
					return br.ReadDateTime(typeResolver);

				if (type == typeof(TimeSpan?))
					return br.ReadIsNull() ? default : br.ReadTimeSpan();
				if (type == typeof(DateTimeOffset?))
					return br.ReadIsNull() ? null : br.ReadDateTimeOffset();
				if (type == typeof(DateTime?))
					return br.ReadIsNull() ? null : ReadDateTime(br, typeResolver);

				if (typeof(IDictionary<,>).IsreplacedignableFromGeneric(type))
				{
					if (br.ReadIsNull())
						return null;

					var method = ReadTypedDictionaryMethod;
					if (method == null)
						throw new NullReferenceException();

					var genericMethod = method.MakeGenericMethod(type.GenericTypeArguments);
					return genericMethod.Invoke(null, new object [] { br, typeResolver });
				}

				if (typeof(IList<>).IsreplacedignableFromGeneric(type))
					return br.ReadIsNull() ? null : br.ReadTypedList(type, typeResolver);
				
				if (typeof(IList).IsreplacedignableFrom(type))
					return br.ReadIsNull() ? null : br.ReadList(type, typeResolver);

				if (type.IsEnum)
				{
					type = GetEnumType(type);
					goto readValue;
				}

				if (Nullable.GetUnderlyingType(type) != null)
				{
					if (!br.ReadIsNull())
					{
						type = Nullable.GetUnderlyingType(type);
						goto readValue;
					}

					return null;
				}

				return br.ReadObject(type, typeResolver);
			}
		}

19 Source : TR4FileReadUtilities.cs
with MIT License
from DanzaG

private static TR4RoomLight ReadRoomLight(BinaryReader reader)
        {
            return new TR4RoomLight
            {
                X = reader.ReadInt32(),
                Y = reader.ReadInt32(),
                Z = reader.ReadInt32(),
                Colour = new TRColour
                {
                    Red = reader.ReadByte(),
                    Green = reader.ReadByte(),
                    Blue = reader.ReadByte()
                },
                LightType = reader.ReadByte(),
                Unknown = reader.ReadByte(),
                Intensity = reader.ReadByte(),
                In = reader.ReadSingle(),
                Out = reader.ReadSingle(),
                Length = reader.ReadSingle(),
                CutOff = reader.ReadSingle(),
                dx = reader.ReadSingle(),
                dy = reader.ReadSingle(),
                dz = reader.ReadSingle()
            };
        }

19 Source : TR5FileReadUtilities.cs
with MIT License
from DanzaG

public static void PopulateRooms(BinaryReader reader, TR5Level lvl)
        {
            lvl.LevelDataChunk.Unused = reader.ReadUInt32();
            lvl.LevelDataChunk.NumRooms = reader.ReadUInt32();
            lvl.LevelDataChunk.Rooms = new TR5Room[lvl.LevelDataChunk.NumRooms];

            long lastPosition = 0;

            for (int i = 0; i < lvl.LevelDataChunk.NumRooms; i++)
            {
                TR5Room room = new TR5Room();

                room.XELALandmark = reader.ReadBytes(4);

                Debug.replacedert(room.XELALandmark[0] == 'X');
                Debug.replacedert(room.XELALandmark[1] == 'E');
                Debug.replacedert(room.XELALandmark[2] == 'L');
                Debug.replacedert(room.XELALandmark[3] == 'A');

                room.RoomDataSize = reader.ReadUInt32();
                lastPosition = reader.BaseStream.Position;

                room.Seperator = reader.ReadUInt32();
                room.EndSDOffset = reader.ReadUInt32();
                room.StartSDOffset = reader.ReadUInt32();
                room.Seperator2 = reader.ReadUInt32();
                room.EndPortalOffset = reader.ReadUInt32();

                TR5RoomInfo info = new TR5RoomInfo
                {
                    X = reader.ReadInt32(),
                    Y = reader.ReadInt32(),
                    Z = reader.ReadInt32(),
                    yBottom = reader.ReadInt32(),
                    yTop = reader.ReadInt32()
                };

                room.Info = info;

                room.NumZSectors = reader.ReadUInt16();
                room.NumXSectors = reader.ReadUInt16();
                room.RoomColourARGB = reader.ReadUInt32();
                room.NumLights = reader.ReadUInt16();
                room.NumStaticMeshes = reader.ReadUInt16();

                room.Reverb = reader.ReadByte();
                room.AlternateGroup = reader.ReadByte();
                room.WaterScheme = reader.ReadUInt16();

                room.Filler = new uint[2];
                room.Filler[0] = reader.ReadUInt32();
                room.Filler[1] = reader.ReadUInt32();

                room.Seperator3 = new uint[2];
                room.Seperator3[0] = reader.ReadUInt32();
                room.Seperator3[1] = reader.ReadUInt32();

                room.Filler2 = reader.ReadUInt32();
                room.AlternateRoom = reader.ReadUInt16();
                room.Flags = reader.ReadUInt16();

                room.Unknown1 = reader.ReadUInt32();
                room.Unknown2 = reader.ReadUInt32();
                room.Unknown3 = reader.ReadUInt32();
                room.Seperator4 = reader.ReadUInt32();
                room.Unknown4 = reader.ReadUInt16();
                room.Unknown5 = reader.ReadUInt16();

                room.RoomX = reader.ReadSingle();
                room.RoomY = reader.ReadSingle();
                room.RoomZ = reader.ReadSingle();

                room.Seperator5 = new uint[4];
                room.Seperator5[0] = reader.ReadUInt32();
                room.Seperator5[1] = reader.ReadUInt32();
                room.Seperator5[2] = reader.ReadUInt32();
                room.Seperator5[3] = reader.ReadUInt32();

                room.Seperator6 = reader.ReadUInt32();
                room.Seperator7 = reader.ReadUInt32();

                room.NumRoomTriangles = reader.ReadUInt32();
                room.NumRoomRectangles = reader.ReadUInt32();

                room.RoomLightsPtr = reader.ReadUInt32();
                room.RoomFogBulbsPtr = reader.ReadUInt32();

                room.NumLights2 = reader.ReadUInt32();
                room.NumFogBulbs = reader.ReadUInt32();

                room.RoomYTop = reader.ReadSingle();
                room.RoomYBottom = reader.ReadSingle();

                room.NumLayers = reader.ReadUInt32();
                room.LayersPtr = reader.ReadUInt32();
                room.VerticesDataSize = reader.ReadUInt32();
                room.PolyOffset = reader.ReadUInt32();
                room.PolyOffset2 = reader.ReadUInt32();
                room.NumVertices = reader.ReadUInt32();

                room.Seperator8 = new uint[4];
                room.Seperator8[0] = reader.ReadUInt32();
                room.Seperator8[1] = reader.ReadUInt32();
                room.Seperator8[2] = reader.ReadUInt32();
                room.Seperator8[3] = reader.ReadUInt32();

                //Record the stream pointer after the header
                long afterhdr = reader.BaseStream.Position;

                //Room data is currently read as bytes.
                //To modify in future we will need to parse properly.
                TR5RoomData data = new TR5RoomData();
                data.AsBytes = reader.ReadBytes((int)(lastPosition + room.RoomDataSize) - (int)afterhdr);

                PopulateLightsBulbsAndSectors(room, data);

                room.RoomData = data;
                lvl.LevelDataChunk.Rooms[i] = room;
            }
        }

19 Source : TR5FileReadUtilities.cs
with MIT License
from DanzaG

private static TR5RoomLight ReadRoomLight(BinaryReader r)
        {
            return new TR5RoomLight()
            {
                X = r.ReadSingle(),
                Y = r.ReadSingle(),
                Z = r.ReadSingle(),
                R = r.ReadSingle(),
                G = r.ReadSingle(),
                B = r.ReadSingle(),
                Seperator = r.ReadUInt32(),
                In = r.ReadSingle(),
                Out = r.ReadSingle(),
                RadIn = r.ReadSingle(),
                RadOut = r.ReadSingle(),
                Range = r.ReadSingle(),
                DX = r.ReadSingle(),
                DY = r.ReadSingle(),
                DZ = r.ReadSingle(),
                X2 = r.ReadInt32(),
                Y2 = r.ReadInt32(),
                Z2 = r.ReadInt32(),
                DX2 = r.ReadInt32(),
                DY2 = r.ReadInt32(),
                DZ2 = r.ReadInt32(),
                LightType = r.ReadByte(),
                Filler = r.ReadBytes(3)
            };
        }

19 Source : TR5FileReadUtilities.cs
with MIT License
from DanzaG

private static TR5FogBulb ReadRoomBulbs(BinaryReader r)
        {
            return new TR5FogBulb()
            {
                X = r.ReadSingle(),
                Y = r.ReadSingle(),
                Z = r.ReadSingle(),
                R = r.ReadSingle(),
                G = r.ReadSingle(),
                B = r.ReadSingle(),
                Seperator = r.ReadUInt32(),
                In = r.ReadSingle(),
                Out = r.ReadSingle()
            };
        }

19 Source : TR5FileReadUtilities.cs
with MIT License
from DanzaG

private static TR5RoomLayer ReadRoomLayer(BinaryReader r)
        {
            return new TR5RoomLayer()
            {
                NumLayerVertices = r.ReadUInt32(),
                UnknownL1 = r.ReadUInt16(),
                NumLayerRectangles = r.ReadUInt16(),
                NumLayerTriangles = r.ReadUInt16(),
                UnknownL2 = r.ReadUInt16(),
                Filler = r.ReadUInt16(),
                Filler2 = r.ReadUInt16(),
                LayerBoundingBoxX1 = r.ReadSingle(),
                LayerBoundingBoxY1 = r.ReadSingle(),
                LayerBoundingBoxZ1 = r.ReadSingle(),
                LayerBoundingBoxX2 = r.ReadSingle(),
                LayerBoundingBoxY2 = r.ReadSingle(),
                LayerBoundingBoxZ2 = r.ReadSingle(),
                Filler3 = r.ReadUInt32(),
                UnknownL6 = r.ReadUInt32(),
                UnknownL7 = r.ReadUInt32(),
                UnknownL8 = r.ReadUInt32()
            };
        }

19 Source : TR5FileReadUtilities.cs
with MIT License
from DanzaG

private static TR5RoomVertex ReadRoomVertex(BinaryReader r)
        {
            return new TR5RoomVertex()
            {
                Vert = new TR5Vertex()
                {
                    X = r.ReadSingle(),
                    Y = r.ReadSingle(),
                    Z = r.ReadSingle()
                },

                Norm = new TR5Vertex()
                {
                    X = r.ReadSingle(),
                    Y = r.ReadSingle(),
                    Z = r.ReadSingle()
                },

                Colour = r.ReadUInt32()
            };
        }

19 Source : JJ2Block.cs
with GNU General Public License v3.0
from deathkiller

public float ReadFloat()
        {
            return reader.ReadSingle();
        }

19 Source : ResourcesFile.cs
with MIT License
from deepakkumar1984

private object LoadObjectV1(int dataOffset)
		{
			Debug.replacedert(System.Threading.Monitor.IsEntered(reader));
			reader.Seek(dataSectionPosition + dataOffset, SeekOrigin.Begin);
			int typeIndex = reader.Read7BitEncodedInt();
			if (typeIndex == -1)
				return null;
			string typeName = FindType(typeIndex);
			int comma = typeName.IndexOf(',');
			if (comma > 0) {
				// strip replacedembly name
				typeName = typeName.Substring(0, comma);
			}
			switch (typeName) {
				case "System.String":
					return reader.ReadString();
				case "System.Byte":
					return reader.ReadByte();
				case "System.SByte":
					return reader.ReadSByte();
				case "System.Int16":
					return reader.ReadInt16();
				case "System.UInt16":
					return reader.ReadUInt16();
				case "System.Int32":
					return reader.ReadInt32();
				case "System.UInt32":
					return reader.ReadUInt32();
				case "System.Int64":
					return reader.ReadInt64();
				case "System.UInt64":
					return reader.ReadUInt64();
				case "System.Single":
					return reader.ReadSingle();
				case "System.Double":
					return reader.ReadDouble();
				case "System.DateTime":
					// Ideally we should use DateTime's ToBinary & FromBinary,
					// but we can't for compatibility reasons.
					return new DateTime(reader.ReadInt64());
				case "System.TimeSpan":
					return new TimeSpan(reader.ReadInt64());
				case "System.Decimal":
					int[] bits = new int[4];
					for (int i = 0; i < bits.Length; i++)
						bits[i] = reader.ReadInt32();
					return new decimal(bits);
				default:
					return new ResourceSerializedObject(FindType(typeIndex), this, reader.BaseStream.Position);
			}
		}

19 Source : ResourcesFile.cs
with MIT License
from deepakkumar1984

private object LoadObjectV2(int dataOffset)
		{
			Debug.replacedert(System.Threading.Monitor.IsEntered(reader));
			reader.Seek(dataSectionPosition + dataOffset, SeekOrigin.Begin);
			var typeCode = (ResourceTypeCode)reader.Read7BitEncodedInt();
			switch (typeCode) {
				case ResourceTypeCode.Null:
					return null;

				case ResourceTypeCode.String:
					return reader.ReadString();

				case ResourceTypeCode.Boolean:
					return reader.ReadBoolean();

				case ResourceTypeCode.Char:
					return (char)reader.ReadUInt16();

				case ResourceTypeCode.Byte:
					return reader.ReadByte();

				case ResourceTypeCode.SByte:
					return reader.ReadSByte();

				case ResourceTypeCode.Int16:
					return reader.ReadInt16();

				case ResourceTypeCode.UInt16:
					return reader.ReadUInt16();

				case ResourceTypeCode.Int32:
					return reader.ReadInt32();

				case ResourceTypeCode.UInt32:
					return reader.ReadUInt32();

				case ResourceTypeCode.Int64:
					return reader.ReadInt64();

				case ResourceTypeCode.UInt64:
					return reader.ReadUInt64();

				case ResourceTypeCode.Single:
					return reader.ReadSingle();

				case ResourceTypeCode.Double:
					return reader.ReadDouble();

				case ResourceTypeCode.Decimal:
					return reader.ReadDecimal();

				case ResourceTypeCode.DateTime:
					// Use DateTime's ToBinary & FromBinary.
					long data = reader.ReadInt64();
					return DateTime.FromBinary(data);

				case ResourceTypeCode.TimeSpan:
					long ticks = reader.ReadInt64();
					return new TimeSpan(ticks);

				// Special types
				case ResourceTypeCode.ByteArray: {
						int len = reader.ReadInt32();
						if (len < 0) {
							throw new BadImageFormatException("Resource with negative length");
						}
						return reader.ReadBytes(len);
					}

				case ResourceTypeCode.Stream: {
						int len = reader.ReadInt32();
						if (len < 0) {
							throw new BadImageFormatException("Resource with negative length");
						}
						byte[] bytes = reader.ReadBytes(len);
						return new MemoryStream(bytes, writable: false);
					}

				default:
					if (typeCode < ResourceTypeCode.StartOfUserTypes) {
						throw new BadImageFormatException("Invalid typeCode");
					}
					return new ResourceSerializedObject(FindType(typeCode - ResourceTypeCode.StartOfUserTypes), this, reader.BaseStream.Position);
			}
		}

19 Source : AcFile.cs
with GNU General Public License v3.0
from DeepHydro

public  float[][][] Summerize(string filename, int[] intevals, ref int step, ref string[] varNames, int[][] subindex, NumericalDataType statFlag =  NumericalDataType.Average)
        {
            step = 0;
            int feaNum = 0;
            FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
            BinaryReader br = new BinaryReader(fs);

            int varnum = br.ReadInt32();
            int nzone = subindex.Length;
            varNames = new string[varnum];
            float[][][] stat = new float[nzone][][];

            for (int i = 0; i < nzone; i++)
            {
                stat[i] = new float[varnum][];
            }

            for (int i = 0; i < varnum; i++)
            {
                int varname_len = br.ReadInt32();
                varNames[i] = new string(br.ReadChars(varname_len)).Trim();
                feaNum = br.ReadInt32();
                for (int z = 0; z < nzone; z++)
                {
                    stat[z][i] = new float[intevals.Length];
                }
            }

            float[][] matrix = new float[varnum][];
            for (int i = 0; i < varnum; i++)
            {
                matrix[i] = new float[feaNum];
            }

            for (int i = 0; i < intevals.Length; i++)
            {
                MatrixExtension<float>.Set(matrix, 0);
                for (int d = 0; d < intevals[i]; d++)
                {
                    for (int s = 0; s < feaNum; s++)
                    {
                        for (int v = 0; v < varnum; v++)
                        {
                            matrix[v][s] += br.ReadSingle();
                        }
                    }
                    step++;
                }
                for (int z = 0; z < nzone; z++)
                {
                    for (int v = 0; v < varnum; v++)
                    {
                        float temp = 0;
                        foreach (var id in subindex[z])
                        {
                            temp += matrix[v][id];
                        }
                        if (statFlag ==  NumericalDataType.Average)
                            stat[z][v][i] = temp / subindex[z].Length / intevals[i];
                        else if (statFlag ==  NumericalDataType.replacedulative)
                            stat[z][v][i] = temp / subindex[z].Length;

                    }
                }
            }
            br.Close();
            fs.Close();
            return stat;
        }

19 Source : DataCubeStreamReader.cs
with GNU General Public License v3.0
from DeepHydro

public override void LoadDataCube()
        {
            var xml = _FileName + ".xml";
            if (File.Exists(xml))
            {
                _Descriptor = DataCubeDescriptor.Deserialize(xml);
            }
            if (MaxTimeStep <= 0 || NumTimeStep == 0)
            {
                Scan();
                MaxTimeStep = NumTimeStep;
            }
            int feaNum = 0;
            int varnum = 0;
            int nstep = StepsToLoad;
            FileStream fs = new FileStream(_FileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
            BinaryReader br = new BinaryReader(fs);

            try
            {
                varnum = br.ReadInt32();
                Variables = new string[varnum];
                for (int i = 0; i < varnum; i++)
                {
                    int varname_len = br.ReadInt32();
                    Variables[i] = new string(br.ReadChars(varname_len)).Trim();
                    feaNum = br.ReadInt32();
                }
                if (DataCube == null)
                    DataCube = new DataCube<float>(varnum, nstep, feaNum);
                OnLoading(0);
                for (int t = 0; t < nstep; t++)
                {
                    float[][] buf = new float[varnum][];
                    for (int i = 0; i < varnum; i++)
                    {
                        buf[i] = new float[feaNum];
                    }
                    for (int s = 0; s < feaNum; s++)
                    {
                        for (int v = 0; v < varnum; v++)
                        {
                            //DataCube[v, t, s] = br.ReadSingle() * Scale;
                            buf[v][s] = br.ReadSingle() * Scale;
                        }
                    }
                    for (int i = 0; i < varnum; i++)
                    {
                        DataCube.ILArrays[i][t, ":"] = buf[i];
                    }
                    int progress = Convert.ToInt32(t * 100 / NumTimeStep);
                    OnLoading(progress);
                }
                if (_Descriptor.TimeStamps != null)
                {
                    DataCube.DateTimes = new DateTime[nstep];
                    for (int t = 0; t < nstep; t++)
                    {
                        DataCube.DateTimes[t] = _Descriptor.TimeStamps[t];
                    }
                }
                br.Close();
                fs.Close();
                OnDataCubedLoaded(DataCube);
            }
            catch (Exception ex)
            {
                br.Close();
                fs.Close();
                OnLoadFailed("Failed to load. Error message: " + ex.Message);
            }
        }

19 Source : AcFile.cs
with GNU General Public License v3.0
from DeepHydro

public  float[][][] Read(string filename, int flag, int varIndex,ref int step, ref string[] varNames, int maxsteps = -1, float scale = 1)
        {
            float[][][] acmatrix = null;
            step = 0;
            int feaNum = 0;
            // 4字节,integer, 变量个数
            // 对变量个数循环
            // 4字节,变量名字符长度var_len
            //var_len长字节,为字符
            //  4字节, 网格数
            //结束循环

            //时间步长循环
            //网格数循环
            //变量循环
            //4字节, 浮点数
            FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
            BinaryReader br = new BinaryReader(fs);

            int varnum = br.ReadInt32();
            varNames = new string[varnum];

            for (int i = 0; i < varnum; i++)
            {
                int varname_len = br.ReadInt32();
                varNames[i] = new string(br.ReadChars(varname_len)).Trim();
                feaNum = br.ReadInt32();
            }

            if (flag > 0)
            {
                acmatrix = new float[1][][];

                float[][] matrix = new float[1][];
                for (int i = 0; i < 1; i++)
                {
                    acmatrix[i] = new float[1][];
                    acmatrix[i][0] = new float[feaNum];
                }
                while (!(fs.Position == fs.Length))
                {
                    for (int s = 0; s < feaNum; s++)
                    {
                        for (int v = 0; v < varIndex; v++)
                        {
                           br.ReadSingle();
                        }
                        for (int v = varIndex; v < varIndex+1; v++)
                        {
                            acmatrix[v][0][s] += br.ReadSingle() * scale;
                        }
                        for (int v = varIndex + 1; v < varnum; v++)
                        {
                            br.ReadSingle();
                        }
                    }
                    step++;
                    if (maxsteps > 0)
                    {
                        if (step >= maxsteps)
                            break;
                    }
                }
                if (flag == 1)
                {
                    for (int s = 0; s < feaNum; s++)
                    {
                        for (int v = 0; v < 1; v++)
                        {
                            acmatrix[v][0][s] /= step;
                        }
                    }
                }
            }
            else if (flag == 0) // step by  step
            {
                acmatrix = new float[1][][];
                List<float[]>[] cbcLst = new List<float[]>[1];
                for (int i = 0; i < 1; i++)
                {
                    cbcLst[i] = new List<float[]>();
                }
                while (!(fs.Position == fs.Length))
                {
                    float[][] matrix = new float[1][];
                    for (int i = 0; i < 1; i++)
                    {
                        matrix[i] = new float[feaNum];
                    }
                    for (int s = 0; s < feaNum; s++)
                    {
                        if(varIndex == 0)
                        {
                            matrix[0][s] = br.ReadSingle() * scale;
                        }
                        else if (varIndex == varnum-1)
                        {
                            br.ReadBytes(4 * (varnum - 1));
                        }
                        else
                        {
                            br.ReadBytes(4 * (varIndex));
                            matrix[0][s] = br.ReadSingle() * scale;
                            br.ReadBytes(4 * (varnum - 1 - varIndex));
                        }
                    }
                    for (int v = 0; v < 1; v++)
                    {
                        cbcLst[v].Add(matrix[v]);
                    }
                    step++;
                    if (maxsteps > 0)
                    {
                        if (step >= maxsteps)
                            break;
                    }
                    if (step % 100 == 0)
                        Console.WriteLine("Reading " + step);
                }
                for (int v = 0; v < 1; v++)
                {
                    acmatrix[v] = cbcLst[v].ToArray();
                }
            }
            br.Close();
            fs.Close();

            return acmatrix;
        }

19 Source : AcFile.cs
with GNU General Public License v3.0
from DeepHydro

public  float[][][] Summerize(string filename, int[] intevals, ref int step, ref string[] varNames, int[][] subindex, float [] offset, NumericalDataType statFlag = NumericalDataType.Average)
        {
            step = 0;
            int feaNum = 0;
            FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
            BinaryReader br = new BinaryReader(fs);

            int varnum = br.ReadInt32();
            int nzone = subindex.Length;
            varNames = new string[varnum];
            float[][][] stat = new float[nzone][][];

            for (int i = 0; i < nzone; i++)
            {
                stat[i] = new float[varnum][];
            }

            for (int i = 0; i < varnum; i++)
            {
                int varname_len = br.ReadInt32();
                varNames[i] = new string(br.ReadChars(varname_len)).Trim();
                feaNum = br.ReadInt32();
                for (int z = 0; z < nzone; z++)
                {
                    stat[z][i] = new float[intevals.Length];
                }
            }

            float[][] matrix = new float[varnum][];
            for (int i = 0; i < varnum; i++)
            {
                matrix[i] = new float[feaNum];
            }

            for (int i = 0; i < intevals.Length; i++)
            {
                MatrixExtension<float>.Set(matrix, 0);
                for (int d = 0; d < intevals[i]; d++)
                {
                    for (int s = 0; s < feaNum; s++)
                    {
                        for (int v = 0; v < varnum; v++)
                        {
                            matrix[v][s] += (br.ReadSingle() + offset[s]);
                        }
                    }
                    step++;
                }
                for (int z = 0; z < nzone; z++)
                {
                    for (int v = 0; v < varnum; v++)
                    {
                        float temp = 0;
                        foreach (var id in subindex[z])
                        {
                            temp += matrix[v][id];
                        }
                        if (statFlag == NumericalDataType.Average)
                            stat[z][v][i] = temp / subindex[z].Length / intevals[i];
                        else if (statFlag == NumericalDataType.replacedulative)
                            stat[z][v][i] = temp / subindex[z].Length;

                    }
                }
            }
            br.Close();
            fs.Close();
            return stat;
        }

19 Source : DataCubeStreamReader.cs
with GNU General Public License v3.0
from DeepHydro

public void LoadDataCubeSingle(int var_index)
        {
            var xml = _FileName + ".xml";
            if (File.Exists(xml))
            {
                _Descriptor = DataCubeDescriptor.Deserialize(xml);
            }
            if (MaxTimeStep <= 0 || NumTimeStep == 0)
            {
                Scan();
                MaxTimeStep = NumTimeStep;
            }
            int feaNum = 0;
            int varnum = 0;
            int nstep = StepsToLoad;
            int progress = 0;
            FileStream fs = new FileStream(_FileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
            BinaryReader br = new BinaryReader(fs);
            try
            {
                varnum = br.ReadInt32();
                Variables = new string[varnum];

                for (int i = 0; i < varnum; i++)
                {
                    int varname_len = br.ReadInt32();
                    Variables[i] = new string(br.ReadChars(varname_len)).Trim();
                    feaNum = br.ReadInt32();
                }
                OnLoading(0);
                if (DataCube == null)
                {
                    DataCube = new DataCube<float>(Variables.Length, nstep, feaNum, true);
                    DataCube.Variables = Variables;
                }
                if (!DataCube.IsAllocated(var_index) || DataCube.Size[1] != nstep)
                    DataCube.Allocate(var_index);
                for (int t = 0; t < nstep; t++)
                {
                    for (int s = 0; s < feaNum; s++)
                    {
                        DataCube[var_index, t, s] = br.ReadSingle() * Scale;
                    }
                    progress = Convert.ToInt32(t * 100 / nstep);
                    OnLoading(progress);
                }
                br.Close();
                fs.Close();
                if (_Descriptor.TimeStamps != null)
                {
                    DataCube.DateTimes = new DateTime[nstep];
                    for (int t = 0; t < nstep; t++)
                    {
                        DataCube.DateTimes[t] = _Descriptor.TimeStamps[t];
                    }
                }
                OnDataCubedLoaded(DataCube);
            }
            catch (Exception ex)
            {
                br.Close();
                fs.Close();
                OnLoadFailed("Failed to load. Error message: " + ex.Message);
            }
        }

19 Source : AcFile.cs
with GNU General Public License v3.0
from DeepHydro

public  float[][][]Read(string filename, int flag, ref int step, ref string[] varNames, int maxsteps = -1, float scale = 1)
        {
            float[][][] acmatrix = null;
            step = 0;
            int feaNum = 0;
            // 4字节,integer, 变量个数
            // 对变量个数循环
               // 4字节,变量名字符长度var_len
               //var_len长字节,为字符
               //  4字节, 网格数
            //结束循环

            //时间步长循环
              //网格数循环
                //变量循环
                   //4字节, 浮点数
            FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
            BinaryReader br = new BinaryReader(fs);

            int varnum = br.ReadInt32();
            varNames = new string[varnum];

            for (int i = 0; i < varnum; i++)
            {
                int varname_len = br.ReadInt32();
                varNames[i] = new string(br.ReadChars(varname_len)).Trim();
                feaNum = br.ReadInt32();
            }

            if (flag > 0)
            {
                acmatrix = new float[varnum][][];

                float[][] matrix = new float[varnum][];
                for (int i = 0; i < varnum; i++)
                {
                    acmatrix[i] = new float[1][];
                    acmatrix[i][0] = new float[feaNum];
                }
                while (!(fs.Position == fs.Length))
                {
                    for (int s = 0; s < feaNum; s++)
                    {
                        for (int v = 0; v < varnum; v++)
                        {
                            acmatrix[v][0][s] += br.ReadSingle() * scale;
                        }
                    }
                    step++;
                    if (maxsteps > 0)
                    {
                        if (step >= maxsteps)
                            break;
                    }
                }
                if (flag == 1)
                {
                    for (int s = 0; s < feaNum; s++)
                    {
                        for (int v = 0; v < varnum; v++)
                        {
                            acmatrix[v][0][s] /= step;
                        }
                    }
                }
            }
            else if (flag == 0) // step by  step
            {
                acmatrix = new float[varnum][][];
                List<float[]>[] cbcLst = new List<float[]>[varnum];
                for (int i = 0; i < varnum; i++)
                {
                    cbcLst[i] = new List<float[]>();
                }
                while (!(fs.Position == fs.Length))
                {
                    float[][] matrix = new float[varnum][];
                    for (int i = 0; i < varnum; i++)
                    {
                        matrix[i] = new float[feaNum];
                    }
                    for (int s = 0; s < feaNum; s++)
                    {
                        for (int v = 0; v < varnum; v++)
                        {
                            matrix[v][s] = br.ReadSingle() * scale;
                        }
                    }
                    for (int v = 0; v < varnum; v++)
                    {
                        cbcLst[v].Add(matrix[v]);
                    }
                    step++;
                    if (maxsteps > 0)
                    {
                        if (step >= maxsteps)
                            break;
                    }
                }
                for (int v = 0; v < varnum; v++)
                {
                    acmatrix[v] = cbcLst[v].ToArray();
                }
            }
            br.Close();
            fs.Close();

            return acmatrix;
        }

19 Source : AcFile.cs
with GNU General Public License v3.0
from DeepHydro

public  float[][][] Read(string filename, int flag, int[] intevals, ref int step, ref string[] varNames, int maxsteps = -1, float scale = 1)
        {
            float[][][] acmatrix = null;
            step = 0;
            int feaNum = 0;
            FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
            BinaryReader br = new BinaryReader(fs);

            int ninteval = intevals.Length;
            int varnum = br.ReadInt32();
            varNames = new string[varnum];

            for (int i = 0; i < varnum; i++)
            {
                int varname_len = br.ReadInt32();
                varNames[i] = new string(br.ReadChars(varname_len)).Trim();
                feaNum = br.ReadInt32();
            }

            if (flag > 0)
            {
                acmatrix = new float[varnum][][];
                float[][] derived = new float[varnum][];

                for (int i = 0; i < varnum; i++)
                {
                    acmatrix[i] = new float[ninteval][];
                    derived[i] = new float[feaNum];
                    for (int t = 0; t < ninteval; t++)
                    {
                        acmatrix[i][t] = new float[feaNum];
                    }
                }

                for (int n = 0; n < ninteval; n++)
                {
                    MatrixExtension<float>.Set(derived, 0);

                    for (int t = 0; t < intevals[n]; t++)
                    {
                        for (int s = 0; s < feaNum; s++)
                        {
                            for (int v = 0; v < varnum; v++)
                            {
                                //if(!(fs.Position == fs.Length))
                                //{
                                    derived[v][s] += br.ReadSingle() * scale;
                                //}
                            }
                        }
                    }
                    if (flag == 1)
                    {
                        for (int s = 0; s < feaNum; s++)
                        {
                            for (int v = 0; v < varnum; v++)
                            {
                                derived[v][s] = derived[v][s] / intevals[n];
                            }
                        }
                    }
                    for (int s = 0; s < feaNum; s++)
                    {
                        for (int v = 0; v < varnum; v++)
                        {
                            acmatrix[v][n][s] = derived[v][s];
                        }
                    }

                    step++;
                    if (maxsteps > 0)
                    {
                        if (step >= maxsteps)
                            break;
                    }
                }
            }


            br.Close();
            fs.Close();

            return acmatrix;
        }

19 Source : DataCubeStreamReader.cs
with GNU General Public License v3.0
from DeepHydro

public override void LoadDataCube(int var_index)
        {
            var xml = _FileName + ".xml";
            if (File.Exists(xml))
            {
                _Descriptor = DataCubeDescriptor.Deserialize(xml);
            }
            if (MaxTimeStep <= 0 || NumTimeStep == 0)
            {
                Scan();
                MaxTimeStep = NumTimeStep;
            }

            int feaNum = 0;
            int varnum = 0;
            int nstep = StepsToLoad;
            int progress = 0;
            FileStream fs = new FileStream(_FileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
            BinaryReader br = new BinaryReader(fs);
            varnum = br.ReadInt32();
            Variables = new string[varnum];
            try
            {
                for (int i = 0; i < varnum; i++)
                {
                    int varname_len = br.ReadInt32();
                    Variables[i] = new string(br.ReadChars(varname_len)).Trim();
                    feaNum = br.ReadInt32();
                }
                OnLoading(0);
                if (DataCube == null)
                {
                    DataCube = new DataCube<float>(Variables.Length, nstep, feaNum, true);
                    DataCube.Variables = Variables;
                }
                if (!DataCube.IsAllocated(var_index) || DataCube.Size[1] != nstep)
                    DataCube.Allocate(var_index);
              
                for (int t = 0; t < nstep; t++)
                {
                    var buf = new float[feaNum];
                    for (int s = 0; s < feaNum; s++)
                    {
                        br.ReadBytes(4 * var_index);
                        buf[s] = br.ReadSingle() * Scale;
                        br.ReadBytes(4 * (varnum - var_index - 1));
                    }
                    DataCube.ILArrays[var_index][t, ":"] = buf;
                    progress = Convert.ToInt32(t * 100 / nstep);
                    OnLoading(progress);
                }
                br.Close();
                fs.Close();
                if (_Descriptor.TimeStamps != null)
                {
                    DataCube.DateTimes = new DateTime[nstep];
                    for (int t = 0; t < nstep; t++)
                    {
                        DataCube.DateTimes[t] = _Descriptor.TimeStamps[t];
                    }
                }
                OnDataCubedLoaded(DataCube);
            }
            catch (Exception ex)
            {
                br.Close();
                fs.Close();
                OnLoadFailed("Failed to load. Error message: " + ex.Message);
            }
        }

19 Source : DataCubeStreamReader.cs
with GNU General Public License v3.0
from DeepHydro

public void LoadDataCubeSingle(Dictionary<int, int> mapping, int var_index)
        {
            var xml = _FileName + ".xml";
            if (File.Exists(xml))
            {
                _Descriptor = DataCubeDescriptor.Deserialize(xml);
            }
            if (MaxTimeStep <= 0 || NumTimeStep == 0)
            {
                Scan();
                MaxTimeStep = NumTimeStep;
            }
            int feaNum = 0;
            int varnum = 0;
            int nstep = StepsToLoad;
            int nhru = mapping.Keys.Count;
            int progress = 0;
            FileStream fs = new FileStream(_FileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
            BinaryReader br = new BinaryReader(fs);
            try
            {
                varnum = br.ReadInt32();
                Variables = new string[varnum];

                for (int i = 0; i < varnum; i++)
                {
                    int varname_len = br.ReadInt32();
                    Variables[i] = new string(br.ReadChars(varname_len)).Trim();
                    feaNum = br.ReadInt32();
                }

                OnLoading(0);
                if (DataCube == null)
                {
                    DataCube = new DataCube<float>(Variables.Length, nstep, nhru, true);
                    DataCube.Variables = Variables;
                }
                if (!DataCube.IsAllocated(var_index) || DataCube.Size[1] != nstep)
                    DataCube.Allocate(var_index, nstep, nhru);
                var vv = new float[feaNum];
                for (int t = 0; t < nstep; t++)
                {
                    var buf = new float[nhru];
                    for (int i = 0; i < feaNum; i++)
                    {
                        vv[i] = br.ReadSingle() * Scale;
                    }
                    for (int i = 0; i < nhru; i++)
                    {
                        buf[i] = vv[mapping[i + 1] - 1];
                    }
                    //for (int i = 0; i < nhru; i++)
                    //{
                    //    //DataCube[var_index, t, i] = vv[mapping[i + 1] - 1];
                    //    DataCube[var_index][t, i] = vv[mapping[i + 1] - 1];
                    //}
                    DataCube[var_index][t, ":"] = buf;
                    progress = Convert.ToInt32(t * 100 / nstep);
                    OnLoading(progress);
                }

                br.Close();
                fs.Close();
                if (_Descriptor.TimeStamps != null)
                {
                    DataCube.DateTimes = new DateTime[nstep];
                    for (int t = 0; t < nstep; t++)
                    {
                        DataCube.DateTimes[t] = _Descriptor.TimeStamps[t];
                    }
                }
                OnDataCubedLoaded(DataCube);
            }
            catch (Exception ex)
            {
                br.Close();
                fs.Close();
                OnLoadFailed("Failed to load. Error message: " + ex.Message);
            }
        }

19 Source : CBCFile.cs
with GNU General Public License v3.0
from DeepHydro

public override void LoadDataCube()
        {
            if (MaxTimeStep <= 0 || NumTimeStep == 0)
            {
                Scan();
                MaxTimeStep = NumTimeStep;
            }
            FileStream fs = new FileStream(_FileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
            BinaryReader br = new BinaryReader(fs);
            int nstep = StepsToLoad;
            float vv = 0;
            long layerbyte = _Grid.RowCount * _Grid.ColumnCount * 4;
            fs = new FileStream(_FileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
            br = new BinaryReader(fs);
            DataCube = new DataCube<float>(Variables.Length, nstep, _Grid.ActiveCellCount);

            for (int s = 0; s < NumTimeStep; s++)
            {
                for (int v = 0; v < Variables.Length; v++)
                {
                    fs.Seek(4 * 2, SeekOrigin.Current);
                    var vn = new string(br.ReadChars(16)).Trim();
                    fs.Seek(4 * 3, SeekOrigin.Current);
                    for (int l = 0; l < _Grid.ActualLayerCount; l++)
                    {
                        if (l == Layer)
                        {
                            int index = 0;
                            var buf = new float[_Grid.ActiveCellCount];
                            for (int r = 0; r < _Grid.RowCount; r++)
                            {
                                for (int c = 0; c < _Grid.ColumnCount; c++)
                                {
                                    vv = br.ReadSingle();
                                    if (_Grid.IBound[Layer, r, c] != 0)
                                    {
                                        buf[index] = vv;
                                        index++;
                                    }
                                }
                            }
                            DataCube.ILArrays[v][s, ":"] = buf;
                        }
                        else
                        {
                            fs.Seek(layerbyte, SeekOrigin.Current);
                        }
                    }
                }
            }

            br.Close();
            fs.Close();

        }

19 Source : CBCFile.cs
with GNU General Public License v3.0
from DeepHydro

public override void LoadDataCube(int var_index)
        {
            OnLoading(0);
            if (MaxTimeStep <= 0 || NumTimeStep == 0)
            {
                Scan();
                MaxTimeStep = NumTimeStep;
            }
            FileStream fs = new FileStream(_FileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
            BinaryReader br = new BinaryReader(fs);
            int nstep = StepsToLoad;
            float vv = 0;
            long layerbyte = _Grid.RowCount * _Grid.ColumnCount * 4;
            long var_byte = 8 + 16 + 12 + layerbyte * _Grid.ActualLayerCount;
            int progress = 0;

            fs = new FileStream(_FileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
            br = new BinaryReader(fs);
            if (DataCube == null)
                DataCube = new DataCube<float>(Variables.Length, nstep, _Grid.ActualLayerCount, true);
            DataCube.Allocate(var_index);
            for (int t = 0; t < nstep; t++)
            {
                for (int v = 0; v < var_index; v++)
                {
                    fs.Seek(var_byte, SeekOrigin.Current);
                }
                fs.Seek(4 * 2, SeekOrigin.Current);
                var vn = new string(br.ReadChars(16)).Trim();
                fs.Seek(4 * 3, SeekOrigin.Current);
                if ( LoadingBehavior == MFLoadingLayersBehavior.Sum)
                {
                    var buf = new float[_Grid.ActiveCellCount];
                    for (int l = 0; l < _Grid.ActualLayerCount; l++)
                    {
                        int index = 0;
                        for (int r = 0; r < _Grid.RowCount; r++)
                        {
                            for (int c = 0; c < _Grid.ColumnCount; c++)
                            {
                                vv = br.ReadSingle();
                                if (_Grid.IBound[Layer, r, c] != 0)
                                {
                                    buf[index] = buf[index] + vv * Scale;
                                    index++;
                                }
                            }
                        }
                    }
                    DataCube.ILArrays[var_index][t, ":"] = buf;
                }
                else if (LoadingBehavior == MFLoadingLayersBehavior.Average)
                {
                    var buf = new float[_Grid.ActiveCellCount];
                    for (int l = 0; l < _Grid.ActualLayerCount; l++)
                    {
                        int index = 0;
                        for (int r = 0; r < _Grid.RowCount; r++)
                        {
                            for (int c = 0; c < _Grid.ColumnCount; c++)
                            {
                                vv = br.ReadSingle();
                                if (_Grid.IBound[Layer, r, c] != 0)
                                {
                                    buf[index] = buf[index] + vv * Scale;
                                    index++;
                                }
                            }
                        }
                    }
                    for (int i = 0; i < _Grid.ActiveCellCount; i++)
                    {
                        buf[i] = buf[i] / _Grid.ActualLayerCount;
                    }
                    DataCube.ILArrays[var_index][t, ":"] = buf;
                }
                else if (LoadingBehavior == MFLoadingLayersBehavior.None)
                {
                    for (int l = 0; l < _Grid.ActualLayerCount; l++)
                    {
                        if (l == Layer)
                        {
                            int index = 0;
                            var buf = new float[_Grid.ActiveCellCount];
                            for (int r = 0; r < _Grid.RowCount; r++)
                            {
                                for (int c = 0; c < _Grid.ColumnCount; c++)
                                {
                                    vv = br.ReadSingle();
                                    if (_Grid.IBound[Layer, r, c] != 0)
                                    {
                                        buf[index] = vv * Scale;
                                        index++;
                                    }
                                }
                            }
                            DataCube.ILArrays[var_index][t, ":"] = buf;
                        }
                        else
                        {
                            fs.Seek(layerbyte, SeekOrigin.Current);
                        }
                    }
                }
                for (int v = var_index + 1; v < Variables.Length; v++)
                {
                    fs.Seek(var_byte, SeekOrigin.Current);
                }
                progress = Convert.ToInt32(t * 100 / nstep);
                OnLoading(progress);
            }
            br.Close();
            fs.Close();
            OnDataCubedLoaded(DataCube);
        }

19 Source : MFPackage.cs
with GNU General Public License v3.0
from DeepHydro

public void ReadBinaryFHD(string filename = "")
        {
            if (filename == "")
            {
                filename = GetInputFile("FHD");
            }

            if (File.Exists(filename))
            {
                var grid = mfgrid;

                FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
                BinaryReader br = new BinaryReader(fs);

                List<float[]> headLst = new List<float[]>();
                long layerbyte = 32 + 4 * 3 + grid.RowCount * grid.ColumnCount * 4;
                float head = 0;
                while (fs.Position < fs.Length)
                {
                    for (int l = 0; l < grid.ActualLayerCount; l++)
                    {
                        if (l == 0)
                        {
                            fs.Seek(32, SeekOrigin.Current);
                            var vv = br.ReadInt32();
                            vv = br.ReadInt32();
                            vv = br.ReadInt32();
                            int index = 0;
                            float[] heads = new float[grid.ActiveCellCount];

                            for (int r = 0; r < grid.RowCount; r++)
                            {
                                for (int c = 0; c < grid.ColumnCount; c++)
                                {
                                    head = br.ReadSingle();
                                    if (grid.IBound.LayeredValues[0][r, c] != 0)
                                    {
                                        heads[index] = head;
                                        index++;
                                    }
                                }
                            }
                            headLst.Add(heads);
                        }
                        else
                        {
                            fs.Seek(layerbyte, SeekOrigin.Current);
                        }
                    }
                }
                grid.ArrayCube = new MatrixCube<float>(headLst.Count, true);
                for (int i = 0; i < headLst.Count; i++)
                {
                    grid.ArrayCube.LayeredSerialValue[i] = headLst[i];
                }

                br.Close();
                fs.Close();
                headLst.Clear();
            }
        }

19 Source : MFPackage.cs
with GNU General Public License v3.0
from DeepHydro

public void ReadCBC(string[] varNames, string filename = "", int maxstep = -1, int layer = 0)
        {
            if (filename == "")
            {
                filename = GetInputFile("CBC");
            }

            if (File.Exists(filename))
            {
                var grid = mfgrid;
                FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
                BinaryReader br = new BinaryReader(fs);
                List<string> vnLst = new List<string>();
                long layerbyte = grid.RowCount * grid.ColumnCount * 4;
                float vv = 0;
                int step = 0;
                int varLen = varNames.Length;
                List<float[]>[] cbcLst = new List<float[]>[varLen];
                for (int i = 0; i < varLen; i++)
                {
                    cbcLst[i] = new List<float[]>();
                }
                int varIndex = 0;

                while (!(fs.Position == fs.Length))
                {
                    fs.Seek(4 * 2, SeekOrigin.Current);
                    var vn = new string(br.ReadChars(16)).Trim();
                    fs.Seek(4 * 3, SeekOrigin.Current);
                    if (varNames.Contains(vn))
                    {
                        if (vnLst.Contains(vn))
                        {
                            varIndex = 0;
                            vnLst.Clear();
                            step++;
                        }
                        for (int l = 0; l < grid.ActualLayerCount; l++)
                        {
                            if (l == layer)
                            {
                                int index = 0;
                                float[] values = new float[grid.ActiveCellCount];

                                for (int r = 0; r < grid.RowCount; r++)
                                {
                                    for (int c = 0; c < grid.ColumnCount; c++)
                                    {
                                        vv = br.ReadSingle();
                                        if (grid.IBound.LayeredValues[layer][r, c] != 0)
                                        {
                                            values[index] = vv;
                                            index++;
                                        }
                                    }
                                }
                                vnLst.Add(vn);
                                cbcLst[varIndex].Add(values);
                            }
                            else
                            {
                                fs.Seek(layerbyte, SeekOrigin.Current);
                            }
                        }
                        varIndex++;
                    }
                    else
                    {
                        fs.Seek(layerbyte * grid.ActualLayerCount, SeekOrigin.Current);
                    }
                    if (maxstep > 0)
                    {
                        if (step >= maxstep)
                            break;
                    }
                }
                grid.MultipleArrayCube = new MatrixCube<float>[varLen];

                for (int i = 0; i < varLen; i++)
                {
                    grid.MultipleArrayCube[i] = new MatrixCube<float>(step, true)
                    {
                        Name = varNames[i]
                    };
                    for (int s = 0; s < step; s++)
                    {
                        if (s < cbcLst[i].Count)
                            grid.MultipleArrayCube[i].LayeredSerialValue[s] = cbcLst[i][s];
                    }
                }

                br.Close();
                fs.Close();
            }
        }

19 Source : MFPackage.cs
with GNU General Public License v3.0
from DeepHydro

public void ReadBinAvWaterTable(string filename = "", int maxstep = 30)
        {
            if (filename == "")
            {
                filename = GetInputFile("FHD");
            }

            if (File.Exists(filename))
            {
                var grid = mfgrid;

                FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
                BinaryReader br = new BinaryReader(fs);

                long layerbyte = 32 + 4 * 3 + grid.RowCount * grid.ColumnCount * 4;
                float head = 0;
                float[][] heads = new float[grid.ActualLayerCount][];
                for (int l = 0; l < grid.ActualLayerCount; l++)
                {
                    heads[l] = new float[grid.ActiveCellCount];
                }
                int step = 0;
                float[] wt = new float[grid.ActiveCellCount];
                float[] wtsum = new float[grid.ActiveCellCount];
                while (!(fs.Position == fs.Length))
                {
                    for (int l = 0; l < grid.ActualLayerCount; l++)
                    {
                        fs.Seek(32, SeekOrigin.Current);
                        var vv = br.ReadInt32();
                        vv = br.ReadInt32();
                        vv = br.ReadInt32();
                        int index = 0;
                        for (int r = 0; r < grid.RowCount; r++)
                        {
                            for (int c = 0; c < grid.ColumnCount; c++)
                            {
                                head = br.ReadSingle();
                                if (grid.IBound.LayeredValues[0][r, c] != 0)
                                {
                                    heads[l][index] = head;
                                    index++;
                                }
                            }
                        }
                        if (step > 0)
                        {
                            float[] lwt = new float[grid.ActualLayerCount];
                            for (int i = 0; i < grid.ActiveCellCount; i++)
                            {
                                for (int ll = 0; ll < grid.ActualLayerCount; ll++)
                                {
                                    lwt[ll] = heads[ll][i];
                                }
                                wt[i] = lwt.Max();
                            }
                        }
                    }
                    for (int i = 0; i < grid.ActiveCellCount; i++)
                    {
                        wtsum[i] += wt[i];
                    }
                    step++;
                    if (maxstep > 0 && step >= maxstep)
                        break;
                }

                grid.ArrayCube = new MatrixCube<float>(1, true);
                grid.ArrayCube.LayeredSerialValue[0] = new float[grid.ActiveCellCount];
                for (int i = 0; i < grid.ActiveCellCount; i++)
                {
                    grid.ArrayCube.LayeredSerialValue[0][i] = wtsum[i] / (step - 1);
                }

                heads = null;
                br.Close();
                fs.Close();
                GC.Collect();
            }
        }

19 Source : MFPackage.cs
with GNU General Public License v3.0
from DeepHydro

public void ReadArrayCube(string filename, int maxstep)
        {
            FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
            BinaryReader br = new BinaryReader(fs);
            List<float[]> list = new List<float[]>();
            MFGrid grid = mfgrid;

            int step = 0;
            while (fs.Position < fs.Length)
            {
                float[] data = new float[grid.ActiveCellCount];
                for (int l = 0; l < grid.ActiveCellCount; l++)
                {
                    data[l] = br.ReadSingle();
                }
                step++;
                if (step >= maxstep)
                    break;
                list.Add(data);
            }
            grid.ArrayCube = new MatrixCube<float>(list.Count, true);
            for (int i = 0; i < list.Count; i++)
            {
                grid.ArrayCube.LayeredSerialValue[i] = list[i];
            }

            br.Close();
            fs.Close();
        }

19 Source : AcFile.cs
with GNU General Public License v3.0
from DeepHydro

public  float[][] Summerize(string filename, int[] intevals, ref int step, ref string[] varNames, int[] subindex = null, NumericalDataType statFlag = NumericalDataType.Average)
        {
            step = 0;
            int feaNum = 0;
            FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
            BinaryReader br = new BinaryReader(fs);

            int varnum = br.ReadInt32();
            varNames = new string[varnum];
            float[][] stat = new float[varnum][];
            for (int i = 0; i < varnum; i++)
            {
                int varname_len = br.ReadInt32();
                varNames[i] = new string(br.ReadChars(varname_len)).Trim();
                feaNum = br.ReadInt32();
                stat[i] = new float[intevals.Length];
            }

            float[][] matrix = new float[varnum][];
            for (int i = 0; i < varnum; i++)
            {
                matrix[i] = new float[feaNum];
            }

            for (int i = 0; i < intevals.Length; i++)
            {
                MatrixExtension<float>.Set(matrix, 0);
                for (int d = 0; d < intevals[i]; d++)
                {
                    for (int s = 0; s < feaNum; s++)
                    {
                        for (int v = 0; v < varnum; v++)
                        {
                            matrix[v][s] += br.ReadSingle();
                        }
                    }
                    step++;
                }
                if (subindex == null)
                {
                    for (int v = 0; v < varnum; v++)
                    {
                        if (statFlag == NumericalDataType.Average)
                            stat[v][i] = matrix[v].Average() / intevals[i];
                        else if (statFlag == NumericalDataType.replacedulative)
                            stat[v][i] = matrix[v].Average();
                    }
                }
                else
                {
                    for (int v = 0; v < varnum; v++)
                    {
                        float temp = 0;
                        foreach (var id in subindex)
                        {
                            temp += matrix[v][id];
                        }
                        if (statFlag == NumericalDataType.Average)
                            stat[v][i] = temp / subindex.Length / intevals[i];
                        else if (statFlag == NumericalDataType.replacedulative)
                            stat[v][i] = temp / subindex.Length;
                    }
                }
            }
            br.Close();
            fs.Close();
            return stat;
        }

19 Source : DataCubeStreamReader.cs
with GNU General Public License v3.0
from DeepHydro

public DataCube<float> LoadStep()
        {
            var varnum = Variables.Length;
            DataCube<float> mat = new DataCube<float>(varnum, 1, FeatureCount);
            for (int s = 0; s < FeatureCount; s++)
            {
                for (int v = 0; v < varnum; v++)
                {
                    mat[v,0,s] = _BinaryReader.ReadSingle() * Scale;
                }
            }
            return mat;
        }

19 Source : DataCubeStreamReader.cs
with GNU General Public License v3.0
from DeepHydro

public  void LoadDataCubeSingleStep()
        {
            var xml = _FileName + ".xml";
            if (File.Exists(xml))
            {
                _Descriptor = DataCubeDescriptor.Deserialize(xml);
            }
            int feaNum = 0;
            int varnum = 0;
            int nstep = 1;
            FileStream fs = new FileStream(_FileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
            BinaryReader br = new BinaryReader(fs);

            try
            {
                varnum = br.ReadInt32();
                Variables = new string[varnum];
                for (int i = 0; i < varnum; i++)
                {
                    int varname_len = br.ReadInt32();
                    Variables[i] = new string(br.ReadChars(varname_len)).Trim();
                    feaNum = br.ReadInt32();
                }
                if (DataCube == null)
                    DataCube = new DataCube<float>(varnum, nstep, feaNum);
                OnLoading(0);
                for (int t = 0; t < nstep; t++)
                {
                    float[][] buf = new float[varnum][];
                    for (int i = 0; i < varnum; i++)
                    {
                        buf[i] = new float[feaNum];
                    }
                    for (int s = 0; s < feaNum; s++)
                    {
                        for (int v = 0; v < varnum; v++)
                        {
                            buf[v][s] = br.ReadSingle() * Scale;
                        }
                    }
                    for (int i = 0; i < varnum; i++)
                    {
                        DataCube.ILArrays[i][t, ":"] = buf[i];
                    }
                    int progress = Convert.ToInt32(t * 100 / NumTimeStep);
                    OnLoading(progress);
                }
                if (_Descriptor.TimeStamps != null)
                {
                    DataCube.DateTimes = new DateTime[nstep];
                    for (int t = 0; t < nstep; t++)
                    {
                        DataCube.DateTimes[t] = _Descriptor.TimeStamps[t];
                    }
                }
                br.Close();
                fs.Close();
                OnDataCubedLoaded(DataCube);
            }
            catch (Exception ex)
            {
                br.Close();
                fs.Close();
                OnLoadFailed("Failed to load. Error message: " + ex.Message);
            }
        }

19 Source : FHDFile.cs
with GNU General Public License v3.0
from DeepHydro

public void ReadBinLayerHead(int layer)
        {
            if (File.Exists(_FileName))
            {
                OnLoading(0);
                if (MaxTimeStep <= 0 || NumTimeStep == 0)
                {
                    Scan();
                    MaxTimeStep = NumTimeStep;
                }
                var grid = _Grid as MFGrid;
                FileStream fs = new FileStream(_FileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
                BinaryReader br = new BinaryReader(fs);
                // KSTP,KPER,PERTIM,TOTIM,TEXT,NCOL,NROW,ILAY
                long layerbyte = 32 + 4 * 3 + grid.RowCount * grid.ColumnCount * 4;
                int nstep = StepsToLoad;
                float head = 0;
                int progress = 0;

                layer = layer - 1;
                if (layer < 0)
                    layer = 0;
                // MyLazy3DMat<float> mat = new MyLazy3DMat<float>(Variables.Length, nstep, grid.ActiveCellCount);
                if (DataCube == null)
                    DataCube = new DataCube<float>(Variables.Length, nstep, grid.ActualLayerCount, true);
                DataCube.Allocate(layer + 1);
                for (int t = 0; t < nstep; t++)
                {
                    for (int l = 0; l < layer; l++)
                    {
                        fs.Seek(layerbyte, SeekOrigin.Current);
                    }
                    fs.Seek(32, SeekOrigin.Current);
                    var vv = br.ReadInt32();
                    vv = br.ReadInt32();
                    vv = br.ReadInt32();
                    int index = 0;
                    var buf = new float[grid.ActiveCellCount];
                    for (int r = 0; r < grid.RowCount; r++)
                    {
                        for (int c = 0; c < grid.ColumnCount; c++)
                        {
                            head = br.ReadSingle();
                            if (grid.IBound[0, r, c] != 0)
                            {
                                buf[index] = head;
                                index++;
                            }
                        }
                    }
                    DataCube.ILArrays[layer + 1][t, ":"] = buf;
                    for (int l = layer + 1; l < grid.ActualLayerCount; l++)
                    {
                        fs.Seek(layerbyte, SeekOrigin.Current);
                    }
                    progress = Convert.ToInt32(t * 100 / nstep);
                    OnLoading(progress);
                }
                OnLoading(100);
                br.Close();
                fs.Close();
                OnDataCubedLoaded(DataCube);
            }
            else
            {
                OnLoadFailed("The FHD file dose not exist: " + _FileName);
            }
        }

19 Source : FHDFile.cs
with GNU General Public License v3.0
from DeepHydro

public void ReadBinLayerDepth(int layer)
        {
            if (File.Exists(_FileName))
            {
                OnLoading(0);
                if (MaxTimeStep <= 0 || NumTimeStep == 0)
                {
                    Scan();
                    MaxTimeStep = NumTimeStep;
                }
                var grid = _Grid as MFGrid;
                FileStream fs = new FileStream(_FileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
                BinaryReader br = new BinaryReader(fs);
                long layerbyte = 32 + 4 * 3 + grid.RowCount * grid.ColumnCount * 4;
                int nstep = StepsToLoad;
                float head = 0;
                int progress = 0;

                layer = layer - 1;
                if (layer < 0)
                    layer = 0;
                if (DataCube == null)
                    DataCube = new DataCube<float>(Variables.Length, nstep, grid.ActualLayerCount, true);
                DataCube.Allocate(layer + 1);
                for (int t = 0; t < nstep; t++)
                {
                    for (int l = 0; l < layer; l++)
                    {
                        fs.Seek(layerbyte, SeekOrigin.Current);
                    }
                    fs.Seek(32, SeekOrigin.Current);
                    var vv = br.ReadInt32();
                    vv = br.ReadInt32();
                    vv = br.ReadInt32();
                    int index = 0;
                    var buf = new float[grid.ActiveCellCount];
                    for (int r = 0; r < grid.RowCount; r++)
                    {
                        for (int c = 0; c < grid.ColumnCount; c++)
                        {
                            head = br.ReadSingle();
                            if (grid.IBound[0, r, c] != 0)
                            {
                                buf[index] = grid.Elevations[0, 0, index] - head;
                                index++;
                            }
                        }
                    }
                    DataCube.ILArrays[layer + 1][t, ":"] = buf;
                    for (int l = layer + 1; l < grid.ActualLayerCount; l++)
                    {
                        fs.Seek(layerbyte, SeekOrigin.Current);
                    }
                    progress = Convert.ToInt32(t * 100 / nstep);
                    OnLoading(progress);
                }
                if (progress < 100)
                    OnLoading(100);
                br.Close();
                fs.Close();

                OnDataCubedLoaded(DataCube);
            }
            else
            {
                OnLoadFailed("The FHD file dose not exist: " + _FileName);
            }
        }

19 Source : FHDFile.cs
with GNU General Public License v3.0
from DeepHydro

public void ReadBinTotalVertDis()
        {
            if (File.Exists(_FileName))
            {
                OnLoading(0);
                if (MaxTimeStep <= 0 || NumTimeStep == 0)
                {
                    Scan();
                    MaxTimeStep = NumTimeStep;
                }
                var grid = _Grid as MFGrid;
                FileStream fs = new FileStream(_FileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
                BinaryReader br = new BinaryReader(fs);
                long layerbyte = 32 + 4 * 3 + grid.RowCount * grid.ColumnCount * 4;
                int nstep = StepsToLoad;
                float head = 0;
                int progress = 0;
                float[][] vts = new float[grid.ActualLayerCount][];

                for (int l = 0; l < grid.ActualLayerCount; l++)
                {
                    vts[l] = new float[grid.ActiveCellCount];
                }

                if (DataCube == null)
                    DataCube = new DataCube<float>(Variables.Length, nstep, grid.ActualLayerCount, true);
                DataCube.Allocate(0);
                float total_vt = 0;
                for (int t = 0; t < nstep; t++)
                {
                    for (int l = 0; l < grid.ActualLayerCount; l++)
                    {
                        fs.Seek(32, SeekOrigin.Current);
                        var vv = br.ReadInt32();
                        vv = br.ReadInt32();
                        vv = br.ReadInt32();
                        int index = 0;
                        for (int r = 0; r < grid.RowCount; r++)
                        {
                            for (int c = 0; c < grid.ColumnCount; c++)
                            {
                                head = br.ReadSingle();
                                if (grid.IBound[0, r, c] != 0)
                                {
                                    vts[l][index] = head;
                                    index++;
                                }
                            }
                        }
                    }
                  
                    for (int i = 0; i < grid.ActiveCellCount; i++)
                    {
                        total_vt = 0;
                        for (int ll = 0; ll < grid.ActualLayerCount; ll++)
                        {
                            total_vt += vts[ll][i];
                        }
                        DataCube[0, t, i] = total_vt / grid.ActualLayerCount;
                    }

                    progress = Convert.ToInt32(t * 100 / nstep);
                    OnLoading(progress);
                }
                if (progress < 100)
                    OnLoading(100);
                br.Close();
                fs.Close();
                OnDataCubedLoaded(DataCube);
            }
            else
            {

            }
        }

19 Source : FHDFile.cs
with GNU General Public License v3.0
from DeepHydro

public void ReadBinWaterTable()
        {
            if (File.Exists(_FileName))
            {
                OnLoading(0);
                if (MaxTimeStep <= 0 || NumTimeStep == 0)
                {
                    Scan();
                    MaxTimeStep = NumTimeStep;
                }
                var grid = _Grid as MFGrid;
                FileStream fs = new FileStream(_FileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
                BinaryReader br = new BinaryReader(fs);
                long layerbyte = 32 + 4 * 3 + grid.RowCount * grid.ColumnCount * 4;
                int nstep = StepsToLoad;
                float head = 0;
                int progress = 0;
                float[][] heads = new float[grid.ActualLayerCount][];

                for (int l = 0; l < grid.ActualLayerCount; l++)
                {
                    heads[l] = new float[grid.ActiveCellCount];
                }

                if (DataCube == null)
                    DataCube = new DataCube<float>(Variables.Length, nstep, grid.ActualLayerCount, true);
                DataCube.Allocate(0);
                float[] lwt = new float[grid.ActualLayerCount];
                for (int t = 0; t < nstep; t++)
                {
                    for (int l = 0; l < grid.ActualLayerCount; l++)
                    {
                        fs.Seek(32, SeekOrigin.Current);
                        var vv = br.ReadInt32();
                        vv = br.ReadInt32();
                        vv = br.ReadInt32();
                        int index = 0;
                        for (int r = 0; r < grid.RowCount; r++)
                        {
                            for (int c = 0; c < grid.ColumnCount; c++)
                            {
                                head = br.ReadSingle();
                                if (grid.IBound[0, r, c] != 0)
                                {
                                    heads[l][index] = head;
                                    index++;
                                }
                            }
                        }
                        var buf = new float[grid.ActiveCellCount];
                        for (int i = 0; i < grid.ActiveCellCount; i++)
                        {
                            for (int ll = 0; ll < grid.ActualLayerCount; ll++)
                            {
                                lwt[ll] = heads[ll][i];
                            }
                            buf[i] = lwt.Max();
                        }
                        DataCube.ILArrays[0][t, ":"] = buf;
                    }
                    progress = Convert.ToInt32(t * 100 / nstep);
                    OnLoading(progress);
                }
                if (progress < 100)
                    OnLoading(100);
                br.Close();
                fs.Close();
                OnDataCubedLoaded(DataCube);      
            }
            else
            {
                OnLoadFailed("The FHD file dose not exist: " + _FileName);
            }
        }

19 Source : FHDFile.cs
with GNU General Public License v3.0
from DeepHydro

public void ReadBinWaterDepth()
        {
            if (File.Exists(_FileName))
            {
                OnLoading(0);
                if (MaxTimeStep <= 0 || NumTimeStep == 0)
                {
                    Scan();
                    MaxTimeStep = NumTimeStep;
                }
                var grid = _Grid as MFGrid;
                FileStream fs = new FileStream(_FileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
                BinaryReader br = new BinaryReader(fs);
                long layerbyte = 32 + 4 * 3 + grid.RowCount * grid.ColumnCount * 4;
                int nstep = StepsToLoad;
                float head = 0;
                int progress = 0;
                float[][] heads = new float[grid.ActualLayerCount][];

                for (int l = 0; l < grid.ActualLayerCount; l++)
                {
                    heads[l] = new float[grid.ActiveCellCount];
                }

                if (DataCube == null)
                    DataCube = new DataCube<float>(Variables.Length, nstep, grid.ActualLayerCount,true);
                DataCube.Allocate(0);
                float[] lwt = new float[grid.ActualLayerCount];
                for (int t = 0; t < nstep; t++)
                {
                    for (int l = 0; l < grid.ActualLayerCount; l++)
                    {
                        fs.Seek(32, SeekOrigin.Current);
                        var vv = br.ReadInt32();
                        vv = br.ReadInt32();
                        vv = br.ReadInt32();
                        int index = 0;
                        for (int r = 0; r < grid.RowCount; r++)
                        {
                            for (int c = 0; c < grid.ColumnCount; c++)
                            {
                                head = br.ReadSingle();
                                if (grid.IBound[0, r, c] != 0)
                                {
                                    heads[l][index] = head;
                                    index++;
                                }
                            }
                        }
                    }
                    var buf = new float[grid.ActiveCellCount];
                    for (int i = 0; i < grid.ActiveCellCount; i++)
                    {
                        for (int ll = 0; ll < grid.ActualLayerCount; ll++)
                        {
                            lwt[ll] = heads[ll][i];
                        }
                       buf[i] = grid.Elevations[0, 0, i] - lwt.Max();
                    }
                    DataCube.ILArrays[0][t, ":"] = buf;
                    progress = Convert.ToInt32(t * 100 / nstep);
                    OnLoading(progress);
                }
                if (progress < 100)
                    OnLoading(100);
                br.Close();
                fs.Close();
                OnDataCubedLoaded(DataCube);
            }
            else
            {
                OnLoadFailed("The FHD file dose not exist: " + _FileName);
            }
        }

19 Source : MFPackage.cs
with GNU General Public License v3.0
from DeepHydro

private float[] ReadNonZeroArray(BinaryReader br, MFGrid grid, float[][] values)
        {
            float[] wt = new float[grid.ActiveCellCount];
            float vv = 0;
            for (int l = 0; l < grid.ActualLayerCount; l++)
            {
                int index = 0;
                for (int r = 0; r < grid.RowCount; r++)
                {
                    for (int c = 0; c < grid.ColumnCount; c++)
                    {
                        vv = br.ReadSingle();
                        if (grid.IBound.LayeredValues[0][r, c] != 0)
                        {
                            values[l][index] = vv;
                            index++;
                        }
                    }
                }
            }

            for (int i = 0; i < grid.ActiveCellCount; i++)
            {
                for (int ll = 0; ll < grid.ActualLayerCount; ll++)
                {
                    if (values[ll][i] != 0)
                    {
                        wt[i] = values[ll][i];
                        break;
                    }
                }
            }
            return wt;
        }

19 Source : MFPackage.cs
with GNU General Public License v3.0
from DeepHydro

public void ReadYearlyBinWaterTable(string filename = "",int yrs=13, int maxstep = 30)
        {
            if (filename == "")
            {
                filename = GetInputFile("FHD");
            }

            if (File.Exists(filename))
            {
                var grid = mfgrid;

                FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
                BinaryReader br = new BinaryReader(fs);

                List<float[]> headLst = new List<float[]>();
                long layerbyte = 32 + 4 * 3 + grid.RowCount * grid.ColumnCount * 4;
                float head = 0;
                float[][] heads = new float[grid.ActualLayerCount][];
                for (int l = 0; l < grid.ActualLayerCount; l++)
                {
                    heads[l] = new float[grid.ActiveCellCount];
                }
                int step = 0;
                while (!(fs.Position == fs.Length))
                {
                    float[] wt = new float[grid.ActiveCellCount];
                    for (int l = 0; l < grid.ActualLayerCount; l++)
                    {
                        fs.Seek(32, SeekOrigin.Current);
                        var vv = br.ReadInt32();
                        vv = br.ReadInt32();
                        vv = br.ReadInt32();
                        int index = 0;
                        for (int r = 0; r < grid.RowCount; r++)
                        {
                            for (int c = 0; c < grid.ColumnCount; c++)
                            {
                                head = br.ReadSingle();
                                if (grid.IBound.LayeredValues[0][r, c] != 0)
                                {
                                    heads[l][index] = head;
                                    index++;
                                }
                            }
                        }

                        float[] lwt = new float[grid.ActualLayerCount];
                        for (int i = 0; i < grid.ActiveCellCount; i++)
                        {
                            for (int ll = 0; ll < grid.ActualLayerCount; ll++)
                            {
                                lwt[ll] = heads[ll][i];
                            }
                            wt[i] = lwt.Max();
                        }
                    }

                    headLst.Add(wt);
                    step++;
                    if (maxstep > 0)
                        if (step >= maxstep)
                            break;
                }
                grid.ArrayCube = new MatrixCube<float>(yrs, true);
                int tt = 0;
                for (int i = 0; i < yrs; i++)
                {
                    float[] ff = new float[grid.ActiveCellCount];
                    for (int m = 0; m < 36; m++)
                    {
                        for (int s = 0; s < ff.Length; s++)
                        {
                            ff[s] += headLst[tt][s];
                        }
                        tt++;
                    }
                    for (int s = 0; s < ff.Length; s++)
                    {
                        ff[s] /= 36;
                    }
                    grid.ArrayCube.LayeredSerialValue[i] = ff;
                }

                heads = null;

                br.Close();
                fs.Close();
                headLst.Clear();
                GC.Collect();
            }
        }

19 Source : MFPackage.cs
with GNU General Public License v3.0
from DeepHydro

public void ReadBinWaterTable(string filename = "", int maxstep=30)
        {
            if (filename == "")
            {
                filename = GetInputFile("FHD");
            }

            if (File.Exists(filename))
            {
                var grid = mfgrid;

                FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
                BinaryReader br = new BinaryReader(fs);

                List<float[]> headLst = new List<float[]>();
                long layerbyte = 32 + 4 * 3 + grid.RowCount * grid.ColumnCount * 4;
                float head = 0;
                float[][] heads = new float[grid.ActualLayerCount][];
                for (int l = 0; l < grid.ActualLayerCount; l++)
                {
                    heads[l] = new float[grid.ActiveCellCount];
                }
                int step = 0;
                while (!(fs.Position == fs.Length))
                {
                    float[] wt = new float[grid.ActiveCellCount];
                    for (int l = 0; l < grid.ActualLayerCount; l++)
                    {
                        fs.Seek(32, SeekOrigin.Current);
                        var vv = br.ReadInt32();
                        vv = br.ReadInt32();
                        vv = br.ReadInt32();
                        int index = 0;
                        for (int r = 0; r < grid.RowCount; r++)
                        {
                            for (int c = 0; c < grid.ColumnCount; c++)
                            {
                                head = br.ReadSingle();
                                if (grid.IBound.LayeredValues[0][r, c] != 0)
                                {
                                    heads[l][index] = head;
                                    index++;
                                }
                            }
                        }

                        float[] lwt = new float[grid.ActualLayerCount];
                        for (int i = 0; i < grid.ActiveCellCount; i++)
                        {
                            for (int ll = 0; ll < grid.ActualLayerCount; ll++)
                            {
                                lwt[ll] = heads[ll][i];
                            }
                            wt[i] = lwt.Max();
                        }
                    }

                    headLst.Add(wt);
                    step++;
                    if (maxstep > 0)
                        if (step >= maxstep)
                            break;
                }

                grid.ArrayCube = new MatrixCube<float>(headLst.Count, true);
                for (int i = 0; i < headLst.Count; i++)
                {
                    grid.ArrayCube.LayeredSerialValue[i] = headLst[i];
                }

                heads = null;

                br.Close();
                fs.Close();
                headLst.Clear();
                GC.Collect();
            }
        }

19 Source : UCNPackage.cs
with GNU General Public License v3.0
from DeepHydro

public override LoadingState Load(int var_index, ICancelProgressHandler progress)
        {
            var result = LoadingState.Normal;
            _ProgressHandler = progress;
            NumTimeStep = TimeService.IOTimeline.Count;
            var grid = Owner.Grid as MFGrid;
            var btn = Owner.GetPackage(BTNPackage.PackageName) as BTNPackage;
            if (DataCube == null || DataCube.Size[1] != StepsToLoad)
            {
                if (LoadAllLayers)
                {
                    DataCube = new DataCube<float>(Variables.Length, StepsToLoad, grid.ActiveCellCount * grid.ActualLayerCount, true)
                    {
                        Name = "UCN"
                    };
                }
                else
                {
                    DataCube = new DataCube<float>(Variables.Length, StepsToLoad, grid.ActiveCellCount, true)
                    {
                        Name = "UCN"
                    };
                }
            }

            if (LoadAllLayers && DataCube.Size[2] != grid.ActiveCellCount * grid.ActualLayerCount)
            {
                DataCube = new DataCube<float>(Variables.Length, StepsToLoad, grid.ActiveCellCount * grid.ActualLayerCount, true)
                {
                    Name = "UCN"
                };
            }

            DataCube.Allocate(var_index, StepsToLoad, grid.ActiveCellCount * grid.ActualLayerCount);
            DataCube.Topology = (this.Grid as RegularGrid).Topology;
            DataCube.DateTimes = this.TimeService.IOTimeline.Take(StepsToLoad).ToArray();
            DataCube.Variables = this.Variables;
            DataCube.Layers = grid.ActualLayerCount;

            var fn = string.Format("PHT3D{0}.UCN", (var_index + 1).ToString().PadLeft(3, '0'));
            var file = Path.Combine(Owner.Project.AbsolutePathToProjectFile, fn);
            bool filefound = false;

            if (File.Exists(file))
            {
                filefound = true;
            }
            else
            {
                file = Path.Combine(Owner.Project.AbsolutePathToProjectFile, string.Format("MT3D{0}.UCN", (var_index + 1).ToString().PadLeft(3, '0')));
                if (File.Exists(file))
                {
                    filefound = true;
                }
            }

            if (filefound)
            {
                FileStream fs = new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
                try
                {
                    var cell_index = grid.Topology.GetIndexIn2DMat();
                 
                    BinaryReader br = new BinaryReader(fs);

                    float[] cells = new float[grid.RowCount * grid.ColumnCount];
                    int prog = 0;
                    for (int t = 0; t < StepsToLoad; t++)
                    {
                        for (int k = 0; k < grid.ActualLayerCount; k++)
                        {
                            for (int b = 0; b < 4; b++)
                            {
                                var buf = br.ReadInt32();
                            }
                            //fs.Seek(4 * 2, SeekOrigin.Current);
                            var vn = new string(br.ReadChars(16)).Trim();
                            // fs.Seek(4 * 3, SeekOrigin.Current);
                            for (int b = 0; b < 3; b++)
                            {
                                var buf = br.ReadInt32();
                            }
                            int c = 0;
                            for (int i = 0; i < grid.RowCount; i++)
                            {
                                for (int j = 0; j < grid.ColumnCount; j++)
                                {
                                    cells[c] = br.ReadSingle();
                                    c++;
                                }
                            }
                            for (int a = 0; a < grid.ActiveCellCount; a++)
                            {
                                if (cells[cell_index[a]] <= btn.CINACT)
                                    DataCube[var_index, t, k * grid.ActiveCellCount + a] = this.NoDataValue;
                                else
                                    DataCube[var_index, t, k * grid.ActiveCellCount + a] = cells[cell_index[a]];

                            }
                        }
                        prog = Convert.ToInt32(t * 100 / StepsToLoad);
                        OnLoading(prog);
                    }
         
                    result = LoadingState.Normal;
                    OnLoaded(progress, new LoadingObjectState() { Message = Message, Object = this, State = result });
                }
                catch (Exception ex)
                {
                    ShowWarning(ex.Message, progress);
                    result = LoadingState.Warning;
                    acn_LoadFailed(this, ex.Message);
                }
                finally
                {
                    fs.Close();
                }
            }
            else
            {
                Message = "The file does not exist: " + file;
                ShowWarning(Message, progress);
                result = LoadingState.Warning;
                acn_LoadFailed(this, Message);
            }
            return result;
        }

19 Source : MFPackage.cs
with GNU General Public License v3.0
from DeepHydro

public void ReadAverageCBC(string[] varNames, string filename = "", int layer = 0)
        {
            if (filename == "")
            {
                filename = GetInputFile("CBC");
            }

            if (File.Exists(filename))
            {
                var grid = mfgrid;
                FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
                BinaryReader br = new BinaryReader(fs);
                List<string> vnLst = new List<string>();
                long layerbyte = grid.RowCount * grid.ColumnCount * 4;
                float vv = 0;
                int step = 0;
                int varLen = varNames.Length;
                List<float[]>[] cbcLst = new List<float[]>[varLen];
                for (int i = 0; i < varLen; i++)
                {
                    cbcLst[i] = new List<float[]>();
                }
                int varIndex = 0;

                while (!(fs.Position == fs.Length))
                {
                    fs.Seek(4 * 2, SeekOrigin.Current);
                    var vn = new string(br.ReadChars(16)).Trim();
                    fs.Seek(4 * 3, SeekOrigin.Current);
                    if (varNames.Contains(vn))
                    {
                        if (vnLst.Contains(vn))
                        {
                            varIndex = 0;
                            vnLst.Clear();
                            step++;
                        }
                        for (int l = 0; l < grid.ActualLayerCount; l++)
                        {
                            if (l == layer)
                            {
                                int index = 0;
                                float[] values = new float[grid.ActiveCellCount];

                                for (int r = 0; r < grid.RowCount; r++)
                                {
                                    for (int c = 0; c < grid.ColumnCount; c++)
                                    {
                                        vv = br.ReadSingle();
                                        if (grid.IBound.LayeredValues[layer][r, c] != 0)
                                        {
                                            values[index] = vv;
                                            index++;
                                        }
                                    }
                                }
                                vnLst.Add(vn);
                                cbcLst[varIndex].Add(values);
                            }
                            else
                            {
                                fs.Seek(layerbyte, SeekOrigin.Current);
                            }
                        }
                        varIndex++;
                    }
                    else
                    {
                        fs.Seek(layerbyte * grid.ActualLayerCount, SeekOrigin.Current);
                    }
                }
                grid.MultipleArrayCube = new MatrixCube<float>[varLen];

                for (int i = 0; i < varLen; i++)
                {
                    grid.MultipleArrayCube[i] = new MatrixCube<float>(1, true)
                    {
                        Name = varNames[i]
                    };
                    grid.MultipleArrayCube[i].LayeredSerialValue[0] = new float[grid.ActiveCellCount];
                    for (int s = 0; s < step; s++)
                    {
                        for (int t = 0; t < grid.ActiveCellCount; t++)
                        {
                            grid.MultipleArrayCube[i].LayeredSerialValue[0][t] += cbcLst[i][s][t];
                        }
                    }
                    for (int t = 0; t < grid.ActiveCellCount; t++)
                    {
                        grid.MultipleArrayCube[i].LayeredSerialValue[0][t] /= step;
                    }
                }

                br.Close();
                fs.Close();
            }
        }

19 Source : SFROutputPackage.cs
with GNU General Public License v3.0
from DeepHydro

private LoadingState LoadSingleVarFromBanary(string filename, int var_index, ICancelProgressHandler progresshandler)
        {
            var network = _SFRPackage.RiverNetwork;
            int reachNum = network.ReachCount;
            int count = 1;
            int nstep = StepsToLoad;
            var result = LoadingState.Normal;
            int feaNum = 0;
            int varnum = 0;

            OnLoading(0);
            FileStream fs = new FileStream(_FileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
            BinaryReader br = new BinaryReader(fs);

            varnum = br.ReadInt32();
            Variables = new string[varnum];
            for (int i = 0; i < varnum; i++)
            {
                int varname_len = br.ReadInt32();
                Variables[i] = new string(br.ReadChars(varname_len)).Trim();
                feaNum = br.ReadInt32();
            }

            int progress = 0;
            int stepbyte = feaNum * 4 * varnum;
            if (!IsLoadCompleteData)
            {
                reachNum = network.RiverCount;
            }

            if (IsReadSSData)
            {
                SkippedSteps = SkippedSteps - 1;
            }
            for (int t = 0; t < SkippedSteps; t++)
            {
                br.ReadBytes(stepbyte);
            }

            OnLoading(progress);
            try
            {
                DataCube = new DataCube<float>(varnum, nstep, reachNum, true)
                {
                    Name = "SFR_Output",
                };
                DataCube.Allocate(var_index);
                DataCube.DateTimes = new DateTime[nstep];
            }
            catch (Exception ex)
            {
                Message = "Out of memory. Error message: " + ex.Message;
                ShowWarning(Message, progresshandler);
                result = LoadingState.Warning;
                OnLoaded(progresshandler, new LoadingObjectState() { Message = Message, Object = this, State = result });
                return result;
            }
            var scale = (float)ScaleFactor;
            var lastreach_index_list = new int[network.RiverCount];
            for (int j = 0; j < network.RiverCount;j++ )
            {
                lastreach_index_list[j] = GetReachSerialIndex(network.Rivers[j].ID, network.Rivers[j].LastReach.SubID);
            }
            for (int t = 0; t < nstep; t++)
            {
                var buf = new float[feaNum];
                for (int s = 0; s < feaNum; s++)
                {
                    br.ReadBytes(4 * var_index);
                    buf[s] = br.ReadSingle() * scale;
                    br.ReadBytes(4 * (varnum - var_index - 1));
                }

                if (IsLoadCompleteData)
                {
                    DataCube.ILArrays[var_index][t, ":"] = buf;
                }
                else
                {
                    var last_vec = new float[network.RiverCount];
                    for (int i = 0; i < network.RiverCount; i++)
                    {
                        //rch_index = GetReachSerialIndex(network.Rivers[i].ID, network.Rivers[i].LastReach.SubID);
                        //DataCube[var_index, t, i] = buf[rch_index];
                        last_vec[i] = buf[lastreach_index_list[i]];
                    }
                    DataCube.ILArrays[var_index][t, ":"] = last_vec;
                }
                DataCube.DateTimes[t] = TimeService.Timeline[t];
                progress = t * 100 / nstep;
                if (progress > count)
                {
                    OnLoading(progress);
                    count++;
                }
            }
            br.Close();
            fs.Close();
            if (IsLoadCompleteData)
                DataCube.Topology = _SFRPackage.ReachTopology;
            else
                DataCube.Topology = _SFRPackage.SegTopology;
            DataCube.Variables = DefaultAttachedVariables;
            Variables = DefaultAttachedVariables;
            result = LoadingState.Normal;

            return result;
        }

19 Source : SFROutputPackage.cs
with GNU General Public License v3.0
from DeepHydro

private LoadingState LoadAllVarsFromBinary(string filename, ICancelProgressHandler progresshandler)
        {
            var network = _SFRPackage.RiverNetwork;
            RiverNetwork = network;
            int reachNum = network.ReachCount;
            int count = 1;
            int nstep = StepsToLoad;
            var result = LoadingState.Normal;
            int feaNum = 0;
            int varnum = 0;

            OnLoading(0);
            FileStream fs = new FileStream(_FileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
            BinaryReader br = new BinaryReader(fs);

            varnum = br.ReadInt32();
            Variables = new string[varnum];
            for (int i = 0; i < varnum; i++)
            {
                int varname_len = br.ReadInt32();
                Variables[i] = new string(br.ReadChars(varname_len)).Trim();
                feaNum = br.ReadInt32();
            }

            int progress = 0;
            int stepbyte = feaNum * 4 * varnum;
            if (!IsLoadCompleteData)
            {
                reachNum = network.RiverCount;
            }

            if (IsReadSSData)
            {
                SkippedSteps = SkippedSteps - 1;
            }
            for (int t = 0; t < SkippedSteps; t++)
            {
                br.ReadBytes(stepbyte);
            }

            OnLoading(progress);
            try
            {
                DataCube = new DataCube<float>(varnum, nstep, reachNum)
                {
                    Name = "SFR_Output",
                };
                DataCube.DateTimes = new DateTime[nstep];
            }
            catch (Exception ex)
            {
                Message = "Out of memory. Error message: " + ex.Message;
                ShowWarning(Message, progresshandler);
                result = LoadingState.Warning;
                OnLoaded(progresshandler, new LoadingObjectState() { Message = Message, Object = this, State = result });
                return result;
            }
            var scale = (float)ScaleFactor;
            var buf = new float[varnum, feaNum];
            for (int t = 0; t < nstep; t++)
            {
                int rch_index = 0;

                if (IsLoadCompleteData)
                {
                    for (int s = 0; s < feaNum; s++)
                    {
                        for (int k = 0; k < varnum; k++)
                        {
                            DataCube[k, t, s] = br.ReadSingle() * scale;
                        }
                    }
                }
                else
                {
                    for (int s = 0; s < feaNum; s++)
                    {
                        for (int k = 0; k < varnum; k++)
                        {
                            buf[k, s] = br.ReadSingle() * scale;
                        }
                    }
                    for (int i = 0; i < network.RiverCount; i++)
                    {
                        rch_index = GetReachSerialIndex(network.Rivers[i].ID, network.Rivers[i].LastReach.SubID);
                        for (int k = 0; k < varnum; k++)
                        {
                            DataCube[k, t, i] = buf[k, rch_index];
                        }
                    }
                }

                DataCube.DateTimes[t] = TimeService.Timeline[t];
                progress = t * 100 / nstep;
                if (progress > count)
                {
                    OnLoading(progress);
                    count++;
                }
            }
            br.Close();
            fs.Close();
            if (IsLoadCompleteData)
                DataCube.Topology = _SFRPackage.ReachTopology;
            else
                DataCube.Topology = _SFRPackage.SegTopology;
            DataCube.Variables = DefaultAttachedVariables;
            Variables = DefaultAttachedVariables;
            result = LoadingState.Normal;

            return result;
        }

See More Examples