Home My Page Projects Code Snippets Project Openings diderot
Summary Activity Tracker Tasks SCM

SCM Repository

[diderot] Diff of /benchmarks/programs/vr-lite-cam/bmark-teem.c
ViewVC logotype

Diff of /benchmarks/programs/vr-lite-cam/bmark-teem.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1587, Mon Oct 31 11:50:21 2011 UTC revision 1600, Thu Nov 3 05:00:16 2011 UTC
# Line 1  Line 1 
1  /*! \file vr-lite-cam.c  /*! \file vr-lite-cam.c
2   *   *
3   * \author Nick Seltzer   * \author Nick Seltzer & Gordon Kindlmann
  */  
   
 /*  
  * COPYRIGHT (c) 2011 The Diderot Project (http://diderot-language.cs.uchicago.edu)  
  * All rights reserved.  
4   */   */
5    
6  #include <stdio.h>  #include <stdio.h>
# Line 82  Line 77 
77    return (unsigned char)((0.0f * (in_max - in) + 255.0f * (in - in_min)) / (in_max - in_min));    return (unsigned char)((0.0f * (in_max - in) + 255.0f * (in - in_min)) / (in_max - in_min));
78  }  }
79    
80  int main ()  int main (int argc, const char *argv[])
81  {  {
82      const char *me = argv[0];
83    char *infile = "../../data/vfrhand-nohip.nhdr";    char *infile = "../../data/vfrhand-nohip.nhdr";
84    char *outfile = "vr-lite-cam.pgm";    char *outfile = "vr-lite-cam.pgm";
   double Zero[3] = {0, 0, 0};  
85    double camEye[3] = {127.331, -1322.05, 272.53};    double camEye[3] = {127.331, -1322.05, 272.53};
86    double camAt[3] = {63.0, 82.6536, 98.0};    double camAt[3] = {63.0, 82.6536, 98.0};
87    double camUp[3] = {0.9987, 0.0459166, -0.0221267};    double camUp[3] = {0.9987, 0.0459166, -0.0221267};
# Line 112  Line 107 
107    norm3(temp, camU);    norm3(temp, camU);
108    double camV[3];    double camV[3];
109    cross(camN, camU, camV);    cross(camN, camU, camV);
110    double camVmax = tan(camFOV*3.1415926536/360.0)*camDist;    double camVmax = tan(camFOV*AIR_PI/360.0)*camDist;
111    double camUmax = camVmax*(double)(imgResU)/(double)(imgResV);    double camUmax = camVmax*(double)(imgResU)/(double)(imgResV);
112    double lightVspDir[3] = {0.9, -1.0, -2.5};    double lightVspDir[3] = {0.9, -1.0, -2.5};
113    scale_vec3(lightVspDir[0], camU, temp);    scale_vec3(lightVspDir[0], camU, temp);
# Line 125  Line 120 
120    double phongKa = 0.05;    double phongKa = 0.05;
121    double phongKd = 0.80;    double phongKd = 0.80;
122    double phongKs = 0.20;    double phongKs = 0.20;
123    double phongSp = 30.0;    double phongSp = 50.0;
124    
125    // Read in the data    // Read in the data
126    char* err;    char* err;
127    Nrrd *nin;    Nrrd *nin;
128    int status;    int status;
129    nin = nrrdNew();    airArray *mop;
130    if(nin == NULL) {    mop = airMopNew();
     err = biffGetDone(NRRD);  
     fprintf(stderr, "Trouble allocating nrrd struct:\n%s", err);  
     free(err);  
     return -1;  
   }  
131    
132      nin = nrrdNew();
133      airMopAdd(mop, nin, (airMopper)nrrdNuke, airMopAlways);
134    
135    status = nrrdLoad(nin, infile, NULL);    if (nrrdLoad(nin, infile, NULL)) {
136    if (status) {      airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
     err = biffGetDone(NRRD);  
137      fprintf(stderr, "Trouble reading \"%s\":\n%s", infile, err);      fprintf(stderr, "Trouble reading \"%s\":\n%s", infile, err);
138      free(err);      airMopError(mop);
     nrrdNix(nin);  
139      return -1;      return -1;
140    }    }
141    
# Line 154  Line 144 
144    gagePerVolume *pvl;    gagePerVolume *pvl;
145    const double *val;    const double *val;
146    const double *grad;    const double *grad;
147    double kparm[NRRD_KERNEL_PARMS_NUM];    double kparm[NRRD_KERNEL_PARMS_NUM] = {0.0};
148      int E;
149    
150    ctx = gageContextNew();    ctx = gageContextNew();
151    if(ctx == NULL) {    airMopAdd(mop, ctx, (airMopper)gageContextNix, airMopAlways);
     err = biffGetDone(GAGE);  
     fprintf(stderr, "Trouble allocating gage context:\n%s", err);  
     free(err);  
     nrrdNuke(nin);  
     return -1;  
   }  
   
152    pvl = gagePerVolumeNew(ctx, nin, gageKindScl);    pvl = gagePerVolumeNew(ctx, nin, gageKindScl);
153    if(pvl == NULL) {    if (!( ctx && pvl )) {
154      err = biffGetDone(GAGE);      fprintf(stderr, "%s: couldn't allocate gage ctx or pvl", me);
155      fprintf(stderr, "Trouble allocating gage PerVolume:\n%s", err);      airMopError(mop);
156      free(err);      return -1;
157      gageContextNix(ctx);    }
158      nrrdNuke(nin);    if (gagePerVolumeAttach(ctx, pvl)
159      return -1;        || gageKernelSet(ctx, gageKernel00, nrrdKernelBSpline3, kparm)
160    }        || gageKernelSet(ctx, gageKernel11, nrrdKernelBSpline3D, kparm)
161          || gageQueryItemOn(ctx, pvl, gageSclValue)
162    status = gagePerVolumeAttach(ctx, pvl);        || gageQueryItemOn(ctx, pvl, gageSclGradVec)
163    if(status) {        || gageUpdate(ctx)) {
164      err = biffGetDone(GAGE);      airMopAdd(mop, err = biffGetDone(GAGE), airFree, airMopAlways);
165      fprintf(stderr, "Trouble attaching gage PerVolume:\n%s", err);      fprintf(stderr, "Trouble setting up gage context:\n%s", err);
166      free(err);      airMopError(mop);
     gageContextNix(ctx);  
     nrrdNuke(nin);  
     return -1;  
   }  
   
   // It's okay to use kparm unitialized here: gageKernelSet ignores it.  
   status = gageKernelSet(ctx, gageKernel00, nrrdKernelBSpline3, kparm);  
   if(status) {  
     err = biffGetDone(GAGE);  
     fprintf(stderr, "Trouble setting kernel:\n%s", err);  
     free(err);  
     gageContextNix(ctx);  
     nrrdNuke(nin);  
167      return -1;      return -1;
168    }    }
169    
170    // It's okay to use kparm unitialized here: gageKernelSet ignores it.    if (!( (val = gageAnswerPointer(ctx, pvl, gageSclValue))
171    status = gageKernelSet(ctx, gageKernel11, nrrdKernelBSpline3D, kparm);           && (grad = gageAnswerPointer(ctx, pvl, gageSclGradVec)) )) {
172    if(status) {      fprintf(stderr, "Trouble getting answer pointer\n");
173      err = biffGetDone(GAGE);      airMopError(mop);
     fprintf(stderr, "Trouble setting kernel:\n%s", err);  
     free(err);  
     gageContextNix(ctx);  
     nrrdNuke(nin);  
     return -1;  
   }  
   
   status = gageQueryItemOn(ctx, pvl, gageSclValue);  
   if(status) {  
     err = biffGetDone(GAGE);  
     fprintf(stderr, "Trouble with gageQueryItemOn:\n%s", err);  
     free(err);  
     gageContextNix(ctx);  
     nrrdNuke(nin);  
     return -1;  
   }  
   
   status = gageQueryItemOn(ctx, pvl, gageSclGradVec);  
   if(status) {  
     err = biffGetDone(GAGE);  
     fprintf(stderr, "Trouble with gageQueryItemOn:\n%s", err);  
     free(err);  
     gageContextNix(ctx);  
     nrrdNuke(nin);  
     return -1;  
   }  
   
   status = gageUpdate(ctx);  
   if(status) {  
     err = biffGetDone(GAGE);  
     fprintf(stderr, "Trouble with gageUpdate:\n%s", err);  
     free(err);  
     gageContextNix(ctx);  
     nrrdNuke(nin);  
     return -1;  
   }  
   
   val = gageAnswerPointer(ctx, pvl, gageSclValue);  
   if(val == NULL) {  
     err = biffGetDone(GAGE);  
     fprintf(stderr, "Trouble getting answer pointer:\n%s", err);  
     free(err);  
     gageContextNix(ctx);  
     nrrdNuke(nin);  
     return -1;  
   }  
   
   grad = gageAnswerPointer(ctx, pvl, gageSclGradVec);  
   if(grad == NULL) {  
     err = biffGetDone(GAGE);  
     fprintf(stderr, "Trouble getting answer pointer:\n%s", err);  
     free(err);  
     gageContextNix(ctx);  
     nrrdNuke(nin);  
174      return -1;      return -1;
175    }    }
176    
# Line 272  Line 189 
189    bool set = false;    bool set = false;
190    double max_gray = 0;    double max_gray = 0;
191    double min_gray = 0;    double min_gray = 0;
192    double *out_data = malloc(sizeof(double) * 4 * imgResU * imgResV);  
193    if(out_data == NULL) {    // allocate image and output
194      fprintf(stderr, "Trouble with malloc.\n");    Nrrd *nimg = nrrdNew();
195      gageContextNix(ctx);    airMopAdd(mop, nimg, (airMopper)nrrdNuke, airMopAlways);
196      nrrdNuke(nin);    Nrrd *nout = nrrdNew();
197      airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
198      if (nrrdAlloc_va(nimg, nrrdTypeDouble, 3,
199                       AIR_CAST(size_t, 4),
200                       AIR_CAST(size_t, imgResU),
201                       AIR_CAST(size_t, imgResV))
202          || nrrdAlloc_va(nout, nrrdTypeUChar, 2,
203                          AIR_CAST(size_t, imgResU),
204                          AIR_CAST(size_t, imgResV))) {
205        airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
206        fprintf(stderr, "Trouble allocating image and output:\n%s", err);
207        airMopError(mop);
208      return -1;      return -1;
209    }    }
210      double *out_data = AIR_CAST(double *, nimg->data);
211      unsigned char *uc_out_data = AIR_CAST(unsigned char *, nout->data);
212    
213    double t0 = GetTime(); // start timing    double t0 = airTime(); // start timing
214    for(vi = 0; vi < imgResV; vi++) {    for(vi = 0; vi < imgResV; vi++) {
215      rayV = lerp(-camVmax, camVmax, -0.5, (double)(vi), (double)(imgResV) - 0.5);      rayV = lerp(-camVmax, camVmax, -0.5, (double)(vi), (double)(imgResV) - 0.5);
216      scale_vec3(rayV, camV, temp);      scale_vec3(rayV, camV, temp);
# Line 302  Line 232 
232          scale_vec3(rayN, rayDir, temp2);          scale_vec3(rayN, rayDir, temp2);
233          add3(temp2, camEye, rayPos);          add3(temp2, camEye, rayPos);
234          if(inside(rayPos)) {          if(inside(rayPos)) {
235            status = gageProbe(ctx, rayPos[0], rayPos[1], rayPos[2]);            if (gageProbe(ctx, rayPos[0], rayPos[1], rayPos[2])) {
           if(status) {  
236              fprintf(stderr, "Trouble with gageProbe:\n%s", ctx->errStr);              fprintf(stderr, "Trouble with gageProbe:\n%s", ctx->errStr);
237              free(out_data);              airMopError(mop); return -1;
             gageContextNix(ctx);  
             nrrdNuke(nin);  
             return -1;  
238            }            }
239            if(*val > valOpacMin) {            if(*val > valOpacMin) {
240              temp2[0] = *(grad + 0);              temp2[0] = -*(grad + 0);
241              temp2[1] = *(grad + 1);              temp2[1] = -*(grad + 1);
242              temp2[2] = *(grad + 2);              temp2[2] = -*(grad + 2);
             sub3(Zero, temp2, temp2);  
243              norm3(temp2, norm);              norm3(temp2, norm);
244              alpha = lerp(0.0, 1.0,  valOpacMin, *val, valOpacMax);              alpha = lerp(0.0, 1.0,  valOpacMin, *val, valOpacMax);
245              alpha = (alpha < 1.0) ? alpha : 1;              alpha = (alpha < 1.0) ? alpha : 1;
# Line 352  Line 277 
277      }      }
278    }    }
279    
   unsigned char *uc_out_data = malloc(sizeof(unsigned char) * imgResU * imgResV);  
280    for(vi = 0; vi < imgResV; vi++) {    for(vi = 0; vi < imgResV; vi++) {
281      for(ui = 0; ui < imgResU; ui++) {      for(ui = 0; ui < imgResU; ui++) {
282        *(uc_out_data + vi * imgResU + ui) = ulerp(min_gray, *(out_data + ui * imgResV * 4 + vi * 4 + 0), max_gray);        *(uc_out_data + vi * imgResU + ui) = ulerp(min_gray, *(out_data + ui * imgResV * 4 + vi * 4 + 0), max_gray);
283      }      }
284    }    }
285    
286    double totalTime = GetTime() - t0;    double totalTime = airTime() - t0;
287    printf("usr=%f\n", totalTime);    printf("usr=%f\n", totalTime);
288    
289    // Write out data    if (nrrdSave(outfile, nout, NULL)) {
290    Nrrd *nout;      airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
291    nout = nrrdNew();      fprintf(stderr, "Trouble writing output:\n%s", err);
292    if(nout == NULL) {      airMopError(mop);
     err = biffGetDone(NRRD);  
     fprintf(stderr, "Trouble allocating nrrd struct:\n%s", err);  
     free(err);  
     free(out_data);  
     free(uc_out_data);  
     gageContextNix(ctx);  
     nrrdNuke(nin);  
     return -1;  
   }  
   
   status = nrrdWrap_va(nout, uc_out_data, nrrdTypeUChar, 2, imgResU, imgResV);  
   if(status) {  
     err = biffGetDone(NRRD);  
     fprintf(stderr, "Trouble wrapping nrrd struct:\n%s", err);  
     free(err);  
     nrrdNix(nout);  
     free(out_data);  
     gageContextNix(ctx);  
     nrrdNuke(nin);  
293      return -1;      return -1;
294    }    }
295    
296    status = nrrdSave(outfile, nout, NULL);    airMopOkay(mop);
   if(status) {  
     err = biffGetDone(NRRD);  
     fprintf(stderr, "Trouble saving nrrd struct:\n%s", err);  
     free(err);  
     nrrdNuke(nout);  
     free(out_data);  
     gageContextNix(ctx);  
     nrrdNuke(nin);  
     return -1;  
   }  
   
   
   free(out_data);  
   nrrdNuke(nout);  
   gageContextNix(ctx);  
   nrrdNuke(nin);  
297    return 0;    return 0;
298    
299  }  }

Legend:
Removed from v.1587  
changed lines
  Added in v.1600

root@smlnj-gforge.cs.uchicago.edu
ViewVC Help
Powered by ViewVC 1.0.0