density-map.cpp

Go to the documentation of this file.

/*
 * density-map.cpp
 *
 * Copyright (C) 2010  Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * See density-map.h
 */

// includes --------------------------------------------------------------------
#include "density-map.h"                // always include our own header first!

#include <math.h>

#include "perf/perf.h"


namespace glut {


static const int s_maxRGBA = 255;


////////////////////////////////////////////////////////////////////////////////
//
//      static helper methods
//
////////////////////////////////////////////////////////////////////////////////

static void
setUpImage
(
IN int width,
IN int height,
OUT media::image_t& img
)
{
        ASSERT(width > 1, "Bad width: %d", width);
        ASSERT(height > 1, "Bad height: %d", height);

        img.clear();
        img.width = width;
        img.height = height;
        img.bit_depth = 24;
        img.color_format = media::eColorFormat_RGBA;
        img.bytes_per_pixel = 4;
        img.setImageType("DENSITY");
        img.allocate();
}



////////////////////////////////////////////////////////////////////////////////
//
//      public API
//
////////////////////////////////////////////////////////////////////////////////

void
createSphericalDensityMap
(
IN int size,
IN const img_color_t& color,
OUT media::image_t& img
)
{
        perf::Timer timer("createSphericalDensityMap");
        ASSERT(size > 1, "bad size: %d", size);

        setUpImage(size, size, img);

        // set up for radius calculations
        float r = 0.5 * (size - 1);
        float r2 = r * r;
        float cx = r;
        float cy = r;
        float invr = 1.0 / r;

        // loop through image
        img_color_t * p = (img_color_t *) img.data;
        for (int y = 0; y < size; ++y) {
                float dy = cy - y;
                float dy2 = dy * dy;
                for (int x = 0; x < size; ++x, ++p) {
                        float dx = cx - x;
                        float dx2 = dx * dx;
                        float d2 = r2 - dx2 - dy2;
                        float z = (d2 > 0) ? sqrt(d2) : 0.0;
                        float q = z * invr;     // 0 <= q <= 1
                        int a = color.alpha * q;
                        p->set(color.red, color.green, color.blue, a);
                }
        }
}



void
createCircularDensityMap
(
IN int size,
IN const img_color_t& color,
OUT media::image_t& img
)
{
        perf::Timer timer("createCircularDensityMap");
        ASSERT(size > 1, "bad size: %d", size);

        setUpImage(size, size, img);

        // set up for radius calculations
        float r = 0.5 * (size - 1);
        float r2 = r * r;
        float cx = r;
        float cy = r;
        float threshold = 0.2 * r2;     // 20% of distance
        float inv = 0.0;
        if (threshold > 0) {
                inv = 1.0 / threshold;
        }

        // loop through image
        img_color_t * p = (img_color_t *) img.data;
        for (int y = 0; y < size; ++y) {
                float dy = cy - y;
                float dy2 = dy * dy;
                for (int x = 0; x < size; ++x, ++p) {
                        float dx = cx - x;
                        float dx2 = dx * dx;
                        float d2 = r2 - dx2 - dy2;
                        int alpha = 0;
                        if (d2 > threshold)
                                alpha = color.alpha;
                        else if (d2 > 0)
                                alpha = (int) (d2 * inv * color.alpha);
                        p->set(color.red, color.green, color.blue, alpha);
                }
        }
}



void
createLineSegmentDensityMap
(
IN int width,
IN const img_color_t& color,
OUT media::image_t& img
)
{
        perf::Timer timer("createHorizontalDensityMap");

        int height = (2 * width) / 3;
        setUpImage(width, height, img);

        // set up for horizontal calculations
        float midH = 0.5 * (height - 1);
        float q = 0.6;
        float alpha = 130.0 / powf(midH * midH, q);
        float invalpha = 1.0 / alpha;

        // loop through image
        img_color_t * p = (img_color_t *) img.data;
        for (int y = 0; y < height; ++y) {
                float dy = midH - y;
                float dy2 = dy * dy;
                for (int x = 0; x < width; ++x, ++p) {
                        float dx = 0;
                        if (x < midH) {
                                dx = midH - x;
                        } else if (x > width - 1 - midH) {
                                dx = x - (width - 1 - midH);
                        }
                        float dx2 = dx * dx;
                        float r2 = dx2 + dy2;
                        float r2q = 0.0;
                        if (r2 > 0.0) {
                                r2q = powf(r2, q);
                        }
                        float invr = 1.0;
                        if (r2q > invalpha) {
                                invr = 1.0 / (alpha * r2q);
                        }
                        int a = img_color_t::eMaxComponent * invr;
                        p->set(color.red, color.green, color.blue, a);
                }
        }
}



};      // glut namespace