#### Single-Pass Subvoxel Processing

Subvoxel processing is an empirical algorithm (rather than one derived from mathematical theory), and is based on two assumptions: 1) smaller voxels are more likely to have high BVF, and 2) bone is generally in close proximity to more bone. The starting point of the algorithm is the partitioning of each voxel into eight subvoxels by strictly enforcing conservation of bone mass, i.e., the total BVF in the original voxel is divided among the subvoxels. The precise amount allotted to a subvoxel is determined by the amount and location of bone outside the voxel but adjacent to the subvoxel. Thus, bone tends to be sequestered in the area of the voxel that is closest to other bone.

The images subjected to subvoxel processing are assumed to be BVF maps, i.e., the value of each voxel is equal to the volume fraction occupied by bone. Since protons in bone have very short transverse relaxation times, their signal is not ordinarily detected. Thus, bone appears with background intensity in MR images and, in the absence of noise, voxel intensity is proportional to marrow volume fraction (MVF). Although MR images are actually images of marrow, not bone, bone is the material of primary interest in regard to predicting the mechanical competence of trabecular bone; therefore, processing of the images has been discussed and defined in terms of BVF. Since images of trabecular bone may be considered as containing only marrow and bone, BVF = 1 − MVF, and MVF maps may be converted to BVF maps without loss or corruption of information.

The principle of subvoxel processing is illustrated in two dimensions with a 3 × 3 array of voxels in which the central voxel (BVF = 0.2) has been partitioned into four subvoxels (Fig. 1a). The weight for a subvoxel is computed as the sum of the BVFs from all the voxels adjacent to the subvoxel. For the example, the weight for subvoxel *a* is obtained as the sum of the three adjacent voxel BVFs (i.e., 0.3 + 0.4 + 0.6 = 1.3). Similarly, the weights for subvoxels *b*, *c*, and *d* are 1.1, 0, and 0.3, respectively. In general, the number of adjacent voxels is 2^{N}-1, where *N* is the dimensionality of the image array.

To explicitly define the subvoxel weights, let (*x*, *y*), where *x* = 0, 1, 2, … *xres*-1 and *y* = 0, 1, 2, … *yres*-1, represent the indices of the voxel being processed in an array of resolution *xres* × *yres*. Each subvoxel is referenced by an integer *s*, ranging from 0 to 2^{N}-1 (Fig. 2). The 2^{N}-1 offsets (*vx*_{s,n}, *vy*_{s,n}) for localizing the neighboring voxels in reference to the voxel containing subvoxel *s* are shown in Table 1, where *n* = 0 to 2^{N}-2. The subvoxel weights *w*_{s} are then computed as:

- (1)

where BVF_{voxel}(*x*,*y*) is the voxel BVF at (*x*, *y*). The weights for a 3D voxel are computed in similar manner with the 3D offsets (*vx*_{s,n}, *vy*_{s,n}, *vz*_{s,n}) shown in Table 2.

Table 1. Voxel Offsets (*vx, vy*) for Computing the Weights for Subvoxels 0 Through 3 in a 2D VoxelSubvoxel 0 | Subvoxel 1 | Subvoxel 2 | Subvoxel 3 |
---|

(−1, −1) | (1, −1) | (1, 1) | (−1, 1) |

(−1, 0) | (1, 0) | (1, 0) | (−1, 0) |

(0, −1) | (0, −1) | (0, 1) | (0, 1) |

Table 2. Voxel Offsets (*vx, vy, vz*) for Computing the Weights for Subvoxels 0 Through 7 in a 3D VoxelSubvoxel 0 | Subvoxel 1 | Subvoxel 2 | Subvoxel 3 | Subvoxel 4 | Subvoxel 5 | Subvoxel 6 | Subvoxel 7 |
---|

(−1, −1, −1) | (1, −1, −1) | (1, 1, −1) | (−1, 1, −1) | (−1, −1, 1) | (1, −1, 1) | (1, 1, 1) | (−1, 1, 1) |

(−1, −1, 0) | (1, −1, 0) | (1, 1, 0) | (−1, 1, 0) | (−1, −1, 0) | (1, −1, 0) | (1, 1, 0) | (−1, 1, 0) |

(−1, 0, 1) | (1, 0, −1) | (1, 0, −1) | (−1, 0, −1) | (−1, 0, 1) | (1, 0, 1) | (1, 0, 1) | (−1, 0, 1) |

(−1, 0, 0) | (1, 0, 0) | (1, 0, 0) | (−1, 0, 0) | (−1, 0, 0) | (1, 0, 0) | (1, 0, 0) | (−1, 0, 0) |

(0, −1, −1) | (0, −1, −1) | (0, 1, −1) | (0, 1, −1) | (0, −1, 1) | (0, −1, 1) | (0, 1, 1) | (0, 1, 1) |

(0, −1, 0) | (0, −1, 0) | (0, 1, 0) | (0, 1, 0) | (0, −1, 0) | (0, −1, 0) | (0, 1, 0) | (0, 1, 0) |

(0, 0, −1) | (0, 0, −1) | (0, 0, −1) | (0, 0, −1) | (0, 0, 1) | (0, 0, 1) | (0, 0, 1) | (0, 0, 1) |

The bone is then partitioned among the subvoxels according to their fractional weights, which may be computed as *w*_{si}/*w*_{total}, where *w*_{total} is the total sum of weights:

- (2)

The absolute volume of bone in the voxel, BV_{voxel}, is equal to the product of BVF_{voxel}, the bone volume fraction of the voxel, and *V*_{voxel}, the volume of the voxel. To enforce conservation of bone mass, the volume of bone allotted to a subvoxel, BV_{subvoxel,i}, may be assumed to be:

- (3)

Note that

- (4)

demonstrating that the amount of bone is conserved. Subsequently, the subvoxel BVF is given by

- (5)

Note that the product BVF_{voxel} × 2^{N} is equal to the sum of BVF from all the subvoxels in the voxel. For the example in Fig. 1, the sum of weights is 2.7. Thus, 1.3/2.7 = 0.48 of the bone volume is allotted to subvoxel *a*, yielding a BVF of 0.48 × 0.2 × 4 = 0.38.

If voxel BVF is high, a subvoxel may be assigned an unrealistic BVF > 1 because the subvoxels are smaller than the original voxel. For example, if the center voxel had a BVF of 0.9, the resulting BVF_{subvoxel} for *a* would be 1.7. In such a case, the subvoxel is assigned a BVF of 1 and the residual bone is partitioned among the other subvoxels according to the remaining weights. Therefore, for each voxel, the algorithm processes each subvoxel in order of decreasing weight. The BVF assigned to each subvoxel is determined from the subvoxel's weight and then subtracted from the remaining bone in the voxel. To express this algorithm mathematically, each subvoxel in a voxel may be referenced by the subscript *n*, where *n* is an integer ranging from 0 through 2^{N}-1. The subscript *n* differs from *s* in that *n* references each subvoxel in order of decreasing weight such that subvoxel *n* must have a weight less than or equal to subvoxel *n*-1. If the residual sum of BVF is defined as

- (6)

then the residual BVF for the first voxel is BVF_{residual,0} = 2^{N} × BVF_{voxel}, the product that was noted in Eq. [5] as the sum of BVF from all the subvoxels in the voxel. A residual sum of unprocessed subvoxel weights is also expressed as

- (7)

Subvoxel BVF is then given as in Eq. [5], except that the sums of subvoxel BVF and of the weights are replaced by the residual sums of BVF and the weights. In addition, the minimum function, min(*a*,*b*), which returns the lesser of *a* and *b*, is applied to restrict BVF to values ≤1:

- (8)

#### Multiple-Pass Algorithm

Trabeculae may still become artifactually diffuse with the single-pass algorithm. For example, consider the 2D trabeculae represented by the array of voxels in Fig. 3a. After applying the single-pass subvoxel algorithm (Fig. 3c), bone has been preferentially allocated towards the central rows of subvoxels, but none of them contain 100% bone. If it is assumed that the original spatial resolution is high enough that there are no voxels that contain more than one trabecula, only subvoxels that are on the boundary of a trabecula should contain partial fractions of both bone and marrow. Blurred trabeculae may be completely eliminated to produce a more compact solution by application of a multiple-pass algorithm. Subvoxels are classified as boundary or central subvoxels on the basis of the output of the first-pass algorithm. During subsequent passes, boundary subvoxels are not assigned bone until the central voxels contain 100% bone (Fig. 3d). If image resolution is low, the assumption of no more than one trabecula in each voxel may be violated. Given a single voxel that contains partial volumes of both bone and marrow, it is impossible to know how many trabeculae are within the voxel. For example, if it is known that a voxel is 20% bone, there could be two trabeculae, each of which occupies 10% of the voxel, or four trabeculae, each of which occupies 5% of the voxel. The BVF map in Fig. 3b would be identical if the vertical trabecula were replaced by multiple thinner trabeculae (e.g., by two trabeculae of half the original thickness) passing through the same two columns of voxels (Fig. 3e). Subvoxel processing would then, of course, result in an incorrect solution. However, at the current in vivo voxel size of 137 × 137 × 350 μm^{3}, and considering average trabecular thicknesses and intertrabecular spacings of 100 and 500–1000 μm, respectively, the occurrence of multiple trabeculae within a single voxel is highly unlikely.

In the multiple-pass algorithm, bone-containing subvoxels are classified as boundary or central subvoxels on the basis of adjacency and connectivity criteria. The adjacency criterion requires that one of the subvoxel's six nearest neighbors in 3D (four nearest neighbors in 2D) does not contain bone. A boundary subvoxel also must not be critical to the trabecular network as quantified by local connectivity. The local connectivity is computed on the basis of the 2^{N}-1 nearest-neighbor previous-pass subvoxels. The connectivity is equal to the number of “islands” of bone that are generated in the local neighborhood by temporarily assuming the central subvoxel contains marrow only (Fig. 4). If the edge subvoxel has a connectivity of <2, its bone may be shifted to another voxel without damaging the connectivity of the network, and may thus be classified as a boundary voxel. Subvoxels, which do not satisfy both of these criteria, are classified as central subvoxels.

Central subvoxels are preferentially filled with bone by assigning subvoxels primary and secondary weights. Boundary voxels that are not critical to the trabecular network are assigned a primary weight of zero. Bone is then partitioned among the subvoxels on the basis of the primary weights. After the subvoxels with non-zero primary weights have been assigned bone, the remaining bone is partitioned among the subvoxels, which have not been assigned a BVF, according to the secondary weights. Weights may be computed as the weights in the single-pass algorithm. However, the current implementation of the algorithm further compacts the bone by calculating the secondary weights as the sum of the BVFs of the 2^{N}-1 first-pass subvoxels whose locations are adjacent to that of the second-pass subvoxel but outside the voxel (Fig. 5):

- (9)

where (*svx*_{s}, *svy*_{s}) is an additional offset for each subvoxel relative to subvoxel 0. For example, the offsets for subvoxels 0–3 for a 2D subvoxel are (0, 0), (1, 0), (1, 1), and (0, 1), respectively. The factors of 2 in the indices of BVF_{subvoxel} are necessary since there are twice as many subvoxels for each dimension. Central subvoxels only require primary weights, which are thus identical to the secondary weights. For the boundary subvoxels, the secondary weights are obtained in the same manner (Eq. [9]) but the primary weights are set to zero :

- (10)

As was done in the single-pass algorithm, subvoxels are sorted in order of decreasing primary weights, and those with the same primary weight are further sorted according to their secondary weights. Subvoxel BVFs are then computed in a manner similar to the single-pass algorithm using the following modified definitions:

- (11)

- (12)

where *B* is the index of the first subvoxel that is not a central subvoxel, i.e., the first voxel that has a zero primary weight. BVF_{residual} is defined as in Eq. [6]. Since only the central subvoxels have non-zero primary weights, the boundary subvoxels are not assigned any bone unless all the central subvoxels are assigned BVF = 1 (Fig. 3d).