← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/ginkgocadx/oneiric

« back to all changes in this revision

Viewing changes to src/visualizator/visualizator/estudios/globalmeasurements.h

  • Committer: Bazaar Package Importer
  • Author(s): Andreas Tille
  • Date: 2011-05-02 08:09:26 UTC
  • Revision ID: james.westby@ubuntu.com-20110502080926-bql5wep49c7hg91t
Tags: upstream-2.4.1.1
Import upstream version 2.4.1.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/visualizator/visualizator/estudios/globalmeasurements.h
 
1
 /*  
 
2
 *  $Id: globalmeasurements.h 3699 2011-04-14 13:13:09Z carlos $
 
3
 *  Ginkgo CADx Project
 
4
 *
 
5
 *  Copyright 2008-10 MetaEmotion S.L. All rights reserved.
 
6
 *  http://ginkgo-cadx.com
 
7
 *
 
8
 *  This file is licensed under LGPL v3 license.
 
9
 *  See License.txt for details
 
10
 *
 
11
 *
 
12
 */
 
13
#pragma once
 
14
#include "globalmeasurement.h"
 
15
#include <vector>
 
16
#include <yasper/yasper.h>
 
17
 
 
18
namespace GNKVisualizator {
 
19
        struct Spike
 
20
        {
 
21
                unsigned short Time;
 
22
                unsigned short Amplitude;
 
23
 
 
24
                Spike() {
 
25
                        //Time = MeasurementNoValue;
 
26
                        //Amplitude = GlobalMeasurement::NoAxisValue;
 
27
                }
 
28
        };
 
29
 
 
30
///////////////////////////////////////////////////////////////////
 
31
 
 
32
 
 
33
///////////////////////////////////////////////////////////////////
 
34
        class GlobalMeasurements
 
35
                {
 
36
                public:
 
37
                                
 
38
                        
 
39
                        GlobalMeasurement::TQTcCalcType QTcType;
 
40
                        
 
41
 
 
42
                        GlobalMeasurements();
 
43
 
 
44
                private:
 
45
                        unsigned short _QTc;
 
46
                        unsigned short _VentRate;
 
47
 
 
48
                public:
 
49
                        unsigned short AvgRR;
 
50
                        unsigned short AvgPP;
 
51
                        std::vector<GnkPtr<GlobalMeasurement> > measurment;
 
52
                        std::vector<GnkPtr<Spike> > spike;
 
53
 
 
54
                        
 
55
                                unsigned short getVentRate() 
 
56
                                {
 
57
                                        if (_VentRate < MeasurementNoValue)
 
58
                                                return _VentRate;
 
59
 
 
60
                                        return (unsigned short) ((AvgRR == 0) || (AvgRR == MeasurementNoValue) ? 0 : (60000 / AvgRR));
 
61
                                }
 
62
                                void setVentRate(unsigned short value)
 
63
                                {
 
64
                                        _VentRate = value < MeasurementNoValue ? value : MeasurementNoValue;
 
65
                                }
 
66
                        
 
67
                                unsigned short getPdur()
 
68
                                {
 
69
                                        if (measurment.size() > 0 && measurment[0].IsValid())
 
70
                                                return measurment[0]->Pdur();
 
71
 
 
72
                                        return MeasurementNoValue;
 
73
                                }
 
74
                        
 
75
                                unsigned short getPRint()
 
76
                                {
 
77
                                        if (measurment.size() > 0 && measurment[0].IsValid())
 
78
                                                return measurment[0]->PRint();
 
79
 
 
80
                                        return MeasurementNoValue;
 
81
                                }
 
82
                        
 
83
                                unsigned short getQRSdur()
 
84
                                {
 
85
                                        if (measurment.size() > 0 && measurment[0].IsValid())
 
86
                                                return measurment[0]->QRSdur();
 
87
 
 
88
                                        return MeasurementNoValue;
 
89
                                }
 
90
                        
 
91
                                unsigned short getQTdur()
 
92
                                {
 
93
                                        if (measurment.size() > 0 && measurment[0].IsValid())
 
94
                                                return measurment[0]->QTdur();
 
95
 
 
96
                                        return MeasurementNoValue;
 
97
                                }
 
98
                        
 
99
                                unsigned short  getQTc()
 
100
                                {
 
101
                                        if (_QTc < MeasurementNoValue)
 
102
                                                return _QTc;
 
103
 
 
104
                                        if (measurment.size() > 0 && measurment[0].IsValid()
 
105
                                                &&      (AvgRR != MeasurementNoValue))
 
106
                                                return measurment[0]->calcQTc(AvgRR, getVentRate(),(GNKVisualizator::GlobalMeasurement::TQTcCalcType) QTcType);
 
107
 
 
108
                                        return MeasurementNoValue;
 
109
                                }
 
110
                                void setQTc(unsigned short value)
 
111
                                {
 
112
                                        _QTc = value;
 
113
                                }
 
114
                        
 
115
                        
 
116
                                GlobalMeasurement::TQTcCalcType getQTcType()
 
117
                                {
 
118
                                        if (_QTc >= MeasurementNoValue)
 
119
                                                return (GlobalMeasurement::TQTcCalcType) (_QTc - MeasurementNoValue);
 
120
 
 
121
                                        return GlobalMeasurement::Unknown;
 
122
                                }
 
123
                                void setQTcType(GlobalMeasurement::TQTcCalcType value)
 
124
                                {
 
125
                                        if (value != GlobalMeasurement::Unknown)
 
126
                                                _QTc = (unsigned short) (MeasurementNoValue + value);
 
127
                                        else if (_QTc >= MeasurementNoValue)
 
128
                                                _QTc = 0;
 
129
                                }
 
130
                                /*
 
131
                        public GlobalMeasurements Clone()
 
132
                        {
 
133
                                GlobalMeasurements ret = new GlobalMeasurements();
 
134
 
 
135
                                ret._QTc = _QTc;
 
136
                                ret._VentRate = VentRate;
 
137
                                ret.AvgPP = AvgPP;
 
138
                                ret.AvgRR = AvgRR;
 
139
 
 
140
                                if (measurment != null)
 
141
                                {
 
142
                                        ret.measurment = new GlobalMeasurement[measurment.Length];
 
143
                                        for (int i=0;i < measurment.Length;i++)
 
144
                                        {
 
145
                                                ret.measurment[i] = new GlobalMeasurement();
 
146
 
 
147
                                                ret.measurment[i].Ponset = measurment[i].Ponset;
 
148
                                                ret.measurment[i].Poffset = measurment[i].Poffset;
 
149
                                                ret.measurment[i].QRSonset = measurment[i].QRSonset;
 
150
                                                ret.measurment[i].QRSoffset = measurment[i].QRSoffset;
 
151
                                                ret.measurment[i].Toffset = measurment[i].Toffset;
 
152
 
 
153
                                                ret.measurment[i].Paxis = measurment[i].Paxis;
 
154
                                                ret.measurment[i].QRSaxis = measurment[i].QRSaxis;
 
155
                                                ret.measurment[i].Taxis = measurment[i].Taxis;
 
156
                                        }
 
157
                                }
 
158
 
 
159
                                if (spike != null)
 
160
                                {
 
161
                                        ret.spike = new Spike[spike.Length];
 
162
                                        for (int i=0;i < spike.Length;i++)
 
163
                                        {
 
164
                                                ret.spike[i] = new Spike();
 
165
                                                ret.spike[i].Amplitude = spike[i].Amplitude;
 
166
                                                ret.spike[i].Time = spike[i].Time;
 
167
                                        }
 
168
                                }
 
169
 
 
170
                                return ret;
 
171
                        }*/
 
172
                };
 
173
}
 
 
b'\\ No newline at end of file'