imgblock_util.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/filter/3d.h"
#include "jwsc/imgblock/imgblock.h"


Error* down_sample_imgblock_f
(
    Imgblock_f**      img_out, 
    const Imgblock_f* img_in, 
    float             img_factor,
    float             row_factor,
    float             col_factor
)
{
    int64_t num_in_imgs, num_in_rows, num_in_cols;
    int64_t num_out_imgs, num_out_rows, num_out_cols;
    int64_t num_h_imgs, num_h_rows, num_h_cols;
    int64_t in_img, in_row, in_col;
    int64_t out_img, out_row, out_col;
    int64_t h_img, h_row, h_col;
    int64_t h_img_center;
    int64_t h_row_center;
    int64_t h_col_center;
    int64_t i, j, k;

    float img_delta_sum, col_delta_sum, row_delta_sum;
    float r_sum, g_sum, b_sum;
    float img_delta;
    float row_delta;
    float col_delta;
    float img_sigma;
    float row_sigma;
    float col_sigma;
    float weight;
    float weight_sum;

    Imgblock_f*  img = NULL;
    Matblock_f*  h   = NULL;

    /* Test if the factors are in (0, 1]. */
    if (0 >= img_factor || img_factor > 1.0 ||
        0 >= row_factor || row_factor > 1.0 ||
        0 >= col_factor || col_factor > 1.0)
    {
        if (*img_out != img_in)
        {
            free_imgblock_f(*img_out);
            *img_out = NULL;
        }
        return JWSC_EARG("Down sampling factors must be in (0, 1]");
    }

    num_in_imgs = img_in->num_imgs;
    num_in_rows = img_in->num_rows;
    num_in_cols = img_in->num_cols;

    num_out_imgs = ceil(img_factor*num_in_imgs);
    num_out_rows = ceil(row_factor*num_in_rows);
    num_out_cols = ceil(col_factor*num_in_cols);

    if (num_in_imgs == num_out_imgs && 
        num_in_rows == num_out_rows && 
        num_in_cols == num_out_cols)
        return  NULL;

    img_delta = 1.0 / img_factor;
    row_delta = 1.0 / row_factor;
    col_delta = 1.0 / col_factor;

    img_sigma = 0.35 * img_delta;
    row_sigma = 0.35 * row_delta;
    col_sigma = 0.35 * col_delta;

    assert(create_auto_3d_gaussian_filter_f(&h, img_sigma, row_sigma, 
                col_sigma) == NULL);
    num_h_imgs = h->num_mats;
    num_h_rows = h->num_rows;
    num_h_cols = h->num_cols;

    img = (*img_out == img_in) ? NULL : *img_out;
    create_imgblock_f(&img, num_out_imgs, num_out_rows, num_out_cols);

    h_img_center = num_h_imgs / 2;
    h_row_center = num_h_rows / 2;
    h_col_center = num_h_cols / 2;

    img_delta_sum = 0.5*img_delta;
    in_img = ceil(img_delta_sum) - 1;
    for (out_img = 0; out_img < num_out_imgs; out_img++)
    {
        row_delta_sum = 0.5*row_delta;
        in_row = ceil(row_delta_sum) - 1;
        for (out_row = 0; out_row < num_out_rows; out_row++)
        {
            col_delta_sum = 0.5*col_delta;
            in_col = ceil(col_delta_sum) - 1;
            for (out_col = 0; out_col < num_out_cols; out_col++)
            {
                r_sum = 0;
                g_sum = 0;
                b_sum = 0;
                weight_sum = 0;

                i = -1;
                j = -1;
                k = -1;

                for (h_img = 0; h_img < num_h_imgs; h_img++)
                {
                    for (h_row = 0; h_row < num_h_rows; h_row++)
                    {
                        for (h_col = 0; h_col < num_h_cols; h_col++)
                        {
                            i = in_img + (h_img - h_img_center);
                            if (i < 0)
                            {
                                i = 0;
                            }
                            else if (i >= num_in_imgs)
                            {
                                i = num_in_imgs - 1;
                            }

                            j = in_row + (h_row - h_row_center);
                            if (j < 0)
                            {
                                j = 0;
                            }
                            else if (j >= num_in_rows)
                            {
                                j = num_in_rows - 1;
                            }

                            k = in_col + (h_col - h_col_center);
                            if (k < 0)
                            {
                                k = 0;
                            }
                            else if (k >= num_in_cols)
                            {
                                k = num_in_cols - 1;
                            }

                            weight = h->elts[ h_img ][ h_row ][ h_col ];

                            r_sum += img_in->pxls[ i ][ j ][ k ].r * weight;
                            g_sum += img_in->pxls[ i ][ j ][ k ].g * weight;
                            b_sum += img_in->pxls[ i ][ j ][ k ].b * weight;

                            weight_sum += weight;
                        }
                    }
                }

                if (weight_sum > 0)
                {
                    r_sum /= weight_sum;
                    g_sum /= weight_sum;
                    b_sum /= weight_sum;

                    img->pxls[ out_img ][ out_row ][ out_col ].r = r_sum;
                    img->pxls[ out_img ][ out_row ][ out_col ].g = g_sum;
                    img->pxls[ out_img ][ out_row ][ out_col ].b = b_sum;
                }
                else
                {
                    img->pxls[ out_img ][ out_row ][ out_col ].r = 
                        img_in->pxls[ i ][ j ][ k ].r;
                    img->pxls[ out_img ][ out_row ][ out_col ].g = 
                        img_in->pxls[ i ][ j ][ k ].g;
                    img->pxls[ out_img ][ out_row ][ out_col ].b = 
                        img_in->pxls[ i ][ j ][ k ].b;
                }

                col_delta_sum += col_delta;
                in_col = floor(col_delta_sum);
                if (in_col >= num_in_cols) 
                    in_col = num_in_cols - 1;
            }

            row_delta_sum += row_delta;
            in_row = floor(row_delta_sum);
            if (in_row >= num_in_rows) 
                in_row = num_in_rows - 1;
        }

        img_delta_sum += img_delta;
        in_img = floor(img_delta_sum);
        if (in_img >= num_in_imgs) 
            in_img = num_in_imgs - 1;
    }

    if (*img_out == img_in)
    {
        copy_imgblock_f(img_out, img);
        free_imgblock_f(img);
    }
    else
    {
        *img_out = img;
    }

    free_matblock_f(h);

    return NULL;
}