How to generate snowflakes of a fixed area as challenges for the FridgeIQ puzzle?
SAT solvers are my favorite "big sledgehammer" to apply to this kind of problem, so let me describe how you could use a SAT solver for this problem.

Let's constrain the shape to fit within a 15x15 grid (say), and express the problem of finding a valid shape as a SAT problem.  It gets a bit messy, so you'll have to be willing to tolerate that, but the approach is powerful.   Introduce boolean variables $x_{i,j,k}$, with the intended meaning that $x_{i,j,k,r}=1$ means that we rotate tile $k$ into orientation $r$ and then put its upper-left corner in the grid cell at coordinates $(i,j)$.  We'll now write down some boolean formulas that characterize what it means for this to be a valid snowflake.

There a bunch of requirements to count as a valid snowflake; I'll sketch how to express each one as a boolean formula:


Each tile must be used exactly once.  In other words, for each $k$, exactly one of the $x_{i,j,k,r}$'s must be true; this is is a one-out-of-n constraint.  See Encoding 1-out-of-n constraint for SAT solvers for some techniques for encoding this as a boolean formula (or if you use Z3, see https://stackoverflow.com/q/43081929/781723).
The shape must be symmetric. To help check this, let's introduce auxiliary boolean variables $y_{i,j}$, with the intended meaning that $y_{i,j}=1$ means that the grid cell at coordinates $(i,j)$ is covered by some tile.  It is easy to express $y_{i,j}$ as a logical-or of a subset of the $x$'s (namely, all the $x_{i',j',k,r}$ such that placing tile $k$ in orientation $r$ at position $(i',j')$ will also cover $(i,j)$; knowing the shape of each tile, you can precompute all such $x$'s; there will be 160 of them).  Moreover, let's require this to have fourfold symmetry around the origin.  That means $y_{i,j} = y_{-i,j} = y_{i,-j} = y_{-i,-j}$ holds for all $i,j$.
No two pieces overlap.  This involves a bunch of constraints of the form $(\neg x_{i,j,k,r}) \lor (\neg x_{i',j',k',r'})$, for all $i,j,k,r,i',j',k,k',r,r'$ such that placing tile $k$ at coordinates $(i,j)$ in orientation $r$ would overlap with placing tile $k'$ at coordinates $(i',j')$ in orientation $r'$.  (This can be easily precomputed based on the shape of tiles $k$ and $k'$.)


This gives you a bunch of boolean formulas.  Write down the conjunction of all of them, and then feed it to an off-the-shelf SAT solver and ask the SAT solver to find a satisfying solution for you.  This will then correspond to a snowflake.

For implementing this stuff, I find Z3 a very convenient API to a SAT solver.

This will find one snowflake.  What if you want multiple of them?  There is a straightforward way to generate multiple solutions: after you have found one solution, you generate what's called a "blocking clause" and add it to the list of constraints (i.e., conjoin it to the formula).  The "blocking clause" just says "not that one I already know of".  For instance, if you already have a satisfying assignment that assigns values $c_{i,j,k,r}$ to each $x_{i,j,k,r}$, then the blocking clause is the formula $\lor_{i,j,k,r} (x_{i,j,k,r} \ne c_{i,j,k,r})$.  You can repeat this to obtain multiple solutions: each time you find another solution, you generate another blocking clause, add it to the formula, and apply the SAT solver again.  Some SAT solvers even have special support for incrementally adding additional constraints that is more efficient than starting the search from scratch, though that might not be necessary.

Well, that's the idea, anyway.  But here I have to confess that I lied.  There is one requirement that I've left out so far: connectivity.  You said you want each snowflake to be connected.  That's messier to implement in a boolean formula, though also possible.  The crude hack is to generate many candidate snowflakes as above, check each for connectivity, and keep only the connected ones.  However, this might not work very well.  So, let me describe how to encode the connectivity constraint in SAT.  Beware; it gets messy, so hold onto your hat.

The shape must be connected. The main idea will be to pick a particular grid cell, require that it be present, and require that every other covered grid cell be connected to it.  Let's say we require that the grid cell at the origin $(0,0)$ be covered.  Then we can introduce auxiliary variables $z_{i,j,s}$, with the intended meaning that $z_{i,j,s}=1$ means that grid cell $(i,j)$ can be reached by starting at the origin and then taking $s$ steps across adjacent covered grid cells.  This constraint can be encoded in SAT by noting

$$z_{i,j,s} = y_{i,j} \land (z_{i-1,j,s-1} \lor z_{i,j-1,s-1} \lor z_{i+1,j,s-1} \lor z_{i,j+1,s-1}).$$

We'll adopt the convention that $z_{i,j,0}=1$, and if $(i,j)$ is outside of the 15x15 bounding box then by convention $y_{i,j,s}=z_{i,j,s}=0$  (we don't introduce extra variables for that, we just replace those terms with "false").

Finally, for each $i,j$, we add the constraint that $y_{i,j} \implies \lor_{s=0}^{39} z_{i,j,s}$.  This ensures that every covered cell is reachable.  (Note that if it is reachable, it is reachable in at most 39 steps, so we only need to go up that high.  In practice, I suspect that 19 or even 9 are probably large enough.)

That ensures connectivity.  However, there's a potential catch: this requires everything to be connected to the origin, so it only generates snowflakes that cover the origin.  We also want snowflakes that have a hole at the origin.  I think you can fix this by iterating over all possibilities for the 'anchor point' (one grid cell that you'll require to be covered and require everything to be connected to), and solving the SAT instance for each possible anchor point.  (To avoid duplicates, if you like you can add additional constraints to ensure disjointness of solutions.  For instance, solve one SAT system where you require $(0,0)$ to be covered and everything to be connected to $(0,0)$; solve another where you require $(0,1)$ to be covered and everything to be connected to $(0,1)$ and you require $(0,0)$ to be uncovered; another where you require $(0,2)$ to be covered and everything to be connected to $(0,2)$ and you require $(0,0)$ and $(0,1)$ to be uncovered; and so on.)

Lastly, in the above I assumed that your shapes are collections of squares, i.e., they either completely cover a grid cell or don't touch it at all.  Of course, this isn't valid for your tiles, due to those diagonal pieces.  So, I suggest that after breaking down the 15x15 region into 225 small squares, you break down each square into four triangles.  Then, instead of using the $y$'s to record which grid squares are covered, you'll need to adjust the definition of the $y$'s and the above formulas to record which triangles are covered.  Everything should go through with some straightforward adjustments.

Phew.  I told you it would get messy.  The basic idea here is that we are taking each of the conditions for a shape to count as a valid snowflake, writing them down in boolean logic, and then letting the SAT solver find solutions that meet all of those requirements.  SAT solvers today are amazing and contain clever and powerful strategies to automatically find solutions that meet your requirements.  Researchers have spent decades coming up with better algorithms and improving the engineering of the tools; you can't hope to duplicate that, so rather than trying, you can build on all of their work and apply it to your specific situation.