Poisson-Based Continuous Surface Generation for Goal-Based Caustics

Overview

This project implements and builds upon the method described in the paper Poisson-Based Continuous Surface Generation for Goal-Based Caustics.

What does it do?

With the code in this repository you can calculate the shape of a transparent window that casts an image if light passes through.

It does that by modulating the angle of the surface across the entire surface to steer the light in the desired directions.

A more detailed explanation is that it first calculates from where on the lens surface to where on the screen the light should go. It then calculates the the shape of the lens such that it satisfies all these directions.

Result simulated with Blender using LuxRender:

Features

• Implementation of the Poisson-based continuous surface generation algorithm by Yue et al.
• exports a solidified .obj
• the only non-standard C++ dependancy is libpng
• can export the the inverse transport map (can be used for for density sampling)
• multithreaded poisson solver

Installation

Prerequisites

• C++ compiler with C++17 support for your platform
• libpng (requires zlib)

Building from Source: Unix

1. Clone the repository:

   git clone [email protected]:dylanmsu/caustic_engineering.git

2. Navigate to the project directory:

   cd caustic_engineering

3. Compile the source code:

   # create build directory
   mkdir build && cd build
   
   # generate build files
   cmake ..
   
   # build
   make

4. Run the code:

   ./CausticEngineering [parameters]

Building from Source: Windows

1. Clone the repository:

   git clone [email protected]:dylanmsu/caustic_engineering.git

2. Navigate to the project directory:

   cd caustic_engineering

3. Compile the source code:

   # create build directory
   mkdir build && cd build
   
   # generate build files (assumes C:/mingw64 to be the mingw64 path)
   & "C:/mingw64/bin/cmake.exe" -G "MinGW Makefiles" .. 
   
   # build
   & "C:/mingw64/bin/mingw32-make.exe"

4. Run the code:

   ./CausticEngineering.exe [parameters]

Usage

Running the Program

1. Parameters:

   •   --input_png=[image path] # input image path (REQUIRED)

   •   --progress_out=[output svg path] # path to put the transport solver progress in svg

   •   --output=[output] # path to put the final 3d model of the lens

   •   --res_w=[grid resolution] # mesh resolution in the x-axis

   •   --mesh_width=[mesh width] # physical width of the mesh

   •   --focal_l=[focal length] # focal length

   •   --thickness=[lens thickness] # thickness of the final caustic lens

   •   --conv_tres=[convergence treshold] # higher number = faster but lower contrast image

   •   --threads=[max number of threads] # sets the maximum cpu threads for the poisson solver

2. Execute the program:

   ./CausticEngineering.exe --input_png=../img/siggraph.png --progress_out=../ --output=../ --res_w=100 --mesh_width=0.5 --focal_l=1.5 --thickness=0.1 --conv_tres=0.01 --threads=16

Sample Output

	input_image	parameterization	inverted parameterization	3d_model	simulation
Lena (Mesh: 256 x 256)
Siggraph logo (Mesh: 200 x 200)
Hello World (Mesh: 256 x 128)

transport from an image to an almost uniform distribution:

Prototype

Machined acrylic prototype:

Shadow of the machined prototype:

Future plans

1. least squares solver for the heightmap -> this will allow more freedom in the lens design
2. reflective caustics -> is currently not that usefull because of the limited freedom in the height solver
3. circular caustic lenses
4. use the fast transport map algoritm from the paper: [https://gnader.github.io/publications/2018-ot-transport.html](Instant Transport Maps on 2D Grids)

Contributing

Contributions are welcome! If you'd like to contribute to this project, please follow these steps:

1. Fork the repository
2. Create a new branch (git checkout -b feature)
3. Make your changes
4. Commit your changes (git commit -am 'Add new feature')
5. Push to the branch (git push origin feature)
6. Create a new Pull Request

License

This project uses the MIT License.

Acknowledgements

Thank you to Yue et al for their awesome research paper.

I would also like to thank Matt Ferraro for providing their informative article about the paper.