evd::PNGArena Class Reference

#include <PNGArena.h>

Public Types
enum	{ kArenaSize = 4096, kBlockSize = 512, kTotBytes = MipMapOffset(1, kArenaSize)+4 }

Public Member Functions
	PNGArena (const std::string &name)
png_byte &	operator() (int i, int x, int y, int c)
const png_byte &	operator() (int i, int x, int y, int c) const
void	WritePNGBytes (FILE *fout, int imgIdx, int dim)
png_byte *	NewBlock ()

Public Attributes
std::string	name
int	elemx
int	elemy
int	nviews
std::vector< std::unique_ptr < std::array< png_byte, kTotBytes > > >	data

Protected Member Functions
void	FillMipMaps (int d)

Protected Attributes
std::vector< std::mutex * >	fMIPLocks
std::vector< bool >	fHasMIP

Friends
class	PNGView
void	AnalyzeArena (const PNGArena &)

Detailed Description

Definition at line 22 of file PNGArena.h.

Member Enumeration Documentation

anonymous enum

Enumerator
kArenaSize
kBlockSize
kTotBytes

Definition at line 28 of file PNGArena.h.

        {
      // Square because seems to be necessary for mipmapping. Larger than this
      // doesn't seem to work in the browser.
      kArenaSize = 4096,
      // We have APAs with 480 and 1148 wires. This fits them in 1 and 3 blocks
      // without being too wasteful.
      kBlockSize = 512,
      kTotBytes = MipMapOffset(1, kArenaSize)+4 // leave space for 1x1 as well
    };

Constructor & Destructor Documentation

evd::PNGArena::PNGArena

(

const std::string &

name

)

Definition at line 14 of file PNGArena.cxx.

                                       : name(n), nviews(0)
  {
  }

Member Function Documentation

void evd::PNGArena::FillMipMaps ( int  d )

protected

Definition at line 43 of file PNGArena.cxx.

  {
    png_byte* src = data[d]->data();
    png_byte* dest = data[d]->data() + kArenaSize*kArenaSize*4;

    for(int newdim = kArenaSize/2; newdim >= 1; newdim /= 2){
      const int olddim = newdim*2;

      // The alpha channel is set to twice the average of the source
      // pixels. The intuition is that a linear feature should remain equally
      // as bright, but would be expected to only hit 2 of the 4 source
      // pixels. The colour channels are averaged, weighted by the alpha
      // values.
      for(int y = 0; y < newdim; ++y){
        for(int x = 0; x < newdim; ++x){
          int totc[3] = {0,};
          int tota = 0;
          for(int dy = 0; dy <= 1; ++dy){
            for(int dx = 0; dx <= 1; ++dx){
              const int i = (y*2+dy)*olddim + (x*2+dx);

              const png_byte va = src[i*4+3]; // alpha value
              tota += va;

              for(int c = 0; c < 3; ++c){
                const png_byte vc = src[i*4+c]; // colour value
                totc[c] += vc * va;
              } // end for c
            } // end for dx
          } // end for dy

          const int i = y*newdim+x;
          for(int c = 0; c < 3; ++c) dest[i*4+c] = tota > 0 ? std::min(totc[c]/tota, 255) : 0;
          dest[i*4+3] = std::min(tota/2, 255);
        } // end for x
      } // end for y

      src = dest;
      dest += 4*newdim*newdim;
    } // end for newdim
  }

png_byte * evd::PNGArena::NewBlock

(

)

Definition at line 19 of file PNGArena.cxx.

  {
    const int nfitx = kArenaSize/kBlockSize;
    const int nfity = kArenaSize/kBlockSize;

    int ix = nviews%nfitx;
    int iy = nviews/nfitx;

    if(data.empty() || iy >= nfity){
      ix = 0;
      iy = 0;
      nviews = 0;
      data.push_back(std::make_unique<std::array<png_byte, kTotBytes>>());
      data.back()->fill(0);
      fHasMIP.push_back(false);
      fMIPLocks.push_back(new std::mutex);
    }

    ++nviews;

    return &(*data.back())[(iy*kArenaSize + ix)*kBlockSize*4];
  }

png_byte& evd::PNGArena::operator() ( int  i, int  x, int  y, int  c  )

inline

Definition at line 40 of file PNGArena.h.

    {
      return (*data[i])[(y*kArenaSize+x)*4+c];
    }

const png_byte& evd::PNGArena::operator() ( int  i, int  x, int  y, int  c  ) const

inline

Definition at line 45 of file PNGArena.h.

    {
      return (*data[i])[(y*kArenaSize+x)*4+c];
    }

void evd::PNGArena::WritePNGBytes	(	FILE *	fout,
		int	imgIdx,
		int	dim
	)

Definition at line 108 of file PNGArena.cxx.

  {
    if(imgIdx >= int(data.size())){
      std::cout << "Bad index " << imgIdx << std::endl;
      return; // TODO return 404 instead
    }

    if(dim != kArenaSize){ // might need MIPMaps generated
      std::lock_guard<std::mutex> guard(*fMIPLocks[imgIdx]);
      if(!fHasMIP[imgIdx]){
        FillMipMaps(imgIdx);
        fHasMIP[imgIdx] = true;
      }
    }

    // Figure out offset
    png_byte* src = &(*data[imgIdx])[MipMapOffset(dim, kArenaSize)];

    if(src + 4*dim*dim - 1 > &(*data[imgIdx]).back()){ // would run off end of data
      std::cout << "Bad mipmap size " << dim << std::endl;
      return; // TODO return 404 instead
    }

    png_struct_def* png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);

    auto info_ptr = png_create_info_struct(png_ptr);

    // I'm trying to optimize the compression speed, without blowing the file
    // size up. It's far from clear these are the best parameters, but they do
    // seem to be an improvement on the defaults.
    png_set_compression_level(png_ptr, 1);
    png_set_compression_strategy(png_ptr, Z_RLE);

    png_set_IHDR(png_ptr, info_ptr, dim, dim,
                 8/*bit_depth*/, PNG_COLOR_TYPE_RGBA, PNG_INTERLACE_NONE,
                 PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);

    std::vector<png_byte*> pdatas(dim);
    for(int i = 0; i < dim; ++i) pdatas[i] = src + i*dim*4;

    png_set_rows(png_ptr, info_ptr, pdatas.data());

    // This works fine until libpng throws a fatal error when the browser hangs
    // up
    // png_init_io(png_ptr, fout);

    // So set our own write function that does the same thing but ignores
    // errors
    png_set_write_fn(png_ptr, fout, webevd_png_write_fn, webevd_png_flush_fn);

    png_write_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, NULL);

    png_destroy_write_struct(&png_ptr, &info_ptr);
  }

Friends And Related Function Documentation

void AnalyzeArena ( const PNGArena &  )

friend

Definition at line 169 of file PNGArena.cxx.

  {
    for(int blockSize = 1; blockSize <= PNGArena::kArenaSize; blockSize *= 2){
      long nfilled = 0;
      for(unsigned int d = 0; d < bytes.data.size(); ++d){
        for(int iy = 0; iy < PNGArena::kArenaSize/blockSize; ++iy){
          for(int ix = 0; ix < PNGArena::kArenaSize/blockSize; ++ix){
            bool filled = false;
            for(int y = 0; y < blockSize && !filled; ++y){
              for(int x = 0; x < blockSize; ++x){
                if(bytes(d, ix*blockSize+x, iy*blockSize+y, 3) > 0){
                  filled = true;
                  break;
                }
              }
            } // end for y
            if(filled) ++nfilled;
          }
        }
      }

      std::cout << "With block size = " << blockSize << " " << double(nfilled)/((PNGArena::kArenaSize*PNGArena::kArenaSize)/(blockSize*blockSize)*bytes.data.size()) << " of the blocks are filled" << std::endl;
    }
  }

friend class PNGView

friend

Definition at line 25 of file PNGArena.h.

Member Data Documentation

std::vector<std::unique_ptr<std::array<png_byte, kTotBytes> > > evd::PNGArena::data

Definition at line 59 of file PNGArena.h.

int evd::PNGArena::elemx

Definition at line 56 of file PNGArena.h.

int evd::PNGArena::elemy

Definition at line 56 of file PNGArena.h.

std::vector<bool> evd::PNGArena::fHasMIP

protected

Definition at line 65 of file PNGArena.h.

std::vector<std::mutex*> evd::PNGArena::fMIPLocks

protected

Definition at line 64 of file PNGArena.h.

std::string evd::PNGArena::name

Definition at line 55 of file PNGArena.h.

int evd::PNGArena::nviews

Definition at line 57 of file PNGArena.h.

---

The documentation for this class was generated from the following files:

• PNGArena.h
• PNGArena.cxx