Exemplo n.º 1
0
        protected override int _Read(byte[] buffer, int offset)
        {
            _AfterSpikes     = true;
            _AfterSpikesInfo = true;
            _AfterQRSType    = true;
            int end       = offset - Size + Length;
            int frontsize = Marshal.SizeOf(_NrRefTypeQRS) + Marshal.SizeOf(_NrSpikes) + Marshal.SizeOf(_AvgRRInterval) + Marshal.SizeOf(_AvgPPInterval);

            if ((offset + frontsize) > end)
            {
                return(0x1);
            }

            _NrRefTypeQRS  = (byte)BytesTool.readBytes(buffer, offset, Marshal.SizeOf(_NrRefTypeQRS), true);
            offset        += Marshal.SizeOf(_NrRefTypeQRS);
            _NrSpikes      = (byte)BytesTool.readBytes(buffer, offset, Marshal.SizeOf(_NrSpikes), true);
            offset        += Marshal.SizeOf(_NrSpikes);
            _AvgRRInterval = (ushort)BytesTool.readBytes(buffer, offset, Marshal.SizeOf(_AvgRRInterval), true);
            offset        += Marshal.SizeOf(_AvgRRInterval);
            _AvgPPInterval = (ushort)BytesTool.readBytes(buffer, offset, Marshal.SizeOf(_AvgPPInterval), true);
            offset        += Marshal.SizeOf(_AvgPPInterval);

            if (_NrRefTypeQRS > 0)
            {
                if (((offset + (_NrRefTypeQRS * SCPMeasurement.Size)) > end) &&
                    (_NrSpikes == 0))
                {
                    _NrRefTypeQRS = (byte)((end - offset) / SCPMeasurement.Size);
                }

                if ((offset + (_NrRefTypeQRS * SCPMeasurement.Size)) > end)
                {
                    return(0x2);
                }
                else
                {
                    _Measurements = new SCPMeasurement[_NrRefTypeQRS];
                    for (int loper = 0; loper < _NrRefTypeQRS; loper++)
                    {
                        _Measurements[loper] = new SCPMeasurement();
                        _Measurements[loper].Read(buffer, offset);
                        offset += SCPMeasurement.Size;
                    }
                }
            }
            if (_NrSpikes > 0)
            {
                if ((offset + (_NrSpikes * SCPSpike.Size)) > end)
                {
                    return(0x4);
                }
                _Spikes = new SCPSpike[_NrSpikes];
                for (int loper = 0; loper < _NrSpikes; loper++)
                {
                    _Spikes[loper] = new SCPSpike();
                    _Spikes[loper].Read(buffer, offset);
                    offset += SCPSpike.Size;
                }
                if (offset + (_NrSpikes * SCPSpikeInfo.Size) > end)
                {
                    _AfterSpikes     = false;
                    _AfterSpikesInfo = false;
                    _AfterQRSType    = false;
                    return(0x0);
                }
                _SpikesInfo = new SCPSpikeInfo[_NrSpikes];
                for (int loper = 0; loper < _NrSpikes; loper++)
                {
                    _SpikesInfo[loper] = new SCPSpikeInfo();
                    _SpikesInfo[loper].Read(buffer, offset);
                    offset += SCPSpikeInfo.Size;
                }
            }

            if ((offset + Marshal.SizeOf(_NrQRS)) > end)
            {
                _AfterSpikesInfo = false;
                _AfterQRSType    = false;
                return(0x0);
            }

            _NrQRS  = (ushort)BytesTool.readBytes(buffer, offset, Marshal.SizeOf(_NrQRS), true);
            offset += Marshal.SizeOf(_NrQRS);

            if (_NrQRS > 0)
            {
                if ((offset + (_NrQRS * Marshal.SizeOf(typeof(byte)))) > end)
                {
                    return(0x10);
                }
                _QRSType = new byte[_NrQRS];
                for (int loper = 0; loper < _NrQRS; loper++)
                {
                    _QRSType[loper] = (byte)BytesTool.readBytes(buffer, offset, Marshal.SizeOf(_QRSType[loper]), true);
                    offset         += Marshal.SizeOf(_QRSType[loper]);
                }
            }

            int err = _ExtraMeasurements.Read(buffer, offset);

            offset += _ExtraMeasurements.getLength();

            // added an extra byte in check to prevent some errors
            if ((err != 0) ||
                (offset > end + 1))
            {
                _AfterQRSType = false;
                _ExtraMeasurements.Empty();
                return(0x20);
            }

            if ((end - offset) > 0)
            {
                _Rest   = new byte[end - offset];
                offset += BytesTool.copy(_Rest, 0, buffer, offset, _Rest.Length);
            }

            return(0x0);
        }
Exemplo n.º 2
0
        public int setGlobalMeasurements(GlobalMeasurements mes)
        {
            if ((mes != null) &&
                (mes.measurment != null))
            {
                Empty();

                _AvgRRInterval = mes.AvgRR;
                _AvgPPInterval = mes.AvgPP;

                _NrRefTypeQRS = (byte)mes.measurment.Length;
                _Measurements = new SCPMeasurement[_NrRefTypeQRS];
                for (int loper = 0; loper < _NrRefTypeQRS; loper++)
                {
                    _Measurements[loper] = new SCPMeasurement();
                    if (mes.measurment[loper] != null)
                    {
                        _Measurements[loper].Ponset    = mes.measurment[loper].Ponset;
                        _Measurements[loper].Poffset   = mes.measurment[loper].Poffset;
                        _Measurements[loper].QRSonset  = mes.measurment[loper].QRSonset;
                        _Measurements[loper].QRSoffset = mes.measurment[loper].QRSoffset;
                        _Measurements[loper].Toffset   = mes.measurment[loper].Toffset;
                        _Measurements[loper].Paxis     = mes.measurment[loper].Paxis;
                        _Measurements[loper].QRSaxis   = mes.measurment[loper].QRSaxis;
                        _Measurements[loper].Taxis     = mes.measurment[loper].Taxis;
                    }
                }

                _NrSpikes = 0;

                if (mes.spike != null)
                {
                    _NrSpikes   = (byte)mes.spike.Length;
                    _Spikes     = new SCPSpike[_NrSpikes];
                    _SpikesInfo = new SCPSpikeInfo[_NrSpikes];
                    for (int loper = 0; loper < _NrSpikes; loper++)
                    {
                        _Spikes[loper]     = new SCPSpike();
                        _SpikesInfo[loper] = new SCPSpikeInfo();
                        if (mes.spike[loper] != null)
                        {
                            _Spikes[loper].Time      = mes.spike[loper].Time;
                            _Spikes[loper].Amplitude = mes.spike[loper].Amplitude;
                        }
                    }
                }

                _AfterSpikes = true;

                _AfterSpikesInfo = true;

                _NrQRS   = 0;
                _QRSType = null;

                _AfterQRSType = true;

                _ExtraMeasurements          = new SCPExtraMeasurements();
                _ExtraMeasurements.VentRate = mes.VentRate;
                _ExtraMeasurements.QTc      = mes.QTc;

                byte temp = (byte)(mes.QTcType + 1);

                if (temp > 2)
                {
                    temp = 0;
                }

                _ExtraMeasurements.FormulaType = temp;

                return(0);
            }
            return(1);
        }