image.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/matrix/matrix.h"
#include "jwsc/image/image.h"

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


void create_image_f
(
    Image_f** img_out, 
    uint32_t  num_rows, 
    uint32_t  num_cols
)
{
    uint32_t row;
    Pixel_f* pxls;
    Image_f* img;

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

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

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

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

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

void create_init_image_f
(
    Image_f** img_out, 
    uint32_t  num_rows, 
    uint32_t  num_cols,
    Pixel_f   val
)
{
    uint32_t num_pxls;
    uint32_t pxl;
    Pixel_f* img_pxls;

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

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

void create_zero_image_f
(
    Image_f** img_out, 
    uint32_t  num_rows, 
    uint32_t  num_cols
)
{
    Pixel_f p = {0};

    create_init_image_f(img_out, num_rows, num_cols, p);
}

void create_random_image_f
(
    Image_f** img_out, 
    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_image_f(img_out, num_rows, num_cols);
    img_pxls = *((*img_out)->pxls);
    num_pxls = 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_image_from_matrices_f
(
    Image_f**   img_out, 
    const Matrix_f* m_r,
    const Matrix_f* m_g,
    const Matrix_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_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_image_f(*img_out); *img_out = NULL;
        return JWSC_EARG("Inconsistent image channel sizes");
    }

    create_image_f(img_out, 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_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_image_from_matrix_f
(
    Image_f**   img_out, 
    const Matrix_f* m
)
{
    create_image_from_matrices_f(img_out, m, m, m);
}

void create_matrices_from_image_f
(
    Matrix_f**     m_r_out, 
    Matrix_f**     m_g_out, 
    Matrix_f**     m_b_out, 
    const Image_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_matrix_f(m_r_out, img->num_rows, img->num_cols);
    create_matrix_f(m_g_out, img->num_rows, img->num_cols);
    create_matrix_f(m_b_out, 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_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_matrix_from_image_f
(
    Matrix_f**     m_out, 
    const Image_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_matrix_f(m_out, img->num_rows, img->num_cols);

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

    num_elts = 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_image_f(Image_f** img_out, const Image_f* img_in)
{
    uint32_t num_pxls;
    uint32_t pxl;
    Pixel_f* img_out_pxls;
    Pixel_f* img_in_pxls;

    create_image_f(img_out, 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_rows*img_in->num_cols;

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

void free_image_f(Image_f* img)
{
    if (img == NULL) return;

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