comparison data/fft/FFTFileCacheReader.cpp @ 929:59e7fe1b1003 warnfix_no_size_t

Unsigned removals and warning fixes in data/

 {
     if (m_readbuf) delete[] m_readbuf;
     delete m_mfc;
 }
 
-size_t
+int
 FFTFileCacheReader::getWidth() const
 {
     return m_mfc->getWidth();
 }
 
-size_t
+int
 FFTFileCacheReader::getHeight() const
 {
-    size_t mh = m_mfc->getHeight();
+    int mh = m_mfc->getHeight();
     if (mh > m_factorSize) return (mh - m_factorSize) / 2;
     else return 0;
 }
 
 float
-FFTFileCacheReader::getMagnitudeAt(size_t x, size_t y) const
+FFTFileCacheReader::getMagnitudeAt(int x, int y) const
 {
     Profiler profiler("FFTFileCacheReader::getMagnitudeAt", false);
 
     float value = 0.f;
 

 
     return value;
 }
 
 float
-FFTFileCacheReader::getNormalizedMagnitudeAt(size_t x, size_t y) const
+FFTFileCacheReader::getNormalizedMagnitudeAt(int x, int y) const
 {
     float value = 0.f;
 
     switch (m_storageType) {
 
     case FFTCache::Compact:
         value = getFromReadBufCompactUnsigned(x, y * 2) / 65535.0;
         break;
 
-    default:
+    case FFTCache::Rectangular:
+    case FFTCache::Polar:
     {
         float mag = getMagnitudeAt(x, y);
         float factor = getNormalizationFactor(x);
         if (factor != 0) value = mag / factor;
         else value = 0.f;

 
     return value;
 }
 
 float
-FFTFileCacheReader::getMaximumMagnitudeAt(size_t x) const
+FFTFileCacheReader::getMaximumMagnitudeAt(int x) const
 {
     return getNormalizationFactor(x);
 }
 
 float
-FFTFileCacheReader::getPhaseAt(size_t x, size_t y) const
+FFTFileCacheReader::getPhaseAt(int x, int y) const
 {
     float value = 0.f;
     
     switch (m_storageType) {
 

 
     return value;
 }
 
 void
-FFTFileCacheReader::getValuesAt(size_t x, size_t y, float &real, float &imag) const
+FFTFileCacheReader::getValuesAt(int x, int y, float &real, float &imag) const
 {
 //    SVDEBUG << "FFTFileCacheReader::getValuesAt(" << x << "," << y << ")" << endl;
 
     switch (m_storageType) {
 
     case FFTCache::Rectangular:
         real = getFromReadBufStandard(x, y * 2);
         imag = getFromReadBufStandard(x, y * 2 + 1);
         return;
 
-    default:
+    case FFTCache::Compact:
+    case FFTCache::Polar:
         float mag = getMagnitudeAt(x, y);
         float phase = getPhaseAt(x, y);
         real = mag * cosf(phase);
         imag = mag * sinf(phase);
         return;
     }
 }
 
 void
-FFTFileCacheReader::getMagnitudesAt(size_t x, float *values, size_t minbin, size_t count, size_t step) const
+FFTFileCacheReader::getMagnitudesAt(int x, float *values, int minbin, int count, int step) const
 {
     Profiler profiler("FFTFileCacheReader::getMagnitudesAt");
 
     switch (m_storageType) {
 
     case FFTCache::Compact:
-        for (size_t i = 0; i < count; ++i) {
-            size_t y = minbin + i * step;
+        for (int i = 0; i < count; ++i) {
+            int y = minbin + i * step;
             values[i] = (getFromReadBufCompactUnsigned(x, y * 2) / 65535.0)
                 * getNormalizationFactor(x);
         }
         break;
 
     case FFTCache::Rectangular:
     {
         float real, imag;
-        for (size_t i = 0; i < count; ++i) {
-            size_t y = minbin + i * step;
+        for (int i = 0; i < count; ++i) {
+            int y = minbin + i * step;
             real = getFromReadBufStandard(x, y * 2);
             imag = getFromReadBufStandard(x, y * 2 + 1);
             values[i] = sqrtf(real * real + imag * imag);
         }
         break;
     }
 
     case FFTCache::Polar:
-        for (size_t i = 0; i < count; ++i) {
-            size_t y = minbin + i * step;
+        for (int i = 0; i < count; ++i) {
+            int y = minbin + i * step;
             values[i] = getFromReadBufStandard(x, y * 2);
         }
         break;
     }
 }
 
 bool
-FFTFileCacheReader::haveSetColumnAt(size_t x) const
+FFTFileCacheReader::haveSetColumnAt(int x) const
 {
     if (m_readbuf && m_readbufGood &&
         (m_readbufCol == x || (m_readbufWidth > 1 && m_readbufCol+1 == x))) {
 //        SVDEBUG << "FFTFileCacheReader::haveSetColumnAt: short-circuiting; we know about this one" << endl;
         return true;
     }
     return m_mfc->haveSetColumnAt(x);
 }
 
-size_t
-FFTFileCacheReader::getCacheSize(size_t width, size_t height,
+int
+FFTFileCacheReader::getCacheSize(int width, int height,
                                  FFTCache::StorageType type)
 {
     return (height * 2 + (type == FFTCache::Compact ? 2 : 1)) * width *
         (type == FFTCache::Compact ? sizeof(uint16_t) : sizeof(float)) +
-        2 * sizeof(size_t); // matrix file header size
+        2 * sizeof(int); // matrix file header size
 }
 
 void
-FFTFileCacheReader::populateReadBuf(size_t x) const
+FFTFileCacheReader::populateReadBuf(int x) const
 {
     Profiler profiler("FFTFileCacheReader::populateReadBuf", false);
 
 //    SVDEBUG << "FFTFileCacheReader::populateReadBuf(" << x << ")" << endl;