lib/maracasVisuLib/src/interface/wxWindows/Contour/vectorFunctions.cxx

   1 #include "vectorFunctions.h"
   2
   3 //Constructor
   4 vectorFunctions::vectorFunctions()
   5 {
   6 }
   7 //Destructor
   8 vectorFunctions::~vectorFunctions()
   9 {
  10 }
  11
  12 //---------------------------------------------------------------
  13 //Copy Vector1 in Vector2 (double)
  14 void vectorFunctions::copyVector(std::vector<double>*Vector1,std::vector<double>*Vector2)
  15 {
  16         int size = Vector1->size();
  17         Vector2->clear();
  18         int i;
  19         if(size != 0)
  20         {
  21                 for(i=0; i<size; i++)
  22                 {
  23                         Vector2->push_back( (*Vector1)[i] );
  24                 }
  25         }
  26 }
  27 //---------------------------------------------------------------
  28 //Copy Vector1 in Vector2 (int)
  29 void vectorFunctions::copyintVector(std::vector<int>*Vector1,std::vector<int>*Vector2)
  30 {
  31         int size = Vector1->size();
  32         Vector2->clear();
  33         int i;
  34         if(size =! 0)
  35         {
  36                 for(i=0; i<size; i++)
  37                 {
  38                         Vector2->push_back( (*Vector1)[i] );
  39                 }
  40         }
  41 }
  42 //------------------------------------------------------------------------------------------------------------------------------------------
  43 //Print 2 vectors of the same size
  44 void vectorFunctions::printVector(std::vector<double>*Vector1,std::vector<double>*Vector2)
  45 {
  46         int i;
  47         if( Vector1->size() == Vector2->size() )
  48         {
  49                 for(i=0; i<Vector1->size(); i++)
  50                 {
  51                         printf("\n v1(%d) = %f, v2(%d) = %f",i,(*Vector1)[i],i,(*Vector2)[i]);
  52                 }
  53         }
  54 }
  55 //------------------------------------------------------------------------------------------------------------------------------------------
  56 //Returns the average value of the vector
  57 double vectorFunctions::promVector(std::vector<double>*Vector1, bool OnNormal)
  58 {
  59         int i;
  60         double suma = 0,prom;
  61         std::vector<double> tempv;
  62         int size = Vector1->size();
  63         if(size != 0)
  64         {
  65                 if(OnNormal == false)
  66                 {
  67                         for(i=0; i<size; i++)
  68                         {
  69                                 suma = suma + (*Vector1)[i];
  70                         }
  71                         return prom = suma/Vector1->size();
  72                 }
  73                 int pos;
  74                 double maxval;
  75                 copyVector(Vector1,&tempv);
  76                 if(OnNormal == true)
  77                 {
  78                         pos = maxVector(Vector1,&maxval);
  79                         for(i=0; i<size; i++)
  80                         {
  81                                 tempv.push_back((*Vector1)[i]/maxval);
  82                         }
  83                         suma = 0;
  84                         for(i=0; i<tempv.size(); i++)
  85                         {
  86                                 suma = suma + tempv[i];
  87                         }
  88                         return prom = suma/tempv.size();
  89                 }
  90         }
  91         return -1;
  92 }
  93 //------------------------------------------------------------------------------------------------------------------------------------------
  94 //Returns the maximum value of the vector
  95 int vectorFunctions::maxVector(std::vector<double>*Vector1,double *val)
  96 {
  97         int i, pos;
  98         double max = -1;
  99         if(Vector1->size() != 0)
 100         {
 101                 for(i=0; i<Vector1->size(); i++)
 102                 {
 103                         if( (*Vector1)[i]>max )
 104                         {
 105                                 max = (*Vector1)[i];
 106                                 pos = i;
 107                         }
 108                 }
 109                 *val = max;
 110                 return pos;
 111         }
 112         return -1;
 113 }
 114 //------------------------------------------------------------------------------------------------------------------------------------------
 115 //Returns the minimum value of the vector
 116 int vectorFunctions::minVector(std::vector<double>*Vector1,double *val)
 117 {
 118         int i, pos;
 119         double min = 99999;
 120         if(Vector1->size() != 0)
 121         {
 122                 for(i=0; i<Vector1->size(); i++)
 123                 {
 124                         if( (*Vector1)[i]<min )
 125                         {
 126                                 min = (*Vector1)[i];
 127                                 pos = i;
 128                         }
 129                 }
 130                 *val = min;
 131                 return pos;
 132         }
 133         return -1;
 134 }
 135 //------------------------------------------------------------------------------------------------------------------------------------------
 136 //Find the minimal distance between an input point and an input lists of points
 137 int vectorFunctions::nearPoint(std::vector<double>*VectorX, std::vector<double>*VectorY, double px, double py)
 138 {
 139         int i, pos = -1;
 140         double min = 10000, dist;
 141         if(VectorX->size() != 0)
 142         {
 143                 for(i=0; i<VectorX->size(); i++)
 144                 {
 145                         dist = sqrt(pow(px-(*VectorX)[i],2) + pow(py-(*VectorY)[i],2));
 146                         if(dist<min)
 147                         {
 148                                 min = dist;
 149                                 pos = i;
 150                         }
 151                 }
 152                 return pos;
 153         }
 154         return -1;
 155 }
 156 //------------------------------------------------------------------------------------------------------------------------------------------
 157 //Returns the position of the point in the lsts. (Aprox. + or - 1).
 158 int vectorFunctions::findPointInLst(std::vector<double>*vecX, std::vector<double>*vecY, std::vector<double>*vecZ,
 159                                                                         double x, double y, double z)
 160 {
 161         int i,flag = -1;
 162         double apr = 1.5;
 163         if(vecX->size() != 0)
 164         {
 165                 for(i=0; i<vecX->size(); i++)
 166                 {
 167                         if( ((*vecX)[i]-apr <= x)&&(x <=(*vecX)[i]+apr)&&((*vecY)[i]-apr <= y)&&(y <=(*vecY)[i]+apr)&&((*vecZ)[i]-apr <= z)&&(z <=(*vecZ)[i]+apr) )
 168                         {
 169                                 flag = i;
 170                                 return i;
 171                         }
 172                 }
 173                 return flag;
 174         }
 175         return -1;
 176 }