gzImage.h

Go to the documentation of this file.

//******************************************************************************
// File         : gzImage.h
// Module       : gzBase
// Description  : Class definition of the gzImage class
// Author       : Anders Modén      
// Product      : GizmoBase 2.1.1
//      
// Copyright © 2003- Saab Training Systems AB, Sweden
//          
// NOTE:    GizmoBase is a platform abstraction utility layer for C++. It contains 
//          design patterns and C++ solutions for the advanced programmer.
//
//
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  990223  Created file    
//
//******************************************************************************
#ifndef __GZ_IMAGE_H__
#define __GZ_IMAGE_H__

#include "gzBase.h"
#include "gzReference.h"
#include "gzSerialize.h"

#include "gzRGBA.h"
#include "gzObject.h"

enum gzImageChanges
{
    GZ_IMAGE_CHANGE_DATA    =   1<<0    ,
    GZ_IMAGE_CHANGE_FORMAT  =   1<<1    ,
    GZ_IMAGE_CHANGE_ALL     =   GZ_IMAGE_CHANGE_DATA+GZ_IMAGE_CHANGE_FORMAT
};

enum gzImageType
{
    GZ_IMAGE_TYPE_RGB_8         ,
    GZ_IMAGE_TYPE_RGBA_8        ,
    GZ_IMAGE_TYPE_BW_8          ,
    GZ_IMAGE_TYPE_BWA_8         ,
    GZ_IMAGE_TYPE_DEPTHMAP      ,
    GZ_IMAGE_TYPE_BITMAP        ,
    GZ_IMAGE_TYPE_BGRA_5_5_5_1  ,
    GZ_IMAGE_TYPE_BGR_5_6_5     ,
    GZ_IMAGE_TYPE_CUSTOM
};


//******************************************************************************
// Class    : gzImage
//                                  
// Purpose  : -
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  990223  Created 
//                                  
//******************************************************************************
class  gzImage : public gzObject , public gzNameInterface , public gzUpdateIDFeatureInterface
{
public:

    GZ_DECLARE_TYPE_INTERFACE_EXPORT(GZ_BASE_EXPORT);   // typed interface


    GZ_BASE_EXPORT gzImage(const gzString & name=GZ_EMPTY_STRING);
    
    GZ_BASE_EXPORT virtual ~gzImage(){};
    
    // Methods

    GZ_BASE_EXPORT gzVoid   setAlignment(gzUByte alignment);
    GZ_BASE_EXPORT gzVoid   setSwapBytes(gzBool swap);
    GZ_BASE_EXPORT gzVoid   setRowLength(gzUInt rowLength);
    GZ_BASE_EXPORT gzVoid   setSkipRows(gzUInt skiprows);
    GZ_BASE_EXPORT gzVoid   setSkipPixels(gzUInt skippix);
    GZ_BASE_EXPORT gzVoid   setLSBFirst(gzBool lsbfirst);

    GZ_BASE_EXPORT gzVoid   setWidth(gzULong width);

    GZ_BASE_EXPORT gzVoid   setHeight(gzULong height);

    GZ_BASE_EXPORT gzVoid   setSize(gzULong width , gzULong height);

    GZ_BASE_EXPORT gzVoid   setFormat(gzEnum format);
    GZ_BASE_EXPORT gzVoid   setCompressedFormat(gzEnum format);

    GZ_BASE_EXPORT gzVoid   setComponentType(gzEnum type);
    GZ_BASE_EXPORT gzVoid   setComponents(gzUByte components);
    GZ_BASE_EXPORT gzVoid   setBytesPerComponent(gzFloat size);

    GZ_BASE_EXPORT gzBool   isCompressed()          { return m_compressedFormat!=0; }   

    GZ_BASE_EXPORT virtual  gzBool compress(gzEnum compressFormat);
    GZ_BASE_EXPORT virtual  gzBool uncompress();


    GZ_BASE_EXPORT gzUByte  getAlignment()          { return m_alignment;       }
    GZ_BASE_EXPORT gzBool   getSwapBytes()          { return m_swapBytes;       }
    GZ_BASE_EXPORT gzUInt   getRowLength()          { return m_rowLength;       }
    GZ_BASE_EXPORT gzUInt   getSkipRows()           { return m_skipRows;        }
    GZ_BASE_EXPORT gzUInt   getSkipPixels()         { return m_skipPixels;      }
    GZ_BASE_EXPORT gzBool   getLSBFirst()           { return m_lsbFirst;        }
                                                                                
    GZ_BASE_EXPORT gzULong  getWidth()              { return m_width;           }

    GZ_BASE_EXPORT gzULong  getHeight()             { return m_height;          }

    GZ_BASE_EXPORT gzEnum   getFormat()             { return m_format;          }

    GZ_BASE_EXPORT gzEnum   getCompressedFormat()   { return m_compressedFormat;}

    GZ_BASE_EXPORT gzEnum   getComponentType()      { return m_componentType;           }
    GZ_BASE_EXPORT gzUByte  getComponents()         { return m_components;      }
    GZ_BASE_EXPORT gzFloat  getBytesPerComponent()  { return m_bytesPerComponent; }

    GZ_BASE_EXPORT gzImageType  getImageType()      { return m_imageType; }


    GZ_BASE_EXPORT gzImage * reSample(gzULong width , gzULong height , gzImage *template_image=NULL , gzBool sample=TRUE , gzInt sampleWidth=2,gzBool progress=FALSE);


    GZ_BASE_EXPORT gzImage * create(gzImage *template_image=NULL,gzRGBASwizzle swizzle=GZ_MAP_RGBA_TO_RGBA , gzFloat R_factor =GZ_FLOAT_ONE, gzFloat G_factor =GZ_FLOAT_ONE, gzFloat B_factor =GZ_FLOAT_ONE, gzFloat A_factor =GZ_FLOAT_ONE , gzFloat C_value=GZ_FLOAT_ONE); 


    GZ_BASE_EXPORT gzVoid copyFrom(gzImage *image,gzRGBASwizzle swizzle=GZ_MAP_RGBA_TO_RGBA , gzFloat R_factor =GZ_FLOAT_ONE, gzFloat G_factor =GZ_FLOAT_ONE, gzFloat B_factor =GZ_FLOAT_ONE, gzFloat A_factor =GZ_FLOAT_ONE , gzFloat C_value=GZ_FLOAT_ONE);

    // Utility methods to manage image contents

    GZ_BASE_EXPORT  gzVoid  invert();

    GZ_BASE_EXPORT  gzVoid  toGray();
    GZ_BASE_EXPORT  gzVoid  alphaMask(gzDouble level); 
    GZ_BASE_EXPORT  gzVoid  alphaMask(gzRGBA mask); // Only mask for RGB values
    
    GZ_BASE_EXPORT  gzVoid  flipVertical();

    GZ_BASE_EXPORT  gzVoid  flipHorizontal();


    // Alpha checking utilites

    GZ_BASE_EXPORT gzBool   hasSignificantAlpha(gzBool evaluateDDS =FALSE); 


    GZ_BASE_EXPORT gzBool   hasContiniousAlpha(gzBool evaluateDDS =FALSE,gzFloat minMaxDiff=0.05);  
    
    // Commonn access methods
    GZ_BASE_EXPORT virtual gzBool  hasAlphaComponent();         

    GZ_BASE_EXPORT virtual gzULong getRowSize(gzULong width);   
    
    GZ_BASE_EXPORT virtual gzULong getArraySize(gzULong width=0 , gzULong height=0 );   

    GZ_BASE_EXPORT virtual gzRGBA  getPixel(gzULong width , gzULong height );

    GZ_BASE_EXPORT virtual gzVoid  setPixel(gzULong width , gzULong height , const gzRGBA &value);


    GZ_BASE_EXPORT gzDynamicArray<gzUByte> &    getArray()      { return m_data; }
    GZ_BASE_EXPORT gzDynamicArray<gzUByte> &    createArray(gzBool clearData=FALSE);    // Based on width and height etc.
    GZ_BASE_EXPORT gzVoid           setArray(const gzDynamicArray<gzUByte> &array);
    GZ_BASE_EXPORT gzBool           hasCreatedArray()           { return m_hasCreatedArray; }
    GZ_BASE_EXPORT gzVoid           setCreatedArray(gzBool on)  { m_hasCreatedArray=on; }

    GZ_BASE_EXPORT virtual gzImage *cloneImageType() const;
    GZ_BASE_EXPORT virtual gzReference *clone() const;  

    // Sub Images (mipmaps,animations etc.)

    GZ_BASE_EXPORT gzBool   hasSubImage();

    GZ_BASE_EXPORT gzULong  getNumberOfSubImages();

    GZ_BASE_EXPORT gzImage *getSubImage(gzULong index);

    GZ_BASE_EXPORT gzRefList<gzImage> &getSubImageList();


    GZ_BASE_EXPORT gzVoid   addSubImage(gzImage *image,gzLong index = -1);

    GZ_BASE_EXPORT gzVoid   removeSubImage(gzImage *image);

    GZ_BASE_EXPORT gzVoid   removeAllSubImages();

    // ---- Serializing --------------------------------

    GZ_BASE_EXPORT virtual gzVoid write(gzSerializeAdapter *adapter);

    GZ_BASE_EXPORT virtual gzVoid read(gzSerializeAdapter *adapter);

    GZ_BASE_EXPORT virtual gzULong  getDataSize(gzSerializeAdapter *adapter=NULL) const;

    // Image templates


    GZ_BASE_EXPORT static gzImage *createImage(gzImageType type , const gzString & name=GZ_EMPTY_STRING);


protected:

    GZ_BASE_EXPORT gzFloat  sampleFunction(gzFloat x);
    GZ_BASE_EXPORT gzVoid   setImageType(gzImageType type);


    gzDynamicArray<gzUByte>             m_data;
                                        
    gzUInt                              m_rowLength;
    gzUInt                              m_skipRows;
    gzUInt                              m_skipPixels;
                                        
    gzULong                             m_width;
    gzULong                             m_height;
    gzEnum                              m_format;
    gzEnum                              m_compressedFormat;
    gzEnum                              m_componentType;
    gzImageType                         m_imageType;
                                        
    gzULong                             m_calculatedRowSize;
                                        
    gzUByte                             m_components;
    gzUByte                             m_alignment;
    gzFloat                             m_bytesPerComponent;
                                        
    gzBool                              m_hasCreatedArray:1;
    gzBool                              m_hasCalculatedRowSize:1;
    gzBool                              m_lsbFirst:1;
    gzBool                              m_swapBytes:1;
    
    gzLateBindData<gzRefList<gzImage> > m_subImageList;
};

// Declare smart pointer type
GZ_DECLARE_REFPTR(gzImage);

#define GZ_EVALUATE_EXTENSION ("<*!*>")

// !Image loader flags
#define GZ_IMAGE_FLAG_NUM(x)    (gzSerializeAdapterFlags)(1<<( x+GZ_SERIALIZE_ADAPTER_FLAG_MAX_SIZE))

const gzSerializeAdapterFlags   GZ_IMAGE_FLAGS_DEFAULT                      =   (gzSerializeAdapterFlags)0;

const gzSerializeAdapterFlags   GZ_IMAGE_FLAGS_FLIP_DDS_IMAGES              =   GZ_IMAGE_FLAG_NUM(0);

const gzSerializeAdapterFlags   GZ_IMAGE_FLAGS_NO_CACHED_IMAGE              =   GZ_IMAGE_FLAG_NUM(1);

const gzSerializeAdapterFlags   GZ_IMAGE_FLAGS_NO_ALTERNATE_IMAGE_EXT       =   GZ_IMAGE_FLAG_NUM(2);
const gzSerializeAdapterFlags   GZ_IMAGE_FLAGS_IGNORE_IMAGE_MIPMAPS         =   GZ_IMAGE_FLAG_NUM(3);

const gzSerializeAdapterFlags   GZ_IMAGE_FLAGS_NO_DXT1_ALPHA                =   GZ_IMAGE_FLAG_NUM(4);

const gzULongLong GZ_IMAGE_FLAG_MAX_SIZE    =   GZ_SERIALIZE_ADAPTER_FLAG_MAX_SIZE+5;   // Number of flags in image flag set

//******************************************************************************
// Class    : gzImageManager
//                                  
// Purpose  : -
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  990223  Created 
//                                  
//******************************************************************************

class  gzImageManager : public gzReference
{
public:
    GZ_BASE_EXPORT virtual ~gzImageManager(){};

    GZ_BASE_EXPORT static gzVoid    registerManager(gzImageManager *manager);

    GZ_BASE_EXPORT static gzVoid    unregisterManager(gzImageManager *manager);

    GZ_BASE_EXPORT static gzVoid    unregisterManagers();
        
    GZ_BASE_EXPORT static gzImage   *loadImage(const gzString &url , gzString extension=GZ_EVALUATE_EXTENSION , gzSerializeAdapterFlags flags=GZ_IMAGE_FLAGS_DEFAULT , gzULong version=0 , const gzString &password=GZ_EMPTY_STRING);

    GZ_BASE_EXPORT virtual gzImage  *loadImage(gzSerializeAdapter *adapter);

    GZ_BASE_EXPORT static gzBool    saveImage(gzImage *image , const gzString &url , gzString extension=GZ_EVALUATE_EXTENSION , gzSerializeAdapterFlags flags=GZ_IMAGE_FLAGS_DEFAULT , gzULong version=0, const gzString &password=GZ_EMPTY_STRING);

    GZ_BASE_EXPORT virtual gzBool   saveImage(gzImage *image , gzSerializeAdapter *adapter);

    GZ_BASE_EXPORT static gzVoid    clearCachedImages(gzBool leaveShared=TRUE);

    GZ_BASE_EXPORT static gzVoid    updateCachedImage(gzImage *oldImage , gzImage *newImage);

    GZ_BASE_EXPORT static gzVoid    registerImageFactoryObjects();

    GZ_BASE_EXPORT static gzString  getAllExtensions();

    GZ_BASE_EXPORT virtual gzString getExtensions()=0;

    GZ_BASE_EXPORT virtual gzULong  getVersion(const gzString &extension)=0;

protected:

    GZ_BASE_EXPORT virtual gzVoid   registerManager(const gzString &extension);

    static gzRefDict<gzString,gzImageManager> s_registeredImageManagers;

    static gzRefDict<gzString,gzImage>  s_imageCache;

};  
            
#endif

---