예제 #1
0
        public void DecodeRtiConstructorTest()
        {
            DataSet.GoodEarthDataSet ge = new DataSet.GoodEarthDataSet(DataSet.Ensemble.DATATYPE_INT,                           // Type of data stored (Float or Int)
                                                                       30,                                                      // Number of bins
                                                                       4,                                                       // Number of beams
                                                                       DataSet.Ensemble.DEFAULT_IMAG,                           // Default Image
                                                                       DataSet.Ensemble.DEFAULT_NAME_LENGTH,                    // Default Image length
                                                                       DataSet.Ensemble.GoodEarthID);                           // Dataset ID

            ge.GoodEarthData[0, 0] = 2;
            ge.GoodEarthData[0, 1] = 2;
            ge.GoodEarthData[0, 2] = 1;
            ge.GoodEarthData[0, 3] = 2;
            ge.GoodEarthData[1, 0] = 2;
            ge.GoodEarthData[1, 1] = 2;
            ge.GoodEarthData[1, 2] = 2;
            ge.GoodEarthData[1, 3] = 1;

            Pd0PercentGood pg = new Pd0PercentGood(ge, 2);

            Assert.AreEqual(100, pg.PercentGood[0, 0], "Percent Good Bin 0, Beam 0 is incorrect.");
            Assert.AreEqual(50, pg.PercentGood[0, 1], "Percent Good Bin 0, Beam 1 is incorrect.");
            Assert.AreEqual(100, pg.PercentGood[0, 2], "Percent Good Bin 0, Beam 2 is incorrect.");
            Assert.AreEqual(100, pg.PercentGood[0, 3], "Percent Good Bin 0, Beam 3 is incorrect.");
            Assert.AreEqual(50, pg.PercentGood[1, 0], "Percent Good Bin 1, Beam 0 is incorrect.");
            Assert.AreEqual(100, pg.PercentGood[1, 1], "Percent Good Bin 1, Beam 1 is incorrect.");
            Assert.AreEqual(100, pg.PercentGood[1, 2], "Percent Good Bin 1, Beam 2 is incorrect.");
            Assert.AreEqual(100, pg.PercentGood[1, 3], "Percent Good Bin 1, Beam 3 is incorrect.");
        }
예제 #2
0
        public void DecodePd0Test()
        {
            Pd0PercentGood pg = new Pd0PercentGood(30);

            pg.PercentGood[0, 0] = 100;
            pg.PercentGood[0, 1] = 100;
            pg.PercentGood[0, 2] = 50;
            pg.PercentGood[0, 3] = 100;
            pg.PercentGood[1, 0] = 100;
            pg.PercentGood[1, 1] = 100;
            pg.PercentGood[1, 2] = 100;
            pg.PercentGood[1, 3] = 50;

            DataSet.GoodEarthDataSet goodEarth = new DataSet.GoodEarthDataSet(30);
            goodEarth.DecodePd0Ensemble(pg, 2);

            Assert.AreEqual(1, goodEarth.GoodEarthData[0, 0], "Good Earth Bin 0, Beam 0 is incorrect.");
            Assert.AreEqual(2, goodEarth.GoodEarthData[0, 1], "Good Earth Bin 0, Beam 1 is incorrect.");
            Assert.AreEqual(2, goodEarth.GoodEarthData[0, 2], "Good Earth Bin 0, Beam 2 is incorrect.");
            Assert.AreEqual(2, goodEarth.GoodEarthData[0, 3], "Good Earth Bin 0, Beam 3 is incorrect.");
            Assert.AreEqual(2, goodEarth.GoodEarthData[1, 0], "Good Earthd Bin 1, Beam 0 is incorrect.");
            Assert.AreEqual(1, goodEarth.GoodEarthData[1, 1], "Good Earth Bin 1, Beam 1 is incorrect.");
            Assert.AreEqual(2, goodEarth.GoodEarthData[1, 2], "Good Earth Bin 1, Beam 2 is incorrect.");
            Assert.AreEqual(2, goodEarth.GoodEarthData[1, 3], "Good Earth Bin 1, Beam 3 is incorrect.");
        }
예제 #3
0
파일: Pd0Test.cs 프로젝트: 759991469/RTI
        public void TestEncodeVelCorrEchoPg()
        {
            PD0 pd0 = new PD0();

            pd0.FixedLeader.NumberOfCells = 5;

            Pd0Velocity vel = new Pd0Velocity(5);

            vel.Velocities[0, 0] = 32;
            vel.Velocities[0, 1] = -32;
            pd0.AddDataType(vel);

            Pd0Correlation corr = new Pd0Correlation(5);

            corr.Correlation[0, 0] = 32;
            corr.Correlation[0, 1] = 255;
            pd0.AddDataType(corr);

            Pd0EchoIntensity ei = new Pd0EchoIntensity(5);

            ei.EchoIntensity[0, 0] = 32;
            ei.EchoIntensity[0, 1] = 255;
            pd0.AddDataType(ei);

            Pd0PercentGood pg = new Pd0PercentGood(5);

            pg.PercentGood[0, 0] = 32;
            pg.PercentGood[0, 1] = 255;
            pd0.AddDataType(pg);

            byte[] encode = pd0.Encode();

            int flOffset   = pd0.Header.GetFixedLeader().Offset;
            int velOffset  = pd0.Header.GetVelocity().Offset;
            int corrOffset = pd0.Header.GetCorrelation().Offset;
            int eiOffset   = pd0.Header.GetEchoIntensity().Offset;
            int pgOffset   = pd0.Header.GetPercentGood().Offset;

            Assert.AreEqual(0, encode[flOffset], "Fixed Leader ID LSB is incorrect");
            Assert.AreEqual(0, encode[flOffset + 1], "Fixed Leader ID MSB is incorrect");
            Assert.AreEqual(5, encode[flOffset + 9], "Number of depth cells is incorrect");

            Assert.AreEqual(32, MathHelper.LsbMsbShort(encode[velOffset + 2], encode[velOffset + 3]), "Velocity Bin 0, Beam 0 is incorrect.");
            Assert.AreEqual(-32, MathHelper.LsbMsbShort(encode[velOffset + 4], encode[velOffset + 5]), "Velocity Bin 0, Beam 1 is incorrect.");

            Assert.AreEqual(32, encode[corrOffset + 2], "Correlation Bin 0, Beam 0 is incorrect.");
            Assert.AreEqual(255, encode[corrOffset + 3], "Correlation Bin 0, Beam 1 is incorrect.");

            Assert.AreEqual(32, encode[eiOffset + 2], "Echo Intensity Bin 0, Beam 0 is incorrect.");
            Assert.AreEqual(255, encode[eiOffset + 3], "Echo Intensity Bin 0, Beam 1 is incorrect.");

            Assert.AreEqual(32, encode[pgOffset + 2], "Percent Good Bin 0, Beam 0 is incorrect.");
            Assert.AreEqual(255, encode[pgOffset + 3], "Percent Good Bin 0, Beam 1 is incorrect.");

            Assert.IsFalse(pd0.IsBottomTrackExist, "IsBottomTrackExist is incorrect.");
            Assert.IsTrue(pd0.IsCorrelationExist, "IsCorrelationExist is incorrect.");
            Assert.IsTrue(pd0.IsEchoIntensityExist, "IsEchoIntensityExist is incorrect.");
            Assert.IsTrue(pd0.IsPercentGoodExist, "IsPercentGoodExist is incorrect.");
        }
예제 #4
0
        public void TestEncode()
        {
            Pd0PercentGood pg = new Pd0PercentGood();

            pg.PercentGood = new byte[5, 4];

            pg.PercentGood[0, 0] = 232;
            pg.PercentGood[0, 1] = 123;
            pg.PercentGood[0, 2] = 122;
            pg.PercentGood[0, 3] = 223;

            pg.PercentGood[4, 0] = 111;
            pg.PercentGood[4, 1] = 222;
            pg.PercentGood[4, 2] = 21;
            pg.PercentGood[4, 3] = 34;


            byte[] data = pg.Encode();

            // DS 0 Beam 0
            Assert.AreEqual(0xE8, data[2], "DS 0 Beam 0 Encode is incorrect.");

            // DS 0 Beam 1
            Assert.AreEqual(0x7B, data[3], "DS 0 Beam 1 Encode is incorrect.");

            // DS 0 Beam 2
            Assert.AreEqual(0x7A, data[4], "DS 0 Beam 2 Encode is incorrect.");

            // DS 0 Beam 3
            Assert.AreEqual(0xDF, data[5], "DS 0 Beam 3 Encode is incorrect.");



            // DS 4 Beam 0
            Assert.AreEqual(0x6F, data[(4 * 4) + 2 + 0], "DS 4 Beam 0 Encode is incorrect.");

            // DS 4 Beam 1
            Assert.AreEqual(0xDE, data[(4 * 4) + 2 + 1], "DS 4 Beam 1 Encode is incorrect.");

            // DS 4 Beam 2
            Assert.AreEqual(0x15, data[(4 * 4) + 2 + 2], "DS 4 Beam 2 Encode is incorrect.");

            // DS 4 Beam 3
            Assert.AreEqual(0x22, data[(4 * 4) + 2 + 3], "DS 4 Beam 3 Encode is incorrect.");
        }
예제 #5
0
        public void TestPercentGood()
        {
            Pd0PercentGood pg = new Pd0PercentGood();

            // 2 Byte Header
            // 4 Bytes per depth cell
            // 4 Beams per depth cell
            // 2 Bytes per beam
            byte[] data = new byte[22];

            data[0] = Pd0PercentGood.ID_LSB;
            data[1] = Pd0PercentGood.ID_MSB;
            data[2] = 0xE8;                                   // DS0 Beam 0
            data[3] = 0x7B;                                   // DS0 Beam 1
            data[4] = 0x7A;                                   // DS0 Beam 2
            data[5] = 0xDF;                                   // DS0 Beam 3

            data[(4 * 4) + 2 + 0] = 0x6F;                     // DS4 Beam 0
            data[(4 * 4) + 2 + 1] = 0xDE;                     // DS4 Beam 1
            data[(4 * 4) + 2 + 2] = 0x15;                     // DS4 Beam 2
            data[(4 * 4) + 2 + 3] = 0x22;                     // DS4 Beam 3


            pg.Decode(data);

            Assert.AreEqual(5, pg.PercentGood.GetLength(0), "Number of Depth Cells is incorrect.");
            Assert.AreEqual(232, pg.GetPercentGood(0, 0), "DS 0 Beam 0 is incorrect.");
            Assert.AreEqual(123, pg.GetPercentGood(0, 1), "DS 0 Beam 1 is incorrect.");
            Assert.AreEqual(122, pg.GetPercentGood(0, 2), "DS 0 Beam 2 is incorrect.");
            Assert.AreEqual(223, pg.GetPercentGood(0, 3), "DS 0 Beam 3 is incorrect.");

            Assert.AreEqual(111, pg.GetPercentGood(4, 0), "DS 4 Beam 0 is incorrect.");
            Assert.AreEqual(222, pg.GetPercentGood(4, 1), "DS 4 Beam 1 is incorrect.");
            Assert.AreEqual(21, pg.GetPercentGood(4, 2), "DS 4 Beam 2 is incorrect.");
            Assert.AreEqual(34, pg.GetPercentGood(4, 3), "DS 4 Beam 3 is incorrect.");
        }
예제 #6
0
파일: Pd0Test.cs 프로젝트: 759991469/RTI
        public void TestDecodeVelocityPgCorrEiBt()
        {
            PD0 pd0 = new PD0();

            pd0.FixedLeader.NumberOfCells = 5;

            #region Velocity

            Pd0Velocity vel = new Pd0Velocity();
            // 2 Byte Header
            // 8 Bytes per depth cell
            // 4 Beams per depth cell
            // 2 Bytes per beam
            byte[] velData = new byte[42];

            velData[0] = Pd0Velocity.ID_LSB;
            velData[1] = Pd0Velocity.ID_MSB;
            velData[2] = 0xE8;                                   // DS0 Beam 0 LSB
            velData[3] = 0x00;                                   // DS0 Beam 0 MSB
            velData[4] = 0xBD;                                   // DS0 Beam 1 LSB
            velData[5] = 0xFE;                                   // DS0 Beam 1 MSB
            velData[6] = 0xC8;                                   // DS0 Beam 2 LSB
            velData[7] = 0x01;                                   // DS0 Beam 2 MSB
            velData[8] = 0x72;                                   // DS0 Beam 3 LSB
            velData[9] = 0xFD;                                   // DS0 Beam 3 MSB

            velData[(4 * 8) + 2 + 0] = 0xD0;                     // DS4 Beam 0 LSB
            velData[(4 * 8) + 2 + 1] = 0x04;                     // DS4 Beam 0 MSB
            velData[(4 * 8) + 2 + 2] = 0xD5;                     // DS4 Beam 1 LSB
            velData[(4 * 8) + 2 + 3] = 0xFA;                     // DS4 Beam 1 MSB
            velData[(4 * 8) + 2 + 4] = 0xB0;                     // DS4 Beam 2 LSB
            velData[(4 * 8) + 2 + 5] = 0x05;                     // DS4 Beam 2 MSB
            velData[(4 * 8) + 2 + 6] = 0x8A;                     // DS4 Beam 3 LSB
            velData[(4 * 8) + 2 + 7] = 0xF9;                     // DS4 Beam 3 MSB

            vel.Decode(velData);

            #endregion
            pd0.AddDataType(vel);                       // Add Velocity

            #region Percent Good

            Pd0PercentGood pg = new Pd0PercentGood();

            // 2 Byte Header
            // 4 Bytes per depth cell
            // 4 Beams per depth cell
            // 2 Bytes per beam
            byte[] pgData = new byte[22];

            pgData[0] = Pd0PercentGood.ID_LSB;
            pgData[1] = Pd0PercentGood.ID_MSB;
            pgData[2] = 0xE8;                                   // DS0 Beam 0
            pgData[3] = 0x7B;                                   // DS0 Beam 1
            pgData[4] = 0x7A;                                   // DS0 Beam 2
            pgData[5] = 0xDF;                                   // DS0 Beam 3

            pgData[(4 * 4) + 2 + 0] = 0x6F;                     // DS4 Beam 0
            pgData[(4 * 4) + 2 + 1] = 0xDE;                     // DS4 Beam 1
            pgData[(4 * 4) + 2 + 2] = 0x15;                     // DS4 Beam 2
            pgData[(4 * 4) + 2 + 3] = 0x22;                     // DS4 Beam 3


            pg.Decode(pgData);

            #endregion
            pd0.AddDataType(pg);                        // Add Percent Good

            #region Correlation

            Pd0Correlation corr = new Pd0Correlation();

            // 2 Byte Header
            // 4 Bytes per depth cell
            // 4 Beams per depth cell
            // 2 Bytes per beam
            byte[] corrData = new byte[22];

            corrData[0] = Pd0Velocity.ID_LSB;
            corrData[1] = Pd0Velocity.ID_MSB;
            corrData[2] = 0xE8;                                   // DS0 Beam 0
            corrData[3] = 0x7B;                                   // DS0 Beam 1
            corrData[4] = 0x7A;                                   // DS0 Beam 2
            corrData[5] = 0xDF;                                   // DS0 Beam 3

            corrData[(4 * 4) + 2 + 0] = 0x6F;                     // DS4 Beam 0
            corrData[(4 * 4) + 2 + 1] = 0xDE;                     // DS4 Beam 1
            corrData[(4 * 4) + 2 + 2] = 0x15;                     // DS4 Beam 2
            corrData[(4 * 4) + 2 + 3] = 0x22;                     // DS4 Beam 3


            corr.Decode(corrData);

            #endregion
            pd0.AddDataType(corr);                      // Add Correlation

            #region Echo Intensity

            Pd0EchoIntensity ei = new Pd0EchoIntensity();

            // 2 Byte Header
            // 4 Bytes per depth cell
            // 4 Beams per depth cell
            // 2 Bytes per beam
            byte[] eiData = new byte[22];

            eiData[0] = Pd0Velocity.ID_LSB;
            eiData[1] = Pd0Velocity.ID_MSB;
            eiData[2] = 0xE8;                                   // DS0 Beam 0
            eiData[3] = 0x7B;                                   // DS0 Beam 1
            eiData[4] = 0x7A;                                   // DS0 Beam 2
            eiData[5] = 0xDF;                                   // DS0 Beam 3

            eiData[(4 * 4) + 2 + 0] = 0x6F;                     // DS4 Beam 0
            eiData[(4 * 4) + 2 + 1] = 0xDE;                     // DS4 Beam 1
            eiData[(4 * 4) + 2 + 2] = 0x15;                     // DS4 Beam 2
            eiData[(4 * 4) + 2 + 3] = 0x22;                     // DS4 Beam 3


            ei.Decode(eiData);

            #endregion
            pd0.AddDataType(ei);                        // Add Echo Intensity

            #region Bottom Track

            Pd0BottomTrack bt = new Pd0BottomTrack();

            // 2 Byte Header
            // 4 Bytes per depth cell
            // 4 Beams per depth cell
            // 2 Bytes per beam
            byte[] btData = new byte[Pd0BottomTrack.DATATYPE_SIZE];

            bt.Decode(btData);

            #endregion
            pd0.AddDataType(bt);                        // Add Bottom Track

            byte[] data = pd0.Encode();

            // Size
            int size = pd0.FixedLeader.GetDataTypeSize();
            size += pd0.VariableLeader.GetDataTypeSize();
            size += 2;      // Spare
            size += pd0.Header.GetDataTypeSize();
            size += pd0.Velocity.GetDataTypeSize();
            size += pd0.PercentGood.GetDataTypeSize();
            size += pd0.Correlation.GetDataTypeSize();
            size += pd0.EchoIntensity.GetDataTypeSize();
            size += pd0.BottomTrack.GetDataTypeSize();


            Assert.AreEqual(7, pd0.Header.NumberOfDataTypes(), "Number of Data Types is incorrect.");
            Assert.AreEqual(5, pd0.Header.NumberOfDepthCells, "Number of depth cells is incorrect.");
            Assert.AreEqual(size, MathHelper.LsbMsbShort(data[2], data[3]), "Number of Bytes is incorrect.");
            Assert.AreEqual(7, data[5], "Number of Data Types is incorrect.");
            Assert.AreEqual(size + 2, data.Length, "Array Size is incorrect.");     // Add 2 for the checksum

            int flOffset = pd0.Header.GetDataTypeSize();
            Assert.AreEqual(flOffset, MathHelper.LsbMsbShort(data[6], data[7]), "Fixed Leader offset is incorrect.");

            int vlOffset = pd0.Header.GetDataTypeSize() + Pd0FixedLeader.DATATYPE_SIZE;
            Assert.AreEqual(vlOffset, MathHelper.LsbMsbShort(data[8], data[9]), "Variable Leader offset is incorrect.");

            int velOffset = pd0.Header.GetDataTypeSize() + Pd0FixedLeader.DATATYPE_SIZE + Pd0VariableLeader.DATATYPE_SIZE;
            Assert.AreEqual(velOffset, MathHelper.LsbMsbShort(data[10], data[11]), "Velocity offset is incorrect.");

            int pgOffset = pd0.Header.GetDataTypeSize() + Pd0FixedLeader.DATATYPE_SIZE + Pd0VariableLeader.DATATYPE_SIZE + pd0.Velocity.GetDataTypeSize();
            Assert.AreEqual(pgOffset, MathHelper.LsbMsbShort(data[12], data[13]), "Percent Good offset is incorrect.");

            int corrOffset = pd0.Header.GetDataTypeSize() + Pd0FixedLeader.DATATYPE_SIZE + Pd0VariableLeader.DATATYPE_SIZE + pd0.Velocity.GetDataTypeSize() + pd0.PercentGood.GetDataTypeSize();
            Assert.AreEqual(corrOffset, MathHelper.LsbMsbShort(data[14], data[15]), "Correlation offset is incorrect.");

            int eiOffset = pd0.Header.GetDataTypeSize() + Pd0FixedLeader.DATATYPE_SIZE + Pd0VariableLeader.DATATYPE_SIZE + pd0.Velocity.GetDataTypeSize() + pd0.PercentGood.GetDataTypeSize() + pd0.Correlation.GetDataTypeSize();
            Assert.AreEqual(eiOffset, MathHelper.LsbMsbShort(data[16], data[17]), "Echo Intensity offset is incorrect.");

            int btOffset = pd0.Header.GetDataTypeSize() + Pd0FixedLeader.DATATYPE_SIZE + Pd0VariableLeader.DATATYPE_SIZE + pd0.Velocity.GetDataTypeSize() + pd0.PercentGood.GetDataTypeSize() + pd0.Correlation.GetDataTypeSize() + pd0.EchoIntensity.GetDataTypeSize();
            Assert.AreEqual(btOffset, MathHelper.LsbMsbShort(data[18], data[19]), "Bottom Track offset is incorrect.");
        }
예제 #7
0
파일: Pd0Test.cs 프로젝트: 759991469/RTI
        public void TestDecodeVelocityPg()
        {
            PD0 pd0 = new PD0();

            pd0.FixedLeader.NumberOfCells = 5;

            #region Velocity

            Pd0Velocity vel = new Pd0Velocity();
            // 2 Byte Header
            // 8 Bytes per depth cell
            // 4 Beams per depth cell
            // 2 Bytes per beam
            byte[] velData = new byte[42];

            velData[0] = Pd0Velocity.ID_LSB;
            velData[1] = Pd0Velocity.ID_MSB;
            velData[2] = 0xE8;                                   // DS0 Beam 0 LSB
            velData[3] = 0x00;                                   // DS0 Beam 0 MSB
            velData[4] = 0xBD;                                   // DS0 Beam 1 LSB
            velData[5] = 0xFE;                                   // DS0 Beam 1 MSB
            velData[6] = 0xC8;                                   // DS0 Beam 2 LSB
            velData[7] = 0x01;                                   // DS0 Beam 2 MSB
            velData[8] = 0x72;                                   // DS0 Beam 3 LSB
            velData[9] = 0xFD;                                   // DS0 Beam 3 MSB

            velData[(4 * 8) + 2 + 0] = 0xD0;                     // DS4 Beam 0 LSB
            velData[(4 * 8) + 2 + 1] = 0x04;                     // DS4 Beam 0 MSB
            velData[(4 * 8) + 2 + 2] = 0xD5;                     // DS4 Beam 1 LSB
            velData[(4 * 8) + 2 + 3] = 0xFA;                     // DS4 Beam 1 MSB
            velData[(4 * 8) + 2 + 4] = 0xB0;                     // DS4 Beam 2 LSB
            velData[(4 * 8) + 2 + 5] = 0x05;                     // DS4 Beam 2 MSB
            velData[(4 * 8) + 2 + 6] = 0x8A;                     // DS4 Beam 3 LSB
            velData[(4 * 8) + 2 + 7] = 0xF9;                     // DS4 Beam 3 MSB

            vel.Decode(velData);

            #endregion
            pd0.AddDataType(vel);                       // Add Velocity

            #region Percent Good

            Pd0PercentGood pg = new Pd0PercentGood();

            // 2 Byte Header
            // 4 Bytes per depth cell
            // 4 Beams per depth cell
            // 2 Bytes per beam
            byte[] pgData = new byte[22];

            pgData[0] = Pd0PercentGood.ID_LSB;
            pgData[1] = Pd0PercentGood.ID_MSB;
            pgData[2] = 0xE8;                                   // DS0 Beam 0
            pgData[3] = 0x7B;                                   // DS0 Beam 1
            pgData[4] = 0x7A;                                   // DS0 Beam 2
            pgData[5] = 0xDF;                                   // DS0 Beam 3

            pgData[(4 * 4) + 2 + 0] = 0x6F;                     // DS4 Beam 0
            pgData[(4 * 4) + 2 + 1] = 0xDE;                     // DS4 Beam 1
            pgData[(4 * 4) + 2 + 2] = 0x15;                     // DS4 Beam 2
            pgData[(4 * 4) + 2 + 3] = 0x22;                     // DS4 Beam 3


            pg.Decode(pgData);

            #endregion
            pd0.AddDataType(pg);                        // Add Percent Good

            byte[] data = pd0.Encode();

            // Size
            int size = Pd0VariableLeader.DATATYPE_SIZE;
            size += Pd0FixedLeader.DATATYPE_SIZE;
            size += 2;      // Spare
            //size += 2;      // Checksum
            size += pd0.Header.GetDataTypeSize();
            size += pd0.Velocity.GetDataTypeSize();
            size += pd0.PercentGood.GetDataTypeSize();


            Assert.AreEqual(4, pd0.Header.NumberOfDataTypes(), "Number of Data Types is incorrect.");
            Assert.AreEqual(5, pd0.Header.NumberOfDepthCells, "Number of depth cells is incorrect.");
            Assert.AreEqual(size, MathHelper.LsbMsbShort(data[2], data[3]), "Number of Bytes is incorrect.");
            Assert.AreEqual(4, data[5], "Number of Data Types is incorrect.");
            Assert.AreEqual(size + 2, data.Length, "Array Size is incorrect.");     // Add 2 for the checksum

            int flOffset = pd0.Header.GetDataTypeSize();
            Assert.AreEqual(flOffset, MathHelper.LsbMsbShort(data[6], data[7]), "Fixed Leader offset is incorrect.");

            int vlOffset = pd0.Header.GetDataTypeSize() + Pd0FixedLeader.DATATYPE_SIZE;
            Assert.AreEqual(vlOffset, MathHelper.LsbMsbShort(data[8], data[9]), "Variable Leader offset is incorrect.");

            int velOffset = pd0.Header.GetDataTypeSize() + Pd0FixedLeader.DATATYPE_SIZE + Pd0VariableLeader.DATATYPE_SIZE;
            Assert.AreEqual(velOffset, MathHelper.LsbMsbShort(data[10], data[11]), "Velocity offset is incorrect.");

            int pgOffset = pd0.Header.GetDataTypeSize() + Pd0FixedLeader.DATATYPE_SIZE + Pd0VariableLeader.DATATYPE_SIZE + pd0.Velocity.GetDataTypeSize();
            Assert.AreEqual(pgOffset, MathHelper.LsbMsbShort(data[12], data[13]), "Percent Good offset is incorrect.");
        }
예제 #8
0
        /// <summary>
        /// Decode the given data into an object.
        /// </summary>
        /// <param name="data">Data to decode.</param>
        /// <param name="numDepthCells">NOT USED.</param>
        /// <param name="numBeams">NOT USED</param>
        public void Decode(byte[] data, int numDepthCells = 0, int numBeams = 4)
        {
            try
            {
                if (data.Length > HEADER_MIN_BYTE)
                {
                    // Ensure the correct data type is given
                    if (data[0] == ID_LSB && data[1] == ID_MSB)
                    {
                        // Number of bytes
                        NumberOfBytes = MathHelper.LsbMsbInt(data[2], data[3]);

                        //DataTypes.Clear();                                  // Clear anything currently stored
                        int numDT    = data[5];                          // Number of Data types
                        int dtOffset = HEADER_MIN_BYTE;                  // Start of the offsets
                        RTI.PD0.CoordinateTransforms xform = RTI.PD0.CoordinateTransforms.Coord_Earth;

                        // Determine the size of each data type.
                        // This will start at the end of the header
                        //int prevOffset = dtOffset + (numDT * SHORT_NUM_BYTE);

                        // Collect each offset
                        for (int x = 0; x < numDT; x++)
                        {
                            // Get the offset and add it to the list
                            byte   lsb    = data[dtOffset];
                            byte   msb    = data[dtOffset + 1];
                            ushort offset = MathHelper.LsbMsbUShort(lsb, msb);

                            if (data.Length > offset)
                            {
                                // Determine the data type
                                byte  lsbID = data[offset];
                                byte  msbID = data[offset + 1];
                                Pd0ID id    = Pd0ID.GetType(lsbID, msbID);

                                // Set the XFORM


                                // Create and add the data type to the ensemble
                                switch (id.Type)
                                {
                                case Pd0ID.Pd0Types.FixedLeader:
                                    // Copy the buffer
                                    byte[] flBuffer = new byte[Pd0FixedLeader.DATATYPE_SIZE];
                                    Buffer.BlockCopy(data, offset, flBuffer, 0, flBuffer.Length);

                                    if (DataTypes.ContainsKey(Pd0ID.Pd0Types.FixedLeader))
                                    {
                                        GetFixedLeader().Decode(flBuffer);
                                        xform = GetFixedLeader().GetCoordinateTransform();
                                    }
                                    else
                                    {
                                        AddDataType(new Pd0FixedLeader(flBuffer, offset));
                                    }

                                    break;

                                case Pd0ID.Pd0Types.VariableLeader:
                                    // Copy the buffer
                                    byte[] vlBuffer = new byte[Pd0VariableLeader.DATATYPE_SIZE];
                                    Buffer.BlockCopy(data, offset, vlBuffer, 0, vlBuffer.Length);

                                    if (DataTypes.ContainsKey(Pd0ID.Pd0Types.VariableLeader))
                                    {
                                        GetVariableLeader().Decode(vlBuffer);
                                    }
                                    else
                                    {
                                        AddDataType(new Pd0VariableLeader(vlBuffer, offset));
                                    }

                                    break;

                                case Pd0ID.Pd0Types.BottomTrack:
                                    // Copy the buffer
                                    byte[] btBuffer = new byte[Pd0BottomTrack.DATATYPE_SIZE];
                                    Buffer.BlockCopy(data, offset, btBuffer, 0, btBuffer.Length);

                                    // Decode the data
                                    if (DataTypes.ContainsKey(Pd0ID.Pd0Types.BottomTrack))
                                    {
                                        GetBottomTrack().Decode(btBuffer, GetFixedLeader().NumberOfBeams);
                                    }
                                    else
                                    {
                                        AddDataType(new Pd0BottomTrack(btBuffer, offset, GetFixedLeader().NumberOfBeams));
                                    }
                                    break;

                                case Pd0ID.Pd0Types.Velocity:
                                    // Copy the buffer
                                    byte[] velBuffer = new byte[Pd0Velocity.GetVelocitySize(GetFixedLeader().NumberOfCells, GetFixedLeader().NumberOfBeams)];
                                    Buffer.BlockCopy(data, offset, velBuffer, 0, velBuffer.Length);

                                    // Decode the data
                                    if (DataTypes.ContainsKey(Pd0ID.Pd0Types.Velocity))
                                    {
                                        GetVelocity().Decode(velBuffer, GetFixedLeader().NumberOfCells, GetFixedLeader().NumberOfBeams);
                                    }
                                    else
                                    {
                                        AddDataType(new Pd0Velocity(velBuffer, offset, GetFixedLeader().NumberOfCells, GetFixedLeader().NumberOfBeams));
                                    }
                                    break;

                                case Pd0ID.Pd0Types.Correlation:
                                    // Copy the buffer
                                    byte[] corrBuffer = new byte[Pd0Correlation.GetCorrelationSize(GetFixedLeader().NumberOfCells, GetFixedLeader().NumberOfBeams)];
                                    Buffer.BlockCopy(data, offset, corrBuffer, 0, corrBuffer.Length);

                                    // Decode the data
                                    if (DataTypes.ContainsKey(Pd0ID.Pd0Types.Correlation))
                                    {
                                        GetCorrelation().Decode(corrBuffer, GetFixedLeader().NumberOfCells, GetFixedLeader().NumberOfBeams);
                                    }
                                    else
                                    {
                                        AddDataType(new Pd0Correlation(corrBuffer, offset, GetFixedLeader().NumberOfCells, GetFixedLeader().NumberOfBeams));
                                    }
                                    break;

                                case Pd0ID.Pd0Types.EchoIntensity:
                                    // Copy the buffer
                                    byte[] eiBuffer = new byte[Pd0EchoIntensity.GetEchoIntensitySize(GetFixedLeader().NumberOfCells, GetFixedLeader().NumberOfBeams)];
                                    Buffer.BlockCopy(data, offset, eiBuffer, 0, eiBuffer.Length);

                                    // Decode the data
                                    if (DataTypes.ContainsKey(Pd0ID.Pd0Types.EchoIntensity))
                                    {
                                        GetEchoIntensity().Decode(eiBuffer, GetFixedLeader().NumberOfCells, GetFixedLeader().NumberOfBeams);
                                    }
                                    else
                                    {
                                        AddDataType(new Pd0EchoIntensity(eiBuffer, offset, GetFixedLeader().NumberOfCells, GetFixedLeader().NumberOfBeams));
                                    }
                                    break;

                                case Pd0ID.Pd0Types.PercentGood:
                                    // Copy the buffer
                                    byte[] pgBuffer = new byte[Pd0PercentGood.GetPercentGoodSize(GetFixedLeader().NumberOfCells, GetFixedLeader().NumberOfBeams)];
                                    Buffer.BlockCopy(data, offset, pgBuffer, 0, pgBuffer.Length);

                                    // Decode the data
                                    if (DataTypes.ContainsKey(Pd0ID.Pd0Types.PercentGood))
                                    {
                                        GetPercentGood().Decode(pgBuffer, GetFixedLeader().NumberOfCells, GetFixedLeader().NumberOfBeams);
                                    }
                                    else
                                    {
                                        AddDataType(new Pd0PercentGood(pgBuffer, offset, GetFixedLeader().NumberOfCells, GetFixedLeader().NumberOfBeams));
                                    }
                                    break;

                                case Pd0ID.Pd0Types.NmeaData:

                                    // Get the Dataset Size
                                    // Get the first 6 bytes to determine the size
                                    // Number of bytes to read for NMEA size
                                    byte[] nmeaSize = new byte[6];
                                    Buffer.BlockCopy(data, offset, nmeaSize, 0, 6);
                                    int nmeaDsSize = Pd0NmeaData.GetNmeaDataSize(nmeaSize);

                                    // Copy the buffer
                                    byte[] nmeaBuffer = new byte[nmeaDsSize];
                                    Buffer.BlockCopy(data, offset, nmeaBuffer, 0, nmeaBuffer.Length);

                                    // Decode the data
                                    if (DataTypes.ContainsKey(Pd0ID.Pd0Types.NmeaData))
                                    {
                                        GetNmeaData().Decode(nmeaBuffer);
                                    }
                                    else
                                    {
                                        AddDataType(new Pd0NmeaData(nmeaBuffer, offset));
                                    }
                                    break;

                                default:
                                    Debug.WriteLine(string.Format("Unknown PD0 ID {0}", id.Type));
                                    break;
                                }
                            }

                            // Move the offset to the next value
                            dtOffset += 2;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                log.Error("Error Decoding PD0 Data. ", ex);
            }
        }