Image.h

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <vector>
#include <iostream>
#include <fstream>
 
using namespace std;
 
class __declspec(dllexport) WPImage
{
public:
    WPImage         ();
    WPImage         (int width, int height);
    WPImage         (int width, int height, float* image);
    WPImage         (int width, int height, const float* image);
    virtual ~WPImage    ();
 
    int     GetWidth            ()                      const   { return _width; }
    int     GetHeight           ()                      const   { return _height; }
 
    void    GetCharData         (unsigned char* data)   const;
    void    GetShortData        (unsigned short int* data) const;
 
    float   GetThresholdCoeff   ()                      const   { return _thresholdCoeff; }
    void    GetCropIndices      (int &low, int &high)   const   { low = _cropHeightLow; high = _cropHeightHigh; }
 
    void    SetWidth            (int value)             { _width = value; }
    void    SetHeight           (int value)             { _height = value; }
    void    SetWidthAndHeight   (int width, int height) { _width = width;  _height = height; }
    void    SetThresholdCoeff   (float value)           { _thresholdCoeff = value; }
    void    SetCropIndices      (int low, int high)     { _cropHeightLow = low; _cropHeightHigh = high; }
 
    bool    TransposeArray      (const float* src, float* dst, int inWidth, int inHeight) const;
    bool    TransposeArray      (const unsigned short* src, unsigned short* dst, int inWidth, 
                                 int inHeight) const;
    bool    TransposeArray      (const unsigned char* src, unsigned char* dst, int inWidth, 
                                 int inHeight) const;
 
    static  bool    ConvertFloatToUnsignedChar  (const float* inData, unsigned char* outData, 
                                                 int size);
    static  bool    ConvertFloatToUnsignedShort (const float* inData, unsigned short* outData, 
                                                 int size);
 
    template <typename T>
    static  bool    TransposeAnyArray   (T* src, T* dst, int inWidth, int inHeight);
    template <typename T>
    static  bool    TransposeAnyArray   (const T* src, T* dst, int inWidth, int inHeight);
 
    template <typename T>
    static  bool    FlipHorizontal      (T* data, int width, int height);
    template <typename T>
    static  bool    FlipVertical        (T* data, int width, int height);
    template <typename T>
    static  bool    Rotate              (const T* dataIn, T* dataOut, int width, int height, 
                                         unsigned int cw90Multiplier);
 
private:
    void    Init                ();
 
    bool    SmoothImage         (const std::vector<float>& inData, int width, int height, 
                                 int neighbors, std::vector<float>& outData) const;
    bool    ThresholdImage      (const std::vector<float>& inData, std::vector<float>& averagedData, 
                                 float threshold, std::vector<float>& outData) const;
    bool    TakeLogOfImage      (const std::vector<float>& inData, std::vector<float>& outData) const;
    bool    CropImageHeight     (const std::vector<float>& inData, std::vector<float>& outData, 
                                 int topCutoff, int botCutoff) const;
 
    float   GetMinValue         () const;
    float   GetMaxValue         () const;
    float   GetMinValue         (const std::vector<float>& image) const;
    float   GetMaxValue         (const std::vector<float>& image) const;
 
    float   GetMeanOfMaxes      (const std::vector<float>& image, int imageHeight, 
                                 std::vector<float>& rows) const;
    float   GetMeanOfContainer  (const std::vector<float>& container) const;
 
    bool    ReadFile            (string name, vector<float>& outdata);
    bool    WriteFile           (string name, std::vector<signed char>& outData);
 
    virtual bool ThresholdAndScale  (const std::vector<float>& inData, 
                                     std::vector<float>& outData) const;
    virtual bool NormalizeFor8Bit   (const std::vector<float>& intensityData, 
                                     std::vector<unsigned char>&  outData) const;
 
    static  float   GetMinValue         (const float* data, int size);
    static  float   GetMaxValue         (const float* data, int size);
 
    static  bool    NormalizeFor8Bit    (const float* inData, unsigned char* outData, int size);
    static  bool    NormalizeFor16Bit   (const float* inData, unsigned short int* outData, int size);
 
    int             _width;
    int             _height;
 
    int             _cropHeightLow, _cropHeightHigh; 
    int             _topCutoffHeight;
    int             _botCutoffHeight;
 
    float           _thresholdCoeff;
    const float*    _floatData;
 
};
 
// Implementation
 
template <typename T>
bool WPImage::FlipHorizontal(T* data, int width, int height)
{
    if (data == nullptr || width <= 0 || height <= 0) return false;
 
    bool result = false;
    T temp = 0;
 
    try
    {
        for (int y = 0; y < height; y++)
        {
            int rowStart = y * width;
            for (int x = 0; x < width / 2; x++)
            {
                temp = data[rowStart + x];
                data[rowStart + x] = data[rowStart + width - 1 - x];
                data[rowStart + width - 1 - x] = temp;
            }
        }
    }
    catch (exception&)
    {
    }
 
    return result;
}
 
template <typename T>
bool WPImage::FlipVertical(T* data, int width, int height)
{
    if (data == nullptr || width <= 0 || height <= 0) return false;
 
    bool result = false;
    T temp = 0;
 
    try
    {
        for (int y = 0; y < height / 2; y++)
        {
            int rowStartTop = y * width;
            int rowStartBot = (height - 1 - y) * width;
            for (int x = 0; x < width; x++)
            {
                temp = data[rowStartTop + x];
                data[rowStartTop + x] = data[rowStartBot + x];
                data[rowStartBot + x] = temp;
            }
        }
    }
    catch (exception&)
    {
    }
    return result;
}
 
template <typename T>
bool WPImage::Rotate(const T* dataIn, T* dataOut, int width, int height, unsigned int cw90Multiplier)
{
    if (dataIn == nullptr || dataOut == nullptr || width <= 0 || height <= 0) return false;
 
    bool result = false;
    int i = 0;
    cw90Multiplier %= 4;
    try
    {
        // 90 degrees CW rotation.
        if (cw90Multiplier == 1)
        {
            for (int x = 0; x < width; x++)
            {
                for (int y = height - 1; y >= 0; y--)
                {
                    dataOut[i++] = dataIn[y * width + x];
                }
            }
        }
        // Else, 270 (-90).
        else if (cw90Multiplier == 3)
        {
            for (int x = 0; x < width; x++)
            {
                for (int y = 0; y < height; y++)
                {
                    dataOut[i++] = dataIn[width - 1 - x + y * width];
                }
            }
        }
        // Else, 180
        else if (cw90Multiplier == 2)
        {
            for (int y = 0; y < height; y++)
            {
                for (int x = 0; x < width; x++)
                {
                    dataOut[i++] = dataIn[(height - 1 - y) * width + width - 1 - x];
                }
            }
        }
        // Else, 0.
        else 
        {
            for (int x = 0; x < width * height; x++)
            {
                dataOut[x] = dataIn[x];
            }
        }
        result = true;
    }
    catch (exception&)
    {
    }
 
    return result;
}
 
template <typename T>
bool WPImage::TransposeAnyArray(T* src, T* dst, int inWidth, int inHeight) 
{
    if (src == nullptr || dst == nullptr || inWidth <= 0 || inHeight <= 0) return false;
 
    bool result = false;
    try
    {
        int startLoc = 0;
        for (int i = 0; i < inWidth; i++)
        {
            startLoc = i * inHeight;
            for (int j = 0; j < inHeight ; j++)
            {
                dst[j * inWidth + i] = src[startLoc + j];
            }
        }
        result = true;
    }
    catch (exception& )
    {
    }
    return result;
}
 
template <typename T>
bool WPImage::TransposeAnyArray(const T* src, T* dst, int inWidth, int inHeight) 
{
    if (src == nullptr || dst == nullptr || inWidth <= 0 || inHeight <= 0) return false;
 
    bool result = false;
    try
    {
        int startLoc = 0;
        for (int i = 0; i < inWidth; i++)
        {
            startLoc = i * inHeight;
            for (int j = 0; j < inHeight; j++)
            {
                dst[j * inWidth + i] = src[startLoc + j];
            }
        }
        result = true;
    }
    catch (exception& )
    {
    }
    return result;
}