RenderJob is a Java class to render function mapping two coordinates to a boolean value
(rendered function itself is Java class implementing RenderJob.Boolean2dFun interface).
The function result is rendered as black and white image.
RenderJob will try to use all cores available on the machine and it will benefit from multi-core processors.


There are three functions included:
- TestFormula (which is quick to evaluate, but it can be slowed down by parameter)
- SelfFormulaFast (which contains self referential formula with optimizations, it is slow, it accepts N as single parameter)
- SelfFormula (which contains self referential formula without optimization corresponding 1:1 to presented
  self referential formula, it is very very slow, it accepts N as single parameter)
- SelfFormulaFastEps (variant of SelfFormulaFast that allows to experiment with epsilon parameter as second argument)
- SelfFormulaFastEpsSmoother (different formula that has a change to Wc function: it is more complex but it does
  line approximation when d is smaller than epsilon)


The RenderJob can be run using java 1.8 (newer versions were not tested, but they should work).
It has single argument: a filename with job description.
Description files contains 16 lines. Additional lines are parameters passed used to initialize selected
rendering function.

Lines:

1. description (keep it to one line)
2. output image file name (PNG format, also used for input if restarted)
3. short class name of drawing class (e.g. TestFormula, SelfFormulaFast or SelfFormula)
4. saving interval in seconds (use longer for big images, very slow pixel computaion may delay saving)
5. width of resulting image
6. view port x1
7. view port x2
8. view port y1
9. view port y2
10. render x1
11. render x2
12. render y1
13. render y2
14. subpixel grid (1=no grid)
15. subpixel shift x (0=no shift)
16. subpixel shift y (0=no shift)
17+ arguments to drawing class (e.g. big N number for SelfFormulaFast on single line)


RenderJob will create a bitmap that will be stored in PNG format that corresponds to specified view port
and specified width. RenderJob saves image during computation periodically. Pixel that were not computed
yet are transparent. If for some reason computation is interrupted, it can be restarted with same job file and it
will continue to compute remaining pixels. Additional output file is generated with suffix ".previous.png" to
protect against termination during file saving. If primary file is not readable upon restart, it will use the previous
file.

Render coordinates can be same as viewport coordinates for full rendering, but they can also specify smaller rectangle
to compute which may be useful to distribute computation.

Subpixel grid is used to shift all coordinates by a fraction of pixel to render several images and combine them to get
antialiased image.

There is also MergeImages class to do simple merge of multiple images to support merging of subpixel shifted images into
single antialiased image (you can also merge layers manually in GIMP, just set transparency of second layer to 50%,
third layer 33.3%, then 25%, 20%, 16.6%, 14.3%, 12.5%, ...). Output is always written to merged.png in current directory.


Quick FAQ

Q: Why are pixels computed in strange patterns of lines?
A: I have made it that way so I can see early if computed data covers what I need.

Q: RenderJob finishes without image being fully rendered. What to do?
A: Check if you have sufficient -Xss JVM argument. SelfFormula requires deep recursion so it is needed.
I am using -Xss200m