Count Maximal Fence Arrangements
Mathematica, 301 bytes

(t~SetAttributes~Orderless;u=Subsets;c=Complement;l=Select;f=FreeQ;Count[s=List@@@l[t@@@u[Sort@l[Sort/@#~u~{2},!f[#-#2&amp;@@#,0]&amp;]//.{a___,{x_,y_},{x_,z_},b___,{y_,z_},c___}:&gt;{a,{x,y},b,{y,z},c}],f[#,t[{{a_,b_},{a_,c_}},{{d_,e_},{f_,e_}},___]/;d&lt;a&lt;f&amp;&amp;b&lt;e&lt;c]&amp;],l_/;f[s,k_List/;k~c~l!={}&amp;&amp;l~c~k=={},{1}]])&amp;


This is an unnamed function which takes the coordinates as a nested List and returns an integer. That is, you can either give it a name and call it, or just append

@ {{3, 0}, {1, 1}, {0, 2}, {-1, 1}, {-2, 0}, {-1, -1}, {0, -2}, {1, -1}}


With indentation:

(
  t~SetAttributes~Orderless;
  u = Subsets;
  c = Complement;
  l = Select;
  f = FreeQ;
  Count[
    s = List @@@ l[
      t @@@ u[
        Sort @ l[
          Sort /@ #~u~{2}, 
          !f[# - #2 &amp; @@ #, 0] &amp;
        ] //. {a___, {x_, y_}, {x_, z_}, b___, {y_, z_}, c___} :&gt; 
              {a, {x, y}, b, {y, z}, c}
      ],
      f[
        #,
        t[{{a_, b_}, {a_, c_}}, {{d_, e_}, {f_, e_}}, ___] 
          /; d &lt; a &lt; f &amp;&amp; b &lt; e &lt; c
      ] &amp;
    ], 
    l_ /; f[
      s, 
      k_List /; k~c~l != {} &amp;&amp; l~c~k == {}, 
      {1}
    ]
  ]
) &amp;


I can't even begin to express how naive this implementation is... it definitely couldn't be more brute force...


Get all (unordered) pairs of poles.
Sort each pair and all pairs into a canonical order.
Discard pairs which don't share one coordinate (i.e. which aren't connectible by an orthogonal line).
Discard pairs can be formed from two shorter pairs (so that o--o--o yields only two fences instead of three).
Get all subsets of those pairs - i.e. all possible combinations of fences.
Filter out combinations which have fences crossing each other.
Count the number of resulting fence sets for which no strict superset can be found in the list.


Surprisingly it does solve all the test cases virtually immediately.

A really neat trick I discovered for this is the use of Orderless to cut down on the number of patterns I have to match. Essentially, when I want to ditch fence sets with crossing fences, I need to find a pair of vertical and horizontal fence and check the condition on them. But I don't know what order they'll appear in. Since list patterns are normally order dependent, this would result in two really long patterns. So instead I replace with surrounding list with a function t with t @@@ - which isn't defined so it is held as it is. But that function is Orderless, so I can just check a single order in the pattern, and Mathematica will check it against all permutations. Afterwards, I put the lists back in place with List @@@.

I wish there was a built-in that is a) Orderless, b) not Listable and c) not defined for 0 arguments or list arguments. Then I could replace t by that. But there doesn't seem to be such an operator.