X-Git-Url: http://git.kpe.io/?p=ctsim.git;a=blobdiff_plain;f=libctsim%2Fimagefile.cpp;h=3f7c0beff717a84bafe3f588816dfc50d29bf0db;hp=4cae5d2569768a26e5439871589e682663395670;hb=a5139613f6b92aeb8db9daa87f021c78d17d82a5;hpb=44ba9ce559d2d52cbd7bbea6bcd76242840fd3eb

diff --git a/libctsim/imagefile.cpp b/libctsim/imagefile.cpp
index 4cae5d2..3f7c0be 100644
--- a/libctsim/imagefile.cpp
+++ b/libctsim/imagefile.cpp
@@ -9,7 +9,7 @@
 **  This is part of the CTSim program
 **  Copyright (C) 1983-2000 Kevin Rosenberg
 **
-**  $Id: imagefile.cpp,v 1.2 2000/06/20 17:54:51 kevin Exp $
+**  $Id: imagefile.cpp,v 1.10 2000/08/22 16:49:56 kevin Exp $
 **
 **  This program is free software; you can redistribute it and/or modify
 **  it under the terms of the GNU General Public License (version 2) as
@@ -28,144 +28,451 @@
 #include "ct.h"
 
 
-///////////////////////////////////////////////////////////////////////////
-// CLASS IMPLEMENTATION
-//
-//     Name: Array2dFileLabel
-//     Purpose: Labels for Array2dFiles
-///////////////////////////////////////////////////////////////////////////
 
-void
-Array2dFileLabel::init (void)
+void 
+ImageFile::filterResponse (const char* const domainName, double bw, const char* const filterName, double filt_param)
 {
-    m_calcTime = 0;
-    m_labelType = L_EMPTY;
-    TIMEDATE td;
-    td_get_tmdt (&td);
-    m_year = td.d.year;
-    m_month = td.d.month;
-    m_day = td.d.date;
-    m_hour = td.t.hour;
-    m_minute = td.t.minute;
-    m_second = td.t.second;
+  int hx = (m_nx - 1) / 2;
+  int hy = (m_ny - 1) / 2;
+  ImageFileArray v = getArray();
+  SignalFilter filter (filterName, domainName, bw, filt_param);
+
+  for (int i = -hx; i <= hx; i++) {
+    for (int j = -hy; j <= hy; j++) {
+      double r = sqrt (i * i + j * j);
+      
+      v[i+hx][j+hy] = filter.response (r);
+    }
+  }
 }
 
-Array2dFileLabel::Array2dFileLabel() 
+int
+ImageFile::display (void) const
 {
-    init();
+    double pmin, pmax;
+
+    getMinMax (pmin, pmax);
+
+    return (displayScaling (1, pmin, pmax));
 }
 
-Array2dFileLabel::Array2dFileLabel(const char* const str, double ctime = 0.)
-  : m_strLabel (str)
+int 
+ImageFile::displayScaling (const int scale, const ImageFileValue pmin, const ImageFileValue pmax) const
 {
-    init();
+    int nx = m_nx;
+    int ny = m_ny;
+    ImageFileArrayConst v = getArray();
+    if (v == NULL || nx == 0 || ny == 0)
+      return 0;
+
+#if HAVE_G2_H
+    int pens [nx * ny * scale * scale ];
 
-    m_labelType = L_USER;
-    m_calcTime = ctime;
+    double view_scale = 255 / (pmax - pmin);
+    int id_X11 = g2_open_X11 (nx * scale, ny * scale);
+    int grayscale[256];
+    for (int i = 0; i < 256; i++) {
+	double cval = i / 255.;
+	grayscale[i] = g2_ink (id_X11, cval, cval, cval);
+    }
+
+    for (int i= 0, iy = ny - 1; iy >= 0; iy--) {
+	for (int ix = 0; ix < nx; ix++) {
+	    int cval = static_cast<int>((v[ix][iy] - pmin) * view_scale);
+	    if (cval < 0)  
+	      cval = 0;
+	    else if (cval > 255) 
+	      cval = 255;
+	    pens[i++] = grayscale[cval];
+	}
+    }
+
+    g2_image (id_X11, 0., 0., nx, ny, pens);
+
+    return (id_X11);
+
+#endif
 }
 
-Array2dFileLabel::Array2dFileLabel(const int type, const char* const str, double ctime = 0.)
-  :  m_strLabel (str)
+
+
+// ImageFile::comparativeStatistics    Calculate comparative stats
+//
+// OUTPUT
+//   d   Normalized root mean squared distance measure
+//   r   Normalized mean absolute distance measure
+//   e   Worst case distance measure
+//
+// REFERENCES
+//  G.T. Herman, Image Reconstruction From Projections, 1980
+
+bool
+ImageFile::comparativeStatistics (const ImageFile& imComp, double& d, double& r, double& e) const
 {
-    init();
+    if (imComp.nx() != m_nx && imComp.ny() != m_ny) {
+	sys_error (ERR_WARNING, "Image sizes differ [ImageFile::comparativeStatistics]");
+	return false;
+    }
+    ImageFileArrayConst v = getArray();
+    if (v == NULL || m_nx == 0 || m_ny == 0)
+      return false;
+
+    ImageFileArrayConst vComp = imComp.getArray();
+
+    double myMean = 0.;
+    for (unsigned int ix = 0; ix < m_nx; ix++) {
+	for (unsigned int iy = 0; iy < m_ny; iy++) {
+	    myMean += v[ix][iy];
+	}
+    }
+    myMean /= (m_nx * m_ny);
+
+    double sqErrorSum = 0.;
+    double absErrorSum = 0.;
+    double sqDiffFromMeanSum = 0.;
+    double absValueSum = 0.;
+    for (unsigned int ix = 0; ix < m_nx; ix++) {
+	for (unsigned int iy = 0; iy < m_ny; iy++) {
+	    double diff = v[ix][iy] - vComp[ix][iy];
+	    sqErrorSum += diff * diff;
+	    absErrorSum += fabs(diff);
+	    double diffFromMean = v[ix][iy] - myMean;
+	    sqDiffFromMeanSum += diffFromMean * diffFromMean;
+	    absValueSum += fabs(v[ix][iy]);
+	}
+    }
+
+    d = sqrt (sqErrorSum / sqDiffFromMeanSum);
+    r = absErrorSum / absValueSum;
+
+    int hx = m_nx / 2;
+    int hy = m_ny / 2;
+    double eMax = -1;
+    for (int ix = 0; ix < hx; ix++) {
+      for (int iy = 0; iy < hy; iy++) {
+	double avgPixel = 0.25 * (v[2*ix][2*iy] + v[2*ix+1][2*iy] + v[2*ix][2*iy+1] + v[2*ix+1][2*iy+1]);
+	double avgPixelComp = 0.25 * (vComp[2*ix][2*iy] + vComp[2*ix+1][2*iy] + vComp[2*ix][2*iy+1] + vComp[2*ix+1][2*iy+1]);
+	double error = fabs (avgPixel - avgPixelComp);
+	if (error > eMax)
+	  eMax = error;
+      }
+    }
+
+    e = eMax;
 
-    m_labelType = type;
-    m_calcTime = ctime;
+    return true;
 }
 
-Array2dFileLabel::~Array2dFileLabel()
+
+bool
+ImageFile::printComparativeStatistics (const ImageFile& imComp, ostream& os) const
 {
+  double d, r, e;
+
+  if (comparativeStatistics (imComp, d, r, e)) {
+    os << "  Normalized root mean squared distance (d): " << d << endl;
+    os << "      Normalized mean absolute distance (r): " << r << endl;
+    os << "Worst case distance (2x2 pixel average) (e): " << e << endl;
+    return true;
+  }
+  return false;
 }
 
-const string& 
-Array2dFileLabel::getDateString (void) const
+
+void
+ImageFile::printStatistics (ostream& os) const
 {
-  ostringstream oss;
-  oss <<  m_month <<"/"<< m_day <<"/"<< m_year << " " << m_hour <<":"<<  m_minute <<":"<< m_second;
-  m_strDate = oss.str();
-  return m_strDate;
+    double min, max, mean, mode, median, stddev;
+
+    statistics (min, max, mean, mode, median, stddev);
+
+    os << "   min: " << min << endl;
+    os << "   max: " << max << endl;
+    os << "  mean: " << mean << endl;
+    os << "  mode: " << mode << endl;
+    os << "median: " << median << endl;
+    os << "stddev: " << stddev << endl;
 }
 
 
-/* FILE
- *   image.c				Routines for managing images
- *
- * PROGRAMMER:	Kevin Rosenberg
- * DATE:	Aug 1984
- *
- * FUNCTION
- *	Provides a set of routines for handling image files
- */
+void
+ImageFile::statistics (double& min, double& max, double& mean, double& mode, double& median, double& stddev) const
+{
+    int nx = m_nx;
+    int ny = m_ny;
+    ImageFileArrayConst v = getArray();
+    
+    if (v == NULL || nx == 0 || ny == 0)
+      return;
+
+    mean = 0;
+    min = v[0][0];
+    max = v[0][0];
+    for (int ix = 0; ix < nx; ix++) {
+      for (int iy = 0; iy < ny; iy++) {
+	if (v[ix][iy] > max)
+	  max = v[ix][iy];
+	if (v[ix][iy] < min)
+	  min = v[ix][iy];
+	mean += v[ix][iy];
+      }
+    }
+    mean /= (nx * ny);
 
+    static const int nbin = 1024;
+    int hist[ nbin ] = {0};
+    double spread = max - min;
+    mode = 0;
+    stddev = 0;
+    for (int ix = 0; ix < nx; ix++) {
+      for (int iy = 0; iy < ny; iy++) {
+	int b = static_cast<int>((((v[ix][iy] - min) / spread) * (nbin - 1)) + 0.5);
+	hist[b]++;
+	double diff = (v[ix][iy] - mean);
+	stddev += diff * diff;
+	}
+    }
+    stddev = sqrt(stddev / (nx * ny));
+
+    int max_binindex = 0;
+    int max_bin = -1;
+    for (int ibin = 0; ibin < nbin; ibin++) {
+      if (hist[ibin] > max_bin) {
+	max_bin = hist[ibin];
+	max_binindex = ibin;
+      }
+    }
+
+    mode = (max_binindex * spread / (nbin - 1)) + min;
+
+    int nPixels = nx * ny;
+    slist<double> vecImage;
+    for (int ix = 0; ix < nx; ix++)
+      for (int iy = 0; iy < ny; iy++)
+	vecImage.push_front (v[ix][iy]);
+    vecImage.sort();
+    slist<double>::const_iterator iter = vecImage.begin();
+    for (int i = 0; i < (nPixels / 2) - 1; i++)
+      iter++; // Advance iterator to (nPixels / 2) - 1;
+
+    if (nPixels % 2) {  // Odd
+      iter++;
+      median = *iter;
+    } else                // Even
+      median = (*iter++ + *iter) / 2;
+}
+
+
+void
+ImageFile::getMinMax (double& min, double& max) const
+{
+    int nx = m_nx;
+    int ny = m_ny;
+    ImageFileArrayConst v = getArray();
+    
+    if (v == NULL || nx == 0 || ny == 0)
+      return;
+
+    min = v[0][0];
+    max = v[0][0];
+    for (int ix = 0; ix < nx; ix++) {
+      for (int iy = 0; iy < ny; iy++) {
+	if (v[ix][iy] > max)
+	  max = v[ix][iy];
+	if (v[ix][iy] < min)
+	  min = v[ix][iy];
+      }
+    }
+}
 
 void 
-image_filter_response (ImageFile& im, const DomainType domain, double bw, const FilterType filt_type, double filt_param, const int opt_trace)
+ImageFile::writeImagePGM (const char *outfile, int nxcell, int nycell, double densmin, double densmax)
 {
-  int hx = im.nx() / 2;
-  int hy = im.ny() / 2;
-  ImageFileArray v = im.getArray();
+  FILE *fp;
+  int nx = m_nx;
+  int ny = m_ny;
+  ImageFileArray v = getArray();
 
-  for (int i = -hx; i <= hx; i++) {
-    for (int j = -hy; j <= hy; j++) {
-      double r = sqrt(i * i + j * j);
-      
-      if (domain == D_SPATIAL)
-	v[i+hx][j+hy] = SignalFilter::spatialResponseAnalytic (filt_type, bw, r, filt_param);
-      else
-	v[i+hx][j+hy] = SignalFilter::frequencyResponse (filt_type, bw, r, filt_param);
-      if (opt_trace >= TRACE_PHM)
-	printf ("r=%8.4f, v=%8.4f\n", r, v[i+hx][j+hy]);
+  unsigned char rowp [nx * nxcell];
+
+  if ((fp = fopen (outfile, "wb")) == NULL)
+     return;
+
+  fprintf(fp, "P5\n");
+  fprintf(fp, "%d %d\n", nx, ny);
+  fprintf(fp, "255\n");
+
+  for (int irow = ny - 1; irow >= 0; irow--) {
+    for (int icol = 0; icol < nx; icol++) {
+      int pos = icol * nxcell;
+      double dens = (v[icol][irow] - densmin) / (densmax - densmin);
+      dens = clamp (dens, 0., 1.);
+      for (int p = pos; p < pos + nxcell; p++) {
+	rowp[p] = static_cast<unsigned int> (dens * 255.);
+      }
+    }
+    for (int ir = 0; ir < nycell; ir++) {
+      for (int ic = 0; ic < nx * nxcell; ic++) 
+	fprintf(fp, "%c ", rowp[ic]);
     }
   }
+
+  fclose(fp);
 }
 
-int
-image_display (const ImageFile& im)
+void 
+ImageFile::writeImagePGMASCII (const char *outfile, int nxcell, int nycell, double densmin, double densmax)
 {
-    ImageFileValue pmin, pmax;
+  FILE *fp;
+  int nx = m_nx;
+  int ny = m_ny;
+  ImageFileArray v = getArray();
+
+  unsigned char rowp [nx * nxcell];
+  if (rowp == NULL)
+    return;
 
-    im.getPixelValueRange (pmin, pmax);
+  if ((fp = fopen (outfile, "wb")) == NULL)
+     return;
 
-    return (image_display_scale (im, 1, pmin, pmax));
+  fprintf(fp, "P2\n");
+  fprintf(fp, "%d %d\n", nx, ny);
+  fprintf(fp, "255\n");
+
+  for (int irow = ny - 1; irow >= 0; irow--) {
+    for (int icol = 0; icol < nx; icol++) {
+      int pos = icol * nxcell;
+      double dens = (v[icol][irow] - densmin) / (densmax - densmin);
+      dens = clamp (dens, 0., 1.);
+      for (int p = pos; p < pos + nxcell; p++) {
+	rowp[p] = static_cast<unsigned int> (dens * 255.);
+      }
+    }
+    for (int ir = 0; ir < nycell; ir++) {
+      for (int ic = 0; ic < nx * nxcell; ic++) 
+	fprintf(fp, "%d ", rowp[ic]);
+      fprintf(fp, "\n");
+    }
+  }
+
+  fclose(fp);
 }
 
-int image_display_scale (const ImageFile& im, const int scale, const double pmin, const double pmax)
+
+#ifdef HAVE_PNG
+void 
+ImageFile::writeImagePNG (const char *outfile, int bitdepth, int nxcell, int nycell, double densmin, double densmax)
 {
-    int grayscale[256];
-    int nx = im.nx();
-    int ny = im.ny();
-    ImageFileArray v = im.getArray();
+  FILE *fp;
+  png_structp png_ptr;
+  png_infop info_ptr;
+  double max_out_level = (1 << bitdepth) - 1;
+  int nx = m_nx;
+  int ny = m_ny;
+  ImageFileArray v = getArray();
 
-#if HAVE_G2_H
-    int* pens = new int [nx * ny * scale * scale ];
+  unsigned char rowp [nx * nxcell * (bitdepth / 8)];
 
-    double view_scale = 255 / (pmax - pmin);
-    int id_X11 = g2_open_X11 (nx * scale, ny * scale);
+  if ((fp = fopen (outfile, "wb")) == NULL)
+     return;
 
-    for (int i = 0; i < 256; i++) {
-	double cval = i / 255.;
-	grayscale[i] = g2_ink (id_X11, cval, cval, cval);
-    }
+  png_ptr = png_create_write_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+  if (! png_ptr)
+    return;
 
-    for (int i= 0, iy = ny - 1; iy >= 0; iy--) {
-	for (int ix = 0; ix < nx; ix++) {
-	    int cval = (int) ((v[ix][iy] - pmin) * view_scale);
-	    if (cval < 0)  
-	      cval = 0;
-	    else if (cval > 255) 
-	      cval = 255;
-	    pens[i++] = grayscale[cval];
+  info_ptr = png_create_info_struct(png_ptr);
+  if (! info_ptr) {
+    png_destroy_write_struct(&png_ptr, (png_infopp) NULL);
+    fclose(fp);
+    return;
+  }
+
+  if (setjmp(png_ptr->jmpbuf)) {
+    png_destroy_write_struct(&png_ptr, &info_ptr);
+    fclose(fp);
+    return;
+  }
+
+  png_init_io(png_ptr, fp);
+
+  png_set_IHDR(png_ptr, info_ptr, nx * nxcell, ny * nycell, bitdepth, PNG_COLOR_TYPE_GRAY, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_DEFAULT);
+
+  png_write_info(png_ptr, info_ptr);
+  for (int irow = ny - 1; irow >= 0; irow--) {
+    png_bytep row_pointer = rowp;
+    
+    for (int icol = 0; icol < nx; icol++) {
+      int pos = icol * nxcell;
+      double dens = (v[icol][irow] - densmin) / (densmax - densmin);
+      dens = clamp (dens, 0., 1.);
+      unsigned int outval = static_cast<unsigned int> (dens * max_out_level);
+
+      for (int p = pos; p < pos + nxcell; p++) {
+	if (bitdepth == 8)
+	  rowp[p] = outval;
+	else {
+	  int rowpos = p * 2;
+	  rowp[rowpos] = (outval >> 8) & 0xFF;
+	  rowp[rowpos+1] = (outval & 0xFF);
 	}
+      }
     }
+    for (int ir = 0; ir < nycell; ir++)
+      png_write_rows (png_ptr, &row_pointer, 1);
+  }
 
-    g2_image (id_X11, 0., 0., nx, ny, pens);
+  png_write_end(png_ptr, info_ptr);
+  png_destroy_write_struct(&png_ptr, &info_ptr);
 
-    delete [] pens;
-    return (id_X11);
-
-#endif
+  fclose(fp);
 }
+#endif
+
+#ifdef HAVE_GD
+#include "gd.h"
+static const int N_GRAYSCALE=256;
 
+void
+ImageFile::writeImageGIF (const char *outfile, int nxcell, int nycell, double densmin, double densmax)
+{
+  gdImagePtr gif;
+  FILE *out;
+  int gs_indices[N_GRAYSCALE];
+  int nx = m_nx;
+  int ny = m_ny;
+  ImageFileArray v = getArray();
 
+  unsigned char rowp [nx * nxcell];
+  if (rowp == NULL)
+    return;
 
+  gif = gdImageCreate(nx * nxcell, ny * nycell);
+  for (int i = 0; i < N_GRAYSCALE; i++)
+    gs_indices[i] = gdImageColorAllocate(gif, i, i, i);
+
+  int lastrow = ny * nycell - 1;
+  for (int irow = 0; irow < ny; irow++) {
+    int rpos = irow * nycell;
+    for (int ir = rpos; ir < rpos + nycell; ir++) {
+      for (int icol = 0; icol < nx; icol++) {
+	int cpos = icol * nxcell;
+	double dens = (v[icol][irow] - densmin) / (densmax - densmin);
+	dens = clamp(dens, 0., 1.);
+	for (int ic = cpos; ic < cpos + nxcell; ic++) {
+	  rowp[ic] = (unsigned int) (dens * (double) (N_GRAYSCALE - 1));
+	  gdImageSetPixel(gif, ic, lastrow - ir, gs_indices[rowp[ic]]);
+	}
+      }
+    }
+  }
+
+  if ((out = fopen(outfile,"w")) == NULL) {
+    sys_error(ERR_FATAL, "Error opening output file %s for writing", outfile);
+    return (1);
+  }
+  gdImageGif(gif,out);
+  fclose(out);
+  gdImageDestroy(gif);
+}
+#endif