---

MDIFrame.cpp

//----------------------------------------------------------------------------
//Borland C++Builder
//Copyright (c) 1987, 1998-2002 Borland International Inc. All Rights Reserved.
//----------------------------------------------------------------------------
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop

#include "MDIFrame.h"
#include "MDIFirstHit.h"
#include "MDIEdit.h"
#include "MDISlice.h"
#include "MDIGradient.h"

#include "MDIMarchingCubes.h"
#include "MDICuberille.h"
#include "MDIIsovalue.h"
#include "MDIRegionBoundary.h"
#include "MDITransparent.h"
#include "MDIAverage.h"
#include "MDINPR.h"
#include "MDIMIP.h"
#include "about.h"
#include "MDITransfer.h"
#include "MDITwoLevel.h"
#include <fastmath.h>
#include <math.h>
//---------------------------------------------------------------------------
#pragma resource "*.dfm"

#define MIN(x,y)        ((x<y) ? (x) : (y))
#define MAX(x,y)        ((x>y) ? (x) : (y))

TFrameForm *FrameForm;

//---------------------------------------------------------------------------
__fastcall TFrameForm::TFrameForm(TComponent* Owner)
    : TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TFrameForm::Exit1Click(TObject *Sender)
{
  Close();
}
//---------------------------------------------------------------------
void __fastcall TFrameForm::Tile1Click(TObject *Sender)
{
  Tile();
}
//---------------------------------------------------------------------
void __fastcall TFrameForm::Cascade1Click(TObject *Sender)
{
  Cascade();
}
//---------------------------------------------------------------------
void __fastcall TFrameForm::Arrangeicons1Click(TObject *Sender)
{
  ArrangeIcons();
}
//---------------------------------------------------------------------
void __fastcall TFrameForm::Open1Click(TObject *Sender)
{
  if(OpenFileDialog->Execute()){ this->Repaint();
        if (loadFile(OpenFileDialog->FileName)){
                        filename->Caption = OpenFileDialog->FileName;
                        dimensions->Caption = IntToStr(sizeX) + " x " +IntToStr(sizeY) + " x " + IntToStr(sizeZ);
                        CoolBar->Visible = true;
                        Ansicht1->Enabled = true;
                        Window1->Enabled = true;
                        Close1->Enabled = true;
                }
  }
}
//---------------------------------------------------------------------
void __fastcall TFrameForm::SlicesClick(TObject *Sender)
{
  if (Slices->Checked)
  {
        SliceForm->Close();
        Slices->Checked = false;
  }
  else
  {
        SliceForm = new TSliceForm(this);
        Slices->Checked = true;
  }
}
//---------------------------------------------------------------------------



void __fastcall TFrameForm::GradientSlicesClick(TObject *Sender)
{
  if (GradientSlices->Checked)
  {
        GradientForm->Close();
        GradientSlices->Checked = false;
  }
  else
  {
        GradientForm = new TGradientForm(this);
        GradientSlices->Checked = true;
  }

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

void __fastcall TFrameForm::AverageClick(TObject *Sender)
{
  if (Average->Checked)
  {
        AverageForm->Close();
        Average->Checked = false;
  }
  else
  {
        AverageForm = new TAverageForm(this);
        Average->Checked = true;
  }

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

void __fastcall TFrameForm::FirstHitClick(TObject *Sender)
{
  if (FirstHit->Checked)
  {
        FirstHitForm->Close();
        FirstHit->Checked = false;
  }
  else
  {
        FirstHitForm = new TFirstHitForm(this);
        FirstHit->Checked = true;
  }

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

void __fastcall TFrameForm::TransparentClick(TObject *Sender)
{
 if (Transparent->Checked)
  {
        TransparentForm->Close();
        Transparent->Checked = false;
  }
  else
  {
        TransparentForm = new TTransparentForm(this);
        Transparent->Checked = true;
  }

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

void __fastcall TFrameForm::CuberilleClick(TObject *Sender)
{
  if (Cuberille->Checked)
  {
        CuberilleForm->Close();
        Cuberille->Checked = false;
  }
  else
  {
        CuberilleForm = new TCuberilleForm(this);
        Cuberille->Checked = true;
  }

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


void __fastcall TFrameForm::MIPClick(TObject *Sender)
{
  if (MIP->Checked)
  {
        MIPForm->Close();
        MIP->Checked = false;
  }
  else
  {
        MIPForm = new TMIPForm(this);
        MIP->Checked = true;
  }

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

void __fastcall TFrameForm::NPRClick(TObject *Sender)
{
 if (NPR->Checked)
  {
        NPRForm->Close();
        NPR->Checked = false;
  }
  else
  {
        NPRForm = new TNPRForm(this);
        NPR->Checked = true;
  }

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


void __fastcall TFrameForm::Saveas1Click(TObject *Sender)
{
  if(SaveFileDialog->Execute()){

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

void __fastcall TFrameForm::Print1Click(TObject *Sender)
{
  if(PrintDialog->Execute()){

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

void __fastcall TFrameForm::Close1Click(TObject *Sender)
{
        filename->Caption = "";
        dimensions->Caption = "0 x 0 x 0";
        CoolBar->Visible = false;
        Ansicht1->Enabled = false;
        Window1->Enabled = false;
        Close1->Enabled = false;
        Open1->Enabled = true;
        deallocate();

}
//---------------------------------------------------------------------------
bool __fastcall TFrameForm::loadFile(AnsiString name)
{
        int pagesize, i;
        double d;

        // Getting data set size:
        ifstream f(name.c_str(), ios::binary|ios::in);

        // read the 6 byte header:
        sizeX = _readInt16(f);
        sizeY = _readInt16(f);
        sizeZ = _readInt16(f);

        pagesize = sizeX*sizeY;

        // reading data:
        StatusProgress->Visible = true;
        size = sizeX*sizeY*sizeZ;

        deallocate();

        data = new __int16[size];
        histo = new THistogram(4096);
        histo->horizontal = false;
        contr = new TContrast(histo->size);
        transe = new TTransfer(histo);
        gradient = new vertex[size+pagesize];
//        gradient2 = new vertex[size];
        absgrad = new __int16[size];
        color = new rgba[size];

        memusage = memusage + size*2;   //data
        memusage = memusage + sizeof(THistogram)+4096*sizeof(__int16);   //histo
        memusage = memusage + sizeof(TContrast); //contr
        memusage = memusage + sizeof(TTransfer); //transe
        memusage = memusage + size*4*3; //gradient
        memusage = memusage + size*2;   //absgrad
        memusage = memusage + size*4;   //color
        memupdate();

        StatusMain->Caption = "Reading File ...";
        StatusMain->Repaint();
        // Reading data in blocks of size "sizeX*__valsize":
        char * buff = (char *)data;
        int __valsize = sizeof(__int16);
        for(int i = 0; i<size*__valsize; i+=(sizeX*__valsize)) {
                f.read(buff+i, sizeX*__valsize);
                StatusProgress->Position = 10*(float(i)/float(size*__valsize))+1;
        }
        for (i=0; i<size; i++)
        { if (data[i]<0) data[i]=0;
          if (data[i]>4095) data[i]=4095; }

        // calculating colors:

        StatusMain->Caption = "Calculating Gradient ...";
        StatusMain->Repaint();

        __int16 dataMax = 0;
        //      step 1: get maximum intensity:

        for (i=0; i<size; i++)
        {
        //        get gradient, then normalize it and store length in absgrad
                if (i<pagesize || i>size-pagesize) { gradient[i].x = gradient[i].y = gradient[i].z=0;absgrad[i]=0.0000001;}
                else
                {
                gradient[i].x = (data[i+1]-data[i-1])/2;
                gradient[i].y = (data[i+sizeX]-data[i-sizeX])/2;
                gradient[i].z = (data[i+pagesize]-data[i-pagesize])/2;
                absgrad[i] = _fm_sqrt(gradient[i].x*gradient[i].x + gradient[i].y*gradient[i].y + gradient[i].z * gradient[i].z);
                d = (double)sqrt(gradient[i].x*gradient[i].x + gradient[i].y*gradient[i].y + gradient[i].z * gradient[i].z);
                gradient[i].x = (float)(gradient[i].x / d);
                gradient[i].y = (float)(gradient[i].y / d);
                gradient[i].z = (float)(gradient[i].z / d);
                }
                if (!(i%(sizeX*sizeY)))
                        StatusProgress->Position = 10+70*(float(i)/float(size))+1;
        }

/*        for (i=0; i<size; i++)
        {

                if (i==0 || i==size-1)
                {
                if (i==0) { gradient[i].x = (data[i+1])/2;}
                if (i==size-1) { gradient[i].x = (0-data[i-1])/2;  }
                }
                else
                {
                gradient[i].x = (data[i+1]-data[i-1])/2;
                }

                if (i<sizeX || i>size-sizeX-1)
                {
                if (i<sizeX) { gradient[i].y = (data[i+sizeX])/2; }
                if (i>size-sizeX-1) { gradient[i].y = (0-data[i-sizeX])/2;   }
                }
                else
                {
                gradient[i].y = (data[i+sizeX]-data[i-sizeX])/2;
                }

                if (i<pagesize || i>size-pagesize-1)
                {
                if (i<pagesize) { gradient[i].z= (data[i+pagesize])/2;  }
                if (i>size-pagesize-1) { gradient[i].z = (0-data[i-pagesize])/2;  }
                }
                else
                {
                gradient[i].z = (data[i+pagesize]-data[i-pagesize])/2;
                }

                absgrad[i] = _fm_sqrt(gradient[i].x*gradient[i].x + gradient[i].y*gradient[i].y + gradient[i].z * gradient[i].z);
                gradient[i].x = (gradient[i].x / absgrad[i]);
                gradient[i].y = (gradient[i].y / absgrad[i]);
                gradient[i].z = (gradient[i].z / absgrad[i]);


            if (!(i%(sizeX*sizeY)))
                        StatusProgress->Position = 10+70*(float(i)/float(size))+1;
        }
*/
  /*      for (i=pagesize; i<size-pagesize; i++)
       {
                gradient2[i].x = (gradient[i+1].x+gradient[i-1].x+gradient[i+sizeX].x+gradient[i-sizeX].x+gradient[i+pagesize].x+gradient[i-pagesize].x+gradient[i].x*2)/8;
                gradient2[i].y = (gradient[i+1].y+gradient[i-1].y+gradient[i+sizeX].y+gradient[i-sizeX].y+gradient[i+pagesize].y+gradient[i-pagesize].y+gradient[i].y*2)/8;
                gradient2[i].z = (gradient[i+1].z+gradient[i-1].z+gradient[i+sizeX].z+gradient[i-sizeX].z+gradient[i+pagesize].z+gradient[i-pagesize].z+gradient[i].z*2)/8;
                StatusProgress->Position = 100*(float(i)/float(size));
        }
  */
        StatusMain->Caption = "Mapping Colors ...";
        StatusMain->Repaint();
        dataMax = 4095;
        //      step 2: fit intensity to color range:
        float ratio = (float)0xFF / (float)dataMax;
        for (int i=0; i<size; ++i)
        {
                color[i].r = color[i].g = color[i].b =
                        (unsigned char)((float)data[i]*ratio);
                if (data[i]>350) {

                        if (data[i]>1200) {
                                color[i].a = 255;
                                color[i].r = 255;
                                color[i].g = 0;
                                color[i].b = 0;
                        } else {
                                color[i].a = 10;
                                color[i].r = 0;
                                color[i].g = 0;
                                color[i].b = 255;
                        }
                } else {
                        color[i].a = 0;
                }

//                color[i].a = 1;
                ++((*histo)[data[i]]);
                if (!(i%(sizeX*sizeY)))
                        StatusProgress->Position = 80+20*(float(i)/float(size))+1;
        }

        StatusMain->Caption = "";
        StatusProgress->Visible = false;
        return true;
}
//---------------------------------------------------------------------------
__int16 __fastcall TFrameForm::_readInt16(ifstream & ifs)
{
        char tmp[2];
        tmp[0] = ifs.get();
        tmp[1] = ifs.get();
        __int16 *res = (__int16 *)tmp;
        return *res;
}

void __fastcall TFrameForm::FormClose(TObject *Sender,
      TCloseAction &Action)
{
        deallocate();
}
//---------------------------------------------------------------------------

void __fastcall TFrameForm::About1Click(TObject *Sender)
{
AboutBox = new TAboutBox(this);
AboutBox->ShowModal();

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


void __fastcall TFrameForm::deallocate()
{

        if (color) {delete [] color;memusage = memusage - size*4;color = NULL;}
        if (gradient) {delete [] gradient; memusage = memusage - size*4*3;gradient = NULL;}
        if (absgrad) {delete [] absgrad; memusage = memusage - size*2;absgrad = NULL;}
        if (data) {delete [] data;memusage = memusage - size*2;data = NULL;}
        if (histo) {delete histo;memusage = memusage - sizeof(THistogram)-4096*sizeof(__int16);histo = NULL;}
        if (contr) {delete contr;memusage = memusage - sizeof(TContrast);contr = NULL;}
        if (transe) {delete transe;memusage = memusage - sizeof(TTransfer);transe = NULL;}
memupdate();
}


void __fastcall TFrameForm::FormResize(TObject *Sender)
{
StatusMain->Width = (Width-168)/2;
StatusMain2->Width = StatusMain->Width;
StatusMain2->Left = StatusMain->Width + 7;
StatusProgress->Width = StatusMain->Width-10;
}
//---------------------------------------------------------------------------

void __fastcall TFrameForm::FormCreate(TObject *Sender)
{
StatusDate->Caption = DateToStr(Date());
memusage = 0;
memupdate();
}
//---------------------------------------------------------------------------
void __fastcall TFrameForm::memupdate()
{
StatusMem->Caption = FloatToStrF(memusage/1000, ffNumber, 7,0) + " K";
StatusMem->Repaint();
}
//---------------------------------------------------------------------------
void __fastcall TFrameForm::METransferfunktionClick(TObject *Sender)
{
  if (METransferfunktion->Checked)
  {
        TransferForm->Close();
        METransferfunktion->Checked = false;
  }
  else
  {
        TransferForm = new TTransferForm(this, transe);
        METransferfunktion->Checked = true;
  }
}
//---------------------------------------------------------------------------

void __fastcall TFrameForm::TwoLevelClick(TObject *Sender)
{
  if (TwoLevel->Checked)
  {
        TwoLevelForm->Close();
        TwoLevel->Checked = false;
  }
  else
  {
        TwoLevelForm = new TTwoLevelForm(this);
        TwoLevel->Checked = true;
  }
}
//---------------------------------------------------------------------------

---