Re: Converting Bitmap into 2D-Array

"Lucress Carol" <incognito.me@gmx.de> ha scritto nel messaggio
news:b8f26056-f07b-43cc-b72d-d4569993f623@s19g2000prg.googlegroups.com...


You may consider a bit useful the following code I developed (more testing
required, but it seems to work on VC++2008):

I defined a simple template class Matrix2D to store 2D matrix data (matrix
elements are stored as 1D array, row-wise); and there is a function
ExtractGrayScaleFromImage, which extracts grayscale values (expressed as
floats) from an input CImage instance; e.g.:

 // CImage img;
 Matrix2D<float> grayScale; // output
 ExtractGrayScaleFromImage( img, grayScale );

The CImage class has easy-to-use methods to get and set a specific pixel
values, etc. (It may be not as fast as GetDIBits, but you can optimize code
later, if you need; it is however more programmer-friendly IMHO than pure
Win32 APIs like GetDIBits.)

<code>

//
// Stores 2D matrix
// (Does bounds-checking in debug builds, using ASSERT macro.)
//
template <typename T>
class Matrix2D
{
public:

    //
    // CONSTRUCTION
    //

    // Constructs an empty matrix
    Matrix2D()
        : _rows(0), _cols(0)
    {
    }

    // Constructs a 2D matrix, with given dimensions
    explicit Matrix2D( int rows, int cols )
        : _rows(rows), _cols(cols)
    {
        // Check parameters
        ASSERT( rows > 0 );
        ASSERT( cols > 0 );

        // Make room in array
        _data.resize( _rows * _cols );
    }

    //
    // ATTRIBUTES
    //

    // Returns number of rows
    int Rows() const
    {
        return _rows;
    }

    // Returns number of columns
    int Columns() const
    {
        return _cols;
    }

    bool IsEmpty() const
    {
        if ( _rows == 0 && _cols == 0)
        {
            ASSERT( _data.empty() );
            return true;
        }
        else
        {
            ASSERT( _rows > 0 && _cols > 0 );
            return false;
        }
    }

    //
    // OPERATIONS
    //

    // Gets item at specified position in matrix
    const T & Get( int row, int col ) const
    {
        ASSERT( IsValidIndex(row, col) );
        return _data[ Get1DIndex( row, col ) ];
    }

    // Sets item value at a specified position in matrix
    void Set( int row, int col, const T & value )
    {
        ASSERT( IsValidIndex(row, col) );
        _data[ Get1DIndex( row, col ) ] = value;
    }

    // Changes matrix size
    void Resize( int rows, int cols )
    {
        ASSERT( rows > 0 && cols > 0 );
        _rows = rows;
        _cols = cols;
        _data.clear();
        _data.resize( _rows * _cols );
    }

    // Makes it an empty matrix
    void Clear()
    {
        _rows = _cols = 0;
        _data.clear();
    }

    // Saves matrix data into 1D vector (row-wise)
    void CopyRowwise( OUT std::vector< T > & v ) const
    {
        v = _data;
    }

    //
    // IMPLEMENTATION
    //
private:

    //
    // DATA MEMBERS
    //

    // 2D data stored as 1D array, row-wise
    std::vector< T > _data;

    // Row count
    int _rows;

    // Column count
    int _cols;

    //
    // HELPER METHODS
    //

    // Checks if (row, col) pair is valid
    bool IsValidIndex( int row, int col ) const
    {
        ASSERT( !IsEmpty() );

        if ( 0 <= row && row < _rows &&
             0 <= col && col < _cols )
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    // Converts from 2D (row, col) to 1D index into array
    int Get1DIndex( int row, int col ) const
    {
        ASSERT( IsValidIndex( row, col ) );

        // Convert from 2D to 1D
        int index = row * _cols + col;

        ASSERT( 0 <= index && index < (int)_data.size() );
        return index;
    }
};

//
// Extracts gray-scale data from an image.
//
void ExtractGrayScaleFromImage(
    IN const CImage & image,
    OUT Matrix2D<float> & grayData )
{
    // Get input image size
    int width = image.GetWidth();
    int height = image.GetHeight();

    // Resize matrix to accommodate new data
    grayData.Resize(height, width);

    // For each pixel in image:
    for ( int row = 0; row < height; row++ )
    {
        for ( int col = 0; col < width; col++ )
        {
            // Get color of current pixel
            COLORREF cr = image.GetPixel( col, row );
            ASSERT( cr != CLR_INVALID );

            // Extract color components (R,G,B)
            BYTE red = GetRValue(cr);
            BYTE green = GetGValue(cr);
            BYTE blue = GetBValue(cr);

            //
            // Convert from RGB to gray scale, using:
            //
            // Y = 0.3*R + 0.59*G + 0.11*B
            //
            float gray = 0.3f*red + 0.59f*green + 0.11f*blue;

            // Store gray value in output matrix
            grayData.Set( row, col, gray );
        }
    }
}

</code>

HTH,
Giovanni