---

MDIFirstHit.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 pi2=2*pi;
const float pih=pi/2;
const float pirad=pi/180;

bool mdown;

//---------------------------------------------------------------------------
__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*1024*1024;
FrameForm->memupdate();
wglDeleteContext(hrc);
ReleaseDC(Handle,hdc);
}
//---------------------------------------------------------------------
void __fastcall TFirstHitForm::FormCreate(TObject *Sender)
{
    int i,a;

    firstview = new rgb[1024*1024];
    memusage = memusage + 3*1024*1024;
    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();
        if (autores->Checked) {RayCast();}
        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 h,ita, ite, detval, detincval;
        float t,ta,te,tx,ty,tz,xrcos,yrcos,zrcos,xrsin,yrsin,zrsin,xrot,yrot,zrot;
        float valgx,valgy,valgz,value1,value2,value3, value4, value11, value22,pfx,pfy,pfz,sx,sy,sz,s1x,s1y;
        float temp;
        bool detset;
        double valsh, ac, ac2;
        float lx, ly, lz;
        unsigned char col;

        detval=DetTrackBar->Position-1;
        vertex pppos;
        vertex dlookup[1024];
        if (autores->Checked)
        { if (w>h) {xres=h;yres=h;} else {xres=w;yres=w;} }
        else
        {
        xres = StrToInt(textx->Caption);
        yres = StrToInt(texty->Caption);
        }
        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);


        lx =0; ly=1; lz=0;

        temp = ly;
        ly = temp*xrcos - lz * xrsin;
        lz = temp*xrsin + lz * xrcos;

        temp = lx;
        lx = temp*zrcos - ly * zrsin;
        ly = temp*zrsin + ly * zrcos;


        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>=2 && ty<sizeY-1 && tz<sizeZ-3) { if (ta==9999) ta=t; else te=t; }

                          t = (sizeX-1-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>=2 && ty<sizeY-1 && tz<sizeZ-3) { 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>=2 && tx<sizeX-1 && tz<sizeZ-3) { if (ta==9999) ta=t; else te=t; }

                          t = (sizeY-1-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>=2 && tx<sizeX-1 && tz<sizeZ-3) { if (ta==9999) ta=t; else te=t; }
                        }

                        if (dz.z!=0)
                        {
                          t = (2-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-1 && ty<sizeY-1) { if (ta==9999) ta=t; else te=t; }

                          t = (sizeZ-3-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-1 && ty<sizeY-1) { if (ta==9999) ta=t; else te=t; }
                        }

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

                        detset=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-detval;
                        for (j=ita; j<ite && value<thresh; j++)
                        { if (detset==0) j += detval;
/*
                          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 (adapt->Checked) { if (detset==0 && detval>0) {detset=1;j -= detval; 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);
                                valgy=((value11*(1-sz) + value22*(sz)));

                                value1 = (float)gradient[aktpos].x*s1x                  + (float)gradient[aktpos+1].x*sx;
                                value2 = (float)gradient[aktpos+rowsize].x*s1x          + (float)gradient[aktpos+rowsize+1].x*sx;
                                value3 = (float)gradient[aktpos+pagesize+rowsize].x*s1x + (float)gradient[aktpos+pagesize+rowsize+1].x*sx;
                                value4 = (float)gradient[aktpos+pagesize].x*s1x         + (float)gradient[aktpos+pagesize+1].x*sx;
                                value11 = value1*(1-sy) + value2*(sy);
                                value22 = value4*(1-sy) + value3*(sy);
                                valgx=((value11*(1-sz) + value22*(sz)));

                                value1 = (float)gradient[aktpos].z*s1x                  + (float)gradient[aktpos+1].z*sx;
                                value2 = (float)gradient[aktpos+rowsize].z*s1x          + (float)gradient[aktpos+rowsize+1].z*sx;
                                value3 = (float)gradient[aktpos+pagesize+rowsize].z*s1x + (float)gradient[aktpos+pagesize+rowsize+1].z*sx;
                                value4 = (float)gradient[aktpos+pagesize].z*s1x         + (float)gradient[aktpos+pagesize+1].z*sx;
                                value11 = value1*(1-sy) + value2*(sy);
                                value22 = value4*(1-sy) + value3*(sy);
                                valgz=((value11*(1-sz) + value22*(sz)));

                                valsh = fabs(valgx*lx+valgy*ly+valgz*lz);
                                if (valsh<0) {valsh=0.0;}
                                //if (valsh>1) {valsh=1.0;}
                                ac = (_fm_acosl(valsh));
                                if (ac<0) {ac=0;}
                                if (ac>pih) {ac=pih;}
                                ac = 1-(ac/pih);
                                //ac = valsh;
                                //ac = fabs(valsh);
                                //ac2 = 1-(_fm_acosl(valsh)/pih);
                                //if (ac2<0) {ac2=0;}

                                if (highlights->Checked) {
                                valsh = valsh*valsh;
                                valsh = valsh*valsh;
                                valsh = valsh*valsh;
                                valsh = valsh*valsh;
                                valsh = valsh*valsh;
                                valsh = valsh*valsh;
                                ac2 = valsh + ac;
                                h = (int)255*ac2;
                                if (h>255) {col=255;} else {col = h;}
                                }
                                else {col = (int)255*ac;}



                                /*ac=_fm_acosl(valsh);
                                ac2=_fm_acosl(valsh);

                                if (ac<0) {ac=0;}
                                if (ac>pih) {ac=pih;}
                                if (ac2<0) {ac2=0;}
                                if (ac2>pih) {ac2=pih;}

                                ac = pih-ac;
                                ac2 = pih-ac2;
                                */



                                //if (highlights->Checked) {if (col+40*ac2>255) {col=255;} else {col=col+40*ac2;}}


/*                                if (ac>(pih))
                                {
                                        firstview[k].r=firstview[k].b=firstview[k].g = 0;
                                }
                                else
                                {*/
                                        firstview[k].r=firstview[k].b=firstview[k].g = (col);
//                                }
                                }
                                else
                                {
                                valsh = fabs(gradient[pagesize*pz + rowsize*py + px].x*lx+gradient[pagesize*pz + rowsize*py + px].y*ly+gradient[pagesize*pz + rowsize*py + px].z*lz);
                                //if (valsh<0) {valsh=0.0;}
                                //if (valsh>1) {valsh=1.0;}
                                ac=_fm_acos(valsh);
                                if (ac<0) {ac=0;}
                                if (ac>pih) {ac=pih;}
                                ac = 1-(ac/pih);

                                if (highlights->Checked) {
                                valsh = valsh*valsh;
                                valsh = valsh*valsh;
                                valsh = valsh*valsh;
                                valsh = valsh*valsh;
                                valsh = valsh*valsh;
                                valsh = valsh*valsh;
                                ac2 = valsh + ac;
                                h = (int)255*ac2;
                                if (h>255) {col=255;} else {col = h;}
                                }
                                else {col = (int)255*ac;}


/*                                if (ac>(pih))
                                {
                                        firstview[k].r=firstview[k].b=firstview[k].g = 0;
                                }
                                else
                                {
*/                                        firstview[k].r=firstview[k].b=firstview[k].g = col;
//                                }

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

                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::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;
}
}
//---------------------------------------------------------------------------

void __fastcall TFirstHitForm::autoresClick(TObject *Sender)
{
if (autores->Checked==true)
        {
        ResTrackBar->Enabled=false;
        textx->Enabled=false;
        Label2->Enabled=false;
        texty->Enabled=false;
        }
        else
        {
        ResTrackBar->Enabled=true;
        textx->Enabled=true;
        Label2->Enabled=true;
        texty->Enabled=true;
        }
if (arepaint->Checked) {RayCast();PaintGL();}

}
//---------------------------------------------------------------------------

void __fastcall TFirstHitForm::adaptClick(TObject *Sender)
{
if (arepaint->Checked) {RayCast();PaintGL();}
}
//---------------------------------------------------------------------------

void __fastcall TFirstHitForm::ResTrackBarChange(TObject *Sender)
{
switch (ResTrackBar->Position)
        {
        case 1: textx->Caption = "32"; texty->Caption = "32"; break;
        case 2: textx->Caption = "64"; texty->Caption = "64"; break;
        case 3: textx->Caption = "128"; texty->Caption = "128"; break;
        case 4: textx->Caption = "256"; texty->Caption = "256"; break;
        case 5: textx->Caption = "512"; texty->Caption = "512"; break;
        case 6: textx->Caption = "1024"; texty->Caption = "1024";
        }
if (arepaint->Checked) {RayCast();PaintGL();}
}
//---------------------------------------------------------------------------

void __fastcall TFirstHitForm::DetTrackBarChange(TObject *Sender)
{
detail->Caption = IntToStr(DetTrackBar->Position);
if (arepaint->Checked) {RayCast();PaintGL();}
}
//---------------------------------------------------------------------------

void __fastcall TFirstHitForm::trilinearClick(TObject *Sender)
{
if (arepaint->Checked) {RayCast();PaintGL();}
        
}
//---------------------------------------------------------------------------

void __fastcall TFirstHitForm::trilinear2Click(TObject *Sender)
{
if (arepaint->Checked) {RayCast();PaintGL();}
       
}
//---------------------------------------------------------------------------

---