imgblock.c

Go to the documentation of this file.

/*
 * This work is licensed under a Creative Commons 
 * Attribution-Noncommercial-Share Alike 3.0 United States License.
 * 
 *    http://creativecommons.org/licenses/by-nc-sa/3.0/us/
 * 
 * You are free:
 * 
 *    to Share - to copy, distribute, display, and perform the work
 *    to Remix - to make derivative works
 * 
 * Under the following conditions:
 * 
 *    Attribution. You must attribute the work in the manner specified by the
 *    author or licensor (but not in any way that suggests that they endorse you
 *    or your use of the work).
 * 
 *    Noncommercial. You may not use this work for commercial purposes.
 * 
 *    Share Alike. If you alter, transform, or build upon this work, you may
 *    distribute the resulting work only under the same or similar license to
 *    this one.
 * 
 * For any reuse or distribution, you must make clear to others the license
 * terms of this work. The best way to do this is by including this header.
 * 
 * Any of the above conditions can be waived if you get permission from the
 * copyright holder.
 * 
 * Apart from the remix rights granted under this license, nothing in this
 * license impairs or restricts the author's moral rights.
 */


#include <jwsc/config.h>

#include <stdlib.h>
#include <inttypes.h>
#include <math.h>
#include <assert.h>

#include "jwsc/base/error.h"
#include "jwsc/matblock/matblock.h"
#include "jwsc/image/image.h"
#include "jwsc/imgblock/imgblock.h"

#ifdef JWSC_HAVE_DMALLOC
#include <dmalloc.h>
#endif


void create_imgblock_f
(
    Imgblock_f** img_out, 
    uint32_t     num_imgs, 
    uint32_t     num_rows, 
    uint32_t     num_cols
)
{
    uint32_t    i;
    uint32_t    row;
    Pixel_f*    pxls;
    Pixel_f**   row_ptrs;
    Imgblock_f* img;

    assert(num_imgs > 0 && num_rows > 0 && num_cols > 0);

    if (*img_out == NULL)
    {
        assert(*img_out = malloc(sizeof(Imgblock_f)));
        (*img_out)->num_imgs = 0;
        (*img_out)->num_rows = 0;
        (*img_out)->num_cols = 0;
        (*img_out)->pxls     = NULL;
    }
    img = *img_out;

    if (img->num_imgs != num_imgs ||
        img->num_rows != num_rows || 
        img->num_cols != num_cols)
    {
        pxls = (img->num_imgs > 0 && img->num_rows > 0) ? **(img->pxls) : NULL;
        pxls = realloc(pxls, num_imgs*num_rows*num_cols*sizeof(Pixel_f));
        assert(pxls);

        row_ptrs = (img->num_imgs > 0) ? *(img->pxls) : NULL;
        row_ptrs = realloc(row_ptrs, num_imgs*num_rows*sizeof(Pixel_f*));
        assert(row_ptrs);

        img->pxls = realloc(img->pxls, num_imgs*sizeof(Pixel_f**));
        assert(img->pxls);

        for (i = 0; i < num_imgs; i++)
        {
            img->pxls[ i ] = &(row_ptrs[ i*num_rows ]);

            for (row = 0; row < num_rows; row++)
            {
                img->pxls[ i ][ row ] = &(pxls[(row+i*num_rows)*num_cols]);
            }
        }
        img->num_imgs = num_imgs;
        img->num_rows = num_rows;
        img->num_cols = num_cols;
    }
}

void create_init_imgblock_f
(
    Imgblock_f** img_out, 
    uint32_t     num_imgs, 
    uint32_t     num_rows, 
    uint32_t     num_cols,
    Pixel_f      val
)
{
    uint32_t num_pxls;
    uint32_t pxl;
    Pixel_f* img_pxls;

    create_imgblock_f(img_out, num_imgs, num_rows, num_cols);
    img_pxls = **((*img_out)->pxls);
    num_pxls = num_imgs*num_rows*num_cols;

    for (pxl = 0; pxl < num_pxls; pxl++)
    {
        img_pxls[ pxl ] = val;
    }
}

void create_zero_imgblock_f
(
    Imgblock_f** img_out, 
    uint32_t     num_imgs, 
    uint32_t     num_rows, 
    uint32_t     num_cols
)
{
    Pixel_f p = {0};

    create_init_imgblock_f(img_out, num_imgs, num_rows, num_cols, p);
}

void create_random_imgblock_f
(
    Imgblock_f** img_out, 
    uint32_t     num_imgs, 
    uint32_t     num_rows, 
    uint32_t     num_cols,
    Pixel_f      min,
    Pixel_f      max
)
{
    uint32_t num_pxls;
    uint32_t pxl;
    Pixel_f* img_pxls;
    float    x;

    create_imgblock_f(img_out, num_imgs, num_rows, num_cols);
    img_pxls = **((*img_out)->pxls);
    num_pxls = num_imgs*num_rows*num_cols;

    for (pxl = 0; pxl < num_pxls; pxl++)
    {
        x = (float)rand() / (float)RAND_MAX;
        img_pxls[ pxl ].r = min.r + (max.r - min.r)*x;
        x = (float)rand() / (float)RAND_MAX;
        img_pxls[ pxl ].g = min.g + (max.g - min.r)*x;
        x = (float)rand() / (float)RAND_MAX;
        img_pxls[ pxl ].b = min.b + (max.b - min.b)*x;
    }
}

Error* create_imgblock_from_matblocks_f
(
    Imgblock_f**      img_out, 
    const Matblock_f* m_r,
    const Matblock_f* m_g,
    const Matblock_f* m_b
)
{
    uint32_t num_elts;
    uint32_t elt;
    Pixel_f* img_pxls;
    float*   m_r_elts;
    float*   m_g_elts;
    float*   m_b_elts;

    if (m_r->num_mats != m_g->num_mats || m_g->num_mats != m_b->num_mats ||
        m_r->num_rows != m_g->num_rows || m_g->num_rows != m_b->num_rows ||
        m_r->num_cols != m_g->num_cols || m_g->num_cols != m_b->num_cols)
    {
        free_imgblock_f(*img_out); *img_out = NULL;
        return JWSC_EARG("Inconsistent imgblock channel sizes");
    }

    create_imgblock_f(img_out, m_r->num_mats, m_r->num_rows, m_r->num_cols);

    img_pxls = **((*img_out)->pxls);
    m_r_elts = **(m_r->elts);
    m_g_elts = **(m_g->elts);
    m_b_elts = **(m_b->elts);

    num_elts = m_r->num_mats*m_r->num_rows*m_r->num_cols;

    for (elt = 0; elt < num_elts; elt++)
    {
        img_pxls[ elt ].r = m_r_elts[ elt ];
        img_pxls[ elt ].g = m_g_elts[ elt ];
        img_pxls[ elt ].b = m_b_elts[ elt ];
    }

    return NULL;
}

void create_imgblock_from_matblock_f
(
    Imgblock_f**      img_out, 
    const Matblock_f* m
)
{
    create_imgblock_from_matblocks_f(img_out, m, m, m);
}

void create_matblocks_from_imgblock_f
(
    Matblock_f**      m_r_out, 
    Matblock_f**      m_g_out, 
    Matblock_f**      m_b_out, 
    const Imgblock_f* img
)
{
    uint32_t num_elts;
    uint32_t elt;
    Pixel_f* img_pxls;
    float*   m_r_elts;
    float*   m_g_elts;
    float*   m_b_elts;

    create_matblock_f(m_r_out, img->num_imgs, img->num_rows, img->num_cols);
    create_matblock_f(m_g_out, img->num_imgs, img->num_rows, img->num_cols);
    create_matblock_f(m_b_out, img->num_imgs, img->num_rows, img->num_cols);

    m_r_elts = **((*m_r_out)->elts);
    m_g_elts = **((*m_g_out)->elts);
    m_b_elts = **((*m_b_out)->elts);
    img_pxls = **(img->pxls);

    num_elts = img->num_imgs*img->num_rows*img->num_cols;

    for (elt = 0; elt < num_elts; elt++)
    {
        m_r_elts[ elt ] = img_pxls[ elt ].r;
        m_g_elts[ elt ] = img_pxls[ elt ].g;
        m_b_elts[ elt ] = img_pxls[ elt ].b;
    }
}

void create_matblock_from_imgblock_f
(
    Matblock_f**      m_out, 
    const Imgblock_f* img,
    float             r_weight,
    float             g_weight,
    float             b_weight
)
{
    uint32_t num_elts;
    uint32_t elt;
    float    weight_sum;
    float*   m_elts;
    Pixel_f* img_pxls;

    assert(r_weight >= 0 && g_weight >= 0 && b_weight >= 0);

    if ((weight_sum = r_weight + g_weight + b_weight) != 1.0)
    {
        r_weight *= 1.0 / weight_sum;
        g_weight *= 1.0 / weight_sum;
        b_weight *= 1.0 / weight_sum;
    }

    create_matblock_f(m_out, img->num_imgs, img->num_rows, img->num_cols);

    m_elts   = **((*m_out)->elts);
    img_pxls = **(img->pxls);

    num_elts = img->num_imgs*img->num_rows*img->num_cols;

    for (elt = 0; elt < num_elts; elt++)
    {
        m_elts[ elt ] = r_weight*img_pxls[ elt ].r +
                        g_weight*img_pxls[ elt ].g +
                        b_weight*img_pxls[ elt ].b;
    }
}

void copy_imgblock_f(Imgblock_f** img_out, const Imgblock_f* img_in)
{
    uint32_t num_pxls;
    uint32_t pxl;
    Pixel_f* img_out_pxls;
    Pixel_f* img_in_pxls;

    create_imgblock_f(img_out, img_in->num_imgs, img_in->num_rows, 
            img_in->num_cols);

    img_out_pxls = **((*img_out)->pxls);
    img_in_pxls  = **(img_in->pxls);

    num_pxls = img_in->num_imgs*img_in->num_rows*img_in->num_cols;

    for (pxl = 0; pxl < num_pxls; pxl++ )
    {
        img_out_pxls[ pxl ] = img_in_pxls[ pxl ];
    }
}

Error* copy_image_into_imgblock_f
(
    Imgblock_f**      ib_out,
    const Imgblock_f* ib_in,
    const Image_f*    i,
    Imgblock_image    orient,
    uint32_t          index
)
{
    uint32_t num_imgs, num_rows, num_cols;
    uint32_t img, row, col;
    uint32_t num_indices;

    Imgblock_f* ib;

    num_imgs = ib_in->num_imgs;
    num_rows = ib_in->num_rows;
    num_cols = ib_in->num_cols;

    switch (orient)
    {
        case IMGBLOCK_IMG_IMAGE:
            num_indices = ib_in->num_imgs;
            if (num_rows != i->num_rows || num_cols != i->num_cols)
            {
                return JWSC_EARG("Incompatible image and imgblock size");
            }
            break;
        case IMGBLOCK_ROW_IMAGE:
            num_indices = ib_in->num_rows;
            if (num_imgs != i->num_rows || num_cols != i->num_cols)
            {
                return JWSC_EARG("Incompatible image and imgblock size");
            }
            break;
        default:
            num_indices = ib_in->num_cols;
            if (num_imgs != i->num_rows || num_rows != i->num_cols)
            {
                return JWSC_EARG("Incompatible image and imgblock size");
            }
    }
    if (index >= num_indices)
    {
        return JWSC_EARG("Invalid index to copy into imgblock");
    }

    if (*ib_out != ib_in)
    {
        copy_imgblock_f(ib_out, ib_in);
    }
    ib = *ib_out;

    switch (orient)
    {
        case IMGBLOCK_IMG_IMAGE:
            for (row = 0; row < num_rows; row++)
            {
                for (col = 0; col < num_cols; col++)
                {
                    ib->pxls[ index ][ row ][ col ] = i->pxls[ row ][ col ];
                }
            }
            break;
        case IMGBLOCK_ROW_IMAGE:
            for (img = 0; img < num_imgs; img++)
            {
                for (col = 0; col < num_cols; col++)
                {
                    ib->pxls[ img ][ index ][ col ] = i->pxls[ img ][ col ];
                }
            }
            break;
        default:
            for (img = 0; img < num_imgs; img++)
            {
                for (row = 0; row < num_rows; row++)
                {
                    ib->pxls[ img ][ row ][ index ] = i->pxls[ img ][ row ];
                }
            }
    }

    return NULL;
}




Error* copy_image_from_imgblock_f
(
    Image_f**         img_out,
    const Imgblock_f* img_blk,
    Imgblock_image    orient,
    uint32_t          index
)
{
    uint32_t num_imgs, num_rows, num_cols;
    uint32_t img, row, col;
    uint32_t num_indices;

    Image_f* image = NULL;

    num_imgs = img_blk->num_imgs;
    num_rows = img_blk->num_rows;
    num_cols = img_blk->num_cols;

    switch (orient)
    {
        case IMGBLOCK_IMG_IMAGE:
            num_indices = img_blk->num_imgs;
            break;
        case IMGBLOCK_ROW_IMAGE:
            num_indices = img_blk->num_rows;
            break;
        default:
            num_indices = img_blk->num_cols;
    }
    if (index >= num_indices)
    {
        return JWSC_EARG("Invalid index to copy from imgblock");
    }

    switch (orient)
    {
        case IMGBLOCK_IMG_IMAGE:
            create_image_f(img_out, num_rows, num_cols);
            image = *img_out;
            for (row = 0; row < num_rows; row++)
            {
                for (col = 0; col < num_cols; col++)
                {
                    image->pxls[ row ][ col ] = 
                        img_blk->pxls[ index ][ row ][ col ];
                }
            }
            break;
        case IMGBLOCK_ROW_IMAGE:
            create_image_f(img_out, num_imgs, num_cols);
            image = *img_out;
            for (img = 0; img < num_imgs; img++)
            {
                for (col = 0; col < num_cols; col++)
                {
                     image->pxls[ img ][ col ] = 
                         img_blk->pxls[ img ][ index ][ col ];
                }
            }
            break;
        default:
            create_image_f(img_out, num_imgs, num_rows);
            image = *img_out;
            for (img = 0; img < num_imgs; img++)
            {
                for (row = 0; row < num_rows; row++)
                {
                    image->pxls[ img ][ row ] = 
                        img_blk->pxls[ img ][ row ][ index ];
                }
            }
    }

    return NULL;
}

void free_imgblock_f(Imgblock_f* img)
{
    if (img == NULL) return;

    free(**(img->pxls));
    free(*(img->pxls));
    free(img->pxls);
    free(img);
}