Determine the area enclosed by slashes For example, let's look at the following ASCII art:
/\    - encloses a total of 2 cells - half a cell per slash
\/
 /\   - encloses 4 cells fully and half of 8 cells, for a total of 8 
/  \
\  /
 \/

Your challenge is to write a program that determines (and outputs) the total area enclosed by ASCII art composed only of spaces, slashes and newlines. Slashes won't necessarily be a part of a shape with non-zero area. A point is defined as enclosed iff it is unreachable from any point outside the art's bounding box, if slashes are impassable.
Slashes have zero area and cells are assumed to be \$1\times1\$ squares. /s represent lines that connect the lower left corner with the upper right corner, and \s represent lines the connect the upper left corner with the lower right corner of the corresponding cells. Spaces represent empty space.
Test cases
/\/\ 
\   \
 \/\/

Encloses 3 cells fully and 10 partially, for a total of 8.
///\\\
//  \\
/ /\ \
\ \/ /
\\  //
\\\///

Encloses 12 cells fully (the four innermost slashes have both corresponding half-cells enclosed) and half of 12 cells, for a total of 18.
/\/\
/\/\
/\/\

Encloses 0 cells.
 /\
/  \
\/\/
/\/\
\  /
 \/

Encloses 8 cells fully and 12 cells partially, for a total of 14.
   /\
  /  \
 /  \ \
/   /  \
\ \/  \/
 \ \  /
  \   \
   \/\/

Encloses 25 cells fully and half of 18 cells, for an area of 34.
This is tagged code-golf, so the shortest answer wins.
JavaScript (ES6),  228 195 192  185 bytes
Expects a matrix of characters as input.
This can be quite slow on some inputs, such as the last test case.
m=&gt;m.map((r,Y)=&gt;r.map((_,X)=&gt;n+=(g=(x,y,z,q=z&amp;2,r=m[y],v=r&amp;&amp;r[x])=&gt;v?(v|=64+(v&gt;{})+!++v)^(r[x]|=v|4&lt;&lt;z)?g(x+--q*~z%2,y-q*z%2,z^2)&amp;g(x,y,v&amp;3?z^=v&amp;2|1:z+1&amp;3)|!(r[x]=v):1:0)(X,Y,0)),n=0)|n

Try it online!
How?
Grid encoding
We divide each cell into 4 areas as follows:

The current position is encoded as \$(x,y,z)\$, where \$(x,y)\$ is the position in the matrix and \$z\$ is the ID of the area.
The characters in the original matrix are converted on the fly to 7-bit integers as they are visited:
+---------&gt; a marker to tell that this tile has been converted (always 1)
|      +--&gt; 4 bits to tell whether a given area has been visited
|      |
|      |      +-----&gt; set to 1 if the cell contains an anti-slash
|  ____|____  |  +--&gt; set to 1 of the cell contains a slash
| /         \ |  |
1 z3 z2 z1 z0 AS S

The conversion is done with:
v |= 64 + (v &gt; {}) + !++v

The expression (v &gt; {}) is only true for '\' and !++v is true for either '/' or '\'. If v is already an integer, it is left unchanged.
Algorithm
Evaluating the area enclosed by slashes is equivalent to counting the number of cells from which we can't escape from the grid, starting from a given area ID. We arbitrary start from area #0, but that would work with any of them as long as it is consistent.
We iterate on all possible starting points and process some kind of flood-filling that takes the area IDs into account.
For each visited cell, we try to move to an adjacent cell (left figure) and  to another area within the same cell (right figure).

The recursion stops either when we escape the grid or when we get trapped.