---

MDITwoLevel.cpp

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "MDITwoLevel.h"
#include "MDIEdit.h"
#include "MDIFrame.h"
#include <iostream>
#include <winbase.h>
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TTwoLevelForm *TwoLevelForm;
rgb *_picture;
//---------------------------------------------------------------------------

TColor RGB2TColor(rgb c)
{
        //return (TColor)(0x01000000+c.r+(c.g<<8)+(c.b<<16));
        return (TColor)(c.r+(c.g<<8)+(c.b<<16));
}
//---------------------------------------------------------------------------

__fastcall TTwoLevelForm::TTwoLevelForm(TComponent* Owner)
    : TForm(Owner),
      _formCreate(true),
      _rotx(0),
      _roty(0),
      _rotz(0),
      _lightX(0.0),
      _lightY(0.0),
      _resolution(128),
      _pic_size(_resolution*_resolution),
      _oldres(0),
      _traging(false),
      _stopIt(false),
      _actres(2),
      _actposx(0),
      _actposy(0),
      _viewx(1,0,0),
      _viewy(0,1,0),
      _viewz(0,0,1),
      /*
      _center(0,0,0),
      _l2(0.0),
      _step(0.0),
      _start(0,0,0),
      _lightPos(0,0,0),
      _lightDir(0,0,0),
      */
      _maxTime(1.5),
      _thres(1200),
      _ambient(1.0),
      _light(1.0),
      _firstHit(0),
      _alphaFH(0.9),
      _thresFH(1200),
      _MIP(0),
      _alphaMIP(0.9),
      _MIPref(2048.0),
      _NPR(0),
      _alphaNPR(0.9),
      _NPRpower(4),
      _NPRref(100.0),
      _Average(0),
      _alphaAverage(0.9),
      _Averageref(2048.0),
      _Transparent(0),
      _alphaTransparent(0.9)
{
}
//---------------------------------------------------------------------------

int __fastcall TTwoLevelForm::_getFirstBitIndex(int val)
{
    _actualBit = -1;
    return _getNextBitIndex(val);
}
//---------------------------------------------------------------------------

int __fastcall TTwoLevelForm::_getNextBitIndex(int val)
{
    int res = 0;
    do {
        ++_actualBit;
        res = (1<<_actualBit);
    } while ((_actualBit<31) && !(res&val));
    if (res&val) return _actualBit;
    else     return -1;
}
//---------------------------------------------------------------------------

inline float __fastcall TTwoLevelForm::_getValue(vectorf & v)
{
    if (CbThreeLinear->Checked) {
        int X = (int)(v.X);
        int Y = (int)(v.Y);
        int Z = (int)(v.Z);
        int idx = X + Y*_rowsize + Z*_pagesize;
        float dx = v.X - X, dy = v.Y - Y, dz = v.Z - Z;
        float d1x = 1.0 - dx, d1y = 1.0 - dy, d1z = 1.0 - dz;
        float value1 = (float)data[idx]*d1x +
                       (float)data[idx+1]*dx;
        float value2 = (float)data[idx+_rowsize]*d1x +
                       (float)data[idx+_rowsize+1]*dx;
        float value3 = (float)data[idx+_pagesize+_rowsize]*d1x +
                       (float)data[idx+_pagesize+_rowsize+1]*dx;
        float value4 = (float)data[idx+_pagesize]*d1x +
                       (float)data[idx+_pagesize+1]*dx;
        float value11 = value1*(d1y) + value2*(dy);
        float value22 = value4*(d1y) + value3*(dy);
        return (value11*(d1z) + value22*(dz));
    } else {
        int X = (int)(v.X+0.5);
        int Y = (int)(v.Y+0.5);
        int Z = (int)(v.Z+0.5);
        return data[X + Y*_rowsize + Z*_pagesize];
    }
}
//---------------------------------------------------------------------------

/*
 * Assuming the following situation:
 *
 *        (*) - (x+1,y+1,z+1)
 *        /|      /|
 *      (*)|--- (*)|
 *       | |     | |
 *       |(*) ---|(*)
 *       |/      |/
 *    (x,y,z) - (*)
 *
 */
inline double __fastcall TTwoLevelForm::_getValue(const vectord & v)
{
    int X = (int)(v.X);
    int Y = (int)(v.Y);
    int Z = (int)(v.Z);
    int idx = X + Y*_rowsize + Z*_pagesize;
    double dx = v.X - X, dy = v.Y - Y, dz = v.Z - Z;
    double d1x = 1.0 - dx, d1y = 1.0 - dy, d1z = 1.0 - dz;
    double value1 = (double)data[idx]*d1x +
                    (double)data[idx+1]*dx;
    double value2 = (double)data[idx+_rowsize]*d1x +
                    (double)data[idx+_rowsize+1]*dx;
    double value3 = (double)data[idx+_pagesize+_rowsize]*d1x +
                    (double)data[idx+_pagesize+_rowsize+1]*dx;
    double value4 = (double)data[idx+_pagesize]*d1x +
                    (double)data[idx+_pagesize+1]*dx;
    double value11 = value1*(d1y) + value2*(dy);
    double value22 = value4*(d1y) + value3*(dy);
    return (value11*(d1z) + value22*(dz));
}
//---------------------------------------------------------------------------

double inline __fastcall TTwoLevelForm::_getGradLength(const vectord & v)
{
    int X = (int)(v.X);
    int Y = (int)(v.Y);
    int Z = (int)(v.Z);
    int idx = X + Y*_rowsize + Z*_pagesize;
    double dx = v.X - X, dy = v.Y - Y, dz = v.Z - Z;
    double d1x = 1.0 - dx, d1y = 1.0 - dy, d1z = 1.0 - dz;
    double value1 = (double)absgrad[idx]*d1x +
                    (double)absgrad[idx+1]*dx;
    double value2 = (double)absgrad[idx+_rowsize]*d1x +
                    (double)absgrad[idx+_rowsize+1]*dx;
    double value3 = (double)absgrad[idx+_pagesize+_rowsize]*d1x +
                    (double)absgrad[idx+_pagesize+_rowsize+1]*dx;
    double value4 = (double)absgrad[idx+_pagesize]*d1x +
                    (double)absgrad[idx+_pagesize+1]*dx;
    double value11 = value1*(d1y) + value2*(dy);
    double value22 = value4*(d1y) + value3*(dy);
    return (value11*(d1z) + value22*(dz));
}
//---------------------------------------------------------------------------

vectorf inline __fastcall TTwoLevelForm::_getGradient(vectorf & v)
{
    if (CbThreeLinear->Checked) {
        vectorf res;
        int X = (int)(v.X);
        int Y = (int)(v.Y);
        int Z = (int)(v.Z);
        int idx = X + Y*_rowsize + Z*_pagesize;
        float dx = v.X - X, dy = v.Y - Y, dz = v.Z - Z;
        float d1x = 1.0 - dx, d1y = 1.0 - dy, d1z = 1.0 - dz;
        float value1 = (float)gradient[idx].x*d1x +
                       (float)gradient[idx+1].x*dx;
        float value2 = (float)gradient[idx+_rowsize].x*d1x +
                       (float)gradient[idx+_rowsize+1].x*dx;
        float value3 = (float)gradient[idx+_pagesize+_rowsize].x*d1x +
                       (float)gradient[idx+_pagesize+_rowsize+1].x*dx;
        float value4 = (float)gradient[idx+_pagesize].x*d1x +
                       (float)gradient[idx+_pagesize+1].x*dx;
        float value11 = value1*(d1y) + value2*(dy);
        float value22 = value4*(d1y) + value3*(dy);
        res.X = value11*(d1z) + value22*(dz);
        value1 = (float)gradient[idx].y*d1x +
                 (float)gradient[idx+1].y*dx;
        value2 = (float)gradient[idx+_rowsize].y*d1x +
                 (float)gradient[idx+_rowsize+1].y*dx;
        value3 = (float)gradient[idx+_pagesize+_rowsize].y*d1x +
                 (float)gradient[idx+_pagesize+_rowsize+1].y*dx;
        value4 = (float)gradient[idx+_pagesize].y*d1x +
                 (float)gradient[idx+_pagesize+1].y*dx;
        value11 = value1*(d1y) + value2*(dy);
        value22 = value4*(d1y) + value3*(dy);
        res.Y = value11*(d1z) + value22*(dz);
        value1 = (float)gradient[idx].z*d1x +
                 (float)gradient[idx+1].z*dx;
        value2 = (float)gradient[idx+_rowsize].z*d1x +
                 (float)gradient[idx+_rowsize+1].z*dx;
        value3 = (float)gradient[idx+_pagesize+_rowsize].z*d1x +
                 (float)gradient[idx+_pagesize+_rowsize+1].z*dx;
        value4 = (float)gradient[idx+_pagesize].z*d1x +
                 (float)gradient[idx+_pagesize+1].z*dx;
        value11 = value1*(d1y) + value2*(dy);
        value22 = value4*(d1y) + value3*(dy);
        res.Z = value11*(d1z) + value22*(dz);
        return res;
    } else {
        int X = (int)(v.X+0.5);
        int Y = (int)(v.Y+0.5);
        int Z = (int)(v.Z+0.5);
        int idx = X + Y*sizeX + Z*sizeX*sizeY;
        return vectorf(gradient[idx].x,
                       gradient[idx].y,
                       gradient[idx].z);
    }
}
//---------------------------------------------------------------------------

vectord inline __fastcall TTwoLevelForm::_getGradient(vectord & v)
{
    vectord res;
    int X = (int)(v.X);
    int Y = (int)(v.Y);
    int Z = (int)(v.Z);
    int idx = X + Y*_rowsize + Z*_pagesize;
    double dx = v.X - X, dy = v.Y - Y, dz = v.Z - Z;
    double d1x = 1.0 - dx, d1y = 1.0 - dy, d1z = 1.0 - dz;
    double value1 = (double)gradient[idx].x*d1x +
                    (double)gradient[idx+1].x*dx;
    double value2 = (double)gradient[idx+_rowsize].x*d1x +
                    (double)gradient[idx+_rowsize+1].x*dx;
    double value3 = (double)gradient[idx+_pagesize+_rowsize].x*d1x +
                    (double)gradient[idx+_pagesize+_rowsize+1].x*dx;
    double value4 = (double)gradient[idx+_pagesize].x*d1x +
                    (double)gradient[idx+_pagesize+1].x*dx;
    double value11 = value1*(d1y) + value2*(dy);
    double value22 = value4*(d1y) + value3*(dy);
    res.X = value11*(d1z) + value22*(dz);
    value1 = (double)gradient[idx].y*d1x +
             (double)gradient[idx+1].y*dx;
    value2 = (double)gradient[idx+_rowsize].y*d1x +
             (double)gradient[idx+_rowsize+1].y*dx;
    value3 = (double)gradient[idx+_pagesize+_rowsize].y*d1x +
             (double)gradient[idx+_pagesize+_rowsize+1].y*dx;
    value4 = (double)gradient[idx+_pagesize].y*d1x +
             (double)gradient[idx+_pagesize+1].y*dx;
    value11 = value1*(d1y) + value2*(dy);
    value22 = value4*(d1y) + value3*(dy);
    res.Y = value11*(d1z) + value22*(dz);
    value1 = (double)gradient[idx].z*d1x +
             (double)gradient[idx+1].z*dx;
    value2 = (double)gradient[idx+_rowsize].z*d1x +
             (double)gradient[idx+_rowsize+1].z*dx;
    value3 = (double)gradient[idx+_pagesize+_rowsize].z*d1x +
             (double)gradient[idx+_pagesize+_rowsize+1].z*dx;
    value4 = (double)gradient[idx+_pagesize].z*d1x +
             (double)gradient[idx+_pagesize+1].z*dx;
    value11 = value1*(d1y) + value2*(dy);
    value22 = value4*(d1y) + value3*(dy);
    res.Z = value11*(d1z) + value22*(dz);
    /*
    // X gradient component:
    double v1 = _getValue(v + vectord(-0.5, 0.0, 0.0));
    double v2 = _getValue(v + vectord( 0.5, 0.0, 0.0));
    res.X = v2-v1;
    // Y gradient component:
    v1 = _getValue(v + vectord( 0.0,-0.5, 0.0));
    v2 = _getValue(v + vectord( 0.0, 0.5, 0.0));
    res.Y = v2-v1;
    // Z gradient component:
    v1 = _getValue(v + vectord( 0.0, 0.0,-0.5));
    v2 = _getValue(v + vectord( 0.0, 0.0, 0.5));
    res.Z = v2-v1;
    */
    return res;
}
//---------------------------------------------------------------------------

void inline __fastcall TTwoLevelForm::_calcColor(rgb& col,
                                                 vectord &normal,
                                                 vectord& view,
                                                 vectord& light)
{
    // Ambient:
    double xxx = normal^view;
    xxx *= xxx;
    xxx *= xxx;
    col.r *= (double)_ambientCol.r/255.0*_ambient*xxx;
    col.g *= (double)_ambientCol.g/255.0*_ambient*xxx;
    col.b *= (double)_ambientCol.b/255.0*_ambient*xxx;
                // Can do this without checking the result
                // for >255 cause all factors are less or
                // equal to one.

    // Specular:
    vectord specH = (view+light)*0.5;
    specH.normal();
    xxx = normal^specH;
    //if (xxx < 0.0) xxx *= -1.0;
    if (xxx < 0.0) xxx = 0.0;

    if (_sinus) {
        xxx = acos(xxx);
        if (xxx < 0.0)  xxx=0.0;
        if (xxx>M_PI_2) xxx=M_PI_2;
        xxx = 1.0-(xxx/M_PI_2);
    }
    switch (_power) {
        case 10: xxx *= xxx;     // 1024
        case  9: xxx *= xxx;     //  512
        case  8: xxx *= xxx;     //  256
        case  7: xxx *= xxx;     //  128
        case  6: xxx *= xxx;     //   64
        case  5: xxx *= xxx;     //   32
        case  4: xxx *= xxx;     //   16
        case  3: xxx *= xxx;     //    8
        case  2: xxx *= xxx;     //    4
        default: xxx *= xxx;     //    2
    }
    col += _lightCol*_light*xxx;
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::_resize()
{
    if (_picture) delete [] _picture;
    _pic_size = _resolution*_resolution;
    _picture = new rgb[_pic_size];
    memusage = memusage - 3*_oldres*_oldres + 3*_pic_size;
    FrameForm->memupdate();
    LResolution->Caption = AnsiString(_resolution) +
                           AnsiString(" x ") +
                           AnsiString(_resolution);
}
//---------------------------------------------------------------------------

void inline __fastcall TTwoLevelForm::_renderPreview()
{
    // Reset from the last image calculation.
    DrawingTimer->Enabled = false;
    FrameForm->StatusProgress->Visible = false;
    FrameForm->StatusMain->Caption = "";


    // We assume the viewing plane lies in x-z-direction. This means:
    // * dragging in horizontal direction corresponds to a rotation around
    //   the z axis,
    // * dragging in vertical direction means a rotation around the x axis,
    // * the ray follows the y axis

    // Viewing direction vectors:
    vectorf viewx(1,0,0), viewy(0,1,0), viewz(0,0,1);
    // rotate them:
    float rrotx = _rotx * 3.14159265 / 180.0;
    float rrotz = _rotz * 3.14159265 / 180.0;
    viewx.rotx(rrotx); viewx.rotz(rrotz); viewx.normal();
    viewy.rotx(rrotx); viewy.rotz(rrotz); viewy.normal();
    viewz.rotx(rrotx); viewz.rotz(rrotz); viewz.normal();
    // Viewing volume center:
    vectorf center(sizeX/2, sizeY/2, sizeZ/2);
    // Distance from volume middle to an edge:
    float l = _dist, l2 = l*2.0;
    // width of one step:
    float step = 2*l/(float)PREVIEW_SIZE;
    // Start position of line:
    vectorf linestart = center + (viewx*(-l)) + (viewy*(-l)) + (viewz*(-l));
    // Start position of ray:
    vectorf start = linestart;
    // Light position:
    vectorf lightPos = center + (viewy*(-l))
                       + (viewx*_lightX) + (viewz*_lightY);
    // Light direction:
    vectorf lightDir = center - lightPos;
    lightDir.normal();
    // Actual position of ray:
    vectorf pos;
    // Last position bevor actual position of ray:
    vectorf oldpos;
    // The actual length of the ray:
    float raylen;
    // Actual data value:
    int val;
    // Actual position in data:
    int X, Y, Z, idx;
    // Inside indicator:
    bool inside;
    // step is the size of one preview pixel in the domain of the image:
    int picstep = _resolution / PREVIEW_SIZE;
    // The color value to be drawn to the _picture:
    rgb col;


    if (!CbAutoUpdate->Checked) {
        FrameForm->StatusProgress->Position = 0;
        FrameForm->StatusProgress->Visible = true;
    }

    int x,y;
    for(y=0; y<PREVIEW_SIZE; ++y) { // line loop:
        for(x=0; x<PREVIEW_SIZE; ++x) { // pixel loop:
            pos = start;
            raylen = 0.0;
            col.r = col.g = col.b = 0;
            // Fast forward to the inside of the viewing volume, ...
            while (!_isInside(pos) && raylen <= l2) {
                pos += viewy*5.0;
                raylen += 5.0;
            }
            // ... one step back ...
            pos -= viewy*5.0; raylen -= 5.0;
            // ... and finally slowly into the volume:
            while (!(inside = _isInside(pos)) && raylen <= l2) {
                pos += viewy*1.0;
                raylen += 1.0;
            }
            // Fast forward to the first hit ...
            if (inside) {
                val = _getValue(pos);
            } else {
                val = 0;
            }
            while (inside && val<TbThres->Position &&
                   raylen <= l2) {
                pos += viewy*3.0;
                raylen += 3.0;
                inside = _isInside(pos);
                if (inside) {
                    val = _getValue(pos);
                } else {
                    val = 0;
                }
            }
            // ... one big step back ...
            pos -= viewy*3.0; raylen -= 3.0;
            if (inside = _isInside(pos)) {
                val = _getValue(pos);
            } else {
                val = 0;
            }
            // ... and slowly to the right position:
            while (inside && val<TbThres->Position &&
                   raylen <= l2) {
                pos += viewy*1.0;
                raylen += 1.0;
                inside = _isInside(pos);
                if (inside) {
                    val = _getValue(pos);
                } else {
                    val = 0;
                }
            }
            if (val >= TbThres->Position) {
                vectorf normal = _getGradient(pos);
                normal.normal();
                //normal = normal*viewy;
                vectorf specH = (viewy+lightDir)*0.5;
                specH.normal();
                float xxx = normal^specH;
                xxx *= xxx;
                xxx *= xxx;
                //float len = normal.L;
                /*
                pixel->r = color[idx].r*(1.0-len);
                pixel->g = color[idx].g*(1.0-len);
                pixel->b = color[idx].b*(1.0-len);
                */
                /*
                col.r = 255*(1.0-len);
                col.g = 255*(1.0-len);
                col.b = 255*(1.0-len);
                */
                col.r = col.g = col.b = 255*xxx;
            }
            _draw(col, x, y, picstep);
            start += viewx*step;
        }
        linestart += viewz*step;
        start = linestart;

        if (!CbAutoUpdate->Checked)
            FrameForm->StatusProgress->Position =
                (int)((float)y/(float)PREVIEW_SIZE*100.0);
    }
    if (!CbAutoUpdate->Checked)
        FrameForm->StatusProgress->Visible = false;

    // Initializing the image calculation:
    _resetRenderer();
}
//---------------------------------------------------------------------------


bool inline __fastcall TTwoLevelForm::_renderImage()
{

// This is used in the ray caster to get the value and area name from the
// actual position pos.
#define _GET_INSIDE_NAME_VAL    inside = _isInside(pos);                \
                                if (inside) {                           \
                                    val = _getValue(pos);               \
                                    name = transe->getName(val);        \
                                    if (name != -1) myName = 1<<name;   \
                                    else            myName = 0;         \
                                } else {                                \
                                    val = 0.0;                          \
                                    myName = 0;                         \
                                }
// How Long is a small step for:
// First Hit:
#define _SMALL_STEP_FH  0.1
// MIP:
#define _SMALL_STEP_MIP 0.5
// NPR:
#define _SMALL_STEP_NPR 0.5
// NR:
#define _SMALL_STEP_NR  0.5
// Average:
#define _SMALL_STEP_AVERAGE 0.5
// Transparent:
#define _SMALL_STEP_TRANSP 0.5


    //return false;


    // On any account turn on the progress bar:
    FrameForm->StatusProgress->Visible = true;


    // ================== Raycaster setup: ==============================
    // We assume the viewing plane lies in x-z-direction. This means:
    // * dragging in horizontal direction corresponds to a rotation around
    //   the z axis,
    // * dragging in vertical direction means a rotation around the x axis,
    // * the ray follows the positive y axis

    /************************************************************************
     * Moved to global and set up by _resertRenderer:
     *
     * // Viewing direction vectors:
     * vectord viewx(1,0,0), viewy(0,1,0), viewz(0,0,1);
     * // rotate them:
     * double rrotx = _rotx * M_PI / 180.0;
     * double rrotz = _rotz * M_PI / 180.0;
     * viewx.rotx(rrotx); viewx.rotz(rrotz); viewx.normal();
     * viewy.rotx(rrotx); viewy.rotz(rrotz); viewy.normal();
     * viewz.rotx(rrotx); viewz.rotz(rrotz); viewz.normal();
     * // Viewing volume center:
     * vectord center(sizeX/2, sizeY/2, sizeZ/2);
     * // Distance from volume middle to an edge:
     * //float l = _fm_sqrtl(sizeX*sizeX/4 + sizeY*sizeY/4 + sizeZ*sizeZ/4);
     * //float l = center.L;
     * double l = _dist, l2 = l*2.0;
     * // width of one step:
     * double step = 2*l/(float)_resolution;
     * // Start position of image:
     * vectord start = center + (viewx*(-l)) + (viewy*(-l)) + (viewz*(-l));
     * // Light position:
     * vectord lightPos = center + (viewy*(-l))
     *                    + (viewx*_lightX) + (viewz*_lightY);
     * // Light direction:
     * vectord lightDir = center - lightPos;
     * lightDir.normal();
     ***********************************************************************/

    // Actual position of ray:
    vectord pos;
    // Accumulator for the alpha value:
    double alpha = 0.0;
    // Insertion alpha value of the ray caster:
    double alphaRC = 0.0;
    // The local alpha value:
    double localAlpha;
    // The actual length of the ray:
    double raylen;
    // Actual data value:
    double val;
    // Data for the actual value;
    TData data;
    // The bit shifted area given by data.
    int name, myName;
    // Inside indicator:
    bool inside;
    // size of a pixel in the domain of _resolution:
    int picstep;
    // the two level accumulator color:
    rgb tlcol;
    // ray caster result color:
    rgb col;


    // ================== Image geometry setup: =========================
    bool finished = false;
    int i = 0;


    // Begin time mesurement:
    TDateTime stime = Time();

    // ================== Raycaster: ====================================
    while (i<_rpc && !finished) {
        picstep = _resolution / _actres;
        pos = _start + _viewx*(_step*_actposx*picstep)
                     + _viewz*(_step*_actposy*picstep);
        raylen = 0.0;
        val = 0.0;
        alpha = 0.0;
        tlcol.r = tlcol.g = tlcol.b = 0;


        // Fast forward to the inside of the viewing volume, ...
        while (!_isInside(pos) && raylen <= _l2) {
            pos += _viewy*5.0;
            raylen += 5.0;
        }
        // ... one step back ...
        pos -= _viewy*5.0; raylen -= 5.0;
        // ... and finally slowly into the volume:
        while (!(inside = _isInside(pos)) && raylen <= _l2) {
            pos += _viewy;
            raylen += 1.0;
        }



        // Calculate first value of this ray:
        _GET_INSIDE_NAME_VAL;

        while (inside && (raylen <= _l2) && alpha < 1.0) {

            // At this point a value should be calculated! So
            // either it is calculated befor the loop or at it's
            // end.

            // reset values:
            col.r = col.g = col.b = 0;
            localAlpha = 0.0;
            alphaRC = 0.0;

            if (!myName) {
                // === None: ================================================
                pos += _viewy;
                raylen += 1.0;
                _GET_INSIDE_NAME_VAL;

            } else if (myName & _firstHit) {
                // === First Hit: ===========================================

                // Set up First Hit:
                alphaRC = _alphaFH;

                // Fast forwart to the surface:
                while ((myName & _firstHit) && (val < _thresFH) && inside) {
                    pos += _viewy;
                    raylen += 1.0;
                    _GET_INSIDE_NAME_VAL;
                }

                // The surface can only be detected if we are behind it. So
                // Let's check this:
                if ((myName & _firstHit) && (val >= _thresFH) && inside) {
                    // We ARE behind the surface

                    // One step back ...
                    pos -= _viewy*1.0;
                    raylen -= 1.0;
                    _GET_INSIDE_NAME_VAL;

                    // ... and small steps forward to the surface ...
                    while (((val < _thresFH)        // The last step back may
                            || !(myName & _firstHit)// have led out of the area
                            || !inside)             // or eaven out of the
                           && raylen < _l2) {       // volume, so go forth till
                                                    // we are inside again!
                        pos += _viewy*_SMALL_STEP_FH;
                        raylen += _SMALL_STEP_FH;
                        _GET_INSIDE_NAME_VAL;
                    }

                    // Found the surface, so let's draw the pixel:
                    if ((myName & _firstHit) && (val >= _thresFH) && inside) {
                        data = transe->getData(val);
                        vectord grad = _getGradient(pos);
                        grad.normal();
                        col = data.col;
                        localAlpha = data.alpha;
                        _calcColor(col, grad, _viewy, _lightDir);
                        col *= data.alpha;
                    }

                    // last of all fast forward to the end of the end of the
                    // area:
                    while ((myName & _firstHit) && inside) {
                        pos += _viewy;
                        raylen += 1.0;
                        _GET_INSIDE_NAME_VAL;
                    }
                }

            } else if (myName & _MIP) {
                // === MIP: =================================================

                // Set up for MIP:
                alphaRC = _alphaMIP;
                double MIPval = 0.0;

                // We are inside the area so let's take one step back ...
                pos -= _viewy;
                raylen -= 1.0;
                _GET_INSIDE_NAME_VAL;

                // ... slow forward to the border ...
                while ((!(myName&_MIP) || !inside) && raylen<_l2) {
                    // While we are outside the area or outside the volume
                    // we step forth. But at most to the max. ray length!
                    pos += _viewy*_SMALL_STEP_MIP;
                    raylen += _SMALL_STEP_MIP;
                    _GET_INSIDE_NAME_VAL;
                }

                // ... and slowly through the area ...
                while ((myName&_MIP) && inside) {
                    if (val>MIPval) {
                        // The highest value so far:
                        data = transe->getData(val);
                        //vectord grad = _getGradient(pos);
                        //grad.normal();
                        //col = data.col;
                        localAlpha = data.alpha;
                        //_calcColor(col, grad, _viewy, _lightDir);
                        col = _ambientCol*(_ambient*val/_MIPref);
                        MIPval = val;
                    }
                    pos += _viewy*_SMALL_STEP_MIP;
                    raylen += _SMALL_STEP_MIP;
                    _GET_INSIDE_NAME_VAL;
                }
                // ... till we are through.

            } else if (myName & _NPR) {
                // === NPR: =================================================

                // Set up for NPR:
                alphaRC = _alphaNPR;
                double gradMax = 0.0;

                // We are inside the area so let's take one step back ...
                pos -= _viewy;
                raylen -= 1.0;
                _GET_INSIDE_NAME_VAL;

                // ... slow forward to the border ...
                while ((!(myName&_NPR) || !inside) && raylen<_l2) {
                    // While we are outside the area or outside the volume
                    // we step forth. But at most to the max. ray length!
                    pos += _viewy*_SMALL_STEP_NPR;
                    raylen += _SMALL_STEP_NPR;
                    _GET_INSIDE_NAME_VAL;
                }

                // ... and slowly through the area ...
                while ((myName&_NPR) && inside) {
                    // get gradient length for this position:
                    double gradlen = _getGradLength(pos);
                    if (gradlen>gradMax && gradlen>_NPRref) {
                        // As long as the ray is transparent:
                        data = transe->getData(val);
                        vectord grad = _getGradient(pos);
                        grad.normal();
                        rgb mycol;
                        mycol = data.col;

                        //_calcColor(mycol, grad, _viewy, _lightDir);
                        // Ambient:
                        double xxx = grad^_viewy;
                        if (xxx < 0.0) xxx *= -1.0;
                        //if (xxx < 0.0) xxx = 0.0;
                        xxx = 1-xxx;
                        switch (_NPRpower) {
                            case 10: xxx *= xxx;     // 1024
                            case  9: xxx *= xxx;     //  512
                            case  8: xxx *= xxx;     //  256
                            case  7: xxx *= xxx;     //  128
                            case  6: xxx *= xxx;     //   64
                            case  5: xxx *= xxx;     //   32
                            case  4: xxx *= xxx;     //   16
                            case  3: xxx *= xxx;     //    8
                            case  2: xxx *= xxx;     //    4
                            default: xxx *= xxx;     //    2
                        }
                        mycol.r *= (double)_ambientCol.r/255.0*_ambient*xxx;
                        mycol.g *= (double)_ambientCol.g/255.0*_ambient*xxx;
                        mycol.b *= (double)_ambientCol.b/255.0*_ambient*xxx;
                                    // Can do this without checking the result
                                    // for >255 cause all factors are less or
                                    // equal to one.

                        // Specular:
                        /*
                        vectord specH = (_viewy+_lightDir)*0.5;
                        specH.normal();
                        xxx = grad^specH;
                        xxx = 1-xxx;
                        if (xxx < 0.0) xxx *= -1.0;
                        xxx = acos(xxx);
                        if (xxx < 0.0)  xxx=0.0;
                        if (xxx>M_PI_2) xxx=M_PI_2;
                        xxx = 1.0-(xxx/M_PI_2);
                        switch (_power) {
                            case 10: xxx *= xxx;     // 1024
                            case  9: xxx *= xxx;     //  512
                            case  8: xxx *= xxx;     //  256
                            case  7: xxx *= xxx;     //  128
                            case  6: xxx *= xxx;     //   64
                            case  5: xxx *= xxx;     //   32
                            case  4: xxx *= xxx;     //   16
                            case  3: xxx *= xxx;     //    8
                            case  2: xxx *= xxx;     //    4
                            default: xxx *= xxx;     //    2
                        }
                        mycol += _lightCol*_light*xxx;
                        */

                        //localAlpha = data.alpha;
                        col = mycol*localAlpha;
                        col = mycol;

                        gradMax = gradlen;
                    }
                    pos += _viewy*_SMALL_STEP_NPR;
                    raylen += _SMALL_STEP_NPR;
                    _GET_INSIDE_NAME_VAL;
                }
                // ... till we are through.

            } else if (myName & _NR) {
                // === NR: ==================================================

                // Set up for NR:
                alphaRC = _alphaNR;
                double NRval = 0.0;

                // We are inside the area so let's take one step back ...
                pos -= _viewy;
                raylen -= 1.0;
                _GET_INSIDE_NAME_VAL;

                // ... slow forward to the border ...
                while ((!(myName&_NR) || !inside) && raylen<_l2) {
                    // While we are outside the area or outside the volume
                    // we step forth. But at most to the max. ray length!
                    pos += _viewy*_SMALL_STEP_NR;
                    raylen += _SMALL_STEP_NR;
                    _GET_INSIDE_NAME_VAL;
                }

                // ... and slowly through the area ...
                while ((myName&_NR) && inside) {
                    if (val>NRval) {
                        // The highest value so far:
                        data = transe->getData(val);
                        vectord grad = _getGradient(pos);
                        grad.normal();
                        col = data.col;
                        localAlpha = data.alpha;
                        _calcColor(col, grad, _viewy, _lightDir);
                        //col = _ambientCol*(_ambient*val/4096.0);
                        NRval = val;
                    }
                    pos += _viewy*_SMALL_STEP_NR;
                    raylen += _SMALL_STEP_NR;
                    _GET_INSIDE_NAME_VAL;
                }
                // ... till we are through.

            } else if (myName & _Average) {
                // === Average: =============================================

                // Set up for average:
                int averageCount = 0;
                double averageVal = 0.0;
                alphaRC = _alphaAverage;
                localAlpha = 1.0;

                // We are inside the area so let's take one step back ...
                pos -= _viewy;
                raylen -= 1.0;
                _GET_INSIDE_NAME_VAL;

                // ... slow forward to the border ...
                while ((!(myName&_Average) || !inside) && raylen<_l2) {
                    // While we are outside the area or outside the volume
                    // we step forth. But at most to the max. ray length!
                    pos += _viewy*_SMALL_STEP_AVERAGE;
                    raylen += _SMALL_STEP_AVERAGE;
                    _GET_INSIDE_NAME_VAL;
                }

                // ... and slowly through the area ...
                while ((myName&_Average) && inside) {
                    data = transe->getData(val);
                    averageVal += val*data.alpha;
                    ++averageCount;
                    pos += _viewy*_SMALL_STEP_AVERAGE;
                    raylen += _SMALL_STEP_AVERAGE;
                    _GET_INSIDE_NAME_VAL;
                }

                // ... till the end or the area.

                averageVal /= (double)averageCount;
                col.r = col.g = col.b = 255.0*averageVal/_Averageref;

            } else if (myName & _Transparent) {
                // === Transparent: =========================================

                // Set up for Transparent:
                alphaRC = _alphaTransparent;

                // We are inside the area so let's take one step back ...
                pos -= _viewy;
                raylen -= 1.0;
                _GET_INSIDE_NAME_VAL;

                // ... slow forward to the border ...
                while ((!(myName&_Transparent) || !inside) && raylen<_l2) {
                    // While we are outside the area or outside the volume
                    // we step forth. But at most to the max. ray length!
                    pos += _viewy*_SMALL_STEP_TRANSP;
                    raylen += _SMALL_STEP_TRANSP;
                    _GET_INSIDE_NAME_VAL;
                }

                // ... and slowly through the area ...
                while ((myName&_Transparent) && inside) {
                    if (localAlpha<1.0) {
                        // As long as the ray is transparent:
                        data = transe->getData(val);
                        vectord grad = _getGradient(pos);
                        grad.normal();
                        rgb mycol;
                        mycol = data.col;
                        _calcColor(mycol, grad, _viewy, _lightDir);
                        col += mycol*data.alpha*_SMALL_STEP_TRANSP;
                        localAlpha += data.alpha*_SMALL_STEP_TRANSP;
                    }
                    pos += _viewy*_SMALL_STEP_TRANSP;
                    raylen += _SMALL_STEP_TRANSP;
                    _GET_INSIDE_NAME_VAL;
                }
                // ... till we are through.

            } else {
                // === None: ================================================
                // This is for areas not assigned with a ray caster.
                pos += _viewy*1.0;
                raylen += 1.0;
                _GET_INSIDE_NAME_VAL;
            }

            // Inserting the color value:
            if (alphaRC != 0.0) {
                // Normize Alpha:
                if (localAlpha > 1.0) localAlpha=1.0;

                alpha += localAlpha*alphaRC;
                tlcol += col*alphaRC;
            }

        }


        _draw(tlcol, _actposx, _actposy, picstep);


        // When a picture with dimention 8 should be drawn, the
        // resulting drawing order is like this (the number are the
        // resolution, at which the are set:
        // +-----------------+
        // | 2 8 4 8 2 8 4 8 |
        // | 8 8 8 8 8 8 8 8 |
        // | 4 8 4 8 4 8 4 8 |
        // | 8 8 8 8 8 8 8 8 |
        // | 2 8 4 8 2 8 4 8 |
        // | 8 8 8 8 8 8 8 8 |
        // | 4 8 4 8 4 8 4 8 |
        // | 8 8 8 8 8 8 8 8 |
        // +-----------------+
        if (_actres == 2) {     // the spezial resolution of 2:
            ++_actposx;
            if (_actposx == 2) {
                _actposx = 0;
                ++_actposy;
            }
            if (_actposy == 2) {
                // move on to the next _actres:
                _actres <<= 1;
                _actposx = 1;   // from now on we allways start
                _actposy = 0;   // on the second position in
                                // the first row.
            }
        } else {                // all other resolutions:
            // on every line with even line-nr we increment x by 2:
            if (_actposy & 1)   _actposx++;
            else                _actposx += 2;
            if (_actposx >= _actres) {
                // we are now at the end of a line:
                ++_actposy;
                // on every line with even line-nr we start at
                // the second position:
                if (_actposy & 1)   _actposx = 0;
                else                _actposx = 1;
            }
            if (_actposy >= _actres) {
                _actres <<= 1;  // move on to the next _actres.
                _actposx = 1;   // as told above.
                _actposy = 0;
                if (picstep != 1) {
                    // For every even step size draw a while line at the right
                    // border. This line will be erased at every odd step size
                    // an therefor also at the end of drawing. It should be a
                    // simple progress display.
                    rgb myWhite;
                    myWhite.r = myWhite.g = myWhite.b = 255;
                    for(int j=0; j<_resolution; ++j)
                        _draw(myWhite, _resolution-11, j, 1);
                }
            }
        }
        ++_progress;
        ++i;            // don't forget to count the number of rays
                        // calculated during this call of _renderImage
        finished = (_actres>_resolution);
        if (!(i%1000) || finished) {
            FrameForm->StatusProgress->Position =
                    (int)((float)_progress/(float)_pic_size*100.0);
            TDateTime dur = Time() - _startTime;
            TDateTime all = (double)dur / _progress * _pic_size;
            FrameForm->StatusMain->Caption = "ETA: " + (all - dur).TimeString();
            LTime->Caption = dur;
        }
    }

    // Stop time mesurement:
    unsigned short hh, min, sec, hsec;
    //TDateTime fdur = Time() - stime;
    (Time() - stime).DecodeTime(&hh, &min, &sec, &hsec);
    float t = (float)sec + (float)hsec/1000.0;
    if (t > _maxTime) {
        _rpc = _rpc*_maxTime/t;
    }
    Lrpc->Caption = AnsiString(_rpc) + " ("
                    + AnsiString::FormatFloat("0.000000", t) + ")";

    LProgress->Caption = AnsiString(_progress) + "/" + AnsiString(_pic_size);

    DrawingTimer->Enabled = !finished && !_stopIt;
    DrawingTimer->Interval = 150;
    FrameForm->StatusProgress->Visible = !finished && !_stopIt;
    if (finished || _stopIt) {
            FrameForm->StatusMain->Caption = "";
            SbStop->Enabled = false;
            SbStart->Enabled = true;
    }
    _stopIt = false;    // users wish should be met, so reset the 'signal'.

    PaintGL();
    return finished;
}
//---------------------------------------------------------------------------

void inline __fastcall TTwoLevelForm::_render()
{
    _renderPreview();
}
//---------------------------------------------------------------------------

void inline __fastcall TTwoLevelForm::_draw(rgb &val, int x, int y, int step)
{
    if (step == 1) {
        _picture[x + y*_resolution] = val;
    } else {
        for(int yy=y*step; yy<(y+1)*step; ++yy) {
            for(int xx=x*step; xx<(x+1)*step; ++xx) {
                if ((xx + yy*_resolution) >= _pic_size)
                    cerr << "xx = " << xx << ", yy = " << yy << endl;
                _picture[xx + yy*_resolution] = val;
            }
        }
    }
}
//---------------------------------------------------------------------------

void inline __fastcall TTwoLevelForm::_resetRenderer()
{
    if (_formCreate) return;

    DrawingTimer->Enabled = false;
    // Resolution things:
    _progress = 0;
    _actposx = 0;
    _actposy = 0;
    _actres = 2;
    _rpc = 10000;

    // Viewing plane:
    _viewx = vectord(1.0, 0.0, 0.0);
    _viewy = vectord(0.0, 1.0, 0.0);
    _viewz = vectord(0.0, 0.0, 1.0);
    double rrotx = _rotx * M_PI / 180.0;
    double rrotz = _rotz * M_PI / 180.0;
    _viewx.rotx(rrotx); _viewx.rotz(rrotz); _viewx.normal();
    _viewy.rotx(rrotx); _viewy.rotz(rrotz); _viewy.normal();
    _viewz.rotx(rrotx); _viewz.rotz(rrotz); _viewz.normal();
    // Viewing center:
    _center = vectord((double)sizeX/2.0, (double)sizeY/2.0, (double)sizeZ/2.0);
    // Ray lenght:
    _l2 = (double)_dist*2.0;
    // Step size:
    _step = _l2/(float)_resolution;
    // Picture start position:
    _start = _center + (_viewx*(double)(-_dist))
             + (_viewy*(double)(-_dist))
             + (_viewz*(double)(-_dist));
    // Light position:
    _lightPos = _center + (_viewy*(double)(-_dist))
                + (_viewx*_lightX) + (_viewz*_lightY);
    // Light direction:
    _lightDir = _center - _lightPos;
    _lightDir.normal();

    //LLength->Caption = AnsiString(_l2);

    SbStop->Enabled = true;
    SbStart->Enabled = false;

    // Fire it up:
    DrawingTimer->Enabled = true;
    DrawingTimer->Interval = 500;
    _startTime = Time();
}
//---------------------------------------------------------------------------

bool inline __fastcall TTwoLevelForm::_isInside(vectorf & v)
{
    return (v.X >= 1.0) && (v.X < (float)(sizeX-1)) &&
           (v.Y >= 1.0) && (v.Y < (float)(sizeY-1)) &&
           (v.Z >= 1.0) && (v.Z < (float)(sizeZ-1));
}
//---------------------------------------------------------------------------

bool inline __fastcall TTwoLevelForm::_isInside(vectord & v)
{
    return (v.X >= 1.0) && (v.X < (double)(sizeX-1)) &&
           (v.Y >= 1.0) && (v.Y < (double)(sizeY-1)) &&
           (v.Z >= 1.0) && (v.Z < (double)(sizeZ-1));
}
//---------------------------------------------------------------------------

void TTwoLevelForm::_setupTLAlpha(TSpeedButton* sb, TEdit* e,
                                  TTabSheet* ts, double f)
{
    if (sb->Down) {
        PTwoLevelAlpha->Top = PageControl1->Top + ts->Top + e->Top + e->Height;
        PTwoLevelAlpha->Left = PageControl1->Left + ts->Left + e->Left;
        _TwoLevelAlphaEdit = e; // Change the edit box to be
                                // manipulated by the track bar BEFOR
                                // changing the track bars position!
        TbTwoLevelAlpha->Position = (int)(f * 1000.0);
        PTwoLevelAlpha->Visible = true;
    } else {
        PTwoLevelAlpha->Visible = false;
    }
}
//---------------------------------------------------------------------------

void TTwoLevelForm::_setupRef(TSpeedButton* sb, TEdit* e,
                              TTabSheet* ts, double f)
{
    if (sb->Down) {
        PRef->Top = PageControl1->Top + ts->Top + e->Top + e->Height;
        PRef->Left = PageControl1->Left + ts->Left + e->Left;
        _RefEdit = e;   // Change the edit box to be
                        // manipulated by the track bar BEFOR
                        // changing the track bars position!
        TbRef->Position = f;
        PRef->Visible = true;
    } else {
        PRef->Visible = false;
    }
}
//---------------------------------------------------------------------------

void TTwoLevelForm::_setupListBox(TListBox* lb, int& rc)
{
    lb->Items->Assign(transe->areaNames);
    int idx = _getFirstBitIndex(rc);
    while (idx != -1) {
        if (idx < lb->Items->Count)
            lb->Selected[idx] = true;
        else
            rc &= ~(1<<idx);    // unset the bit if the idx
                                // is out of range.
        idx = _getNextBitIndex(rc);
    }
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::_unsetBitInAllRCs(int idx)
{
    _firstHit &= ~(1<<idx);
    _MIP &= ~(1<<idx);
    _NPR &= ~(1<<idx);
    _Average &= ~(1<<idx);
    _Transparent &= ~(1<<idx);
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::PaintGL()
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    PrepareGLWindow();
    glColor3f(0.6f,0.6f,0.6f);
    glLineWidth(3.0f);
    glBegin(GL_LINE_STRIP);
    glVertex3f(-50,-50,0);
    glVertex3f(50,-50,0);
    glVertex3f(50,50,0);
    glVertex3f(-50,50,0);
    glVertex3f(-50,-50,0);
    glEnd();

    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    glDrawPixels(_resolution, _resolution, GL_RGB,
                 GL_UNSIGNED_BYTE, _picture);
                    // we use unsigned byte (char) to meet speed issues.
                    // 16 bit data (__int16) slows down drawing to much.

    glFlush();
    SwapBuffers(hdc);
}

void __fastcall TTwoLevelForm::PrepareGLWindow()
{
    wglMakeCurrent(hdc, hrc);

    GLfloat nRange = 50.0;
    w = ClientWidth-200;
    h = ClientHeight;

    if(h == 0) h = 1;
    if(w == 0) w = 1;

    glViewport(200, 0, w, h);
    glLoadIdentity();

    if (w <= h) {
        glOrtho (-nRange, nRange, -nRange*h/w, nRange*h/w, -nRange, nRange);
        glPixelZoom((float)w/(float)_resolution, (float)w/(float)_resolution);
    } else {
        glOrtho (-nRange*w/h, nRange*w/h, -nRange, nRange, -nRange, nRange);
        glPixelZoom((float)h/(float)_resolution, (float)h/(float)_resolution);
    }

    glRasterPos2d(-50,-50);
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::SetPixelFormatDescriptor()
{
    PIXELFORMATDESCRIPTOR pfd = {
        sizeof(PIXELFORMATDESCRIPTOR),
        1,
        PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
        PFD_TYPE_RGBA,
        24,
        0,0,0,0,0,0,
        0,0,
        0,0,0,0,0,
        32,
        0,
        0,
        PFD_MAIN_PLANE,
        0,
        0,0,
    };
    PixelFormat = ChoosePixelFormat(hdc, &pfd);
    SetPixelFormat(hdc, PixelFormat, &pfd);
}
//---------------------------------------------------------------------

void __fastcall TTwoLevelForm::FormCreate(TObject *Sender)
{
    _picture = 0;
    _rowsize = sizeX;
    _pagesize = sizeX*sizeY;
    _dist = MAX(MAX(sizeX, sizeY), sizeZ) >> 1;
    _resize();

    // Setting up UI:
    LRotation->Caption = AnsiString(_rotx) + ", " + AnsiString(_rotz);
    LDist->Caption = AnsiString(_dist);

    TbThres->Position = _thres;
    PThres->Top = PageControl1->Top + TsPreview->Top
                  + EThres->Top + EThres->Height;
    PThres->Left = PageControl1->Left + TsPreview->Left
                   + EThres->Left + 4;

    EmaxTime->Text = AnsiString::FormatFloat("0.000", _maxTime);
    PmaxTime->Top = PageControl1->Top + TsCommon->Top
                    + EmaxTime->Top + EmaxTime->Height;
    PmaxTime->Left = PageControl1->Left + TsCommon->Left
                     + EmaxTime->Left;

    // Ambient:
    EAmbient->Text = AnsiString::FormatFloat("0.000", _ambient);
    PAmbient->Top = PageControl1->Top + TsCommon->Top
                    + EAmbient->Top + EAmbient->Height;
    PAmbient->Left = PageControl1->Left + TsCommon->Left
                     + EAmbient->Left;
    _ambientCol = TColor2RGB(SAmbient->Brush->Color);

    // Light:
    ELight->Text = AnsiString::FormatFloat("0.000", _light);
    PLight->Top = PageControl1->Top + TsCommon->Top
                  + ELight->Top + ELight->Height;
    PLight->Left = PageControl1->Left + TsCommon->Left
                   + ELight->Left;
    _lightCol = TColor2RGB(SLight->Brush->Color);
    LLightPos->Caption = AnsiString(_lightX) + " x " + AnsiString(_lightY);

    // Power:
    _power = TbPower->Position;
    LPower->Caption = AnsiString(1<<_power);
    _sinus = CbSinus->Checked;

    // First Hit:
    EFHAlpha->Text = AnsiString::FormatFloat("0.000", _alphaFH);
    EFHThres->Text = AnsiString(_thresFH);
    PFHThres->Top = PageControl1->Top + TsFirstHit->Top
                    + EFHThres->Top + EFHThres->Height;
    PFHThres->Left = PageControl1->Left + TsFirstHit->Left
                     + EFHThres->Left;
    LbFirstHit->Items->Assign(transe->areaNames);

    // MIP:
    EMIPAlpha->Text = AnsiString::FormatFloat("0.000", _alphaMIP);
    LbMIP->Items->Assign(transe->areaNames);
    EMIPRef->Text = AnsiString(_MIPref);

    // NPR:
    ENPRAlpha->Text = AnsiString::FormatFloat("0.000", _alphaNPR);
    LbNPR->Items->Assign(transe->areaNames);
    TbNPRPower->Position = _NPRpower;
    LNPRPower->Caption = AnsiString(1<<_power);
    ENPRRef->Text = AnsiString(_NPRref);

    // Average:
    EAverageAlpha->Text = AnsiString::FormatFloat("0.000", _alphaAverage);
    LbAverage->Items->Assign(transe->areaNames);

    // Transparent:
    ETransparentAlpha->Text = AnsiString::FormatFloat("0.000",
                                                      _alphaTransparent);
    LbTransparent->Items->Assign(transe->areaNames);
    EAverageRef->Text = AnsiString(_Averageref);


    PageControl1->ActivePage = TsCommon;

    hdc = GetDC(Handle);
    SetPixelFormatDescriptor();
    hrc = wglCreateContext(hdc);
    if(hrc == NULL) ShowMessage("Could not create DC!");
    wglMakeCurrent(hdc, hrc);

    w = ClientWidth;
    h = ClientHeight;

    glEnable(GL_DEPTH_TEST);
    glEnable(GL_CULL_FACE);

    glClearColor(0.2f, 0.2f, 0.2f, 1.0f);
    glOrtho (-50.0,50.0,-50.0,50.0,-50.0,50.0);

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glFlush();
    SwapBuffers(hdc);
    FormResize(Sender);

    _formCreate = false;
}
//---------------------------------------------------------------------

void __fastcall TTwoLevelForm::FormClose(TObject *Sender, TCloseAction &Action)
{
    Action=caFree;

    FrameForm->StatusMain->Caption = "";
    FrameForm->StatusProgress->Visible = false;

    FrameForm->TwoLevel->Checked = false;
    memusage = memusage - 3*_resolution*_resolution;
    if (_picture) {
        delete [] _picture;
        _picture = 0;
    }
    FrameForm->memupdate();
    wglDeleteContext(hrc);
    ReleaseDC(Handle,hdc);
}
//---------------------------------------------------------------------

void __fastcall TTwoLevelForm::FormResize(TObject *Sender)
{
    CbWindowSizeClick(this);
    PrepareGLWindow();
    PaintGL();
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::FormPaint(TObject *Sender)
{
    PaintGL();
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::FormActivate(TObject *Sender)
{
    TsFirstHitShow(this);
    TsMIPShow(this);
    TsNPRShow(this);
    TsAverageShow(this);
    TsTransparentShow(this);
    PaintGL();
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::FormClick(TObject *Sender)
{
    //_render();
    //PaintGL();
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::FormMouseDown(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y)
{
    _startX = X;
    _startY = Y;
    _traging = true;
    _rightButton = (Button == mbRight);
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::FormMouseMove(TObject *Sender,
      TShiftState Shift, int X, int Y)
{
    if (_traging) {
        if (_rightButton) {
            _dist -= (Y-_startY)>>1;
        } else {
            if (Shift.Contains(ssCtrl)) {
                // Light Moving:
                _lightX  += (double)(X-_startX)/2.0;
                _lightY  -= (double)(Y-_startY)/2.0;
            } else {
                _rotz -= (X-_startX)>>1;
                _rotx -= (Y-_startY)>>1;
                if (_rotx < 0)   _rotx += 360;
                if (_rotx > 360) _rotx -= 360;
                if (_rotz < 0)   _rotz += 360;
                if (_rotz > 360) _rotz -= 360;
            }
        }
        _startX = X;
        _startY = Y;
        LRotation->Caption = AnsiString(_rotx) + ", " + AnsiString(_rotz);
        LLightPos->Caption = AnsiString(_lightX) + " x " + AnsiString(_lightY);
        LDist->Caption = AnsiString(_dist);
        if (CbAutoUpdate->Checked) {
            _render();
            PaintGL();
        }
    }
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::FormMouseUp(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y)
{
    _traging = false;
    if (!CbAutoUpdate->Checked) {
        _render();
        PaintGL();
    }
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::CbWindowSizeClick(TObject *Sender)
{
    if (CbWindowSize->Checked) {
        _oldres = _resolution;
        _resolution = TwoLevelForm->ClientHeight;
        TbResolution->Enabled = false;
        LResolution->Enabled = false;
        _resize();
        _render();
    } else {
        TbResolution->Enabled = true;
        LResolution->Enabled = true;
        TbResolutionChange(this);
    }
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::TbResolutionChange(TObject *Sender)
{
    _oldres = _resolution;
    switch(TbResolution->Position) {
        case 1:  _resolution =  128; break;
        case 2:  _resolution =  256; break;
        case 3:  _resolution =  512; break;
        case 4:  _resolution = 1024; break;
        case 5:  _resolution = 2048; break;
        case 6:  _resolution = 4096; break;
        default: _resolution =  128; break;
    }
    CbResizeClick(this);
    if (_oldres != _resolution) {
        _resize();
        _render();
        PaintGL();
    }
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::CbResizeClick(TObject *Sender)
{
    if (CbResize->Checked) {
        if (CbWindowSize->Checked) {
            CbWindowSize->Checked = false;
            TbResolution->Enabled = true;
            LResolution->Enabled = true;
            TbResolutionChange(this);
        }
        if (_resolution > 256) {
            ClientHeight = _resolution;
            ClientWidth = _resolution + 200;
        }
    }
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::TbThresChange(TObject *Sender)
{
    EThres->Text = AnsiString(TbThres->Position);
    if (CbAutoUpdate->Checked) {
        _render();
        PaintGL();
    }
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::DrawingTimerTimer(TObject *Sender)
{
    DrawingTimer->Enabled = false;
    _renderImage();
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::Button1Click(TObject *Sender)
{
    PaintGL();
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::TbmaxTimeChange(TObject *Sender)
{
    EmaxTime->Text =
        AnsiString::FormatFloat("0.000", (float)TbmaxTime->Position/1000.0);
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::EmaxTimeChange(TObject *Sender)
{
    _maxTime = EmaxTime->Text.ToDouble();
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::TbmaxTimeExit(TObject *Sender)
{
    PmaxTime->Visible = !PmaxTime->Visible;
    SbmaxTime->Down = PmaxTime->Visible;
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::SbmaxTimeClick(TObject *Sender)
{
    TbmaxTime->Position = _maxTime * 1000.0;
    PmaxTime->Visible = !PmaxTime->Visible;
    SbmaxTime->Down = PmaxTime->Visible;
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::SbThresClick(TObject *Sender)
{
    TbThres->Position = _thres;
    PThres->Visible = !PThres->Visible;
    SbThres->Down = PThres->Visible;
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::EThresChange(TObject *Sender)
{
    _thres = EThres->Text.ToInt();
    if (CbAutoUpdate->Checked) {
        _render();
        PaintGL();
    }
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::TbThresExit(TObject *Sender)
{
    PThres->Visible = !PThres->Visible;
    SbThres->Down = PThres->Visible;
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::PageControl1Changing(TObject *Sender,
      bool &AllowChange)
{
    PThres->Visible = false;
    SbThres->Down = false;
    PmaxTime->Visible = false;
    SbmaxTime->Down = false;
    PTwoLevelAlpha->Visible = false;
    SbFHAlpha->Down = false;
    PFHThres->Visible = false;
    SbFHThres->Down = false;
    SbMIPAlpha->Down = false;
    SbNPRAlpha->Down = false;
    SbAverageAlpha->Down = false;
    SbTransparentAlpha->Down = false;
    SbAmbient->Down = false;
    PAmbient->Visible = false;
    SbLight->Down = false;
    PLight->Visible = false;
    PRef->Visible = false;
    SbMIPRef->Down = false;
    SbNPRRef->Down = false;
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::SbFHAlphaClick(TObject *Sender)
{
    _setupTLAlpha(SbFHAlpha, EFHAlpha, TsFirstHit, _alphaFH);
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::TbTwoLevelAlphaChange(TObject *Sender)
{
    _TwoLevelAlphaEdit->Text =
        AnsiString::FormatFloat(
            "0.000000", (double)TbTwoLevelAlpha->Position/1000.0);
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::EFHAlphaChange(TObject *Sender)
{
    _alphaFH = AnsiString(EFHAlpha->Text).ToDouble();
    _resetRenderer();
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::EFHThresChange(TObject *Sender)
{
    _thresFH = AnsiString(EFHThres->Text).ToInt();
    _resetRenderer();
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::SbFHThresClick(TObject *Sender)
{
    TbFHThres->Position = _thresFH;
    PFHThres->Visible = !PFHThres->Visible;
    SbFHThres->Down = PFHThres->Visible;
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::LbFirstHitClick(TObject *Sender)
{
    if (LbFirstHit->ItemIndex != -1) {
        _unsetBitInAllRCs(LbFirstHit->ItemIndex);
        _firstHit = 1 << LbFirstHit->ItemIndex;
    }
    _resetRenderer();
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::LbFirstHitDblClick(TObject *Sender)
{
    LbFirstHit->ItemIndex = -1;
    _firstHit = 0;
    _resetRenderer();
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::TbFHThresChange(TObject *Sender)
{
    EFHThres->Text = AnsiString(TbFHThres->Position);
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::TsFirstHitShow(TObject *Sender)
{
    LbFirstHit->Items->Assign(transe->areaNames);
    LbFirstHit->ItemIndex = _getFirstBitIndex(_firstHit);
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::SbMIPAlphaClick(TObject *Sender)
{
    _setupTLAlpha(SbMIPAlpha, EMIPAlpha, TsMIP, _alphaMIP);
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::EMIPAlphaChange(TObject *Sender)
{
    _alphaMIP = AnsiString(EMIPAlpha->Text).ToDouble();
    _resetRenderer();
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::LbMIPClick(TObject *Sender)
{
    _MIP = 0;
    for(int i=0; i<LbMIP->Items->Count; ++i) {
        if (LbMIP->Selected[i]) {
            _unsetBitInAllRCs(i);
            _MIP |= 1<<i;
        }
    }
    _resetRenderer();
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::LbMIPDblClick(TObject *Sender)
{
    LbMIP->Selected[LbMIP->ItemIndex] = false;
    LbMIPClick(this);
    _resetRenderer();
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::TsMIPShow(TObject *Sender)
{
    _setupListBox(LbMIP, _MIP);
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::ENPRAlphaChange(TObject *Sender)
{
    _alphaNPR = AnsiString(ENPRAlpha->Text).ToDouble();
    _resetRenderer();
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::SbNPRAlphaClick(TObject *Sender)
{
    _setupTLAlpha(SbNPRAlpha, ENPRAlpha, TsNPR, _alphaNPR);
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::LbNPRClick(TObject *Sender)
{
    _NPR = 0;
    for(int i=0; i<LbNPR->Items->Count; ++i) {
        if (LbNPR->Selected[i]) {
            _unsetBitInAllRCs(i);
            _NPR |= 1<<i;
        }
    }
    _resetRenderer();
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::LbNPRDblClick(TObject *Sender)
{
    LbNPR->Selected[LbNPR->ItemIndex] = false;
    LbNPRClick(this);
    _resetRenderer();
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::TsNPRShow(TObject *Sender)
{
    _setupListBox(LbNPR, _NPR);
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::EAverageAlphaChange(TObject *Sender)
{
    _alphaAverage = AnsiString(EAverageAlpha->Text).ToDouble();
    _resetRenderer();
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::SbAverageAlphaClick(TObject *Sender)
{
    _setupTLAlpha(SbAverageAlpha, EAverageAlpha, TsAverage, _alphaAverage);
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::LbAverageClick(TObject *Sender)
{
    _Average = 0;
    for(int i=0; i<LbAverage->Items->Count; ++i) {
        if (LbAverage->Selected[i]) {
            _unsetBitInAllRCs(i);
            _Average |= 1<<i;
        }
    }
    _resetRenderer();
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::LbAverageDblClick(TObject *Sender)
{
    LbAverage->Selected[LbAverage->ItemIndex] = false;
    LbAverageClick(this);
    _resetRenderer();
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::TsAverageShow(TObject *Sender)
{
    _setupListBox(LbAverage, _Average);
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::ETransparentAlphaChange(TObject *Sender)
{
    _alphaTransparent = AnsiString(ETransparentAlpha->Text).ToDouble();
    _resetRenderer();
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::SbTransparentAlphaClick(TObject *Sender)
{
    _setupTLAlpha(SbTransparentAlpha, ETransparentAlpha,
                  TsTransparent, _alphaTransparent);
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::LbTransparentClick(TObject *Sender)
{
    _Transparent = 0;
    for(int i=0; i<LbTransparent->Items->Count; ++i) {
        if (LbTransparent->Selected[i]) {
            _unsetBitInAllRCs(i);
            _Transparent |= 1<<i;
        }
    }
    _resetRenderer();
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::LbTransparentDblClick(TObject *Sender)
{
    LbTransparent->Selected[LbTransparent->ItemIndex] = false;
    LbTransparentClick(this);
    _resetRenderer();
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::TsTransparentShow(TObject *Sender)
{
    _setupListBox(LbTransparent, _Transparent);
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::EAmbientChange(TObject *Sender)
{
    _ambient = EAmbient->Text.ToDouble();
    TbAmbient->Position = (int)(_ambient * 1000.0);
    _resetRenderer();
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::SAmbientMouseUp(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y)
{
    ColorDialog1->Color = SAmbient->Brush->Color;
    if (ColorDialog1->Execute()) {
        SAmbient->Brush->Color = ColorDialog1->Color;
        _ambientCol = TColor2RGB(ColorDialog1->Color);
        _resetRenderer();
    }
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::SbAmbientClick(TObject *Sender)
{
    TbAmbient->Position = _ambient*1000;
    PAmbient->Visible = !PAmbient->Visible;
    SbAmbient->Down = PAmbient->Visible;
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::TbAmbientChange(TObject *Sender)
{
    EAmbient->Text =
        AnsiString::FormatFloat(
            "0.000", (double)TbAmbient->Position/1000.0);
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::ELightChange(TObject *Sender)
{
    _light = ELight->Text.ToDouble();
    TbLight->Position = (int)(_light * 1000.0);
    _resetRenderer();
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::SLightMouseUp(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y)
{
    ColorDialog1->Color = SLight->Brush->Color;
    if (ColorDialog1->Execute()) {
        SLight->Brush->Color = ColorDialog1->Color;
        _lightCol = TColor2RGB(ColorDialog1->Color);
        _resetRenderer();
    }
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::SbLightClick(TObject *Sender)
{
    TbLight->Position = _light * 1000;
    PLight->Visible = !PLight->Visible;
    SbLight->Down = PLight->Visible;
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::TbLightChange(TObject *Sender)
{
    ELight->Text =
        AnsiString::FormatFloat(
            "0.000", (double)TbLight->Position/1000.0);
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::TbPowerChange(TObject *Sender)
{
    _power = TbPower->Position;
    LPower->Caption = AnsiString(1<<_power);
    _resetRenderer();
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::TbNPRPowerChange(TObject *Sender)
{
    _NPRpower = TbNPRPower->Position;
    LNPRPower->Caption = AnsiString(1<<_power);
    _resetRenderer();
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::CbSinusClick(TObject *Sender)
{
    _sinus = CbSinus->Checked;
    _resetRenderer();
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::TbRefChange(TObject *Sender)
{
    _RefEdit->Text = AnsiString(TbRef->Position);
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::SbMIPRefClick(TObject *Sender)
{
    _setupRef(SbMIPRef, EMIPRef, TsMIP, _MIPref);
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::EMIPRefChange(TObject *Sender)
{
    _MIPref = AnsiString(EMIPRef->Text).ToDouble();
    _resetRenderer();
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::SbNPRRefClick(TObject *Sender)
{
    _setupRef(SbNPRRef, ENPRRef, TsNPR, _NPRref);
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::ENPRRefChange(TObject *Sender)
{
    _NPRref = AnsiString(ENPRRef->Text).ToDouble();
    _resetRenderer();
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::SbAverageRefClick(TObject *Sender)
{
    _setupRef(SbAverageRef, EAverageRef, TsAverage, _Averageref);
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::EAverageRefChange(TObject *Sender)
{
    _Averageref = AnsiString(EAverageRef->Text).ToDouble();
    _resetRenderer();
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::SbStopClick(TObject *Sender)
{
    _stopIt = true;    
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::SbSaveJpgClick(TObject *Sender)
{
    SbSaveJpg->Enabled = false;
    if (SaveDialogImage->Execute()) {
        Graphics::TBitmap *b = new Graphics::TBitmap();
        b->PixelFormat = pf24bit;
        b->Width = _resolution;
        b->Height = _resolution;
        for(int y=0; y<b->Height; ++y) {
            for(int x=0; x<b->Width; ++x) {
                b->Canvas->Pixels[x][y] =
                    RGB2TColor(_picture[x + (_resolution-1-y)*_resolution]);
            }
        }
        TJPEGImage *jp = new TJPEGImage();
        jp->Assign(b);
        jp->SaveToFile(SaveDialogImage->FileName);
    }
    SbSaveJpg->Enabled = false;
}
//---------------------------------------------------------------------------

void __fastcall TTwoLevelForm::SbStartClick(TObject *Sender)
{
    _resetRenderer();
}
//---------------------------------------------------------------------------

---