kImage.h

Go to the documentation of this file.

#ifndef K_API_IMAGE_H
#define K_API_IMAGE_H

#include <kApi/kApiDef.h>
#include <kApi/Data/kImage.x.h>

//typedef kObject kImage; --forward-declared in kApiDef.x.h 

kFx(kStatus) kImage_Construct(kImage* image, kType pixelType, kSize width, kSize height, kAlloc allocator); 

kFx(kStatus) kImage_Import(kImage* image, const kChar* fileName, kAlloc allocator); 

kFx(kStatus) kImage_Export(kImage image, const kChar* fileName); 

kFx(kStatus) kImage_Allocate(kImage image, kType pixelType, kSize width, kSize height); 

kFx(kStatus) kImage_Attach(kImage image, void* pixels, kType pixelType, kSize width, kSize height, kSize stride); 

#define kImage_AttachT(kImage_image, TPtr_pixels, kType_pixelType, kSize_width, kSize_height, kSize_stride) \
    xkImage_AttachT(kImage_image, TPtr_pixels, kType_pixelType, kSize_width, kSize_height, kSize_stride, sizeof(*TPtr_pixels))

kFx(kStatus) kImage_Assign(kImage image, kImage source); 

kFx(kStatus) kImage_Zero(kImage image); 

kInlineFx(kStatus) kImage_SetPixelFormat(kImage image, kPixelFormat format)
{
    kObj(kImage, image);

    obj->format = format; 

    return kOK; 
}

kInlineFx(kPixelFormat) kImage_PixelFormat(kImage image)
{
    kObj(kImage, image);

    return obj->format;
}

kInlineFx(kStatus) kImage_SetCfa(kImage image, kCfa cfa)
{
    kObj(kImage, image);

    obj->cfa = cfa; 

    return kOK; 
}

kInlineFx(kCfa) kImage_Cfa(kImage image)
{
    kObj(kImage, image);

    return obj->cfa;
}

kFx(kStatus) kImage_SetPixel(kImage image, kSize x, kSize y, const void* pixel); 

#define kImage_SetPixelT(kImage_image, kSize_x, kSize_y, TPtr_pixel) \
    xkImage_SetPixelT(kImage_image, kSize_x, kSize_y, TPtr_pixel, sizeof(*TPtr_pixel))

kFx(kStatus) kImage_Pixel(kImage image, kSize x, kSize y, void* pixel); 

#define kImage_PixelT(kImage_image, kSize_x, kSize_y, TPtr_pixel) \
    xkImage_PixelT(kImage_image, kSize_x, kSize_y, TPtr_pixel, sizeof(*TPtr_pixel))

#define kImage_SetAsT(kImage_image, kSize_x, kSize_y, T_value, T) \
    (kPointer_WriteAs(xkImage_AsT(kImage_image, kSize_x, kSize_y, sizeof(T)), T_value, T), (void)0)

#define kImage_AsT(kImage_image, kSize_x, kSize_y, T) \
    kPointer_ReadAs(xkImage_AsT(kImage_image, kSize_x, kSize_y, sizeof(T)), T)

kInlineFx(void*) kImage_Data(kImage image)
{
    kObj(kImage, image);

    return obj->pixels;
}

#define kImage_DataT(kImage_image, T) \
    kCast(T*, xkImage_DataT(kImage_image, sizeof(T)))

kInlineFx(void*) kImage_DataAt(kImage image, kSSize x, kSSize y)
{
    kObj(kImage, image);
    kSSize byteOffset = y*(kSSize)obj->stride + x*(kSSize)obj->pixelSize; 

    return kPointer_ByteOffset(obj->pixels, byteOffset);
}

#define kImage_DataAtT(kImage_image, kSSize_x, kSSize_y, T) \
    kCast(T*, xkImage_DataAtT(kImage_image, kSSize_x, kSSize_y, sizeof(T)))

kInlineFx(kSize) kImage_DataSize(kImage image)
{
    kObj(kImage, image);

    return obj->height * obj->stride;
}

kInlineFx(void*) kImage_At(kImage image, kSize x, kSize y)
{    
#   if !defined(K_FSS_912_DISABLE_BOUNDS_CHECK)
    {
        kAssert(x < kImage_Width(image));
        kAssert(y < kImage_Height(image));
    }
#   endif

    return kImage_DataAt(image, x, y);
}

#define kImage_AtT(kImage_image, kSize_x, kSize_y, T) \
    kCast(T*, xkImage_AtT(kImage_image, kSize_x, kSize_y, sizeof(T)))

kInlineFx(void*) kImage_RowAt(kImage image, kSize y)
{    
#   if !defined(K_FSS_912_DISABLE_BOUNDS_CHECK)
    {
        kAssert(y < kImage_Height(image));
    }
#   endif

    return kImage_DataAt(image, 0, y);
}

#define kImage_RowAtT(kImage_image, kSize_y, T) \
    kCast(T*, xkImage_RowAtT(kImage_image, kSize_y, sizeof(T)))

kInlineFx(kType) kImage_PixelType(kImage image)
{
    kObj(kImage, image); 

    return obj->pixelType;
}

kInlineFx(kSize) kImage_PixelSize(kImage image)
{
    kObj(kImage, image); 

    return obj->pixelSize;
}

kInlineFx(kSize) kImage_Width(kImage image)
{
    kObj(kImage, image); 

    return obj->width;
}

kInlineFx(kSize) kImage_Height(kImage image)
{
    kObj(kImage, image); 

    return obj->height;
}

kInlineFx(kSize) kImage_Area(kImage image)
{
    kObj(kImage, image); 

    return obj->width * obj->height; 
}

kInlineFx(kSize) kImage_Stride(kImage image)
{
    kObj(kImage, image); 

    return obj->stride;
}

#endif