1.) Describe your results

The final result of the project is a program that creates visually nice
looking collages. I used a method of placement, movements, and growth to
have the images essentially lock themselves into a solution. Each image
is given an initial tiling spot on the canvas, is scaled down in size,
and then a master loop is ran until an equilibrium is reached. Inside
this loop, images push eachother away, swap into better fitting positions
with other images, and grow in size. Once the images no longer
move/swap/resize, the "equilibrium" is reached and the images are layer
sorted, trimmed, and the final resulting collage is produced.

The program reads in a collection of images and creates a collage. This
can very well be used for personal use to create quick collages out of a
set of pictures. It is limited in the fact that it does not produce an
optimal answer for the user, and the time constraint in which the
lower-bound O(n^2) algorithm may not be able to satisfy for extremely
large image sets.

I evaluated/scored the results of the collage creator on a few aspects.
First and foremost was the consumption of space by the hotspots. The
higher the area that was filled by the hotspots, the better the collage
looked and worked. Next was the amount of extra background space left
unfilled, and also trying to keep all images relatively the same size
(and thus the same amount of focus).

2.) Describe the work that you did

Originally, the aim of my project was allow each image to have its own
set of weights, and from there, each image would push others until an
equilibrium would be reached. Ideally, I believed this to be a somewhat
simple project that should produce near optimal results, the only downside
being computation time. I quickly discovered that this was much more
difficult than I had anticipated, and while it did perform well on test
cases where there was a few number of images and the hotspot sizes
weren't large in comparison to the image, it broke down when more pictures
were added. It would get stuck in a local optima that, even though the
images would be fairly well spaced, would produce an unacceptable side
result of overlapping hotspot regions. Attempting to fix this proved
futile, and so I had to greatly refine my approach.

The changes I first made were to implement a rectangle tiling algorithm so
to get a valid placement of images onto the collage canvas before trying to
push eachother. This guarenteed that there were no starting hotspot overlaps,
which saved in both time and the problem of overlapping hotspot regions.
Unfortunately, this didn't resolve the weighted system problem, where images
would find eachother covering others' hotspot rectangles, and getting stuck
at local optimas. Making it impossible for hotspots to cross eachother
essentially made the placement algorithm be the resultant makeup of the
collage if the canvas was well populated with images.

To solve this problem, I constricted image pushing to horizontally and
vertically (one at a time, as opposed to both at the same time). This
resulted in a much faster algorithm, with quick convergence. To
encourage/extend the relocation of the images throughout the collage, I
made the images grow and eventually fuse into place. By starting them off
as very small, I found that flow and separation of images was extremely
easy. Then, for each iteration, I could make minor adjustments to x/y
positioning, grow the images a little more, and swap images that would fit
better in the rapidly fusing image.

I found to be debugging and tuning to be extremely complicated, especially
in the full scale weight model. Finding the reason for a specific behavior
of an image as it tends to equilibrium was a nearly impossible task that
didn't have a definitive answer. Since each image had an adverse and unique
effect on another image, the algorithm produced wildly random results that
were impossible to track in my head.


3.) Describe what you learned from this project

I've learned about many approaches to solving the rectangle packing problem.
This goes for both simple greedy algorithms to more advanced algorithms
such as strip packing, tree maps and advanced gridding. 

I've learned a great deal about spring models and the tribulations they
carry with them. My experiences with attempting to implement a simple
spring model turned to be much more difficult than I anticipated. Attaching
weights sounds simple, but having those weights do something meaningful is
not. Likewise, convergence is a real problem, and I even found that some
cases never found an equilibrium where the images no longer move (or move
very minorly), and thus further weight control and dampening was necessary.

Instead, I learned how to refine my approach and rely on more simplified
movements and heuristics for image swapping and growth rates to get a
better collage.


4.) A self-evaluation

I'm satisfied on how my project resulted. The sizable frustration that
occured trying to get a semi-reasonable result during the beginning of the
semester made the evolution of this project more interesting as ideas were
changed/improved. While the program is not optimal in terms of collaging,
it does produce a result that would be adequate for personal use.

Knowing what I do now, I would have made a great deal of changes to my
methods/paths. First of all, it is very crucial to start simple, which is
a luxury I passed up since I didn't think that a quick starting solution
and a more advanced method (with a nontrivial starting solution) would
relate. I have found it is easier and much more efficient to build and
make improvements to an exisiting project than to try to partially invent
a method/algorithm that has little/scarce documentation for my application.