/home/carolina/workspace/spvolren_cpu/transferEdit.c

Vá para a documentação deste arquivo.

/*
 * Copyright (c) 2005  Institute for Visualization and Interactive
 * Systems, University of Stuttgart, Germany
 *
 * This source code is distributed as part of the single-pass volume
 * rendering project. Details about this project can be found on the
 * project web page at http://www.vis.uni-stuttgart.de/eng/research/
 * fields/current/spvolren. This file may be distributed, modified,
 * and used free of charge as long as this copyright notice is
 * included in its original form. Commercial use is strictly
 * prohibited.
 *
 * Filename: transferEdit.c
 * 
 */

#define GLX_GLXEXT_PROTOTYPES
/*#define GLH_EXT_SINGLE_FILE*/
#include <glh/glh_extensions.h>
/*#include <glh/glh_glut.h>*/
#include <GL/gl.h>
#include <math.h>
#include <stdlib.h>
#include <stdio.h>

#include "transferEdit.h"

#define MAX(a,b) ((a) > (b) ? (a) : (b))
#define MIN(a,b) ((a) < (b) ? (a) : (b))

#define BOXSIZE 8

#define CONST_VAL 20
#define SHIFT_VAL_STEP 4

DataTypeTE **dataTE;

int focus;
int hidden;
int drawOffsetX;
int drawOffsetY;
GLint viewport[4];
int *activeCh;
GLfloat colorTE[5][3] = {
        {1., 0., 0.},
        {0., 1., 0.},
        {0., 0., 1.},
        {1., 1., 1.},
        {0., 1., 1.}
};
int lastMpos[2];

void initTE()
{
        int idx, idi;

        if (! (dataTE = (DataTypeTE **)malloc(NUM_TE * sizeof(DataTypeTE *)))) {
                fprintf(stderr, "not enough memory for transfer editor data\n");
                exit(1);
        }
        if (! (activeCh = (int *)malloc(NUM_TE * sizeof(int)))) {
                fprintf(stderr, "not enough memory for active channels\n");
                exit(1);
        }

        for (idx = 0; idx < NUM_TE; idx++) {
                if (! (dataTE[idx] = (DataTypeTE *)malloc(NUM_TE_ENTRIES *
                                                                                                sizeof(DataTypeTE)))) {
                        fprintf(stderr, "not enough memory for transfer editor data\n");
                        exit(1);
                }
                activeCh[idx] = 1;
        }

        /* Init TFs */
        for (idx = 0; idx < NUM_TE; idx++) {
                for (idi = 0; idi < NUM_TE_ENTRIES; idi++) {
#if 1
                        /* Linear transfer function */
                        if (idx < 4) {
                                dataTE[idx][idi] = (DataTypeTE)idi;
                        } else {
                                dataTE[idx][idi] = (DataTypeTE)128;
                        }
#else
                        dataTE[idx][idi] = (float)rand()/RAND_MAX * (NUM_TE_ENTRIES - 1);
#endif
                }
        }

        drawOffsetX = 10;
        drawOffsetY = 10;
        hidden = 1;
        focus = 0;

        glGetIntegerv(GL_VIEWPORT, viewport);
}

void destTE()
{
        int idx;

        for (idx = 0; idx < NUM_TE; idx++) {
                if (dataTE[idx] != 0)
                        free(dataTE[idx]);
        }
        free(dataTE);
        free(activeCh);
}

void drawTE()
{
        int idx, idi;

        if (hidden)
                return;

        glPushAttrib(GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT | GL_TRANSFORM_BIT);

        glMatrixMode(GL_PROJECTION);
        glPushMatrix();
        glLoadIdentity();
        glOrtho(0, viewport[2], 0, viewport[3], -1., 1.);

        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();
        glLoadIdentity();
        glTranslatef((GLfloat)drawOffsetX, (GLfloat)drawOffsetY, 0.0f);

        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        glEnable(GL_BLEND);
        glBegin(GL_QUADS);
        glColor4f(0.0f, 0.0f, 0.0f, 0.2f);
        glVertex2f(0.0f, 0.0f);
        glVertex2f(255.0f, 0.0f);
        glVertex2f(255.0f, 255.0f);
        glVertex2f(0.0f, 255.0f);
        glEnd();

        glBegin(GL_QUADS);
        for (idx = 0; idx < NUM_TE; idx++) {
                if (activeCh[idx]) {
                        glColor3fv(colorTE[idx]);

                        glVertex2i(idx * 2 * BOXSIZE + BOXSIZE, 8);
                        glVertex2i(idx * 2 * BOXSIZE + 2 * BOXSIZE, 8);
                        glVertex2i(idx * 2 * BOXSIZE + 2 * BOXSIZE, 8 + BOXSIZE);
                        glVertex2i(idx * 2 * BOXSIZE + BOXSIZE, 8 + BOXSIZE);
                }
        }
        glEnd();

        glDisable(GL_BLEND);

        for (idx = 0; idx < NUM_TE; idx++) {
                glBegin(GL_LINE_STRIP);
                glColor3fv(colorTE[idx]);
                for (idi = 0; idi < NUM_TE_ENTRIES; idi++)
                        glVertex2i(idi, dataTE[idx][idi]);
                glEnd();
        }

        glPopMatrix();
        glMatrixMode(GL_PROJECTION);
        glPopMatrix();

        glPopAttrib();
}

int mouseIsInside(int x, int y)
{
        return (((drawOffsetX <= x) && (x <= drawOffsetX + NUM_TE_ENTRIES)) &&
                        ((drawOffsetY <= y) && (y <= drawOffsetY + NUM_TE_ENTRIES)));
}

int mouseTE(int x, int y)
{
        if ((hidden) || (!mouseIsInside(x, viewport[3] - y))) {
            focus = 0;
            return 0;
        }

        lastMpos[0] = x - drawOffsetX;
        lastMpos[1] = viewport[3] - (y + drawOffsetY);
        focus = 1;
        return 1;
}

int motionTE(int x, int y)
{
        int actuMpos[2], startY, i, idt;
        float m;

        if ((hidden) || (!focus))
                return 0;

        actuMpos[0] = x - drawOffsetX;
        actuMpos[1] = viewport[3] - (y + drawOffsetY);

        /* clamping */
        for( i = 0; i < 2; i++) {
                if (actuMpos[i] < 0) actuMpos[i] = 0;
                if (actuMpos[i] > (NUM_TE_ENTRIES-1)) actuMpos[i] = NUM_TE_ENTRIES-1;
        }

        if (actuMpos[0] < lastMpos[0]) {
                m = (lastMpos[1] - actuMpos[1]) / (float) (lastMpos[0] -
                                                                                                   actuMpos[0]);
                startY = actuMpos[1];
        } else {
                m = (actuMpos[1] - lastMpos[1]) / (float) (actuMpos[0] -
                                                                                                   lastMpos[0]);
                startY = lastMpos[1];
        }

        for (idt = 0; idt < NUM_TE; idt++) {
                if (activeCh[idt]) {
                        int idx;
                        for (idx = 0; idx <= abs(actuMpos[0] - lastMpos[0]); idx++)
                                dataTE[idt][MIN(actuMpos[0], lastMpos[0]) + idx] =
                                        (DataTypeTE)(startY + (int) floor(idx * m));
                }
        }
        lastMpos[0] = actuMpos[0];
        lastMpos[1] = actuMpos[1];

        return 1;
}

void setIdentity()
{
    int i, j;
    for (i = 0; i < NUM_TE_ENTRIES; i++) {
        for (j = 0; j < NUM_TE; j++) {
        if (activeCh[j]) dataTE[j][i] = (DataTypeTE)i;
        }
    }
}

void setInvert()
{
    int i, j;
    for (i = 0; i < NUM_TE_ENTRIES; i++) {
        for (j = 0; j < NUM_TE; j++) {
        if (activeCh[j]) dataTE[j][i] = NUM_TE_ENTRIES-1-dataTE[j][i];
        }
    }
}

void setConst(void)
{
    int i, j;

    for (i = 0; i < NUM_TE_ENTRIES; i++) {
        for (j = 0; j < NUM_TE; j++) {
                if (activeCh[j]) {      
                                dataTE[j][i] = CONST_VAL;
                        }
        }
    }
}

void shiftFunc(int delta)
{
    int i, j, temp;

    for (i = 0; i < NUM_TE_ENTRIES; i++) {
        for (j = 0; j < NUM_TE; j++) {
                if (activeCh[j]) {      
                                temp = dataTE[j][i] + delta;
                                if (temp < 0) {
                                        dataTE[j][i] = 0;
                                } else if (temp > 255) {
                                        dataTE[j][i] = 255;
                                } else {
                                        dataTE[j][i] = (DataTypeTE)temp;
                                }
                        }
        }
    }
}

int keyTE(unsigned char k, int x, int y)
{
        if ((hidden) || (!mouseIsInside(x, viewport[3] - y)))
                return 0;

        switch (k) {
        case 'r':
                activeCh[0] = !activeCh[0];
                break;
        case 'g':
                activeCh[1] = !activeCh[1];
                break;
        case 'b':
                activeCh[2] = !activeCh[2];
                break;
        case 'a':
                activeCh[3] = !activeCh[3];
                break;
        case 'o':
                activeCh[4] = !activeCh[4];
                break;
        case 't':
                toggleHidden();
                break;
        case 'i':
                setIdentity();
                break;
        case 'm':
                setInvert();
                break;
        case 'c':
                setConst();
                break;
        case 'h':
                shiftFunc(SHIFT_VAL_STEP);
                break;
        case 'n':
                shiftFunc(-SHIFT_VAL_STEP);
                break;
        default:
                return 0;
        }

        return 1;
}

void setOffsets(int offsetX, int offsetY)
{
        drawOffsetX = offsetX;
        drawOffsetY = offsetY;
}

void setHidden(int h)
{
        hidden = h;
}

void toggleHidden()
{
        hidden = !hidden;
}

void resizeTE()
{
        glGetIntegerv(GL_VIEWPORT, viewport);
}

DataTypeTE **getDataTE(void)
{
        return dataTE;
}

---