./0000755000076600007660000000000010366222023010615 5ustar patpat00000000000000./GNUmakefile0000644000076600007660000000122210366216361012674 0ustar patpat00000000000000 TARG := kchron OBJS := vec.o ray.o mirror.o scope.o PNG.o seq.o progress.o main.o OPTFLG := -g PNGINC := -I/sw/include PNGLIB := -L/sw/lib -lpng -lz %.o: %.cc c++ $(OPTFLG) $(PNGINC) -c -o $@ $< all: $(TARG) clean: rm -f $(TARG) rm -f $(OBJS) $(TARG): $(OBJS) c++ $(OPTFLG) -o $@ $^ $(PNGLIB) vec.o: vec.hh ray.o: vec.hh ray.o: ray.hh mirror.o: vec.hh mirror.o: ray.hh mirror.o: mirror.hh scope.o: vec.hh scope.o: ray.hh scope.o: mirror.hh scope.o: scope.hh PNG.o: PNG.hh seq.o: PNG.hh seq.o: seq.hh progress.o: progress.hh main.o: vec.hh main.o: ray.hh main.o: mirror.hh main.o: scope.hh main.o: PNG.hh main.o: seq.hh main.o: progress.hh ./main.cc0000644000076600007660000001711610366221350012060 0ustar patpat00000000000000 #include #include #include #include #include "vec.hh" #include "ray.hh" #include "mirror.hh" #include "scope.hh" #include "PNG.hh" #include "seq.hh" #include "progress.hh" static unsigned int clip( double _dd, unsigned int _max = 255 ) { int vv = (int)( _dd * (double)_max + 0.5 ); if ( vv < 0 ) { return 0; } else if ( vv > _max ) { return (unsigned int)_max; } else { return vv; } } int main( int _argc, const char* const _argv[] ) { unsigned int ww = 0; unsigned int hh = 0; double cc = 1.0; double length = 5.0; double fps = 29.97; const char* iprefix = "./in/base "; unsigned int ifill = 3; const char* isuffix = ".png"; const char* oprefix = "./out/base "; unsigned int ofill = 3; const char* osuffix = ".png"; /* ** parse arguments */ for ( int ii=1; ii < _argc; ++ii ) { std::string arg( _argv[ ii ] ); if ( arg == "--size" || arg == "-s" ) { ww = std::strtol( _argv[ ++ii ], 0, 0 ); hh = std::strtol( _argv[ ++ii ], 0, 0 ); if ( ww < 1 || hh < 1 ) { std::cerr << "Width and height must both be positive integers"; std::cerr << std::endl; return __LINE__; } } else if ( arg == "--length" || arg == "-l" ) { length = std::strtod( _argv[ ++ii ], 0 ); if ( length < 0.0 ) { std::cerr << "Length must be non-negative"; std::cerr << std::endl; return __LINE__; } } else if ( arg == "--c" || arg == "-c" ) { cc = std::strtod( _argv[ ++ii ], 0 ); if ( cc <= 0.0 ) { std::cerr << "Lightspeed must be positive"; std::cerr << std::endl; return __LINE__; } } else if ( arg == "--informat" || arg == "-i" ) { iprefix = _argv[ ++ii ]; ifill = std::strtol( _argv[ ++ii ], 0, 0 ); isuffix = _argv[ ++ii ]; } else if ( arg == "--outformat" || arg == "-o" ) { oprefix = _argv[ ++ii ]; ofill = std::strtol( _argv[ ++ii ], 0, 0 ); osuffix = _argv[ ++ii ]; } else if ( arg == "--fps" ) { fps = std::strtod( _argv[ ++ii ], 0 ); if ( fps <= 0.0 ) { std::cerr << "Frames-per-second must be positive..."; std::cerr << std::endl; return __LINE__; } } else { if ( arg != "--help" && arg != "-h" && arg != "-?" ) { std::cerr << "Unrecogized arg: " << arg << std::endl; } std::cerr << "Usage: " << _argv[0] << std::endl; std::cerr << " [--informat pre fill post]" << std::endl; std::cerr << " [--outformat pre fill post]" << std::endl; std::cerr << " [--size ww hh]" << std::endl; std::cerr << " [--length ll.lll]" << std::endl; std::cerr << " [--c ss.sss]" << std::endl; std::cerr << " [--fps ff.fff]" << std::endl; return __LINE__; } } /* ** prepare the input sequence */ seq sequence( iprefix, ifill, isuffix ); if ( sequence.getCount() == 0 ) { std::cerr << "No images in the input sequence: " << iprefix; std::cerr << std::endl; return __LINE__; } /* force a preload of the first image */ (void) sequence.getBuffer( 0 ); const PNG& src( sequence[ 0 ] ); /* check width and height from the input image */ if ( ww < 1 || hh < 1 ) { ww = src.getWidth(); hh = src.getHeight(); } unsigned int cntr = 0; double minx; double maxx; double miny; double maxy; double mint; double maxt; bool* hits = new bool[ ww * hh ]; double* xoffs = new double[ ww * hh ]; double* yoffs = new double[ ww * hh ]; double* toffs = new double[ ww * hh ]; scope ss( length ); vec origin( 0.0, 0.0, 0.0, 0.0 ); std::cerr << "Calculating offsets: " << std::flush; progress prepmeter( hh ); for ( unsigned int jj=0; jj < hh; ++jj ) { double yy = - ( (double)jj / (double)(hh-1) ) + 0.5; prepmeter.tick(); for ( unsigned int ii=0; ii < ww; ++ii ) { double xx = ( (double)ii / (double)(ww-1) ) - 0.5; vec dir( 1.0, 2.0 * xx, 2.0 * yy, 1.0 ); ray in( origin, dir ); ray out; unsigned int index = ii + jj * ww; hits[ index ] = ss.reflect( in, &out ); if ( hits[ index ] ) { vec vv( out.getStart() ); vv *= 1.0 / vv.getX(); xoffs[ index ] = vv.getY(); yoffs[ index ] = vv.getZ(); toffs[ index ] = vv.getT(); if ( ++cntr == 1 ) { minx = maxx = xoffs[ index ]; miny = maxy = yoffs[ index ]; mint = maxt = toffs[ index ]; } else { if ( xoffs[ index ] < minx ) { minx = xoffs[ index ]; } else if ( maxx < xoffs[ index ] ) { maxx = xoffs[ index ]; } if ( yoffs[ index ] < miny ) { miny = yoffs[ index ]; } else if ( maxy < yoffs[ index ] ) { maxy = yoffs[ index ]; } if ( toffs[ index ] < mint ) { mint = toffs[ index ]; } else if ( maxt < toffs[ index ] ) { maxt = toffs[ index ]; } } } } } std::cerr << " done" << std::endl; if ( cntr == 0 ) { std::cerr << "Something's wrong... we never hit the image."; std::cerr << std::endl; return __LINE__; } double xrange = ( maxx - minx ); double yrange = ( maxy - miny ); if ( std::fabs( xrange ) < 0.0001 || std::fabs( yrange ) < 0.0001 ) { std::cerr << "Something's wrong... we always hit center."; std::cerr << std::endl; return __LINE__; } double scale; if ( xrange < yrange ) { scale = 1.0 / yrange; } else { scale = 1.0 / xrange; } double tscale = fps / ( maxt - mint ); std::cerr << "Scaling space offsets by " << scale << std::endl; std::cerr << "Scaling time offsets by " << tscale << std::endl; for ( unsigned int jj=0; jj < hh; ++jj ) { for ( unsigned int ii=0; ii < ww; ++ii ) { unsigned int index = ii + jj * ww; if ( hits[ index ] ) { xoffs[ index ] -= minx; xoffs[ index ] *= scale; yoffs[ index ] -= miny; yoffs[ index ] *= scale; toffs[ index ] -= mint; toffs[ index ] *= tscale / cc; } } } maxx = ( maxx - minx ) * scale; minx = 0.0; maxy = ( maxy - miny ) * scale; miny = 0.0; maxt = ( maxt - mint ) * scale / cc; mint = 0.0; /* ** prepare destination image */ PNG dst( ww, hh, 3 ); unsigned int sw = src.getWidth(); unsigned int sh = src.getHeight(); unsigned int sc = src.getChannels(); /* fake output sequence used to generate filenames */ seq outseq( oprefix, ofill, osuffix ); std::cerr << "Generating output: " << std::flush; progress outmeter( sequence.getCount() ); /* ** loop through to create each output frame */ for ( unsigned int ff=0; ff < sequence.getCount(); ++ff ) { unsigned char* dstPtr = dst.getBuffer(); outmeter.tick(); for ( unsigned int jj=0; jj < hh; ++jj ) { for ( unsigned int ii=0; ii < ww; ++ii ) { unsigned int index = ii + jj * ww; if ( hits[ index ] ) { unsigned int xx = clip( xoffs[ index ], (sw-1) ); unsigned int yy = clip( yoffs[ index ], (sh-1) ); unsigned int tt = (unsigned int)( toffs[ index ]+0.5 ) + ff; unsigned char* srcPtr = sequence.getBuffer( tt ); if ( srcPtr != 0 ) { unsigned char* ptr = &srcPtr[ ( xx + yy * sw ) * sc ]; *dstPtr++ = *ptr++; *dstPtr++ = *ptr++; *dstPtr++ = *ptr++; } else { *dstPtr++ = 0x00; *dstPtr++ = 0x00; *dstPtr++ = 0x00; } } else { *dstPtr++ = 0xFF; *dstPtr++ = 0xFF; *dstPtr++ = 0xFF; } } } /* output the frame */ char fname[ seq::MAXPATHLEN+1 ]; outseq.filename( ff, fname, sizeof(fname) ); if ( ! dst.write( fname ) ) { std::cerr << "Unable to write: " << fname << std::endl; std::exit( __LINE__ ); } } std::cerr << " done" << std::endl; delete[] toffs; delete[] yoffs; delete[] xoffs; delete[] hits; return 0; } ./mirror.cc0000644000076600007660000000264310366067475012465 0ustar patpat00000000000000 #include #include #include "vec.hh" #include "ray.hh" #include "mirror.hh" mirror::mirror( void ) { } mirror::mirror( const vec& _normal, double _offset ) { this->set( _normal, _offset ); } mirror::mirror( const mirror& _orig ) { this->set( _orig.normal, _orig.offset ); } mirror& mirror::operator = ( const mirror& _orig ) { this->set( _orig.normal, _orig.offset ); return *this; } bool mirror::checkRayIntersection( const ray& _ray, double* _distance ) const { double dn = this->normal.dot( _ray.getDirection() ); if ( std::fabs( dn ) > 0.0001 ) { double xn = this->normal.dot( _ray.getStart() ); double dd = ( this->offset - xn ) / dn; if ( dd >= 0.0001 ) { if ( _distance != 0 ) { *_distance = dd; } return true; } } return false; } bool mirror::reflect( const ray& _in, ray* _out, double* _distance ) const { double dd; if ( this->checkRayIntersection( _in, &dd ) ) { if ( _distance != 0 ) { *_distance = dd; } if ( _out != 0 ) { vec oldDir( _in.getDirection() ); vec start( oldDir ); start *= dd; start += _in.getStart(); vec dir( this->normal ); dir *= -2.0 * this->normal.dot( oldDir ); dir += oldDir; *_out = ray( start, dir ); } return true; } return false; } void mirror::set( const vec& _normal, double _offset ) { this->normal = _normal; this->offset = _offset; } ./mirror.hh0000644000076600007660000000067010365764457012500 0ustar patpat00000000000000 class mirror { public: mirror( void ); mirror( const vec& _normal, double _offset ); mirror( const mirror& _orig ); mirror& operator = ( const mirror& _orig ); bool checkRayIntersection( const ray& _ray, double* _distance ) const; bool reflect( const ray& _in, ray* _out, double* _distance = 0 ) const; private: void set( const vec& _normal, double _offset ); private: vec normal; double offset; }; ./PNG.cc0000644000076600007660000002035010366005455011560 0ustar patpat00000000000000 #include #include #include #include #include #include "PNG.hh" static void readData( png_structp ctx, png_bytep buffer, png_size_t size ) { std::ifstream* src = (std::ifstream*) ::png_get_io_ptr( ctx ); src->read( (char*)buffer, size ); } static void writeData( png_structp ctx, png_bytep buffer, png_size_t size ) { std::ofstream* dst = (std::ofstream*) ::png_get_io_ptr( ctx ); dst->write( (char*)buffer, size ); } static unsigned int clip( double value, unsigned int max ) { int cc = (int)( value + 0.5 ); if ( cc < 0 ) { cc = 0; } else if ( (unsigned int)cc > max ) { cc = (int)max; } return (unsigned int)cc; } static void flushData( png_structp ctx ) { std::ofstream* dst = (std::ofstream*) ::png_get_io_ptr( ctx ); *dst << std::flush; } PNG::PNG( void ) : pixels( 0 ) { } PNG::~PNG( void ) { delete[] this->pixels; } PNG::PNG( unsigned int ww, unsigned int hh, unsigned int ch ) { this->width = ww; this->height = hh; this->channels = ch; this->pixels = new unsigned char[ this->width * this->height * this->channels ]; ::memset( this->pixels, 0, this->width * this->height * this->channels ); } PNG::PNG( const PNG& other ) : pixels( 0 ) { *this = other; } PNG& PNG::operator = ( const PNG& other ) { delete[] this->pixels; this->width = other.width; this->height = other.height; this->channels = other.channels; this->pixels = new unsigned char[ this->width * this->height * this->channels ]; if ( this->pixels != 0 ) { ::memcpy( this->pixels, other.pixels, this->width * this->height * this->channels ); } return *this; } bool PNG::read( const char* fileName ) { std::ifstream src( fileName ); if ( src.bad() || src.fail() ) { return false; } png_structp pngPtr = ::png_create_read_struct( PNG_LIBPNG_VER_STRING, 0, 0, 0 ); if ( pngPtr == 0 ) { std::cerr << "Unable to create png read structure" << std::endl; return false; } png_infop infoPtr = ::png_create_info_struct( pngPtr ); if ( infoPtr == 0 ) { std::cerr << "Unable to create png info struct" << std::endl; ::png_destroy_read_struct( &pngPtr, 0, 0 ); return false; } if ( ::setjmp( pngPtr->jmpbuf ) ) { std::cerr << "Something wrong during read png" << std::endl; ::png_destroy_read_struct( &pngPtr, &infoPtr, 0 ); return false; } ::png_set_read_fn( pngPtr, &src, ::readData ); ::png_read_info( pngPtr, infoPtr ); png_uint_32 _width = 0; png_uint_32 _height = 0; int bpp = 0; int colorType = 0; int interlaceType = 0; ::png_get_IHDR( pngPtr, infoPtr, &_width, &_height, &bpp, &colorType, &interlaceType, 0, 0 ); this->width = _width; this->height = _height; if ( colorType == PNG_COLOR_TYPE_PALETTE && bpp <= 8 ) { ::png_set_expand( pngPtr ); } if ( colorType == PNG_COLOR_TYPE_GRAY and bpp < 8 ) { ::png_set_expand( pngPtr ); } if ( ::png_get_valid( pngPtr, infoPtr, PNG_INFO_tRNS ) ) { ::png_set_expand( pngPtr ); } if ( ( colorType & PNG_COLOR_MASK_ALPHA ) != 0 ) { ::png_set_strip_alpha( pngPtr ); } if ( colorType == PNG_COLOR_TYPE_GRAY or colorType == PNG_COLOR_TYPE_GRAY_ALPHA ) { ::png_set_gray_to_rgb( pngPtr ); } if ( bpp == 16 ) { #if SDL_BYTEORDER == SDL_LIL_ENDIAN ::png_set_swap( pngPtr ); #endif ::png_set_strip_16( pngPtr ); } unsigned int nPasses = ::png_set_interlace_handling( pngPtr ); ::png_read_update_info( pngPtr, infoPtr ); this->channels = infoPtr->channels; this->pixels = new unsigned char[ this->width * this->height * this->channels ]; if ( this->pixels == 0 ) { ::png_destroy_read_struct( &pngPtr, &infoPtr, 0 ); return false; } png_bytep* rowPtrs = new png_bytep[ this->height ]; if ( rowPtrs == 0 ) { delete[] this->pixels; this->pixels = 0; ::png_destroy_read_struct( &pngPtr, &infoPtr, 0 ); return false; } unsigned char* ptr = &this->pixels[ 0 ]; for ( unsigned int ii=0; ii < height; ++ii ) { rowPtrs[ii] = (png_bytep)ptr; ptr = &ptr[ this->width * this->channels ]; } ::png_read_image( pngPtr, rowPtrs ); delete[] rowPtrs; ::png_read_end( pngPtr, infoPtr ); ::png_destroy_read_struct( &pngPtr, &infoPtr, 0 ); return true; } bool PNG::readAlpha( const char* fileName ) { std::ifstream src( fileName ); if ( src.bad() || src.fail() ) { return false; } png_structp pngPtr = ::png_create_read_struct( PNG_LIBPNG_VER_STRING, 0, 0, 0 ); if ( pngPtr == 0 ) { std::cerr << "Unable to create png read structure" << std::endl; return false; } png_infop infoPtr = ::png_create_info_struct( pngPtr ); if ( infoPtr == 0 ) { std::cerr << "Unable to create png info struct" << std::endl; ::png_destroy_read_struct( &pngPtr, 0, 0 ); return false; } if ( ::setjmp( pngPtr->jmpbuf ) ) { std::cerr << "Something wrong during read png" << std::endl; ::png_destroy_read_struct( &pngPtr, &infoPtr, 0 ); return false; } ::png_set_read_fn( pngPtr, &src, ::readData ); ::png_read_info( pngPtr, infoPtr ); png_uint_32 _width = 0; png_uint_32 _height = 0; int bpp = 0; int colorType = 0; int interlaceType = 0; ::png_get_IHDR( pngPtr, infoPtr, &_width, &_height, &bpp, &colorType, &interlaceType, 0, 0 ); this->width = _width; this->height = _height; if ( colorType == PNG_COLOR_TYPE_PALETTE && bpp <= 8 ) { ::png_set_expand( pngPtr ); } if ( colorType == PNG_COLOR_TYPE_GRAY and bpp < 8 ) { ::png_set_expand( pngPtr ); } if ( ::png_get_valid( pngPtr, infoPtr, PNG_INFO_tRNS ) ) { ::png_set_expand( pngPtr ); } if ( colorType == PNG_COLOR_TYPE_GRAY or colorType == PNG_COLOR_TYPE_GRAY_ALPHA ) { ::png_set_gray_to_rgb( pngPtr ); } if ( bpp == 16 ) { #if SDL_BYTEORDER == SDL_LIL_ENDIAN ::png_set_swap( pngPtr ); #endif ::png_set_strip_16( pngPtr ); } unsigned int nPasses = ::png_set_interlace_handling( pngPtr ); ::png_read_update_info( pngPtr, infoPtr ); this->channels = infoPtr->channels; this->pixels = new unsigned char[ this->width * this->height * this->channels ]; if ( this->pixels == 0 ) { ::png_destroy_read_struct( &pngPtr, &infoPtr, 0 ); return false; } png_bytep* rowPtrs = new png_bytep[ this->height ]; if ( rowPtrs == 0 ) { delete[] this->pixels; this->pixels = 0; ::png_destroy_read_struct( &pngPtr, &infoPtr, 0 ); return false; } unsigned char* ptr = &this->pixels[ 0 ]; for ( unsigned int ii=0; ii < height; ++ii ) { rowPtrs[ii] = (png_bytep)ptr; ptr = &ptr[ this->width * this->channels ]; } ::png_read_image( pngPtr, rowPtrs ); delete[] rowPtrs; ::png_read_end( pngPtr, infoPtr ); ::png_destroy_read_struct( &pngPtr, &infoPtr, 0 ); return true; } bool PNG::write( const char* fileName ) { std::ofstream dst( fileName ); if ( dst.bad() || dst.fail() ) { return false; } png_structp pngPtr = ::png_create_write_struct( PNG_LIBPNG_VER_STRING, 0, 0, 0 ); if ( pngPtr == 0 ) { std::cerr << "Unable to create png write structure" << std::endl; return false; } png_infop infoPtr = ::png_create_info_struct( pngPtr ); if ( infoPtr == 0 ) { std::cerr << "Unable to create png info struct" << std::endl; ::png_destroy_write_struct( &pngPtr, 0 ); return false; } if ( ::setjmp( pngPtr->jmpbuf ) ) { std::cerr << "Something wrong during write png" << std::endl; ::png_destroy_write_struct( &pngPtr, &infoPtr ); return false; } ::png_set_write_fn( pngPtr, &dst, ::writeData, ::flushData ); ::png_set_compression_level( pngPtr, Z_BEST_COMPRESSION ); // ::png_set_compression_method( pngPtr, 8 ); ::png_set_IHDR( pngPtr, infoPtr, this->width, this->height, 8, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT ); ::png_write_info( pngPtr, infoPtr ); for ( unsigned int ii=0; ii < this->height; ++ii ) { png_bytep rowPtr = (png_bytep)&this->pixels[ ii * this->width * this->channels ]; ::png_write_row( pngPtr, rowPtr ); } ::png_write_end( pngPtr, infoPtr ); ::png_destroy_write_struct( &pngPtr, &infoPtr ); return true; } ./PNG.hh0000644000076600007660000000133210366062557011577 0ustar patpat00000000000000 class PNG { public: PNG( void ); ~PNG( void ); PNG( unsigned int ww, unsigned int hh, unsigned int cc = 3 ); PNG( const PNG& other ); PNG& operator = ( const PNG& other ); inline unsigned int getWidth( void ) const { return this->width; }; inline unsigned int getHeight( void ) const { return this->height; }; inline unsigned int getChannels( void ) const { return this->channels; }; inline unsigned char* getBuffer( void ) { return this->pixels; }; bool read( const char* fileName ); bool readAlpha( const char* fileName ); bool write( const char* fileName ); public: unsigned int width; unsigned int height; unsigned int channels; unsigned char* pixels; }; ./progress.cc0000644000076600007660000000054410366065403013002 0ustar patpat00000000000000 #include #include "progress.hh" progress::progress( unsigned int _end ) : end( _end ), cur( 0 ) { } void progress::tick( void ) { unsigned int then = ( this->cur * 60 + this->end / 2 ) / this->end; unsigned int now = ( ++this->cur * 60 + this->end / 2 ) / this->end; if ( then != now ) { std::cerr << "." << std::flush; } } ./progress.hh0000644000076600007660000000021610366065263013014 0ustar patpat00000000000000 class progress { public: progress( unsigned int _end ); void tick( void ); private: unsigned int end; unsigned int cur; }; ./ray.cc0000644000076600007660000000112710365756300011731 0ustar patpat00000000000000 #include "vec.hh" #include "ray.hh" ray::ray( void ) { } ray::ray( const vec& _start, const vec& _dir ) { this->set( _start, _dir ); this->dir.normalize(); } ray::ray( const ray& _orig ) { this->set( _orig.start, _orig.dir ); } ray& ray::operator = ( const ray& _orig ) { this->set( _orig.start, _orig.dir ); return *this; } void ray::set( const vec& _start, const vec& _dir ) { this->start = _start; this->dir = _dir; } std::ostream& operator << ( std::ostream& _oo, const ray& _rr ) { _oo << _rr.getStart() << " -> " << _rr.getDirection(); return _oo; } ./ray.hh0000644000076600007660000000072310365756220011745 0ustar patpat00000000000000 class ray { public: ray( void ); ray( const vec& _start, const vec& _dir ); ray( const ray& _orig ); ray& operator = ( const ray& _orig ); inline const vec& getStart( void ) const { return this->start; } inline const vec& getDirection( void ) const { return this->dir; } private: void set( const vec& _start, const vec& _dir ); private: vec start; vec dir; }; std::ostream& operator << ( std::ostream& _oo, const ray& _rr ); ./scope.cc0000644000076600007660000000406410366110312012236 0ustar patpat00000000000000 #include #include "vec.hh" #include "ray.hh" #include "mirror.hh" #include "scope.hh" scope::scope( double _length ) { static const double aa = 3.0 / 4.0; static const double bb = -1.0 / 4.0; this->add( aa, bb, bb, bb ); this->add( bb, aa, bb, bb ); this->add( bb, bb, aa, bb ); this->add( bb, bb, bb, aa ); this->length = _length; this->plane = mirror( vec( 1.0, 0.0, 0.0, 0.0 ), this->length ); } scope::~scope( void ) { this->mirrors.clear(); } bool scope::reflect( const ray& _in, ray* _out ) const { if ( this->reflect( _in, _out, this->mirrors.end() ) ) { ray rr( *_out ); return this->plane.reflect( rr, _out ); } else { return this->plane.reflect( _in, _out ); } } bool scope::reflect( const ray& _in, ray* _out, iterator _skip ) const { iterator bestHit = this->mirrors.end(); double bestDistance = -1.0; for ( iterator it=this->mirrors.begin(); it != this->mirrors.end(); ++it ) { if ( it != _skip ) { double dd; if ( it->checkRayIntersection( _in, &dd ) ) { if ( bestHit == this->mirrors.end() || dd < bestDistance ) { bestHit = it; bestDistance = dd; } } } } if ( bestHit != this->mirrors.end() ) { ray reflected; bestHit->reflect( _in, &reflected ); if ( reflected.getStart().getX() < this->length ) { this->reflect( reflected, _out, bestHit ); } else { *_out = _in; } return true; } else { *_out = _in; return false; } } void scope::add( double _xx, double _yy, double _zz, double _tt ) { static const double alpha( 0.5 ); static const double beta( M_SQRT1_2 ); static const vec r1( alpha, alpha, alpha, alpha ); static const vec r2( 0.0, 0.0, beta, -beta ); static const vec r3( alpha, alpha, -alpha, -alpha ); static const vec r4( beta, -beta, 0.0, 0.0 ); static const double gamma( std::sqrt( 3.0 ) / 2.0 ); vec vv( _xx, _yy, _zz, _tt ); vec vp( r1.dot( vv ), r2.dot( vv ), r3.dot( vv ), r4.dot( vv ) ); vp.normalize(); mirror mm( vp, gamma ); this->mirrors.push_front( mm ); } ./scope.hh0000644000076600007660000000066110365764241012266 0ustar patpat00000000000000#include class scope { public: scope( double _length = 5.0 ); ~scope( void ); bool reflect( const ray& _in, ray* _out ) const; private: typedef std::list< mirror >::const_iterator iterator; bool reflect( const ray& _in, ray* _out, iterator _skip ) const; void add( double _xx, double _yy, double _zz, double _tt ); private: std::list< mirror > mirrors; double length; mirror plane; }; ./seq.cc0000644000076600007660000000310110366217715011723 0ustar patpat00000000000000 #include #include #include #include #include #include #include #include #include "PNG.hh" #include "seq.hh" seq::seq( const char* _prefix, unsigned int _fill, const char* _suffix ) { this->prefix = _prefix; this->fill = _fill; this->suffix = _suffix; bool done = false; for ( this->count = 0; !done; ++this->count ) { char fname[ MAXPATHLEN+1 ]; this->filename( this->count, fname, sizeof(fname) ); done = ! this->exists( fname ); } --this->count; this->pngs = new PNG[ this->count ]; } seq::~seq( void ) { delete[] this->pngs; } unsigned char* seq::getBuffer( unsigned int _index ) { unsigned char* ret = 0; if ( _index >= this->count ) { _index = this->count - 1; } ret = this->pngs[ _index ].getBuffer(); if ( ret == 0 ) { char fname[ MAXPATHLEN+1 ]; this->filename( _index, fname, sizeof(fname) ); if ( ! this->pngs[ _index ].read( fname ) ) { std::cerr << "PNG READ FAILED: " << fname << std::endl; std::exit( __LINE__ ); } else { ret = this->pngs[ _index ].getBuffer(); } } return ret; } void seq::filename( unsigned int _index, char _buf[], unsigned int _len ) const{ std::ostringstream str; str << this->prefix << std::setfill( '0' ) << std::setw( this->fill ) << ( _index + 1 ) << this->suffix << std::ends; std::strncpy( _buf, str.str().c_str(), _len ); } bool seq::exists( const char* _filename ) const { struct stat sbuf; return ( ::stat( _filename, &sbuf ) == 0 ); } ./seq.hh0000644000076600007660000000117410366106600011733 0ustar patpat00000000000000class seq { public: seq( const char* _prefix, unsigned int _fill, const char* _suffix ); ~seq( void ); inline unsigned int getCount( void ) const { return this->count; }; inline const PNG& operator [] ( unsigned int _index ) const { return this->pngs[ _index ]; }; unsigned char* getBuffer( unsigned int _index ); enum { MAXPATHLEN = 2048 }; void filename( unsigned int _index, char _buf[], unsigned int _len ) const; private: bool exists( const char* _filename ) const; private: const char* prefix; unsigned int fill; const char* suffix; unsigned int count; PNG* pngs; }; ./vec.cc0000644000076600007660000000240310365757422011717 0ustar patpat00000000000000 #include #include "vec.hh" vec::vec( void ) { } vec::vec( double _xx, double _yy, double _zz, double _tt ) { this->set( _xx, _yy, _zz, _tt ); } vec::vec( const vec& _orig ) { this->set( _orig.xx, _orig.yy, _orig.zz, _orig.tt ); } vec& vec::operator = ( const vec& _orig ) { this->set( _orig.xx, _orig.yy, _orig.zz, _orig.tt ); return *this; } vec& vec::operator += ( const vec& _oo ) { this->xx += _oo.xx; this->yy += _oo.yy; this->zz += _oo.zz; this->tt += _oo.tt; } vec& vec::operator *= ( double _ss ) { this->xx *= _ss; this->yy *= _ss; this->zz *= _ss; this->tt *= _ss; return *this; } void vec::normalize( void ) { double vv = this->dot( *this ); if ( vv > 0.0001 ) { *this *= 1.0 / std::sqrt( vv ); } } double vec::dot( const vec& _other ) const { return this->xx * _other.xx + this->yy * _other.yy + this->zz * _other.zz + this->tt * _other.tt ; } void vec::set( double _xx, double _yy, double _zz, double _tt ) { this->xx = _xx; this->yy = _yy; this->zz = _zz; this->tt = _tt; } std::ostream& operator << ( std::ostream& _oo, const vec& _vv ) { _oo << "< " << _vv.getX() << ", " << _vv.getY() << ", " << _vv.getZ() << ", " << _vv.getT() << " >" ; return _oo; } ./vec.hh0000644000076600007660000000142610365756060011732 0ustar patpat00000000000000#include class vec { public: vec( void ); vec( double _xx, double _yy, double _zz, double _tt ); vec( const vec& _orig ); vec& operator = ( const vec& _orig ); vec& operator += ( const vec& _oo ); vec& operator *= ( double _ss ); void normalize( void ); double dot( const vec& _other ) const; inline double getX( void ) const { return this->xx; }; inline double getY( void ) const { return this->yy; }; inline double getZ( void ) const { return this->zz; }; inline double getT( void ) const { return this->tt; }; private: void set( double _xx, double _yy, double _zz, double _tt ); private: double xx; double yy; double zz; double tt; }; std::ostream& operator << ( std::ostream& _oo, const vec& _vv );