2d in progress

Hacene SI HADJ MOHAND
1 parent 2e05aaf7
Showing 1 changed file with 180 additions and 7 deletions Show diff stats
src/ExternLib/DataFiltering/DataFiltering.hh
@@ -49,8 +49,13 @@ namespace AMDA {
             template <typename ElemType>
             class FilteringContainer1D {
             public:
-                  FilteringContainer1D(){
-                  }
+
+                FilteringContainer1D() {
+                }
+
+                virtual ~FilteringContainer1D() {
+                }
+
                 void clean() {
                     _size.clear();
                     _nFilteredPoints.clear();
@@ -84,6 +89,19 @@ namespace AMDA {
             };
  
             template <typename ElemType>
+            class FilteringContainer2D : public FilteringContainer1D<ElemType> {
+            public:
+
+                FilteringContainer2D() {
+                }
+
+                virtual ~FilteringContainer2D() {
+                }
+                std::list<Tab2DData<ElemType> > _2Dvalues;
+
+            };
+
+            template <typename ElemType>
             class DataFiltering : public Operation {
             public:
                 // constructor 
@@ -219,7 +237,7 @@ namespace AMDA {
                 _paramOutput(new ParamDataSpec<std::vector<ElemType> > ()),
                 _factor(factor),
                 _nPoints(nPoints),
-                _container(new FilteringContainer1D<ElemType>()){
+                _container(new FilteringContainer1D<ElemType>()) {
                     _paramDataOutput = _paramOutput;
                 }
  
@@ -237,10 +255,6 @@ namespace AMDA {
                         double crtTime = _paramInput.getTime(_index);
                         std::vector<ElemType> inputElt = _paramInput.get(_index);
  
-                        _paramOutput->pushTime(crtTime);
-                        _paramOutput->getDataList().push_back(inputElt);
-
-
                         // initialiser et remplir container
                         if (*std::min_element(std::begin(_container->_size), std::end(_container->_size)) < _nPoints) {
  
@@ -358,6 +372,165 @@ namespace AMDA {
                  */
                 FilteringContainer1D<ElemType>* _container;
             };
+
+            template <typename ElemType>
+            class DataFiltering2D : public Operation {
+            public:
+
+                DataFiltering2D(Process& pProcess, ParamDataSpec<Tab2DData<ElemType> >& paramInput, double factor = Default::_factor, int nPoints = Default::_nPoints) :
+                Operation(pProcess),
+                _paramInput(paramInput),
+                _paramOutput(new ParamDataSpec<Tab2DData<ElemType> > ()),
+                _factor(factor),
+                _nPoints(nPoints),
+                _container(new FilteringContainer2D<ElemType>()) {
+                    _paramDataOutput = _paramOutput;
+                }
+
+                virtual ~DataFiltering2D() {
+                }
+
+                void write(ParamDataIndexInfo &pParamDataIndexInfo) {
+                    // init container 
+                    int size1 = _paramInput.get(pParamDataIndexInfo._startIndex).getDim1Size();
+                    int size2 = _paramInput.get(pParamDataIndexInfo._startIndex).getDim2Size();
+                    int size = size1*size2;
+                    _container->init(size);
+
+                    for (unsigned int _index = pParamDataIndexInfo._startIndex;
+                            _index < pParamDataIndexInfo._startIndex + pParamDataIndexInfo._nbDataToProcess;
+                            ++_index) {
+                        double crtTime = _paramInput.getTime(_index);
+                        Tab2DData<ElemType> inputElt = _paramInput.get(_index);
+
+                        // initialiser et remplir container
+                        if (*std::min_element(std::begin(_container->_size), std::end(_container->_size)) < _nPoints) {
+
+                            _container->_values.push_back(inputElt);
+                            _container->_times.push_back(crtTime);
+                            for (int i = 0; i < size; i++) {
+                                if (!isNAN(inputElt[i])) {
+                                    _container->_sum[i] += inputElt[i];
+                                    _container->_sumsq[i] += inputElt[i] * inputElt[i];
+                                    _container->_size[i] += 1;
+                                }
+                            }
+                        } else {
+                            for (int i = 0; i < size; i++) {
+                                _container->_ave[i] = (ElemType) _container->_sum[i] / _container->_size[i];
+                                _container->_sig[i] = std::sqrt((_container->_sumsq[i] - _container->_sum[i] * _container->_sum[i] / _container->_size[i]) / _container->_size[i]);
+                            }
+
+                            // filter Elements
+                            for (auto elt2D = _container->_values.begin(); elt2D != _container->_values.end(); ++elt2D) {
+                                int j = 0;
+                                for (auto elt = elt2D->begin(); elt != elt2D->end(); ++elt) {
+                                    j = elt - elt2D->begin();
+                                    int i = 0;
+                                    for (auto it = elt->begin(); it != elt->end(); ++it) {
+                                        i = (it - elt->begin()) * j;
+                                        ElemType crt_val = *it;
+                                        if (isNAN(crt_val)) {
+                                            continue;
+                                        }
+
+                                        if (std::abs(crt_val - _container->_ave[i]) > _factor * _container->_sig[i]) {
+                                            _container->_sum[i] -= crt_val;
+                                            _container->_sumsq[i] -= crt_val*crt_val;
+                                            _container->_size[i] -= 1;
+                                            _container->_nFilteredPoints[i] += 1;
+                                            *it << NotANumber();
+                                        }
+                                    }
+                                }
+                            }
+                            _paramOutput->pushTime(_container->_times.front());
+                            _paramOutput->getDataList().push_back(_container->_values.front());
+                            _container->_values.pop_front();
+                            _container->_times.pop_front();
+                            for (int i = 0; i < size1; i++) {
+                                for (int j = 0; j < size2; j++) {
+                                    if (!isNAN(_container->_values.front()[i][j])) {
+                                        _container->_size[i * j] -= 1;
+                                        _container->_sum[i * j] -= _container->_values.front()[i][j];
+                                        _container->_sumsq[i * j] -= _container->_values.front()[i][j] * _container->_values.front()[i][j];
+                                    }
+                                    if (!isNAN(inputElt[i][j])) {
+                                        _container->_sum[i * j] += inputElt[i * j];
+                                        _container->_sumsq[i * j] += inputElt[i][j] * inputElt[i][j];
+                                        _container->_size[i * j] += 1;
+                                    }
+                                }
+                            }
+                            _container->_values.push_back(inputElt);
+                            _container->_times.push_back(crtTime);
+                        }
+                        // last value filter and write
+                        if (_index == pParamDataIndexInfo._startIndex + pParamDataIndexInfo._nbDataToProcess - 1) {
+                            for (int i = 0; i < size; i++) {
+                                _container->_ave[i] = (ElemType) _container->_sum[i] / _container->_size[i];
+                                _container->_sig[i] = std::sqrt((_container->_sumsq[i] - _container->_sum[i] * _container->_sum[i] / _container->_size[i]) / _container->_size[i]);
+                            }
+                            for (auto elt = _container->_values.begin(); elt != _container->_values.end(); ++elt) {
+                                int i;
+                                for (auto it = elt->begin(); it != elt->end(); ++it) {
+                                    i = it - elt->begin();
+                                    ElemType crt_val = *it;
+                                    if (isNAN(crt_val)) {
+                                        continue;
+                                    }
+
+                                    if (std::abs(crt_val - _container->_ave[i]) > _factor * _container->_sig[i]) {
+                                        _container->_sum[i] -= crt_val;
+                                        _container->_sumsq[i] -= crt_val*crt_val;
+                                        _container->_size[i] -= 1;
+                                        _container->_nFilteredPoints[i] += 1;
+                                        *it << NotANumber();
+                                    }
+                                }
+                            }
+
+                            std::list<double>::iterator itTimes = _container->_times.begin();
+                            for (auto elt : _container->_values) {
+                                _paramOutput->pushTime(*itTimes);
+                                _paramOutput->getDataList().push_back(elt);
+                                ++itTimes;
+                            }
+                        }
+
+                    }
+                }
+            private:
+                /*
+                 * input data
+                 */
+
+
+                ParamDataSpec<std::vector<ElemType > >& _paramInput;
+
+                /*
+                 * oupout filtered data 
+                 */
+                ParamDataSpec<std::vector<ElemType> >* _paramOutput;
+
+                /*
+                 * factor in term of sigma used in the filtering   
+                 */
+                double _factor;
+
+                /*
+                 Number of point used in the fitering algorithm
+                 */
+                int _nPoints;
+
+                /*
+                 * Data container used during filtering 
+                 */
+                FilteringContainer2D<ElemType>* _container;
+            };
+
+
+
         }
     }
 }