MDINPR.cpp Source File

00001 //---------------------------------------------------------------------------
00002 
00003 #include <vcl.h>
00004 #include <math.h>
00005 #pragma hdrstop
00006 
00007 #include "MDINPR.h"
00008 #include "MDIEdit.h"
00009 #include "MDIFrame.h"
00010 #define MIN(x,y)        ((x<y) ? (x) : (y))
00011 #define MAX(x,y)        ((x>y) ? (x) : (y))
00012 //---------------------------------------------------------------------------
00013 #pragma package(smart_init)
00014 #pragma resource "*.dfm"
00015 TNPRForm *NPRForm;
00016 rgb *NPRview;
00017 
00018 float ghisto[128];
00019 const float pi=3.141592;
00020 const float pid2=2*pi;
00021 const float pih=pi/2;
00022 const float pirad=pi/180;
00023 //---------------------------------------------------------------------------
00024 __fastcall TNPRForm::TNPRForm(TComponent* Owner)
00025         : TForm(Owner)
00026 {
00027 }
00028 //---------------------------------------------------------------------------
00029 void __fastcall TNPRForm::SetPixelFormatDescriptor()
00030 {
00031     PIXELFORMATDESCRIPTOR pfd = {
00032         sizeof(PIXELFORMATDESCRIPTOR),
00033         1,
00034         PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
00035         PFD_TYPE_RGBA,
00036         24,
00037         0,0,0,0,0,0,
00038         0,0,
00039         0,0,0,0,0,
00040         32,
00041         0,
00042         0,
00043         PFD_MAIN_PLANE,
00044         0,
00045         0,0,
00046     };
00047     PixelFormat = ChoosePixelFormat(hdc, &pfd);
00048     SetPixelFormat(hdc, PixelFormat, &pfd);
00049 }
00050 
00051 //---------------------------------------------------------------------
00052 void __fastcall TNPRForm::FormClose(TObject *Sender, TCloseAction &Action)
00053 {
00054 delete [] NPRview;
00055 Action=caFree;
00056 FrameForm->NPR->Checked = false;
00057 memusage = memusage - 3*1024*1024;
00058 FrameForm->memupdate();
00059 wglDeleteContext(hrc);
00060 ReleaseDC(Handle,hdc);
00061 }
00062 //---------------------------------------------------------------------
00063 void __fastcall TNPRForm::FormCreate(TObject *Sender)
00064 {
00065     int i,a;
00066 
00067     vr = SFGColor->Brush->Color & 255;
00068     vg = (SFGColor->Brush->Color >> 8) & 255;
00069     vb = (SFGColor->Brush->Color >> 16) & 255;
00070     lr = SBGColor->Brush->Color & 255;
00071     lg = (SBGColor->Brush->Color >> 8) & 255;
00072     lb = (SBGColor->Brush->Color >> 16) & 255;
00073 
00074     ghistomax = 0;
00075     for (i=0; i<128; i++) { ghisto[i]=0;}
00076     for (i=0; i<size; i++) { ghisto[absgrad[i]/32]++; }
00077     for (i=1; i<128; i++) {
00078         if (ghisto[i]>ghistomax) {ghistomax=ghisto[i];}
00079         }
00080     for (i=0; i<128; i++) { ghisto[i]=ghisto[i]*40/ghistomax; }
00081 
00082     if (ghisto[0]>40) ghisto[0]=40;
00083     gmin = 1; gmax = 127; gdragmin = false; gdragmax=false;
00084     garea->Canvas->Pen->Color = clBlack;
00085     garea->Canvas->Brush->Color = clWhite;
00086     NPRview = new rgb[1024*1024];
00087     memusage = memusage + 3*1024*1024;
00088     FrameForm->memupdate();
00089 
00090     mrotx=0; mroty=0;xres=128;yres=128;thresh = 400;
00091     hdc = GetDC(Handle);
00092     SetPixelFormatDescriptor();
00093     hrc = wglCreateContext(hdc);
00094     if(hrc == NULL) ShowMessage("Could not create DC!");
00095     wglMakeCurrent(hdc, hrc);
00096 
00097     w = ClientWidth;
00098     h = ClientHeight;
00099 
00100     glEnable(GL_DEPTH_TEST);
00101     glEnable(GL_CULL_FACE);
00102 
00103     glClearColor(0.2f, 0.2f, 0.2f, 1.0f);
00104     glOrtho (-50.0,50.0,-50.0,50.0,-50.0,50.0);
00105 
00106     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
00107     glFlush();
00108     SwapBuffers(hdc);
00109     FormResize(Sender);
00110     RayCast();
00111 }
00112 //---------------------------------------------------------------------
00113 void __fastcall TNPRForm::FormResize(TObject *Sender)
00114 {
00115         PrepareGLWindow();
00116         if (autores->Checked && arepaint->Checked) {RayCast();}
00117         PaintGL();
00118 }
00119 //---------------------------------------------------------------------------
00120 void __fastcall TNPRForm::FormPaint(TObject *Sender)
00121 {
00122         PaintGL();
00123 }
00124 //---------------------------------------------------------------------------
00125 void __fastcall TNPRForm::PaintGL()
00126 {
00127         float i;
00128 
00129         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
00130         PrepareGLWindow();
00131         glColor3f(0.6f,0.6f,0.6f);
00132         glLineWidth(3.0f);
00133         glBegin(GL_LINE_STRIP);
00134         glVertex3f(-50,-50,0);
00135         glVertex3f(50,-50,0);
00136         glVertex3f(50,50,0);
00137         glVertex3f(-50,50,0);
00138         glVertex3f(-50,-50,0);
00139         glEnd();
00140 
00141         glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
00142         glDrawPixels(xres, yres, GL_RGB, GL_UNSIGNED_BYTE,NPRview);
00143                         // we use unsigned byte (char) to meet speed issues.
00144                         // 16 bit data (__int16) slows down drawing to much.
00145 
00146         glFlush();
00147         SwapBuffers(hdc);
00148 }
00149 
00150 void __fastcall TNPRForm::PrepareGLWindow()
00151 {
00152         wglMakeCurrent(hdc, hrc);
00153 
00154         GLfloat nRange = 50.0;
00155         w = ClientWidth-200;
00156         h = ClientHeight;
00157 
00158         if(h == 0) h = 1;
00159         if(w == 0) w = 1;
00160 
00161         glViewport(200, 0, w, h);
00162         glLoadIdentity();
00163 
00164         if (w <= h)
00165         {        glOrtho (-nRange, nRange, -nRange*h/w, nRange*h/w, -nRange, nRange);
00166                 glPixelZoom((float)w/(float)xres, (float)w/(float)yres);}
00167          else
00168         {        glOrtho (-nRange*w/h, nRange*w/h, -nRange, nRange, -nRange, nRange);
00169                 glPixelZoom((float)h/(float)xres, (float)h/(float)yres);}
00170 
00171         glRasterPos2d(-50,-50);
00172 }
00173 //---------------------------------------------------------------------------
00174 
00175 void __fastcall TNPRForm::FormActivate(TObject *Sender)
00176 {
00177         PaintGL();        
00178 }
00179 //---------------------------------------------------------------------------
00180 
00181 void __fastcall TNPRForm::Button1Click(TObject *Sender)
00182 {
00183 RayCast();
00184 PaintGL();
00185 }
00186 //---------------------------------------------------------------------------
00187 
00188 
00189 
00190 void __fastcall TNPRForm::FormMouseDown(TObject *Sender,
00191       TMouseButton Button, TShiftState Shift, int X, int Y)
00192 {
00193 mdown=true;
00194 ox = X;
00195 oy = Y;
00196 }
00197 //---------------------------------------------------------------------------
00198 
00199 
00200 
00201 void __fastcall TNPRForm::FormMouseUp(TObject *Sender,
00202       TMouseButton Button, TShiftState Shift, int X, int Y)
00203 {
00204 mdown=false;
00205 RayCast();
00206 PaintGL();
00207 }
00208 //---------------------------------------------------------------------------
00209 
00210 void __fastcall TNPRForm::FormMouseMove(TObject *Sender,
00211       TShiftState Shift, int X, int Y)
00212 {
00213 if (mdown)
00214 {
00215 mrotx -= (Y-oy);
00216 mroty -= (X-ox);
00217 if (mrotx<0) mrotx += 360;
00218 if (mrotx>360) mrotx -= 360;
00219 if (mroty<0) mroty += 360;
00220 if (mroty>360) mroty -= 360;
00221 
00222 if (arepaint->Checked) {RayCast(); PaintGL(); }
00223 txrot->Text = IntToStr(mrotx);
00224 tzrot->Text = IntToStr(mroty);
00225 ox = X;
00226 oy = Y;
00227 }
00228 }
00229 //---------------------------------------------------------------------------
00230 void __fastcall TNPRForm::RayCast()
00231 {
00232         int a,i,k,maxres;
00233         __int16 value;
00234         int colx, coly, colz, aktpos, rowsize,pagesize, px, py, pz;
00235         int ita, ite;
00236         float t,ta,te,tx,ty,tz,xrcos,yrcos,zrcos,xrsin,yrsin,zrsin,xrot,yrot,zrot,ac;
00237         float value1,value2,value3, value4, value11, value22,pfx,pfy,pfz,sx,sy,sz,s1x,s1y;
00238         float gscale, jstep, lv, temp,j, tmax, lx, ly, lz, valgx, valgy, valgz, valsh;
00239         long averg, anzavg, aline;
00240         int tlmip, detval, maxdim, levlx, levly, levlz;
00241         bool endcast;
00242 
00243         gscale = 4096/(float)((gmax*32)-(gmin*32));
00244 
00245         jstep = StrToFloat(step->Caption);
00246         tlmip = StrToInt(lmipvalue->Caption);
00247 
00248         levlx = StrToInt(llx->Text);
00249         levly = StrToInt(lly->Text);
00250         levlz = StrToInt(llz->Text);
00251 
00252         if (levlx==0) levlx=9999;
00253         if (levly==0) levly=9999;
00254         if (levlz==0) levlz=9999;
00255 
00256         if (sizeX>sizeY) {maxdim=sizeX;} else {maxdim=sizeY;}
00257         if (maxdim<sizeZ) {maxdim=sizeZ;}
00258         maxdim *= 1.6;
00259 
00260         //detval = StrToInt(detail->Caption);
00261         vertex pppos;
00262         vertex dlookup[1024];
00263 
00264         if (autores->Checked)
00265         { if (w>h) {xres=h;yres=h;} else {xres=w;yres=w;} }
00266         else
00267         {
00268         xres = StrToInt(textx->Caption);
00269         yres = StrToInt(texty->Caption);
00270         }
00271 
00272         xrot = (float)StrToFloat(txrot->Text)*pirad;
00273 //        yrot = (float)StrToFloat(tyrot->Text)*pirad;
00274         zrot = (float)StrToFloat(tzrot->Text)*pirad;
00275 
00276         xrcos = _fm_cos(xrot);
00277 //        yrcos = _fm_cos(yrot);
00278         zrcos = _fm_cos(zrot);
00279         xrsin = _fm_sin(xrot);
00280 //        yrsin = _fm_sin(yrot);
00281         zrsin = _fm_sin(zrot);
00282 
00283         FrameForm->StatusProgress->Position = 0;
00284         FrameForm->StatusProgress->Visible = true;
00285         maxres = MAX(MAX(sizeX,sizeY),sizeZ);
00286 
00287         lx =0; ly=1; lz=0;
00288 
00289         temp = ly;
00290         ly = temp*xrcos - lz * xrsin;
00291         lz = temp*xrsin + lz * xrcos;
00292 
00293         temp = lx;
00294         lx = temp*zrcos - ly * zrsin;
00295         ly = temp*zrsin + ly * zrcos;
00296 
00297 
00298         dx.x = (float)maxres/(float)xres;
00299         dx.y = 0;
00300         dx.z = 0;
00301 
00302         temp = dx.y;
00303 
00304         dx.x = dx.x;
00305         dx.y = temp * xrcos - dx.z*xrsin;
00306         dx.z = temp * xrsin + dx.z*xrcos;
00307 
00308         temp = dx.x;
00309 
00310         dx.x = temp * zrcos - dx.y * zrsin;
00311         dx.y = temp * zrsin + dx.y * zrcos;
00312         dx.z = dx.z;
00313 
00314         dy.x = 0;
00315         dy.y = 0;
00316         dy.z = (float)maxres/(float)yres;
00317 
00318         temp = dy.y;
00319 
00320         dy.x = dy.x;
00321         dy.y = temp * xrcos - dy.z*xrsin;
00322         dy.z = temp * xrsin + dy.z*xrcos;
00323 
00324         temp = dy.x;
00325 
00326         dy.x = temp * zrcos - dy.y * zrsin;
00327         dy.y = temp * zrsin + dy.y * zrcos;
00328         dy.z = dy.z;
00329 
00330 
00331         dz.x = 0;
00332         dz.y = 1;
00333         dz.z = 0;
00334 
00335         temp = dz.y;
00336 
00337         dz.x = dz.x;
00338         dz.y = temp * xrcos - dz.z*xrsin;
00339         dz.z = temp * xrsin + dz.z*xrcos;
00340 
00341         temp = dz.x;
00342 
00343         dz.x = temp * zrcos - dz.y * zrsin;
00344         dz.y = temp * zrsin + dz.y * zrcos;
00345         dz.z = dz.z;
00346 
00347         o.x = -(maxres/2);
00348         o.y = -(sizeY/2);
00349         o.z = -(maxres/2);
00350 
00351         temp = o.y;
00352 
00353         o.x = o.x;
00354         o.y = temp * xrcos - o.z*xrsin;
00355         o.z = temp * xrsin + o.z*xrcos;
00356 
00357         temp = o.x;
00358 
00359         o.x = temp * zrcos - o.y * zrsin;
00360         o.y = temp * zrsin + o.y * zrcos;
00361         o.z = o.z;
00362 
00363         o.x = o.x + sizeX/2;
00364         o.y = o.y + sizeY/2;
00365         o.z = o.z + sizeZ/2;
00366 
00367         pagesize = sizeX*sizeY;
00368         rowsize = sizeX;
00369 
00370         for (i=0; i<1024; i++)
00371         {
00372         dlookup[i].x = (i-512) * dz.x;        //Lookup-Values für RayCast berechnen
00373         dlookup[i].y = (i-512) * dz.y;
00374         dlookup[i].z = (i-512) * dz.z;
00375         }
00376 
00377         k = 0;
00378         for (a=0; a<yres; a++)
00379         {
00380                 pppos.x = o.x + a * dy.x;
00381                 pppos.y = o.y + a * dy.y;
00382                 pppos.z = o.z + a * dy.z;
00383 
00384                 if (arepaint->Checked == false) {FrameForm->StatusProgress->Position = (int)(100 * ((float)a / (float)yres));}
00385                 for (i=0; i<xres; i++)
00386                 {
00387                         ppos.x = pppos.x + i * dx.x;     // Rotierten Startpunkt für parametrisierte
00388                         ppos.y = pppos.y + i * dx.y;     // Gerade berechnen ...
00389                         ppos.z = pppos.z + i * dx.z;
00390 
00391                         ta = 9999;
00392                         te = 9999;
00393 
00394                         if (dz.x!=0)
00395                         {
00396                           t = (1-ppos.x)/dz.x;                      // Schneide Ray mit x=0
00397                           ty = ppos.y + t*dz.y;
00398                           tz = ppos.z + t*dz.z;
00399                           if (ty>=1 && tz>=2 && ty<sizeY-2 && tz<sizeZ-3) { if (ta==9999) ta=t; else te=t; }
00400 
00401                           t = (sizeX-2-ppos.x)/dz.x;               // Schneide Ray mit x=sizeX
00402                           ty = ppos.y + t*dz.y;
00403                           tz = ppos.z + t*dz.z;
00404                           if (ty>=1 && tz>=2 && ty<sizeY-2 && tz<sizeZ-3) { if (ta==9999) ta=t; else te=t; }
00405                         }
00406 
00407                         if (dz.y!=0)
00408                         {
00409                           t = (1-ppos.y)/dz.y;                      // Schneide Ray mit y=0
00410                           tx = ppos.x + t*dz.x;
00411                           tz = ppos.z + t*dz.z;
00412                           if (tx>=1 && tz>=2 && tx<sizeX-2 && tz<sizeZ-3) { if (ta==9999) ta=t; else te=t; }
00413 
00414                           t = (sizeY-2-ppos.y)/dz.y;               // Schneide Ray mit y=sizeY
00415                           tx = ppos.x + t*dz.x;
00416                           tz = ppos.z + t*dz.z;
00417                           if (tx>=1 && tz>=2 && tx<sizeX-2 && tz<sizeZ-3) { if (ta==9999) ta=t; else te=t; }
00418                         }
00419 
00420                         if (dz.z!=0)
00421                         {
00422                           t = (2-ppos.z)/dz.z;                      // Schneide Ray mit z=0
00423                           tx = ppos.x + t*dz.x;
00424                           ty = ppos.y + t*dz.y;
00425                           if (tx>=1 && ty>=1 && tx<sizeX-2 && ty<sizeY-2) { if (ta==9999) ta=t; else te=t; }
00426 
00427                           t = (sizeZ-3-ppos.z)/dz.z;               // Schneide Ray mit z=sizeZ
00428                           tx = ppos.x + t*dz.x;
00429                           ty = ppos.y + t*dz.y;
00430                           if (tx>=1 && ty>=1 && tx<sizeX-2 && ty<sizeY-2) { if (ta==9999) ta=t; else te=t; }
00431                         }
00432 
00433                         if (ta>te) {t=ta; ta=te; te=t;}
00434 
00435                         averg = 0;
00436 
00437                         if (te==9999)
00438                         {
00439                         NPRview[k].r=NPRview[k].b=NPRview[k].g = 0;
00440                         }
00441                         else
00442                         {
00443                         value = 0;
00444                         aline = 0;
00445                         endcast=false;
00446                         for (j=ta; j<te && endcast==false; j += jstep)
00447                         {
00448                           pfx = (ppos.x) + j*dz.x;
00449                           pfy = (ppos.y) + j*dz.y;
00450                           pfz = (ppos.z) + j*dz.z;
00451 
00452                           px = (int)pfx;
00453                           py = (int)pfy;
00454                           pz = (int)pfz;
00455                           aktpos = pagesize*pz + rowsize*py + px;
00456                           if (trilinear->Checked)
00457                           {
00458                                 sx = pfx-px;
00459                                 sy = pfy-py;
00460                                 sz = pfz-pz;
00461                                 s1x = 1-sx;
00462                                 s1y = 1-sy;
00463                                 value1 = (float)absgrad[aktpos]*s1x                  + (float)absgrad[aktpos+1]*sx;
00464                                 value2 = (float)absgrad[aktpos+rowsize]*s1x          + (float)absgrad[aktpos+rowsize+1]*sx;
00465                                 value3 = (float)absgrad[aktpos+pagesize+rowsize]*s1x + (float)absgrad[aktpos+pagesize+rowsize+1]*sx;
00466                                 value4 = (float)absgrad[aktpos+pagesize]*s1x         + (float)absgrad[aktpos+pagesize+1]*sx;
00467                                 value11 = value1*(s1y) + value2*(sy);
00468                                 value22 = value4*(s1y) + value3*(sy);
00469                                 value = (int)(value11*(1-sz) + value22*(sz));
00470 
00471                                 if (value>(gmin*32))
00472                                 {
00473                                 value1 = (float)gradient[aktpos].y*s1x                  + (float)gradient[aktpos+1].y*sx;
00474                                 value2 = (float)gradient[aktpos+rowsize].y*s1x          + (float)gradient[aktpos+rowsize+1].y*sx;
00475                                 value3 = (float)gradient[aktpos+pagesize+rowsize].y*s1x + (float)gradient[aktpos+pagesize+rowsize+1].y*sx;
00476                                 value4 = (float)gradient[aktpos+pagesize].y*s1x         + (float)gradient[aktpos+pagesize+1].y*sx;
00477                                 value11 = value1*(1-sy) + value2*(sy);
00478                                 value22 = value4*(1-sy) + value3*(sy);
00479                                 valgy=((value11*(1-sz) + value22*(sz)));
00480 
00481                                 value1 = (float)gradient[aktpos].x*s1x                  + (float)gradient[aktpos+1].x*sx;
00482                                 value2 = (float)gradient[aktpos+rowsize].x*s1x          + (float)gradient[aktpos+rowsize+1].x*sx;
00483                                 value3 = (float)gradient[aktpos+pagesize+rowsize].x*s1x + (float)gradient[aktpos+pagesize+rowsize+1].x*sx;
00484                                 value4 = (float)gradient[aktpos+pagesize].x*s1x         + (float)gradient[aktpos+pagesize+1].x*sx;
00485                                 value11 = value1*(1-sy) + value2*(sy);
00486                                 value22 = value4*(1-sy) + value3*(sy);
00487                                 valgx=((value11*(1-sz) + value22*(sz)));
00488 
00489                                 value1 = (float)gradient[aktpos].z*s1x                  + (float)gradient[aktpos+1].z*sx;
00490                                 value2 = (float)gradient[aktpos+rowsize].z*s1x          + (float)gradient[aktpos+rowsize+1].z*sx;
00491                                 value3 = (float)gradient[aktpos+pagesize+rowsize].z*s1x + (float)gradient[aktpos+pagesize+rowsize+1].z*sx;
00492                                 value4 = (float)gradient[aktpos+pagesize].z*s1x         + (float)gradient[aktpos+pagesize+1].z*sx;
00493                                 value11 = value1*(1-sy) + value2*(sy);
00494                                 value22 = value4*(1-sy) + value3*(sy);
00495                                 valgz=((value11*(1-sz) + value22*(sz)));
00496 
00497                                 lv = sqrt(valgx*valgx + valgy*valgy + valgz*valgz);
00498                                 valgx /= lv;
00499                                 valgy /= lv;
00500                                 valgz /= lv;
00501 
00502                                 valsh = fabs(valgx*lx+valgy*ly+valgz*lz);
00503                                 if (valsh>0.999) {valsh=0.999;}
00504                                 if (valsh<0) {valsh=0;}
00505                                 valsh = 1-valsh;
00506                                 if (StrToFloat(apower->Caption)>1) valsh = exp(StrToFloat(apower->Caption)*log(valsh));
00507 
00508                                 if (px%levlx == 0 || py%levly == 0 || pz%levlz == 0)
00509                                 { if (px!=0 && py!=0 && pz!=0 && value>aline) {aline=value;} }
00510 
00511                                 value = value-gmin*32;
00512                                 value = int((float)value*(float)gscale);
00513                                 if (value>4095) value=4095;
00514                                 value = value*(valsh);
00515                                 }
00516                                 else
00517                                 {
00518                                 value = value-gmin*32;
00519                                 value = value*gscale;
00520                                 if (value>4095) value=4095;
00521                                 }
00522                                 if (depth->Checked){
00523                                         tmax = j;
00524                                         if (tmax<0) tmax=0;
00525                                         if (tmax>maxdim) tmax=maxdim;
00526                                         if (lmipcheck->Checked) {
00527                                                 if ((value*(maxdim-tmax))>averg)
00528                                                         {averg = (value*(maxdim-tmax));}
00529                                                         else
00530                                                         {
00531                                                         if (averg>(tlmip*(maxdim-tmax)) && (value*(maxdim-tmax))<averg)
00532                                                                 {
00533                                                                 endcast = true;
00534                                                                 }
00535                                                         }
00536                                                 } else {
00537                                                 if ((value*(maxdim-tmax))>averg) {averg = (value*(maxdim-tmax));}
00538                                                 }
00539                                        }
00540                                         else {
00541                                         if (lmipcheck->Checked) {
00542                                                 if (value>averg)
00543                                                         {averg = value;}
00544                                                         else
00545                                                         {
00546                                                         if (averg>tlmip && value<(averg))
00547                                                                 {
00548                                                                 endcast = true;
00549                                                                 }
00550                                                         }
00551                                                 } else {
00552                                                 if (value>averg) {averg = value;}
00553                                                 }
00554                                         }
00555                           }
00556                           else
00557                           {
00558                                 value = absgrad[pagesize*pz + rowsize*py + px];
00559 
00560                                 if (value>(gmin*32))
00561                                 {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);
00562                                 if (valsh>0.999) {valsh=0.999;}
00563                                 if (valsh<0) {valsh=0;}
00564                                 valsh = 1-valsh;
00565                                 value = value-gmin*32;
00566                                 value = int((float)value*(float)gscale);
00567                                 if (value>4095) value=4095;
00568 
00569                                 if (StrToFloat(apower->Caption)>1) valsh = exp(StrToFloat(apower->Caption)*log(valsh));
00570 
00571                                 if (px%levlx == 0 || py%levly == 0 || pz%levlz == 0)
00572                                 { if (px!=0 && py!=0 && pz!=0 && value>aline) {aline=value;} }
00573                                 value = value*(valsh);
00574                                 }
00575                                 else
00576                                 {
00577                                 value = value-gmin*32;
00578                                 value = int((float)value*(float)gscale);
00579                                 if (value>4095) value=4095;
00580                                 }
00581                             if (depth->Checked){
00582                                         tmax = j;
00583                                         if (tmax<0) tmax=0;
00584                                         if (tmax>(maxdim)) tmax=(maxdim);
00585 
00586                                         if (lmipcheck->Checked) {
00587                                                 if ((value*(maxdim-tmax))>averg)
00588                                                         {averg = (value*(maxdim-tmax));}
00589                                                         else
00590                                                         {
00591                                                         if (averg>(tlmip*(maxdim-tmax)) && (value*(maxdim-tmax))<averg)
00592                                                                 {
00593                                                                 endcast = true;
00594                                                                 }
00595                                                         }
00596                                                 } else {
00597                                                 if ((value*(maxdim-tmax))>averg) {averg = (value*(maxdim-tmax));}
00598                                                 }
00599 
00600                                         }
00601                                         else {
00602                                         if (lmipcheck->Checked) {
00603                                                 if (value>averg)
00604                                                         {averg = value;}
00605                                                         else
00606                                                         {
00607                                                         if (averg>tlmip && value<averg)
00608                                                                 {
00609                                                                 endcast = true;
00610                                                                 }
00611                                                         }
00612                                                 } else {
00613                                                 if (value>averg) {averg = value;}
00614                                                 }
00615                                         }
00616                           }
00617 
00618                          }
00619                          if (depth->Checked){
00620                                 colx = ((aline*lr)+(averg*vr)/maxdim)/4096;
00621                                 coly = ((aline*lg)+(averg*vg)/maxdim)/4096;
00622                                 colz = ((aline*lb)+(averg*vb)/maxdim)/4096;
00623                                 if (colx>255) colx=255;
00624                                 if (coly>255) coly=255;
00625                                 if (colz>255) colz=255;
00626                                 NPRview[k].r = colx;
00627                                 NPRview[k].g = coly;
00628                                 NPRview[k].b = colz;
00629                                 }
00630                                 else {
00631 
00632                                 colx = ((aline*lr)+(averg*vr))/4096;
00633                                 coly = ((aline*lg)+(averg*vg))/4096;
00634                                 colz = ((aline*lb)+(averg*vb))/4096;
00635 
00636                                 if (colx>255) colx=255;
00637                                 if (coly>255) coly=255;
00638                                 if (colz>255) colz=255;
00639                                 NPRview[k].r = colx;
00640                                 NPRview[k].g = coly;
00641                                 NPRview[k].b = colz;
00642                                 }
00643                          }
00644                 k++;
00645                 }
00646         }
00647         FrameForm->StatusProgress->Visible = false;
00648 }
00649 
00650 
00651 void __fastcall TNPRForm::ResTrackBarChange(TObject *Sender)
00652 {
00653 switch (ResTrackBar->Position)
00654         {
00655         case 1: textx->Caption = "32"; texty->Caption = "32"; break;
00656         case 2: textx->Caption = "64"; texty->Caption = "64"; break;
00657         case 3: textx->Caption = "128"; texty->Caption = "128"; break;
00658         case 4: textx->Caption = "256"; texty->Caption = "256"; break;
00659         case 5: textx->Caption = "512"; texty->Caption = "512"; break;
00660         case 6: textx->Caption = "1024"; texty->Caption = "1024";
00661         }
00662 if (arepaint->Checked) {RayCast();PaintGL();}
00663         
00664 }
00665 //---------------------------------------------------------------------------
00666 
00667 
00668 void __fastcall TNPRForm::autoresClick(TObject *Sender)
00669 {
00670 if (autores->Checked==true)
00671         {
00672         ResTrackBar->Enabled=false;
00673         textx->Enabled=false;
00674         Label2->Enabled=false;
00675         texty->Enabled=false;
00676         }
00677         else
00678         {
00679         ResTrackBar->Enabled=true;
00680         textx->Enabled=true;
00681         Label2->Enabled=true;
00682         texty->Enabled=true;
00683         }
00684 if (arepaint->Checked) {RayCast();PaintGL();}
00685 
00686 }
00687 //---------------------------------------------------------------------------
00688 
00689 void __fastcall TNPRForm::trilinearClick(TObject *Sender)
00690 {
00691 if (arepaint->Checked) {RayCast();PaintGL();}
00692         
00693 }
00694 //---------------------------------------------------------------------------
00695 
00696 
00697 void __fastcall TNPRForm::TrackBar1Change(TObject *Sender)
00698 {
00699 apower->Caption = FloatToStr(((float)TrackBar1->Position/10)+1);
00700 }
00701 //---------------------------------------------------------------------------
00702 
00703 
00704 void __fastcall TNPRForm::TrackBar2Change(TObject *Sender)
00705 {
00706 lmipvalue->Caption = IntToStr(TrackBar2->Position);
00707 }
00708 //---------------------------------------------------------------------------
00709 
00710 void __fastcall TNPRForm::lmipcheckClick(TObject *Sender)
00711 {
00712 lmipvalue->Enabled = lmipcheck->Checked;
00713 }
00714 //---------------------------------------------------------------------------
00715 
00716 void __fastcall TNPRForm::TrackBar3Change(TObject *Sender)
00717 {
00718 step->Caption = FloatToStr((float)TrackBar3->Position/10);
00719 }
00720 //---------------------------------------------------------------------------
00721 
00722 void __fastcall TNPRForm::gareaPaint(TObject *Sender)
00723 {
00724 int i;
00725 garea->Canvas->FillRect(Rect(0,0,128,39));
00726 garea->Canvas->Pen->Color = clSilver;
00727 for (i=0; i<128; i++) {
00728         garea->Canvas->MoveTo(i,39);
00729         garea->Canvas->LineTo(i,39-ghisto[i]);
00730         }
00731 garea->Canvas->Pen->Color = clGray;
00732 garea->Canvas->MoveTo(gmin,0);
00733 garea->Canvas->LineTo(gmin,39);
00734 garea->Canvas->MoveTo(gmax,0);
00735 garea->Canvas->LineTo(gmax,39);
00736 garea->Canvas->Pen->Color = clBlack;
00737 garea->Canvas->MoveTo(0,39);
00738 garea->Canvas->LineTo(gmin,39);
00739 garea->Canvas->LineTo(gmax,0);
00740 garea->Canvas->LineTo(128,0);
00741 }
00742 //---------------------------------------------------------------------------
00743 
00744 
00745 void __fastcall TNPRForm::gareaMouseMove(TObject *Sender,
00746       TShiftState Shift, int X, int Y)
00747 {
00748 if (gdragmin==false && gdragmax==false) {
00749         if (abs(X-gmin)<3 ||abs(X-gmax)<3)
00750         {garea->Cursor = crSizeWE; }
00751         else {garea->Cursor = crDefault; }
00752         } else {
00753         if (gdragmin) {
00754                 gmin = X;
00755                 if (gmin>gmax-3) {gmin=gmax-3;}
00756                 if (gmin<1) {gmin=1;}
00757                 lgmin->Caption = IntToStr(gmin*32);
00758                 garea->Repaint();}
00759         if (gdragmax) {
00760                 gmax = X;
00761                 if (gmax<gmin+3) {gmax=gmin+3;}
00762                 if (gmax>127) {gmax=127;}
00763                 lgmax->Caption = IntToStr(gmax*32);
00764                 garea->Repaint();}
00765         }
00766 }
00767 //---------------------------------------------------------------------------
00768 
00769 void __fastcall TNPRForm::gareaMouseUp(TObject *Sender,
00770       TMouseButton Button, TShiftState Shift, int X, int Y)
00771 {
00772 gdragmin = false; gdragmax=false;        
00773 }
00774 //---------------------------------------------------------------------------
00775 
00776 void __fastcall TNPRForm::gareaMouseDown(TObject *Sender,
00777       TMouseButton Button, TShiftState Shift, int X, int Y)
00778 {
00779 if (abs(X-gmin)<3) {gdragmin=true;}
00780 if (abs(X-gmax)<3) {gdragmax=true;}
00781 }
00782 //---------------------------------------------------------------------------
00783 
00784 
00785 void __fastcall TNPRForm::SFGColorMouseDown(TObject *Sender,
00786       TMouseButton Button, TShiftState Shift, int X, int Y)
00787 {
00788 if (ColorDialog1->Execute()) {
00789                         SFGColor->Brush->Color = ColorDialog1->Color;}
00790 vr = SFGColor->Brush->Color & 255;
00791 vg = (SFGColor->Brush->Color >> 8) & 255;
00792 vb = (SFGColor->Brush->Color >> 16) & 255;
00793 }
00794 //---------------------------------------------------------------------------
00795 
00796 void __fastcall TNPRForm::SBGColorMouseDown(TObject *Sender,
00797       TMouseButton Button, TShiftState Shift, int X, int Y)
00798 {
00799 if (ColorDialog1->Execute()) {
00800                         SBGColor->Brush->Color = ColorDialog1->Color;}
00801 lr = SBGColor->Brush->Color & 255;
00802 lg = (SBGColor->Brush->Color >> 8) & 255;
00803 lb = (SBGColor->Brush->Color >> 16) & 255;
00804 }
00805 //---------------------------------------------------------------------------
00806 
00807 
00808