---

MDIFirstHit3.cpp

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

#include <vcl.h>
#pragma hdrstop

#include "MDIFirstHit.h"
#include "MDIEdit.h"
#include "MDIFrame.h"
#include <math.h>
#include <fastmath.h>

//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"

#define MIN(x,y)        ((x<y) ? (x) : (y))
#define MAX(x,y)        ((x>y) ? (x) : (y))
rgb *firstview;
TFirstHitForm *FirstHitForm;

const float pi=3.141592;
const float pid2=2*pi;
const float pih=pi/2;
const float pirad=pi/180;

//---------------------------------------------------------------------------
__fastcall TFirstHitForm::TFirstHitForm(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TFirstHitForm::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,0
    };

    PixelFormat = ChoosePixelFormat(hdc, &pfd);
    SetPixelFormat(hdc, PixelFormat, &pfd);
}

//---------------------------------------------------------------------
void __fastcall TFirstHitForm::FormClose(TObject *Sender, TCloseAction &Action)
{
delete [] firstview;
Action=caFree;
FrameForm->FirstHit->Checked = false;
memusage = memusage - 3*512*512;
FrameForm->memupdate();
wglDeleteContext(hrc);
ReleaseDC(Handle,hdc);
}
//---------------------------------------------------------------------
void __fastcall TFirstHitForm::FormCreate(TObject *Sender)
{
    int i,a;

    firstview = new rgb[512*512];
    memusage = memusage + 3*512*512;
    FrameForm->memupdate();

    mrotx=0; mroty=0;xres=256;yres=256;thresh = 400;
    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);
    RayCast();
}
//---------------------------------------------------------------------
void __fastcall TFirstHitForm::FormResize(TObject *Sender)
{
        tPanel->Height = ClientHeight-34;
        TrackBar->Height = ClientHeight-36;
        PrepareGLWindow();
        PaintGL();
}
//---------------------------------------------------------------------------
void __fastcall TFirstHitForm::FormPaint(TObject *Sender)
{
        PaintGL();
}
//---------------------------------------------------------------------------
void __fastcall TFirstHitForm::PaintGL()
{
        float i;

        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(xres, yres, GL_RGB, GL_UNSIGNED_BYTE,firstview);
                        // we use unsigned byte (char) to meet speed issues.
                        // 16 bit data (__int16) slows down drawing to much.

        glFlush();
        SwapBuffers(hdc);
}

void __fastcall TFirstHitForm::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)xres, (float)w/(float)yres);}
         else
        {        glOrtho (-nRange*w/h, nRange*w/h, -nRange, nRange, -nRange, nRange);
                glPixelZoom((float)h/(float)xres, (float)h/(float)yres);}

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


void __fastcall TFirstHitForm::FormActivate(TObject *Sender)
{
        PaintGL();
}
//---------------------------------------------------------------------------

void __fastcall TFirstHitForm::RayCast()
{
        int a,i,j,k,maxres;
        __int16 value;
        int aktpos, rowsize,pagesize, px, py, pz;
        int ita, ite;
        float t,ta,te,tx,ty,tz,xrcos,yrcos,zrcos,xrsin,yrsin,zrsin,xrot,yrot,zrot,ac;
        float value1,value2,value3, value4, value11, value22,pfx,pfy,pfz,sx,sy,sz,s1x,s1y;
        float temp;
        bool detail;

        vertex pppos;
        vertex dlookup[1024];

        xres = StrToInt(textx->Text);
        yres = StrToInt(texty->Text);

        xrot = (float)StrToFloat(txrot->Text)*pirad;
//        yrot = (float)StrToFloat(tyrot->Text)*pirad;
        zrot = (float)StrToFloat(tzrot->Text)*pirad;

        xrcos = _fm_cos(xrot);
//        yrcos = _fm_cos(yrot);
        zrcos = _fm_cos(zrot);
        xrsin = _fm_sin(xrot);
//        yrsin = _fm_sin(yrot);
        zrsin = _fm_sin(zrot);

        FrameForm->StatusProgress->Position = 0;
        FrameForm->StatusProgress->Visible = true;
        maxres = MAX(MAX(sizeX,sizeY),sizeZ);

        dx.x = (float)maxres/(float)xres;
        dx.y = 0;
        dx.z = 0;

        temp = dx.y;

        dx.x = dx.x;
        dx.y = temp * xrcos - dx.z*xrsin;
        dx.z = temp * xrsin + dx.z*xrcos;

        temp = dx.x;

        dx.x = temp * zrcos - dx.y * zrsin;
        dx.y = temp * zrsin + dx.y * zrcos;
        dx.z = dx.z;

        dy.x = 0;
        dy.y = 0;
        dy.z = (float)maxres/(float)yres;

        temp = dy.y;

        dy.x = dy.x;
        dy.y = temp * xrcos - dy.z*xrsin;
        dy.z = temp * xrsin + dy.z*xrcos;

        temp = dy.x;

        dy.x = temp * zrcos - dy.y * zrsin;
        dy.y = temp * zrsin + dy.y * zrcos;
        dy.z = dy.z;


        dz.x = 0;
        dz.y = 1;
        dz.z = 0;

        temp = dz.y;

        dz.x = dz.x;
        dz.y = temp * xrcos - dz.z*xrsin;
        dz.z = temp * xrsin + dz.z*xrcos;

        temp = dz.x;

        dz.x = temp * zrcos - dz.y * zrsin;
        dz.y = temp * zrsin + dz.y * zrcos;
        dz.z = dz.z;

        o.x = -(maxres/2);
        o.y = -(sizeY/2);
        o.z = -(maxres/2);

        temp = o.y;

        o.x = o.x;
        o.y = temp * xrcos - o.z*xrsin;
        o.z = temp * xrsin + o.z*xrcos;

        temp = o.x;

        o.x = temp * zrcos - o.y * zrsin;
        o.y = temp * zrsin + o.y * zrcos;
        o.z = o.z;

        o.x = o.x + sizeX/2;
        o.y = o.y + sizeY/2;
        o.z = o.z + sizeZ/2;

        pagesize = sizeX*sizeY;
        rowsize = sizeX;

        for (i=0; i<1024; i++)
        {
        dlookup[i].x = (i-512) * dz.x;        //Lookup-Values für RayCast berechnen
        dlookup[i].y = (i-512) * dz.y;
        dlookup[i].z = (i-512) * dz.z;
        }

        k = 0;
        for (a=0; a<yres; a++)
        {
                pppos.x = o.x + a * dy.x;
                pppos.y = o.y + a * dy.y;
                pppos.z = o.z + a * dy.z;

                if (arepaint->Checked == false) {FrameForm->StatusProgress->Position = (int)(100 * ((float)a / (float)yres));}
                for (i=0; i<xres; i++)
                {
                        ppos.x = pppos.x + i * dx.x;     // Rotierten Startpunkt für parametrisierte
                        ppos.y = pppos.y + i * dx.y;     // Gerade berechnen ...
                        ppos.z = pppos.z + i * dx.z;

                        ta = 9999;
                        te = 9999;

                        if (dz.x!=0)
                        {
                          t = -ppos.x/dz.x;                      // Schneide Ray mit x=0
                          ty = ppos.y + t*dz.y;
                          tz = ppos.z + t*dz.z;
                          if (ty>=0 && tz>=0 && ty<sizeY && tz<sizeZ) { if (ta==9999) ta=t; else te=t; }

                          t = (sizeX-ppos.x)/dz.x;               // Schneide Ray mit x=sizeX
                          ty = ppos.y + t*dz.y;
                          tz = ppos.z + t*dz.z;
                          if (ty>=0 && tz>=0 && ty<sizeY && tz<sizeZ) { if (ta==9999) ta=t; else te=t; }
                        }

                        if (dz.y!=0)
                        {
                          t = -ppos.y/dz.y;                      // Schneide Ray mit y=0
                          tx = ppos.x + t*dz.x;
                          tz = ppos.z + t*dz.z;
                          if (tx>=0 && tz>=0 && tx<sizeX && tz<sizeZ) { if (ta==9999) ta=t; else te=t; }

                          t = (sizeY-ppos.y)/dz.y;               // Schneide Ray mit y=sizeY
                          tx = ppos.x + t*dz.x;
                          tz = ppos.z + t*dz.z;
                          if (tx>=0 && tz>=0 && tx<sizeX && tz<sizeZ) { if (ta==9999) ta=t; else te=t; }
                        }

                        if (dz.z!=0)
                        {
                          t = -ppos.z/dz.z;                      // Schneide Ray mit z=0
                          tx = ppos.x + t*dz.x;
                          ty = ppos.y + t*dz.y;
                          if (tx>=0 && ty>=0 && tx<sizeX && ty<sizeY) { if (ta==9999) ta=t; else te=t; }

                          t = (sizeZ-ppos.z)/dz.z;               // Schneide Ray mit z=sizeZ
                          tx = ppos.x + t*dz.x;
                          ty = ppos.y + t*dz.y;
                          if (tx>=0 && ty>=0 && tx<sizeX && ty<sizeY) { if (ta==9999) ta=t; else te=t; }
                        }

                        if (ta>te) {t=ta; ta=te; te=t;}

                        detail=0;

                        if (te==9999)
                        {
                        firstview[k].r=firstview[k].b=firstview[k].g = 0;
                        }
                        else
                        {
                        value = 0; ita = (int)ta+512; ite = (int)te+512-2;
                        for (j=ita; j<ite && value<thresh; j++)
                        { if (detail==0) j += 2;
/*
                          pfx = (ppos.x) + j * dz.x;
                          pfy = (ppos.y) + j * dz.y;
                          pfz = (ppos.z) + j * dz.z;
*/
label1:                   pfx = (ppos.x) + dlookup[j].x;
                          pfy = (ppos.y) + dlookup[j].y;
                          pfz = (ppos.z) + dlookup[j].z;

                          px = (int)pfx;
                          py = (int)pfy;
                          pz = (int)pfz;
                          aktpos = pagesize*pz + rowsize*py + px;
                          if (trilinear->Checked)
                          {
                                sx = pfx-px;
                                sy = pfy-py;
                                sz = pfz-pz;
                                s1x = 1-sx;
                                s1y = 1-sy;
                                value1 = (float)data[aktpos]*s1x                  + (float)data[aktpos+1]*sx;
                                value2 = (float)data[aktpos+rowsize]*s1x          + (float)data[aktpos+rowsize+1]*sx;
                                value3 = (float)data[aktpos+pagesize+rowsize]*s1x + (float)data[aktpos+pagesize+rowsize+1]*sx;
                                value4 = (float)data[aktpos+pagesize]*s1x         + (float)data[aktpos+pagesize+1]*sx;
                                value11 = value1*(s1y) + value2*(sy);
                                value22 = value4*(s1y) + value3*(sy);
                                value = (int)(value11*(1-sz) + value22*(sz));
                          }
                          else
                          {
                                value = data[pagesize*pz + rowsize*py + px];
                          }

                          if (value>= thresh)

                          {     if (detail==0) {detail=1;j -= 2; goto label1;}
                                if (trilinear2->Checked)
                                {
                                sx = pfx-px;
                                sy = pfy-py;
                                sz = pfz-pz;
                                s1x = 1-sx;
                                value1 = (float)gradient[aktpos].y*s1x                  + (float)gradient[aktpos+1].y*sx;
                                value2 = (float)gradient[aktpos+rowsize].y*s1x          + (float)gradient[aktpos+rowsize+1].y*sx;
                                value3 = (float)gradient[aktpos+pagesize+rowsize].y*s1x + (float)gradient[aktpos+pagesize+rowsize+1].y*sx;
                                value4 = (float)gradient[aktpos+pagesize].y*s1x         + (float)gradient[aktpos+pagesize+1].y*sx;
                                value11 = value1*(1-sy) + value2*(sy);
                                value22 = value4*(1-sy) + value3*(sy);

                                ac=_fm_acos((value11*(1-sz) + value22*(sz)));
                                if (ac>(pih))
                                {
                                        firstview[k].r=firstview[k].b=firstview[k].g = 0;
                                }
                                else
                                {
                                        firstview[k].r=firstview[k].b=firstview[k].g = (255-160*ac);
                                }
                                }
                                else
                                {
                                ac=_fm_acos(gradient[pagesize*pz + rowsize*py + px].y);
                                if (ac>(pih))
                                {
                                        firstview[k].r=firstview[k].b=firstview[k].g = 0;
                                }
                                else
                                {
                                        firstview[k].r=firstview[k].b=firstview[k].g = 255-160*ac;
                                }

                                }
                          }
                          else {firstview[k].r=firstview[k].b=firstview[k].g=0;}
                        }
                        }

                k++;
                }
        }
        FrameForm->StatusProgress->Visible = false;
}

void __fastcall TFirstHitForm::TrackBarChange(TObject *Sender)
{
threshhold->Caption = IntToStr(TrackBar->Position);
thresh = TrackBar->Position;
if (arepaint->Checked) {RayCast(); PaintGL(); }
}
//---------------------------------------------------------------------------

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



void __fastcall TFirstHitForm::FormMouseDown(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y)
{
mdown=true;
ox = X;
oy = Y;
}
//---------------------------------------------------------------------------



void __fastcall TFirstHitForm::FormMouseUp(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y)
{
mdown=false;
RayCast();
PaintGL();
}
//---------------------------------------------------------------------------

void __fastcall TFirstHitForm::FormMouseMove(TObject *Sender,
      TShiftState Shift, int X, int Y)
{
if (mdown)
{
mrotx -= (Y-oy);
mroty -= (X-ox);
if (mrotx<0) mrotx += 360;
if (mrotx>360) mrotx -= 360;
if (mroty<0) mroty += 360;
if (mroty>360) mroty -= 360;

if (arepaint->Checked) {RayCast(); PaintGL(); }
txrot->Text = IntToStr(mrotx);
tzrot->Text = IntToStr(mroty);
ox = X;
oy = Y;
}
}
//---------------------------------------------------------------------------

---