C:/Active/libraries/cxutils/2.0/src/cxutils/images/image.cpp

Go to the documentation of this file.

#include "cxutils/images/image.h"
#include "cxutils/fileio.h"
#include <assert.h>
#include <string.h>
#include <cstdio>

using namespace CxUtils;

Image::Image()
{
    mpImage = NULL;
    mDataSize = 0;
    mWidth = 0;
    mHeight = 0;
    mChannels = 0;
}

Image::Image(const Image& img)
{
    mpImage = NULL;
    mDataSize = 0;
    mWidth = 0;
    mHeight = 0;
    mChannels = 0;
    *this = img;
}


Image::~Image()
{
    Destroy();
}


int Image::Create(const unsigned short width,
                  const unsigned short height,
                  const unsigned char channels,
                  const unsigned char* rawImage,
                  const bool verticalFlip)
{
    if(width == 0 || height == 0 || !(channels == 1 || channels == 3 || channels == 4) )
    {
        return 0;
    }

    if (mHeight != height || mWidth != width || mChannels != channels)
    {
        Destroy();
        mHeight = height;
        mWidth = width;
        mChannels = channels;
        mDataSize = mHeight*mWidth*mChannels*sizeof(unsigned char);
        mpImage = new unsigned char[mDataSize + 100];
        assert(mpImage);
    }

    if (rawImage != NULL)
    {
        if(verticalFlip)
        {
            unsigned int widthStep = width*channels;
            for(unsigned int row1 = 0, row2 = height - 1;
                row1 < height;
                row1++, row2--)
            {
                memcpy(&mpImage[row1*widthStep], &rawImage[row2*widthStep], widthStep);
            }
        }
        else
        {
            memcpy(mpImage, rawImage, mDataSize);
        }
    }

    return 1;
}


int Image::Create(const unsigned short width,
                  const unsigned short height,
                  const unsigned char channels,
                  const unsigned char* rawImage,
                  const double scale,
                  const bool verticalFlip)
{
    // Must have image data.
    if(rawImage == NULL)
    {
        return 0;
    }

    if(scale >=  0.99 && scale <= 1.01)
    {
        return Create(width, height, channels, rawImage, verticalFlip);
    }

    unsigned short newHeight, newWidth;
    double magnitude;
    newHeight = (unsigned short)(height*scale);
    newWidth = (unsigned short)(width*scale);

    if(newHeight == 0 || newWidth == 0) { return 0; }

    if(scale < 1.0)
    {
        magnitude = (double)(height)/newHeight;
    }
    else
    {
        magnitude = (double)(newHeight)/height;
    }

    // Allocate memory.
    Create(newWidth, newHeight, channels, NULL, false);
    unsigned short x, y;
    if(scale < 1) // Sub sample image
    {
        for(unsigned short i = 0; i < newHeight; i++)
        {
            if(verticalFlip)
            {
                y = (unsigned short)((newHeight - i - 1)*magnitude);
            }
            else
            {
                y = (unsigned short)(i*magnitude);
            }
            for(unsigned short j = 0; j < newWidth; j++)
            {
                if(channels == 1)
                {
                    x = (unsigned short)(j*magnitude);
                    mpImage[i*newWidth + j] = rawImage[y*width + x];
                }
                else if(channels == 3)
                {
                    x = (unsigned short)(j*magnitude);
                    mpImage[i*newWidth*3 + j*3] = rawImage[y*width*3 + x*3];
                    mpImage[i*newWidth*3 + j*3 + 1] = rawImage[y*width*3 + x*3 + 1];
                    mpImage[i*newWidth*3 + j*3 + 2] = rawImage[y*width*3 + x*3 + 2];
                }
                else
                {
                    x = (unsigned short)(j*magnitude);
                    for(unsigned short k = 0; k < channels; k++)
                    {
                        mpImage[i*newWidth*channels + j*channels + k] = rawImage[y*width*channels + x*channels + k];
                    }
                }
            }
        }
    }
    else          // Enlarge image.
    {
        for(unsigned short i = 0; i < height; i++)
        {
            if(verticalFlip)
            {
                y = (height - i - 1);
            }
            else
            {
                y = i;
            }
            for(unsigned short j = 0; j < width; j++)
            {
                // Copy the pixel multiple times based on how much larger
                    // it needs to be.
                for(unsigned short m = (unsigned short)(i*magnitude); m < (unsigned short)((i+1)*magnitude); m++)
                {
                    for(unsigned short n = (unsigned short)(j*magnitude); n < (unsigned short)((j+1)*magnitude); n++)
                    {
                        if(channels == 1)
                        {
                            mpImage[m*newWidth + n] = rawImage[y*width + j];
                        }
                        else if(channels == 3)
                        {
                            mpImage[m*newWidth*3 + n*3] = rawImage[y*width*3 + j*3];
                            mpImage[m*newWidth*3 + n*3 + 1] = rawImage[y*width*3 + j*3 + 1];
                            mpImage[m*newWidth*3 + n*3 + 2] = rawImage[y*width*3 + j*3 + 2];
                        }
                        else
                        {
                            for(unsigned short k = 0; k < channels; k++)
                            {
                                mpImage[m*newWidth*channels + n*channels + k] = rawImage[y*width*channels + j*channels + k];
                            }
                        }
                    }
                }
            }
        }
    }
    return 1;
}


int Image::Create(const unsigned short width,
                  const unsigned short height,
                  const unsigned char channels,
                  const unsigned char* rawImage,
                  const unsigned short maxWidth,
                  const unsigned short maxHeight,
                  const bool verticalFlip)
{
    Image temp;
    // Find out how much to scaled image to fit scaled Width or Height.
    double scaleFactor1 = 1.0, scaleFactor2 = 1.0;

    if(maxWidth == 0 || maxHeight == 0)
    {
        return Create(width, height, channels, rawImage, verticalFlip);
    }

    if(maxWidth > width && maxHeight > height)
    {
        return 0;
    }
    scaleFactor1 = (double)(maxWidth)/width;
    scaleFactor2 = (double)(maxHeight)/height;
    if(scaleFactor2 < scaleFactor1)
    {
        scaleFactor1 = scaleFactor2;
    }

    if(temp.Create(width, height, channels, rawImage, scaleFactor1, verticalFlip) == 0)
    {
        return 0;
    }

    // Now copy the data internally, but make it fit in the center.
    Create(maxWidth, maxHeight, channels, NULL, false);
    memset(mpImage, 0, maxWidth*maxHeight*channels*sizeof(unsigned char));
    unsigned char* ptr1, *ptr2;
    int startRow, startCol;
    ptr1 = mpImage;
    ptr2 = temp.mpImage;

    // Calculate where to start copying the scaled image into the
    // width/height contrained image.
    startRow = ((int)(maxHeight) - 1)/2 - ((int)(temp.mHeight) - 1)/2;
    startCol = ((int)(maxWidth) - 1)/2 - ((int)(temp.mWidth) - 1)/2;
    if(startRow < 0)
        startRow = 0;
    if(startCol < 0)
        startCol = 0;

    for(int i = startRow, m = 0; i < maxHeight && m < temp.mHeight; i++, m++)
    {
        for(int j = startCol, n = 0; j < maxWidth && n < temp.mWidth; j++, n++)
        {
            if(channels == 1)
            {
                mpImage[i*maxWidth*channels + j*channels] = temp.mpImage[m*temp.mWidth*channels + n*channels];
            }
            else if(channels == 3)
            {
                mpImage[i*maxWidth*channels + j*channels] = temp.mpImage[m*temp.mWidth*channels + n*channels];
                mpImage[i*maxWidth*channels + j*channels + 1] = temp.mpImage[m*temp.mWidth*channels + n*channels + 1];
                mpImage[i*maxWidth*channels + j*channels + 2] = temp.mpImage[m*temp.mWidth*channels + n*channels + 2];
            }
            else
            {
                for(int k = 0; k < channels; k++)
                {
                    mpImage[i*maxWidth*channels + j*channels + k] = temp.mpImage[m*temp.mWidth*channels + n*channels + k];
                }
            }
        }
    }
    return 1;
}



int Image::Compress(unsigned char** buffer,
                    unsigned int* len,
                    unsigned int* clen,
                    const Format format,
                    void* args) const
{
    return Compress(mpImage, mWidth, mHeight, mChannels, buffer, len, clen, format, args);
}


int Image::Compress(unsigned char* image,
                    unsigned int width,
                    unsigned int height,
                    unsigned char channels,
                    unsigned char** buffer,
                    unsigned int* len,
                    unsigned int* clen,
                    const Format format,
                    void* args)
{
    int result = 0;

    switch (format)
    {
    case PNG:
        result = PNG::CompressImage(width, height, channels, image, buffer, len, clen);
        break;
    case JPEG:
        {
            int quality = -1;
            if(args)
            {
                quality = *((int *)(args));
            }
            result = JPEG::CompressImage(width, height, channels, image, buffer, len, clen, quality);
        }
        break;
    case MJPEG:
        {
            int quality = -1;
            if(args)
            {
                quality = *((int *)(args));
            }
            result = JPEG::CompressImage(width, height, channels, image, buffer, len, clen, quality);
        }
        break;
    default:
        result = 0;
        break;
    }

    return 1;
}


int Image::Decompress(const unsigned char* compressed,
                      const unsigned int len,
                      const Format format)
{
    int result = 0;

    switch (format)
    {
    case PNG:
        result = PNG::DecompressImage(compressed, len, &mpImage, &mWidth, &mHeight, &mChannels);
        break;
    case JPEG:
        result = JPEG::DecompressImage(compressed, len, &mpImage, &mWidth, &mHeight, &mChannels);
        break;
    case MJPEG:
        result = JPEG::DecompressImage(compressed, len, &mpImage, &mWidth, &mHeight, &mChannels);
        break;
    default:
        result = 0;
        break;
    }

    return result;
}


int Image::Destroy()
{
    if( mpImage )
    {
        delete[] mpImage;
        mpImage = NULL;
    }
    mDataSize = 0;
    mWidth = 0;
    mHeight = 0;
    mChannels = 0;
    return 1;
}


int Image::Save(const std::string& file) const
{
    int result = 0;
    FILE *fp = NULL;
    Format format = GetFormat(file);
    unsigned char *buffer = NULL;
    unsigned len = 0;
    unsigned int clen = 0;

    if( format == Invalid )
    {
        return 0;
    }
    int quality = 100;
    if( Compress(&buffer, &len, &clen, format, &quality ) )
    {
        fp = fopen( file.c_str() , "wb");
        if( fp && fwrite(buffer, clen, 1, fp) )
        {
            result = 1;
        }
    }

    if(fp)
    {
        fclose(fp);
        if(result == 0)
        {
            FileIO::DeleteFiles(file);
        }
    }
    if( buffer )
        delete[] buffer;

    return result;
}


int Image::SaveCompressedImage(const std::string& name,
                               const unsigned char* data,
                               const unsigned int size,
                               const Format format)
{
    int result = 0;
    FILE *fp = NULL;
    
    std::string file = name;
    switch(format)
    {
    case JPEG:
        file += ".jpg";
        break;
    case PNG:
        file += ".png";
        break;
    case MJPEG:
        file += ".jpg";
        break;
    case BMP:
        file += ".bmp";
        break;
    case TIFF:
        file += ".tiff";
        break;
    case GIF:
        file += ".gif";
        break;
    case PPM:
        file += ".ppm";
        break;
    case PGM:
        file += ".pgm";
        break;
    default:
        file += ".jpg";
        break;
    };

    if( data && size > 0 )
    {
        fp = fopen( file.c_str() , "w+b");
        if( fp && fwrite(data, size, 1, fp) )
        {
            result = 1;
        }
    }

    if(fp)
    {
        fclose(fp);
        if(result == 0)
        {
            FileIO::DeleteFiles(file);
        }
    }

    return result;
}


void Image::ApplyTile(const Image& tile)
{
    if(tile.mChannels == mChannels && mWidth > 0 && mHeight > 0 && tile.mWidth > 0 && tile.mHeight > 0)
    {
        double w, h;
        w = mWidth*1.0/tile.mWidth;
        h = mHeight*1.0/tile.mHeight;
        for(double r = 0; r < h; r++)
        {
            for(double c = 0; c < w; c++)
            {
                unsigned char* d = tile.mpImage;
                for(unsigned short int i = 0; i < tile.mHeight; i++)
                {
                    for(unsigned short int j = 0; j < tile.mWidth; j++)
                    {
                        unsigned short int xOffset = (unsigned short int)(c*tile.mWidth);
                        unsigned short int yOffset = (unsigned short int)(r*tile.mHeight);
        
                        for(unsigned char ch = 0; ch < mChannels; ch++)
                        {                
                            unsigned int oPosition = (yOffset + i)*mWidth*mChannels + (xOffset + j)*mChannels + ch; 
                            if(oPosition < mDataSize)
                            {
                                mpImage[oPosition] = d[i*tile.mWidth*tile.mChannels + j*tile.mChannels + ch];
                            }
                        }
                        
                    }
                }
            }
        }
    }
}


int Image::Load(const std::string& file)
{
    Format format = GetFormat(file);
    int result = 0;
    unsigned int len = 0;
    unsigned char* buffer = NULL;

    //  Must handle video sequences differently.
    if( format == Invalid)
    {
        //  Add video code in future... maybe.
        return 0;
    }

    FILE *fp = fopen(file.c_str(), "r+b");
    if( fp )
    {
        //  Add up number of bytes in file so
        //  we can read it all in for decompression.
        while( !feof(fp))
        {
            fgetc(fp);
            len++;
        }
        --len;
        if( len > 0 )
        {
            buffer = new unsigned char[len + 1];
            rewind(fp);
            if( fread( buffer, len, 1, fp) )
            {
                result = Decompress(buffer, len, format);
                if(result > 0)
                {
                    mDataSize = mWidth*mHeight*mChannels;
                }
            }
        }
    }
    if(fp)
    {
        fclose(fp);
    }
    if( buffer )
    {
        delete[] buffer;
    }

    return result;
}


Image::Format Image::GetFormat(const std::string& file)
{
    if ( strstr(file.c_str(), ".png") || strstr(file.c_str(), ".PNG")  )
    {
        return PNG;
    }
    else if ( strstr(file.c_str(), ".jpeg") || strstr(file.c_str(),".JPEG") ||
              strstr(file.c_str(), ".JPG")  || strstr(file.c_str(), ".jpg") )
    {
        return JPEG;
    }

    return Invalid;
}


Image& Image::operator=(const Image& img)
{
    if(this != &img)
    {
        if (mHeight != img.mHeight || mWidth != img.mWidth || mChannels != img.mChannels)
        {
            Destroy();
        }
        if (img.mpImage != NULL)
        {
            if(mpImage == NULL)
            {
                Create(img.mWidth, img.mHeight, img.mChannels, img.mpImage);
            }
            else
            {
                memcpy(mpImage, img.mpImage, mDataSize);
            }
        }
    }
    return *this;
}


/*  End of File */