---

MDIMIP.cpp

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

#include <vcl.h>
#pragma hdrstop

#include "MDIMIP.h"
#include "MDIEdit.h"
#include "MDIFrame.h"
#define MIN(x,y)        ((x<y) ? (x) : (y))
#define MAX(x,y)        ((x>y) ? (x) : (y))
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TMIPForm *MIPForm;
rgb *MIPview;

const float pi=3.141592;
const float pid2=2*pi;
const float pih=pi/2;
const float pirad=pi/180;
//---------------------------------------------------------------------------
__fastcall TMIPForm::TMIPForm(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TMIPForm::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 TMIPForm::FormClose(TObject *Sender, TCloseAction &Action)
{
delete [] MIPview;
Action=caFree;
FrameForm->MIP->Checked = false;
memusage = memusage - 3*1024*1024;
FrameForm->memupdate();
wglDeleteContext(hrc);
ReleaseDC(Handle,hdc);
}
//---------------------------------------------------------------------
void __fastcall TMIPForm::FormCreate(TObject *Sender)
{
    int i,a;

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

    mrotx=0; mroty=0;xres=128;yres=128;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 TMIPForm::FormResize(TObject *Sender)
{
        PrepareGLWindow();
        if (autores->Checked) {RayCast();}
        PaintGL();
}
//---------------------------------------------------------------------------
void __fastcall TMIPForm::FormPaint(TObject *Sender)
{
        PaintGL();
}
//---------------------------------------------------------------------------
void __fastcall TMIPForm::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,MIPview);
                        // we use unsigned byte (char) to meet speed issues.
                        // 16 bit data (__int16) slows down drawing to much.

        glFlush();
        SwapBuffers(hdc);
}

void __fastcall TMIPForm::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 TMIPForm::FormActivate(TObject *Sender)
{
        PaintGL();        
}
//---------------------------------------------------------------------------

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



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



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

void __fastcall TMIPForm::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 TMIPForm::RayCast()
{
        int a,i,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,j, tmax, tmin;
        long averg, anzavg;
        int detval, maxdim;

        if (sizeX>sizeY) {maxdim=sizeX;} else {maxdim=sizeY;}
        if (maxdim<sizeZ) {maxdim=sizeZ;}

        //detval = StrToInt(detail->Caption);
        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);

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

                        averg = 0;

                        if (te==9999)
                        {
                        MIPview[k].r=MIPview[k].b=MIPview[k].g = 0;
                        }
                        else
                        {
                        value = 0; 

                        for (j=ta; j<te; j += 1.0)
                        {
                          pfx = (ppos.x) + j*dz.x;
                          pfy = (ppos.y) + j*dz.y;
                          pfz = (ppos.z) + j*dz.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));
                                if (depth->Checked){
                                        tmax = j;
                                        if (tmax<0) tmax=0;
                                        if (tmax>maxdim) tmax=maxdim;
                                        if ((value*(maxdim-tmax))>averg) {averg = (value*(maxdim-tmax));}
                                        }
                                        else {
                                        if (value>averg) {averg = value;}
                                        }
                          }
                          else
                          {
                                value = data[pagesize*pz + rowsize*py + px];
                                if (depth->Checked){
                                        tmax = j;
                                        if (tmax<0) tmax=0;
                                        if (tmax>maxdim) tmax=maxdim;
                                        if ((value*(maxdim-tmax))>averg) {averg = (value*(maxdim-tmax));}

                                        }
                                        else {
                                        if (value>averg) {averg = value;}
                                        }
                          }

                         }
                         if (depth->Checked){
                                MIPview[k].r = MIPview[k].g = MIPview[k].b = averg/(16*maxdim);
                                }
                                else {
                                MIPview[k].r = MIPview[k].g = MIPview[k].b = averg/16;
                                }
                         }
                k++;
                }
        }
        FrameForm->StatusProgress->Visible = false;
}


void __fastcall TMIPForm::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 TMIPForm::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 TMIPForm::trilinearClick(TObject *Sender)
{
if (arepaint->Checked) {RayCast();PaintGL();}
        
}
//---------------------------------------------------------------------------

---