diff --git a/glymur/codestream.py b/glymur/codestream.py
index 2c24bef..7bd0215 100644
--- a/glymur/codestream.py
+++ b/glymur/codestream.py
@@ -807,6 +807,8 @@ class COCsegment(Segment):
         Coding style for this component.
     spcoc : byte array
         Coding style parameters for this component.
+    precinct_size : list of tuples
+        Dimensions of precinct.
 
     References
     ----------
@@ -820,13 +822,13 @@ class COCsegment(Segment):
         self.scoc = scoc
         self.spcoc = spcoc
 
-        self._code_block_size = (4 * math.pow(2, self.spcoc[2]),
-                                 4 * math.pow(2, self.spcoc[1]))
+        self.code_block_size = (4 * math.pow(2, self.spcoc[2]),
+                                4 * math.pow(2, self.spcoc[1]))
 
         if len(self.spcoc) > 5:
-            self._precinct_size = _parse_precinct_size(self.spcoc[5:])
+            self.precinct_size = _parse_precinct_size(self.spcoc[5:])
         else:
-            self._precinct_size = None
+            self.precinct_size = None
 
         self.length = length
         self.offset = offset
@@ -847,16 +849,16 @@ class COCsegment(Segment):
         msg += '\n        Code block height, width:  ({1} x {2})'
         msg += '\n        Wavelet transform:  {3}'
         msg = msg.format(self.spcoc[0] + 1,
-                         int(self._code_block_size[0]),
-                         int(self._code_block_size[1]),
+                         int(self.code_block_size[0]),
+                         int(self.code_block_size[1]),
                          _WAVELET_TRANSFORM_DISPLAY[self.spcoc[4]])
 
         msg += '\n        '
         msg += _context_string(self.spcoc[3])
 
-        if self._precinct_size is not None:
+        if self.precinct_size is not None:
             msg += '\n        Precinct size:  '
-            for pps in self._precinct_size:
+            for pps in self.precinct_size:
                 msg += '(%d, %d)'.format(pps)
 
         return msg
@@ -876,10 +878,16 @@ class CODsegment(Segment):
         two bytes constituting the marker.
     scod : int
         Default coding style.
+    layers : int
+        Quality layers.
+    code_block_size : tuple
+        Size of code block.
     spcod : bytes
-        Coding style parameters, including quality layers, multicomponent
-        transform usage, decomposition levels, code block size, style of code-
-        block passes, and which wavelet transform is used.
+        Encoded coding style parameters, including quality layers,
+        multi component transform usage, decomposition levels, code block size,
+        style of code-block passes, and which wavelet transform is used.
+    precinct_size : list of tuples
+        Dimensions of precinct.
 
     References
     ----------
@@ -895,7 +903,7 @@ class CODsegment(Segment):
         self.offset = offset
 
         params = struct.unpack('>BHBBBBBB', self.spcod[0:9])
-        self._layers = params[1]
+        self.layers = params[1]
         self._numresolutions = params[3]
 
         if params[3] > opj2.J2K_MAXRLVLS:
@@ -906,12 +914,12 @@ class CODsegment(Segment):
         cblk_width = 4 * math.pow(2, params[4])
         cblk_height = 4 * math.pow(2, params[5])
         code_block_size = (cblk_height, cblk_width)
-        self._code_block_size = code_block_size
+        self.code_block_size = code_block_size
 
         if len(self.spcod) > 9:
-            self._precinct_size = _parse_precinct_size(self.spcod[9:])
+            self.precinct_size = _parse_precinct_size(self.spcod[9:])
         else:
-            self._precinct_size = None
+            self.precinct_size = None
 
     def __str__(self):
         msg = Segment.__str__(self)
@@ -944,18 +952,18 @@ class CODsegment(Segment):
         msg += '\n    '.join(lines)
 
         msg = msg.format(_PROGRESSION_ORDER_DISPLAY[self.spcod[0]],
-                         self._layers,
+                         self.layers,
                          mct,
                          self.spcod[4] + 1,
-                         int(self._code_block_size[0]),
-                         int(self._code_block_size[1]),
+                         int(self.code_block_size[0]),
+                         int(self.code_block_size[1]),
                          _WAVELET_TRANSFORM_DISPLAY[self.spcod[8]])
 
         msg += '\n        Precinct size:  '
-        if self._precinct_size is None:
+        if self.precinct_size is None:
             msg += 'default, 2^15 x 2^15'
         else:
-            for pps in self._precinct_size:
+            for pps in self.precinct_size:
                 msg += '({0}, {1})'.format(pps[0], pps[1])
 
         msg += '\n        '
@@ -1411,7 +1419,11 @@ class SIZsegment(Segment):
     xtosiz, ytosiz : int
         Horizontal and vertical offsets of tile from origin of reference grid.
     ssiz : iterable bytes
-        Precision (depth) in bits and sign of each component.
+        Encoded precision (depth) in bits and sign of each component.
+    bitdepth : iterable bytes
+        Precision (depth) in bits of each component.
+    signed : iterable bool
+        Signedness of each component.
     xrsiz, yrsiz : int
         Horizontal and vertical sample separations with respect to reference
         grid.
@@ -1459,8 +1471,8 @@ class SIZsegment(Segment):
         self.xrsiz = data[1::3]
         self.yrsiz = data[2::3]
 
-        self._bitdepth = tuple(((x & 0x7f) + 1) for x in self.ssiz)
-        self._signed = tuple(((x & 0xb0) > 0) for x in self.ssiz)
+        self.bitdepth = tuple(((x & 0x7f) + 1) for x in self.ssiz)
+        self.signed = tuple(((x & 0xb0) > 0) for x in self.ssiz)
 
         self.length = length
         self.offset = offset
@@ -1483,8 +1495,8 @@ class SIZsegment(Segment):
                          self.yosiz, self.xosiz,
                          self.ytsiz, self.xtsiz,
                          self.ytosiz, self.xtosiz,
-                         self._bitdepth,
-                         self._signed,
+                         self.bitdepth,
+                         self.signed,
                          tuple(zip(self.yrsiz, self.xrsiz)))
 
         return msg
diff --git a/glymur/test/test_opj_suite.py b/glymur/test/test_opj_suite.py
index 102b145..0a15879 100644
--- a/glymur/test/test_opj_suite.py
+++ b/glymur/test/test_opj_suite.py
@@ -1549,9 +1549,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (8,))
+        self.assertEqual(c.segment[1].bitdepth, (8,))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False,))
+        self.assertEqual(c.segment[1].signed, (False,))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)])
@@ -1568,10 +1568,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[3].scod & 2)  # no sop
         self.assertFalse(c.segment[3].scod & 4)  # no eph
         self.assertEqual(c.segment[3].spcod[0], glymur.core.RLCP)
-        self.assertEqual(c.segment[3]._layers, 1)  # layers = 1
+        self.assertEqual(c.segment[3].layers, 1)  # layers = 1
         self.assertEqual(c.segment[3].spcod[3], 0)  # mct
         self.assertEqual(c.segment[3].spcod[4], 3)  # layers
-        self.assertEqual(tuple(c.segment[3]._code_block_size),
+        self.assertEqual(tuple(c.segment[3].code_block_size),
                          (64, 64))  # cblk
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[3].spcod[7] & 0x01)
@@ -1611,9 +1611,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (8,))
+        self.assertEqual(c.segment[1].bitdepth, (8,))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False,))
+        self.assertEqual(c.segment[1].signed, (False,))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(2, 1)])
@@ -1622,10 +1622,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertTrue(c.segment[2].scod & 2)  # sop
         self.assertTrue(c.segment[2].scod & 4)  # eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-        self.assertEqual(c.segment[2]._layers, 6)  # layers = 6
+        self.assertEqual(c.segment[2].layers, 6)  # layers = 6
         self.assertEqual(c.segment[2].spcod[3], 0)  # mct
         self.assertEqual(c.segment[2].spcod[4], 3)  # levels
-        self.assertEqual(tuple(c.segment[2]._code_block_size),
+        self.assertEqual(tuple(c.segment[2].code_block_size),
                          (64, 64))  # cblk
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
@@ -1645,7 +1645,7 @@ class TestSuiteDump(unittest.TestCase):
         # COC: Coding style component
         self.assertEqual(c.segment[3].ccoc, 0)
         self.assertEqual(c.segment[3].spcoc[0], 3)  # levels
-        self.assertEqual(tuple(c.segment[3]._code_block_size),
+        self.assertEqual(tuple(c.segment[3].code_block_size),
                          (32, 32))  # cblk
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[3].spcoc[3] & 0x01)
@@ -1717,9 +1717,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (4,))
+        self.assertEqual(c.segment[1].bitdepth, (4,))
         # signed
-        self.assertEqual(c.segment[1]._signed, (True,))
+        self.assertEqual(c.segment[1].signed, (True,))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)])
@@ -1728,10 +1728,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertTrue(c.segment[2].scod & 2)
         self.assertFalse(c.segment[2].scod & 4)
         self.assertEqual(c.segment[2].spcod[0], glymur.core.PCRL)
-        self.assertEqual(c.segment[2]._layers, 8)  # 8
+        self.assertEqual(c.segment[2].layers, 8)  # 8
         self.assertEqual(c.segment[2].spcod[3], 0)  # mct
         self.assertEqual(c.segment[2].spcod[4], 1)  # levels
-        self.assertEqual(tuple(c.segment[2]._code_block_size),
+        self.assertEqual(tuple(c.segment[2].code_block_size),
                          (64, 64))  # cblk
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
@@ -1834,9 +1834,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (8, 8, 8))
+        self.assertEqual(c.segment[1].bitdepth, (8, 8, 8))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False, False, False))
+        self.assertEqual(c.segment[1].signed, (False, False, False))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1), (1, 1), (1, 1)])
@@ -1845,10 +1845,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)
         self.assertFalse(c.segment[2].scod & 4)
         self.assertEqual(c.segment[2].spcod[0], glymur.core.RLCP)
-        self.assertEqual(c.segment[2]._layers, 20)  # 20
+        self.assertEqual(c.segment[2].layers, 20)  # 20
         self.assertEqual(c.segment[2].spcod[3], 1)  # mct
         self.assertEqual(c.segment[2].spcod[4], 6)  # levels
-        self.assertEqual(tuple(c.segment[2]._code_block_size),
+        self.assertEqual(tuple(c.segment[2].code_block_size),
                          (64, 64))  # cblk
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
@@ -1864,7 +1864,7 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].spcod[7] & 0x0020)
         self.assertEqual(c.segment[2].spcod[8],
                          glymur.core.WAVELET_XFORM_9X7_IRREVERSIBLE)
-        self.assertEqual(c.segment[2]._precinct_size,
+        self.assertEqual(c.segment[2].precinct_size,
                          [(128, 128), (128, 128), (128, 128), (128, 128),
                           (128, 128), (128, 128), (128, 128)])
 
@@ -1943,9 +1943,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (8, 8, 8, 8))
+        self.assertEqual(c.segment[1].bitdepth, (8, 8, 8, 8))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False, False, False, False))
+        self.assertEqual(c.segment[1].signed, (False, False, False, False))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1), (1, 1), (2, 2), (2, 2)])
@@ -1954,10 +1954,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)
         self.assertFalse(c.segment[2].scod & 4)
         self.assertEqual(c.segment[2].spcod[0], glymur.core.PCRL)
-        self.assertEqual(c.segment[2]._layers, 7)  # 7
+        self.assertEqual(c.segment[2].layers, 7)  # 7
         self.assertEqual(c.segment[2].spcod[3], 0)  # mct
         self.assertEqual(c.segment[2].spcod[4], 6)  # levels
-        self.assertEqual(tuple(c.segment[2]._code_block_size),
+        self.assertEqual(tuple(c.segment[2].code_block_size),
                          (32, 32))  # cblk
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
@@ -1978,7 +1978,7 @@ class TestSuiteDump(unittest.TestCase):
         # COC: Coding style component
         self.assertEqual(c.segment[3].ccoc, 1)
         self.assertEqual(c.segment[3].spcoc[0], 3)  # levels
-        self.assertEqual(tuple(c.segment[3]._code_block_size),
+        self.assertEqual(tuple(c.segment[3].code_block_size),
                          (32, 32))  # cblk
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[3].spcoc[3] & 0x01)
@@ -1998,7 +1998,7 @@ class TestSuiteDump(unittest.TestCase):
         # COC: Coding style component
         self.assertEqual(c.segment[4].ccoc, 3)
         self.assertEqual(c.segment[4].spcoc[0], 6)  # levels
-        self.assertEqual(tuple(c.segment[4]._code_block_size),
+        self.assertEqual(tuple(c.segment[4].code_block_size),
                          (32, 32))  # cblk
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[4].spcoc[3] & 0x01)
@@ -2086,9 +2086,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (12, 12, 12, 12))
+        self.assertEqual(c.segment[1].bitdepth, (12, 12, 12, 12))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False, False, False, False))
+        self.assertEqual(c.segment[1].signed, (False, False, False, False))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1), (2, 1), (1, 2), (2, 2)])
@@ -2097,10 +2097,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)
         self.assertFalse(c.segment[2].scod & 4)
         self.assertEqual(c.segment[2].spcod[0], glymur.core.RPCL)
-        self.assertEqual(c.segment[2]._layers, 4)  # 4
+        self.assertEqual(c.segment[2].layers, 4)  # 4
         self.assertEqual(c.segment[2].spcod[3], 0)  # mct
         self.assertEqual(c.segment[2].spcod[4], 6)  # levels
-        self.assertEqual(tuple(c.segment[2]._code_block_size),
+        self.assertEqual(tuple(c.segment[2].code_block_size),
                          (64, 64))  # cblk
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
@@ -2169,7 +2169,7 @@ class TestSuiteDump(unittest.TestCase):
         # COC: Coding style component
         self.assertEqual(c.segment[7].ccoc, 3)
         self.assertEqual(c.segment[7].spcoc[0], 6)  # levels
-        self.assertEqual(tuple(c.segment[7]._code_block_size),
+        self.assertEqual(tuple(c.segment[7].code_block_size),
                          (64, 64))  # cblk
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[7].spcoc[3] & 0x01)
@@ -2223,9 +2223,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (12, 12, 12))
+        self.assertEqual(c.segment[1].bitdepth, (12, 12, 12))
         # signed
-        self.assertEqual(c.segment[1]._signed, (True, True, True))
+        self.assertEqual(c.segment[1].signed, (True, True, True))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1), (1, 1), (1, 1)])
@@ -2234,10 +2234,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertTrue(c.segment[2].scod & 2)
         self.assertTrue(c.segment[2].scod & 4)
         self.assertEqual(c.segment[2].spcod[0], glymur.core.RLCP)
-        self.assertEqual(c.segment[2]._layers, 8)  # 8
+        self.assertEqual(c.segment[2].layers, 8)  # 8
         self.assertEqual(c.segment[2].spcod[3], 0)  # mct
         self.assertEqual(c.segment[2].spcod[4], 3)  # levels
-        self.assertEqual(tuple(c.segment[2]._code_block_size),
+        self.assertEqual(tuple(c.segment[2].code_block_size),
                          (64, 64))  # cblk
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
@@ -2308,9 +2308,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (12, 12, 12))
+        self.assertEqual(c.segment[1].bitdepth, (12, 12, 12))
         # signed
-        self.assertEqual(c.segment[1]._signed, (True, True, True))
+        self.assertEqual(c.segment[1].signed, (True, True, True))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1), (1, 1), (1, 1)])
@@ -2319,10 +2319,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertTrue(c.segment[2].scod & 2)
         self.assertTrue(c.segment[2].scod & 4)
         self.assertEqual(c.segment[2].spcod[0], glymur.core.CPRL)
-        self.assertEqual(c.segment[2]._layers, 30)  # 30
+        self.assertEqual(c.segment[2].layers, 30)  # 30
         self.assertEqual(c.segment[2].spcod[3], 0)  # mct
         self.assertEqual(c.segment[2].spcod[4], 7)  # levels
-        self.assertEqual(tuple(c.segment[2]._code_block_size),
+        self.assertEqual(tuple(c.segment[2].code_block_size),
                          (64, 64))  # cblk
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
@@ -2343,7 +2343,7 @@ class TestSuiteDump(unittest.TestCase):
         # COC: Coding style component
         self.assertEqual(c.segment[3].ccoc, 0)
         self.assertEqual(c.segment[3].spcoc[0], 6)  # levels
-        self.assertEqual(tuple(c.segment[3]._code_block_size),
+        self.assertEqual(tuple(c.segment[3].code_block_size),
                          (64, 64))  # cblk
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[3].spcoc[3] & 0x01)
@@ -2363,7 +2363,7 @@ class TestSuiteDump(unittest.TestCase):
         # COC: Coding style component
         self.assertEqual(c.segment[4].ccoc, 1)
         self.assertEqual(c.segment[4].spcoc[0], 7)  # levels
-        self.assertEqual(tuple(c.segment[4]._code_block_size),
+        self.assertEqual(tuple(c.segment[4].code_block_size),
                          (32, 32))  # cblk
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[4].spcoc[3] & 0x01)
@@ -2383,7 +2383,7 @@ class TestSuiteDump(unittest.TestCase):
         # COC: Coding style component
         self.assertEqual(c.segment[5].ccoc, 2)
         self.assertEqual(c.segment[5].spcoc[0], 8)  # levels
-        self.assertEqual(tuple(c.segment[5]._code_block_size),
+        self.assertEqual(tuple(c.segment[5].code_block_size),
                          (64, 64))  # cblk
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[5].spcoc[3] & 0x01)
@@ -2461,9 +2461,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (8,))
+        self.assertEqual(c.segment[1].bitdepth, (8,))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False,))
+        self.assertEqual(c.segment[1].signed, (False,))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)])
@@ -2472,10 +2472,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)
         self.assertFalse(c.segment[2].scod & 4)
         self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-        self.assertEqual(c.segment[2]._layers, 1)  # 1
+        self.assertEqual(c.segment[2].layers, 1)  # 1
         self.assertEqual(c.segment[2].spcod[3], 0)  # mct
         self.assertEqual(c.segment[2].spcod[4], 5)  # levels
-        self.assertEqual(tuple(c.segment[2]._code_block_size),
+        self.assertEqual(tuple(c.segment[2].code_block_size),
                          (64, 64))  # cblk
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
@@ -2541,9 +2541,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (8, 8, 8))
+        self.assertEqual(c.segment[1].bitdepth, (8, 8, 8))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False, False, False))
+        self.assertEqual(c.segment[1].signed, (False, False, False))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(4, 4), (4, 4), (4, 4)])
@@ -2552,10 +2552,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)
         self.assertFalse(c.segment[2].scod & 4)
         self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-        self.assertEqual(c.segment[2]._layers, 2)  # 2
+        self.assertEqual(c.segment[2].layers, 2)  # 2
         self.assertEqual(c.segment[2].spcod[3], 1)  # mct
         self.assertEqual(c.segment[2].spcod[4], 3)  # levels
-        self.assertEqual(tuple(c.segment[2]._code_block_size),
+        self.assertEqual(tuple(c.segment[2].code_block_size),
                          (64, 64))  # cblk
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
@@ -2682,9 +2682,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (8,))
+        self.assertEqual(c.segment[1].bitdepth, (8,))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False,))
+        self.assertEqual(c.segment[1].signed, (False,))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)])
@@ -2693,10 +2693,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)
         self.assertTrue(c.segment[2].scod & 4)
         self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-        self.assertEqual(c.segment[2]._layers, 1)  # 1
+        self.assertEqual(c.segment[2].layers, 1)  # 1
         self.assertEqual(c.segment[2].spcod[3], 0)  # mct
         self.assertEqual(c.segment[2].spcod[4], 0)  # levels
-        self.assertEqual(tuple(c.segment[2]._code_block_size),
+        self.assertEqual(tuple(c.segment[2].code_block_size),
                          (64, 64))  # cblk
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
@@ -2712,7 +2712,7 @@ class TestSuiteDump(unittest.TestCase):
         self.assertTrue(c.segment[2].spcod[7] & 0x0020)
         self.assertEqual(c.segment[2].spcod[8],
                          glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
-        self.assertEqual(c.segment[2]._precinct_size, [(128, 2)])
+        self.assertEqual(c.segment[2].precinct_size, [(128, 2)])
 
         # QCD: Quantization default
         # quantization type
@@ -2763,9 +2763,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (8,))
+        self.assertEqual(c.segment[1].bitdepth, (8,))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False,))
+        self.assertEqual(c.segment[1].signed, (False,))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)])
@@ -2774,10 +2774,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertTrue(c.segment[2].scod & 2)
         self.assertFalse(c.segment[2].scod & 4)
         self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-        self.assertEqual(c.segment[2]._layers, 1)  # 1
+        self.assertEqual(c.segment[2].layers, 1)  # 1
         self.assertEqual(c.segment[2].spcod[3], 0)  # mct
         self.assertEqual(c.segment[2].spcod[4], 3)  # levels
-        self.assertEqual(tuple(c.segment[2]._code_block_size),
+        self.assertEqual(tuple(c.segment[2].code_block_size),
                          (32, 32))  # cblk
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
@@ -2845,9 +2845,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, tuple([8] * 257))
+        self.assertEqual(c.segment[1].bitdepth, tuple([8] * 257))
         # signed
-        self.assertEqual(c.segment[1]._signed, tuple([False] * 257))
+        self.assertEqual(c.segment[1].signed, tuple([False] * 257))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)] * 257)
@@ -2856,10 +2856,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)  # no sop
         self.assertFalse(c.segment[2].scod & 4)  # no eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.RLCP)
-        self.assertEqual(c.segment[2]._layers, 1)  # layers = 1
+        self.assertEqual(c.segment[2].layers, 1)  # layers = 1
         self.assertEqual(c.segment[2].spcod[3], 1)  # mct
         self.assertEqual(c.segment[2].spcod[4], 1)  # levels
-        self.assertEqual(tuple(c.segment[2]._code_block_size), (32, 32))
+        self.assertEqual(tuple(c.segment[2].code_block_size), (32, 32))
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
         # Reset context probabilities
@@ -2879,7 +2879,7 @@ class TestSuiteDump(unittest.TestCase):
         # COC: Coding style component
         self.assertEqual(c.segment[3].ccoc, 2)
         self.assertEqual(c.segment[3].spcoc[0], 1)  # levels
-        self.assertEqual(tuple(c.segment[3]._code_block_size), (64, 64))
+        self.assertEqual(tuple(c.segment[3].code_block_size), (64, 64))
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[3].spcoc[3] & 0x01)
         # Reset context probabilities
@@ -2971,9 +2971,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (8, 8, 8))
+        self.assertEqual(c.segment[1].bitdepth, (8, 8, 8))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False, False, False))
+        self.assertEqual(c.segment[1].signed, (False, False, False))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)] * 3)
@@ -2982,10 +2982,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)
         self.assertFalse(c.segment[2].scod & 4)
         self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-        self.assertEqual(c.segment[2]._layers, 1)  # 1 layer
+        self.assertEqual(c.segment[2].layers, 1)  # 1 layer
         self.assertEqual(c.segment[2].spcod[3], 1)  # mct
         self.assertEqual(c.segment[2].spcod[4], 5)  # levels
-        self.assertEqual(tuple(c.segment[2]._code_block_size), (64, 64))
+        self.assertEqual(tuple(c.segment[2].code_block_size), (64, 64))
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
         # Reset context probabilities
@@ -3047,9 +3047,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (4,))
+        self.assertEqual(c.segment[1].bitdepth, (4,))
         # signed
-        self.assertEqual(c.segment[1]._signed, (True,))
+        self.assertEqual(c.segment[1].signed, (True,))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)])
@@ -3058,10 +3058,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertTrue(c.segment[2].scod & 2)
         self.assertFalse(c.segment[2].scod & 4)
         self.assertEqual(c.segment[2].spcod[0], glymur.core.PCRL)
-        self.assertEqual(c.segment[2]._layers, 8)  # layers = 8
+        self.assertEqual(c.segment[2].layers, 8)  # layers = 8
         self.assertEqual(c.segment[2].spcod[3], 0)  # mct
         self.assertEqual(c.segment[2].spcod[4], 1)  # levels
-        self.assertEqual(tuple(c.segment[2]._code_block_size), (64, 64))
+        self.assertEqual(tuple(c.segment[2].code_block_size), (64, 64))
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
         # Reset context probabilities
@@ -3201,9 +3201,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (8,))
+        self.assertEqual(c.segment[1].bitdepth, (8,))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False,))
+        self.assertEqual(c.segment[1].signed, (False,))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)])
@@ -3212,10 +3212,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)
         self.assertFalse(c.segment[2].scod & 4)
         self.assertEqual(c.segment[2].spcod[0], glymur.core.RLCP)
-        self.assertEqual(c.segment[2]._layers, 3)  # layers = 3
+        self.assertEqual(c.segment[2].layers, 3)  # layers = 3
         self.assertEqual(c.segment[2].spcod[3], 0)  # mct
         self.assertEqual(c.segment[2].spcod[4], 3)  # levels
-        self.assertEqual(tuple(c.segment[2]._code_block_size), (64, 64))
+        self.assertEqual(tuple(c.segment[2].code_block_size), (64, 64))
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
         # Reset context probabilities
@@ -3269,9 +3269,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (1, 101))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (8,))
+        self.assertEqual(c.segment[1].bitdepth, (8,))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False,))
+        self.assertEqual(c.segment[1].signed, (False,))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(2, 1)])
@@ -3280,10 +3280,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertTrue(c.segment[2].scod & 2)  # SOP
         self.assertTrue(c.segment[2].scod & 4)  # EPH
         self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-        self.assertEqual(c.segment[2]._layers, 5)  # layers = 5
+        self.assertEqual(c.segment[2].layers, 5)  # layers = 5
         self.assertEqual(c.segment[2].spcod[3], 0)  # mct
         self.assertEqual(c.segment[2].spcod[4], 3)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size), (64, 64))
+        self.assertEqual(tuple(c.segment[2].code_block_size), (64, 64))
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
         # Reset context probabilities
@@ -3303,7 +3303,7 @@ class TestSuiteDump(unittest.TestCase):
         # COC: Coding style component
         self.assertEqual(c.segment[3].ccoc, 0)
         self.assertEqual(c.segment[3].spcoc[0], 3)  # level
-        self.assertEqual(tuple(c.segment[3]._code_block_size), (32, 32))
+        self.assertEqual(tuple(c.segment[3].code_block_size), (32, 32))
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[3].spcoc[3] & 0x01)
         # Reset context probabilities
@@ -3369,9 +3369,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, tuple([8] * 3))
+        self.assertEqual(c.segment[1].bitdepth, tuple([8] * 3))
         # signed
-        self.assertEqual(c.segment[1]._signed, tuple([False] * 3))
+        self.assertEqual(c.segment[1].signed, tuple([False] * 3))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)] * 3)
@@ -3380,10 +3380,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)  # no sop
         self.assertFalse(c.segment[2].scod & 4)  # no eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-        self.assertEqual(c.segment[2]._layers, 19)  # layers = 19
+        self.assertEqual(c.segment[2].layers, 19)  # layers = 19
         self.assertEqual(c.segment[2].spcod[3], 1)  # mct
         self.assertEqual(c.segment[2].spcod[4], 6)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size),
+        self.assertEqual(tuple(c.segment[2].code_block_size),
                          (64, 64))  # cblk
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
@@ -3399,7 +3399,7 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].spcod[7] & 0x0020)
         self.assertEqual(c.segment[2].spcod[8],
                          glymur.core.WAVELET_XFORM_9X7_IRREVERSIBLE)
-        self.assertEqual(c.segment[2]._precinct_size,
+        self.assertEqual(c.segment[2].precinct_size,
                          [(128, 128), (256, 256), (512, 512), (1024, 1024),
                           (2048, 2048), (4096, 4096), (8192, 8192)])
 
@@ -3484,9 +3484,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, tuple([8] * 4))
+        self.assertEqual(c.segment[1].bitdepth, tuple([8] * 4))
         # signed
-        self.assertEqual(c.segment[1]._signed, tuple([False] * 4))
+        self.assertEqual(c.segment[1].signed, tuple([False] * 4))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1), (1, 1), (2, 2), (2, 2)])
@@ -3495,10 +3495,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)  # no sop
         self.assertFalse(c.segment[2].scod & 4)  # no eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.PCRL)
-        self.assertEqual(c.segment[2]._layers, 10)  # layers = 10
+        self.assertEqual(c.segment[2].layers, 10)  # layers = 10
         self.assertEqual(c.segment[2].spcod[3], 0)  # mct
         self.assertEqual(c.segment[2].spcod[4], 6)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size), (32, 32))
+        self.assertEqual(tuple(c.segment[2].code_block_size), (32, 32))
         # Selective arithmetic coding bypass
         self.assertTrue(c.segment[2].spcod[7] & 0x01)
         # Reset context probabilities
@@ -3518,7 +3518,7 @@ class TestSuiteDump(unittest.TestCase):
         # COC: Coding style component
         self.assertEqual(c.segment[3].ccoc, 1)
         self.assertEqual(c.segment[3].spcoc[0], 3)  # level
-        self.assertEqual(tuple(c.segment[3]._code_block_size), (32, 32))
+        self.assertEqual(tuple(c.segment[3].code_block_size), (32, 32))
         # Selective arithmetic coding bypass
         self.assertTrue(c.segment[3].spcoc[3] & 0x01)
         # Reset context probabilities
@@ -3537,7 +3537,7 @@ class TestSuiteDump(unittest.TestCase):
         # COC: Coding style component
         self.assertEqual(c.segment[4].ccoc, 3)
         self.assertEqual(c.segment[4].spcoc[0], 6)  # level
-        self.assertEqual(tuple(c.segment[4]._code_block_size), (32, 32))
+        self.assertEqual(tuple(c.segment[4].code_block_size), (32, 32))
         # Selective arithmetic coding bypass
         self.assertTrue(c.segment[4].spcoc[3] & 0x01)
         # Reset context probabilities
@@ -3630,9 +3630,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (12,))
+        self.assertEqual(c.segment[1].bitdepth, (12,))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False,))
+        self.assertEqual(c.segment[1].signed, (False,))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)])
@@ -3641,10 +3641,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)  # no sop
         self.assertFalse(c.segment[2].scod & 4)  # no eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-        self.assertEqual(c.segment[2]._layers, 1)  # layers = 1
+        self.assertEqual(c.segment[2].layers, 1)  # layers = 1
         self.assertEqual(c.segment[2].spcod[3], 0)  # mct
         self.assertEqual(c.segment[2].spcod[4], 3)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size), (64, 64))
+        self.assertEqual(tuple(c.segment[2].code_block_size), (64, 64))
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
         # Reset context probabilities
@@ -3757,9 +3757,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (8, 2))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (8, 8, 8))
+        self.assertEqual(c.segment[1].bitdepth, (8, 8, 8))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False, False, False))
+        self.assertEqual(c.segment[1].signed, (False, False, False))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)] * 3)
@@ -3768,10 +3768,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertTrue(c.segment[2].scod & 2)  # sop
         self.assertTrue(c.segment[2].scod & 4)  # eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.PCRL)
-        self.assertEqual(c.segment[2]._layers, 2)  # levels = 2
+        self.assertEqual(c.segment[2].layers, 2)  # levels = 2
         self.assertEqual(c.segment[2].spcod[3], 1)  # mct
         self.assertEqual(c.segment[2].spcod[4], 7)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size), (64, 8))  # cblk
+        self.assertEqual(tuple(c.segment[2].code_block_size), (64, 8))  # cblk
         # Selective arithmetic coding bypass
         self.assertTrue(c.segment[2].spcod[7] & 0x01)
         # Reset context probabilities
@@ -3786,7 +3786,7 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].spcod[7] & 0x0020)
         self.assertEqual(c.segment[2].spcod[8],
                          glymur.core.WAVELET_XFORM_9X7_IRREVERSIBLE)
-        self.assertEqual(c.segment[2]._precinct_size, [(16, 16)] * 8)
+        self.assertEqual(c.segment[2].precinct_size, [(16, 16)] * 8)
 
         self.assertEqual(c.segment[3].sqcd & 0x1f, 2)  # expounded
         self.assertEqual(c.segment[3]._guard_bits, 3)
@@ -3845,9 +3845,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (8, 8, 8))
+        self.assertEqual(c.segment[1].bitdepth, (8, 8, 8))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False, False, False))
+        self.assertEqual(c.segment[1].signed, (False, False, False))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)] * 3)
@@ -3856,10 +3856,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertTrue(c.segment[2].scod & 2)  # sop
         self.assertTrue(c.segment[2].scod & 4)  # eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.PCRL)
-        self.assertEqual(c.segment[2]._layers, 1)  # layers = 1
+        self.assertEqual(c.segment[2].layers, 1)  # layers = 1
         self.assertEqual(c.segment[2].spcod[3], 1)  # mct
         self.assertEqual(c.segment[2].spcod[4], 4)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size), (32, 64))
+        self.assertEqual(tuple(c.segment[2].code_block_size), (32, 64))
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
         # Reset context probabilities
@@ -3938,9 +3938,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (4, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (8, 8))
+        self.assertEqual(c.segment[1].bitdepth, (8, 8))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False, False))
+        self.assertEqual(c.segment[1].signed, (False, False))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(4, 1), (1, 1)])
@@ -3949,10 +3949,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertTrue(c.segment[2].scod & 2)  # sop
         self.assertTrue(c.segment[2].scod & 4)  # eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.RPCL)
-        self.assertEqual(c.segment[2]._layers, 1)  # layers = 1
+        self.assertEqual(c.segment[2].layers, 1)  # layers = 1
         self.assertEqual(c.segment[2].spcod[3], 0)  # mct
         self.assertEqual(c.segment[2].spcod[4], 1)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size), (64, 64))
+        self.assertEqual(tuple(c.segment[2].code_block_size), (64, 64))
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
         # Reset context probabilities
@@ -3967,12 +3967,12 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].spcod[7] & 0x0020)
         self.assertEqual(c.segment[2].spcod[8],
                          glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
-        self.assertEqual(c.segment[2]._precinct_size, [(1, 1), (2, 2)])
+        self.assertEqual(c.segment[2].precinct_size, [(1, 1), (2, 2)])
 
         # COC: Coding style component
         self.assertEqual(c.segment[3].ccoc, 1)
         self.assertEqual(c.segment[3].spcoc[0], 1)  # level
-        self.assertEqual(tuple(c.segment[3]._code_block_size), (64, 64))
+        self.assertEqual(tuple(c.segment[3].code_block_size), (64, 64))
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[3].spcoc[3] & 0x01)
         # Reset context probabilities
@@ -3987,7 +3987,7 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[3].spcoc[3] & 0x0020)
         self.assertEqual(c.segment[3].spcoc[4],
                          glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
-        self.assertEqual(c.segment[3]._precinct_size, [(2, 2), (4, 4)])
+        self.assertEqual(c.segment[3].precinct_size, [(2, 2), (4, 4)])
 
         # QCD: Quantization default
         # quantization type
@@ -4481,9 +4481,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (12, 12, 12))
+        self.assertEqual(c.segment[1].bitdepth, (12, 12, 12))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False, False, False))
+        self.assertEqual(c.segment[1].signed, (False, False, False))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)] * 3)
@@ -4492,10 +4492,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)  # no sop
         self.assertFalse(c.segment[2].scod & 4)  # no eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.CPRL)
-        self.assertEqual(c.segment[2]._layers, 1)  # layers = 1
+        self.assertEqual(c.segment[2].layers, 1)  # layers = 1
         self.assertEqual(c.segment[2].spcod[3], 1)  # mct
         self.assertEqual(c.segment[2].spcod[4], 5)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size), (32, 32))
+        self.assertEqual(tuple(c.segment[2].code_block_size), (32, 32))
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
         # Reset context probabilities
@@ -4510,8 +4510,8 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].spcod[7] & 0x0020)
         self.assertEqual(c.segment[2].spcod[8],
                          glymur.core.WAVELET_XFORM_9X7_IRREVERSIBLE)
-        self.assertEqual(c.segment[2]._precinct_size[0], (128, 128))
-        self.assertEqual(c.segment[2]._precinct_size[1:], [(256, 256)] * 5)
+        self.assertEqual(c.segment[2].precinct_size[0], (128, 128))
+        self.assertEqual(c.segment[2].precinct_size[1:], [(256, 256)] * 5)
 
         # QCD: Quantization default
         # quantization type
@@ -4527,7 +4527,7 @@ class TestSuiteDump(unittest.TestCase):
         # COC: Coding style component
         self.assertEqual(c.segment[4].ccoc, 1)
         self.assertEqual(c.segment[4].spcoc[0], 5)  # level
-        self.assertEqual(tuple(c.segment[4]._code_block_size), (32, 32))
+        self.assertEqual(tuple(c.segment[4].code_block_size), (32, 32))
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[4].spcoc[3] & 0x01)
         # Reset context probabilities
@@ -4559,7 +4559,7 @@ class TestSuiteDump(unittest.TestCase):
         # COC: Coding style component
         self.assertEqual(c.segment[6].ccoc, 2)
         self.assertEqual(c.segment[6].spcoc[0], 5)  # level
-        self.assertEqual(tuple(c.segment[6]._code_block_size), (32, 32))
+        self.assertEqual(tuple(c.segment[6].code_block_size), (32, 32))
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[6].spcoc[3] & 0x01)
         # Reset context probabilities
@@ -4633,9 +4633,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (8, 8, 8))
+        self.assertEqual(c.segment[1].bitdepth, (8, 8, 8))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False, False, False))
+        self.assertEqual(c.segment[1].signed, (False, False, False))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)] * 3)
@@ -4644,10 +4644,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)  # no sop
         self.assertFalse(c.segment[2].scod & 4)  # no eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-        self.assertEqual(c.segment[2]._layers, 3)  # layers = 3
+        self.assertEqual(c.segment[2].layers, 3)  # layers = 3
         self.assertEqual(c.segment[2].spcod[3], 1)  # mct
         self.assertEqual(c.segment[2].spcod[4], 5)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size), (32, 32))
+        self.assertEqual(tuple(c.segment[2].code_block_size), (32, 32))
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
         # Reset context probabilities
@@ -4662,7 +4662,7 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].spcod[7] & 0x0020)
         self.assertEqual(c.segment[2].spcod[8],
                          glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
-        self.assertEqual(c.segment[2]._precinct_size,
+        self.assertEqual(c.segment[2].precinct_size,
                          [(16, 16), (32, 32), (64, 64), (128, 128),
                           (128, 128), (128, 128)])
 
@@ -4690,9 +4690,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (16,))
+        self.assertEqual(c.segment[1].bitdepth, (16,))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False,))
+        self.assertEqual(c.segment[1].signed, (False,))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)] * 1)
@@ -4701,10 +4701,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)  # no sop
         self.assertFalse(c.segment[2].scod & 4)  # no eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-        self.assertEqual(c.segment[2]._layers, 2)  # layers = 2
+        self.assertEqual(c.segment[2].layers, 2)  # layers = 2
         self.assertEqual(c.segment[2].spcod[3], 0)  # mct
         self.assertEqual(c.segment[2].spcod[4], 5)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size), (64, 64))
+        self.assertEqual(tuple(c.segment[2].code_block_size), (64, 64))
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
         # Reset context probabilities
@@ -4743,9 +4743,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (16,))
+        self.assertEqual(c.segment[1].bitdepth, (16,))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False,))
+        self.assertEqual(c.segment[1].signed, (False,))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)] * 1)
@@ -4754,10 +4754,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)  # no sop
         self.assertFalse(c.segment[2].scod & 4)  # no eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-        self.assertEqual(c.segment[2]._layers, 2)  # layers = 2
+        self.assertEqual(c.segment[2].layers, 2)  # layers = 2
         self.assertEqual(c.segment[2].spcod[3], 0)  # mct
         self.assertEqual(c.segment[2].spcod[4], 5)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size), (64, 64))
+        self.assertEqual(tuple(c.segment[2].code_block_size), (64, 64))
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
         # Reset context probabilities
@@ -4805,9 +4805,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (16,))
+        self.assertEqual(c.segment[1].bitdepth, (16,))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False,))
+        self.assertEqual(c.segment[1].signed, (False,))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)] * 1)
@@ -4816,10 +4816,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)  # no sop
         self.assertFalse(c.segment[2].scod & 4)  # no eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-        self.assertEqual(c.segment[2]._layers, 1)  # layers = 1
+        self.assertEqual(c.segment[2].layers, 1)  # layers = 1
         self.assertEqual(c.segment[2].spcod[3], 0)  # mct
         self.assertEqual(c.segment[2].spcod[4], 11)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size), (64, 64))
+        self.assertEqual(tuple(c.segment[2].code_block_size), (64, 64))
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
         # Reset context probabilities
@@ -4867,9 +4867,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (12,))
+        self.assertEqual(c.segment[1].bitdepth, (12,))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False,))
+        self.assertEqual(c.segment[1].signed, (False,))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)] * 1)
@@ -4878,10 +4878,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)  # no sop
         self.assertFalse(c.segment[2].scod & 4)  # no eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-        self.assertEqual(c.segment[2]._layers, 1)  # layers = 1
+        self.assertEqual(c.segment[2].layers, 1)  # layers = 1
         self.assertEqual(c.segment[2].spcod[3], 0)  # mct
         self.assertEqual(c.segment[2].spcod[4], 5)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size), (64, 64))
+        self.assertEqual(tuple(c.segment[2].code_block_size), (64, 64))
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
         # Reset context probabilities
@@ -4938,9 +4938,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (8,))
+        self.assertEqual(c.segment[1].bitdepth, (8,))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False,))
+        self.assertEqual(c.segment[1].signed, (False,))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)] * 1)
@@ -4949,10 +4949,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)  # no sop
         self.assertFalse(c.segment[2].scod & 4)  # no eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-        self.assertEqual(c.segment[2]._layers, 1)  # layers = 1
+        self.assertEqual(c.segment[2].layers, 1)  # layers = 1
         self.assertEqual(c.segment[2].spcod[3], 0)  # mct
         self.assertEqual(c.segment[2].spcod[4], 5)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size), (64, 64))
+        self.assertEqual(tuple(c.segment[2].code_block_size), (64, 64))
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
         # Reset context probabilities
@@ -5015,9 +5015,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (16,))
+        self.assertEqual(c.segment[1].bitdepth, (16,))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False,))
+        self.assertEqual(c.segment[1].signed, (False,))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)] * 1)
@@ -5026,10 +5026,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)  # no sop
         self.assertFalse(c.segment[2].scod & 4)  # no eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-        self.assertEqual(c.segment[2]._layers, 1)  # layers = 1
+        self.assertEqual(c.segment[2].layers, 1)  # layers = 1
         self.assertEqual(c.segment[2].spcod[3], 1)  # mct
         self.assertEqual(c.segment[2].spcod[4], 11)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size), (64, 64))
+        self.assertEqual(tuple(c.segment[2].code_block_size), (64, 64))
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
         # Reset context probabilities
@@ -5075,9 +5075,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (8, 8, 8))
+        self.assertEqual(c.segment[1].bitdepth, (8, 8, 8))
         # signed
-        self.assertEqual(c.segment[1]._signed, (True, True, True))
+        self.assertEqual(c.segment[1].signed, (True, True, True))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)] * 3)
@@ -5086,10 +5086,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)  # no sop
         self.assertFalse(c.segment[2].scod & 4)  # no eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-        self.assertEqual(c.segment[2]._layers, 1)  # layers = 1
+        self.assertEqual(c.segment[2].layers, 1)  # layers = 1
         self.assertEqual(c.segment[2].spcod[3], 1)  # mct
         self.assertEqual(c.segment[2].spcod[4], 5)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size), (64, 64))
+        self.assertEqual(tuple(c.segment[2].code_block_size), (64, 64))
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
         # Reset context probabilities
@@ -5141,9 +5141,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (16,))
+        self.assertEqual(c.segment[1].bitdepth, (16,))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False,))
+        self.assertEqual(c.segment[1].signed, (False,))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)] * 1)
@@ -5152,10 +5152,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)  # no sop
         self.assertFalse(c.segment[2].scod & 4)  # no eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-        self.assertEqual(c.segment[2]._layers, 12)  # layers = 12
+        self.assertEqual(c.segment[2].layers, 12)  # layers = 12
         self.assertEqual(c.segment[2].spcod[3], 0)  # mct
         self.assertEqual(c.segment[2].spcod[4], 8)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size), (64, 64))
+        self.assertEqual(tuple(c.segment[2].code_block_size), (64, 64))
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
         # Reset context probabilities
@@ -5226,9 +5226,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (16,))
+        self.assertEqual(c.segment[1].bitdepth, (16,))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False,))
+        self.assertEqual(c.segment[1].signed, (False,))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)] * 1)
@@ -5237,10 +5237,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)  # no sop
         self.assertFalse(c.segment[2].scod & 4)  # no eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-        self.assertEqual(c.segment[2]._layers, 1)  # layers = 1
+        self.assertEqual(c.segment[2].layers, 1)  # layers = 1
         self.assertEqual(c.segment[2].spcod[3], 0)  # mct
         self.assertEqual(c.segment[2].spcod[4], 11)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size), (64, 64))
+        self.assertEqual(tuple(c.segment[2].code_block_size), (64, 64))
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
         # Reset context probabilities
@@ -5286,9 +5286,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (8, 8, 8))
+        self.assertEqual(c.segment[1].bitdepth, (8, 8, 8))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False, False, False))
+        self.assertEqual(c.segment[1].signed, (False, False, False))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)] * 3)
@@ -5297,10 +5297,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)  # no sop
         self.assertFalse(c.segment[2].scod & 4)  # no eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-        self.assertEqual(c.segment[2]._layers, 1)  # layers = 1
+        self.assertEqual(c.segment[2].layers, 1)  # layers = 1
         self.assertEqual(c.segment[2].spcod[3], 1)  # mct
         self.assertEqual(c.segment[2].spcod[4], 5)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size), (64, 64))
+        self.assertEqual(tuple(c.segment[2].code_block_size), (64, 64))
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
         # Reset context probabilities
@@ -5344,9 +5344,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (8, 8, 8))
+        self.assertEqual(c.segment[1].bitdepth, (8, 8, 8))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False, False, False))
+        self.assertEqual(c.segment[1].signed, (False, False, False))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)] * 3)
@@ -5355,10 +5355,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)  # no sop
         self.assertFalse(c.segment[2].scod & 4)  # no eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-        self.assertEqual(c.segment[2]._layers, 1)  # layers = 1
+        self.assertEqual(c.segment[2].layers, 1)  # layers = 1
         self.assertEqual(c.segment[2].spcod[3], 1)  # mct
         self.assertEqual(c.segment[2].spcod[4], 5)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size), (64, 64))
+        self.assertEqual(tuple(c.segment[2].code_block_size), (64, 64))
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
         # Reset context probabilities
@@ -5402,9 +5402,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (8, 8, 8))
+        self.assertEqual(c.segment[1].bitdepth, (8, 8, 8))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False, False, False))
+        self.assertEqual(c.segment[1].signed, (False, False, False))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)] * 3)
@@ -5413,10 +5413,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)  # no sop
         self.assertFalse(c.segment[2].scod & 4)  # no eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-        self.assertEqual(c.segment[2]._layers, 1)  # layers = 1
+        self.assertEqual(c.segment[2].layers, 1)  # layers = 1
         self.assertEqual(c.segment[2].spcod[3], 1)  # mct
         self.assertEqual(c.segment[2].spcod[4], 5)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size), (64, 64))
+        self.assertEqual(tuple(c.segment[2].code_block_size), (64, 64))
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
         # Reset context probabilities
@@ -5463,9 +5463,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (8, 8, 8, 8))
+        self.assertEqual(c.segment[1].bitdepth, (8, 8, 8, 8))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False, False, False, False))
+        self.assertEqual(c.segment[1].signed, (False, False, False, False))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)] * 4)
@@ -5474,10 +5474,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)  # no sop
         self.assertFalse(c.segment[2].scod & 4)  # no eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-        self.assertEqual(c.segment[2]._layers, 1)  # layers = 1
+        self.assertEqual(c.segment[2].layers, 1)  # layers = 1
         self.assertEqual(c.segment[2].spcod[3], 0)  # mct
         self.assertEqual(c.segment[2].spcod[4], 5)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size), (64, 64))
+        self.assertEqual(tuple(c.segment[2].code_block_size), (64, 64))
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
         # Reset context probabilities
@@ -5524,9 +5524,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (8, 8, 8, 8))
+        self.assertEqual(c.segment[1].bitdepth, (8, 8, 8, 8))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False, False, False, False))
+        self.assertEqual(c.segment[1].signed, (False, False, False, False))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)] * 4)
@@ -5535,10 +5535,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)  # no sop
         self.assertFalse(c.segment[2].scod & 4)  # no eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-        self.assertEqual(c.segment[2]._layers, 1)  # layers = 1
+        self.assertEqual(c.segment[2].layers, 1)  # layers = 1
         self.assertEqual(c.segment[2].spcod[3], 0)  # mct
         self.assertEqual(c.segment[2].spcod[4], 5)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size), (64, 64))
+        self.assertEqual(tuple(c.segment[2].code_block_size), (64, 64))
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
         # Reset context probabilities
@@ -5584,9 +5584,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (16,))
+        self.assertEqual(c.segment[1].bitdepth, (16,))
         # signed
-        self.assertEqual(c.segment[1]._signed, (True,))
+        self.assertEqual(c.segment[1].signed, (True,))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)] * 1)
@@ -5595,10 +5595,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)  # no sop
         self.assertFalse(c.segment[2].scod & 4)  # no eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-        self.assertEqual(c.segment[2]._layers, 16)  # layers = 16
+        self.assertEqual(c.segment[2].layers, 16)  # layers = 16
         self.assertEqual(c.segment[2].spcod[3], 0)  # mct
         self.assertEqual(c.segment[2].spcod[4], 5)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size), (64, 64))
+        self.assertEqual(tuple(c.segment[2].code_block_size), (64, 64))
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
         # Reset context probabilities
@@ -5654,9 +5654,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (12,))
+        self.assertEqual(c.segment[1].bitdepth, (12,))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False,))
+        self.assertEqual(c.segment[1].signed, (False,))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)] * 1)
@@ -5665,10 +5665,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)  # no sop
         self.assertFalse(c.segment[2].scod & 4)  # no eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-        self.assertEqual(c.segment[2]._layers, 1)  # layers = 1
+        self.assertEqual(c.segment[2].layers, 1)  # layers = 1
         self.assertEqual(c.segment[2].spcod[3], 0)  # mct
         self.assertEqual(c.segment[2].spcod[4], 5)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size), (64, 64))
+        self.assertEqual(tuple(c.segment[2].code_block_size), (64, 64))
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
         # Reset context probabilities
@@ -5723,9 +5723,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (16,))
+        self.assertEqual(c.segment[1].bitdepth, (16,))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False,))
+        self.assertEqual(c.segment[1].signed, (False,))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)] * 1)
@@ -5734,10 +5734,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)  # no sop
         self.assertFalse(c.segment[2].scod & 4)  # no eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-        self.assertEqual(c.segment[2]._layers, 1)  # layers = 1
+        self.assertEqual(c.segment[2].layers, 1)  # layers = 1
         self.assertEqual(c.segment[2].spcod[3], 1)  # mct
         self.assertEqual(c.segment[2].spcod[4], 11)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size),
+        self.assertEqual(tuple(c.segment[2].code_block_size),
                          (64, 64))  # cblk
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
@@ -5785,9 +5785,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (16,))
+        self.assertEqual(c.segment[1].bitdepth, (16,))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False,))
+        self.assertEqual(c.segment[1].signed, (False,))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)] * 1)
@@ -5796,10 +5796,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)  # no sop
         self.assertFalse(c.segment[2].scod & 4)  # no eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-        self.assertEqual(c.segment[2]._layers, 1)  # layers = 1
+        self.assertEqual(c.segment[2].layers, 1)  # layers = 1
         self.assertEqual(c.segment[2].spcod[3], 1)  # mct
         self.assertEqual(c.segment[2].spcod[4], 11)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size),
+        self.assertEqual(tuple(c.segment[2].code_block_size),
                          (64, 64))  # cblk
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
@@ -5848,9 +5848,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (12, 12, 12))
+        self.assertEqual(c.segment[1].bitdepth, (12, 12, 12))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False, False, False))
+        self.assertEqual(c.segment[1].signed, (False, False, False))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)] * 3)
@@ -5859,10 +5859,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)  # no sop
         self.assertFalse(c.segment[2].scod & 4)  # no eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-        self.assertEqual(c.segment[2]._layers, 2)  # layers = 2
+        self.assertEqual(c.segment[2].layers, 2)  # layers = 2
         self.assertEqual(c.segment[2].spcod[3], 1)  # mct
         self.assertEqual(c.segment[2].spcod[4], 5)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size),
+        self.assertEqual(tuple(c.segment[2].code_block_size),
                          (32, 32))  # cblk
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
@@ -5878,7 +5878,7 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].spcod[7] & 0x0020)
         self.assertEqual(c.segment[2].spcod[8],
                          glymur.core.WAVELET_XFORM_9X7_IRREVERSIBLE)
-        self.assertEqual(c.segment[2]._precinct_size,
+        self.assertEqual(c.segment[2].precinct_size,
                          [(128, 128)] + [(256, 256)] * 5)
 
         # QCD: Quantization default
@@ -5957,9 +5957,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (8, 8, 8))
+        self.assertEqual(c.segment[1].bitdepth, (8, 8, 8))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False, False, False))
+        self.assertEqual(c.segment[1].signed, (False, False, False))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)] * 3)
@@ -5975,10 +5975,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[3].scod & 2)  # no sop
         self.assertFalse(c.segment[3].scod & 4)  # no eph
         self.assertEqual(c.segment[3].spcod[0], glymur.core.LRCP)
-        self.assertEqual(c.segment[3]._layers, 1)  # layers = 1
+        self.assertEqual(c.segment[3].layers, 1)  # layers = 1
         self.assertEqual(c.segment[3].spcod[3], 1)  # mct
         self.assertEqual(c.segment[3].spcod[4], 5)  # level
-        self.assertEqual(tuple(c.segment[3]._code_block_size),
+        self.assertEqual(tuple(c.segment[3].code_block_size),
                          (64, 64))  # cblk
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[3].spcod[7] & 0x01)
@@ -6094,9 +6094,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (8, 8, 8))
+        self.assertEqual(c.segment[1].bitdepth, (8, 8, 8))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False, False, False))
+        self.assertEqual(c.segment[1].signed, (False, False, False))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)] * 3)
@@ -6112,10 +6112,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[3].scod & 2)  # no sop
         self.assertFalse(c.segment[3].scod & 4)  # no eph
         self.assertEqual(c.segment[3].spcod[0], glymur.core.LRCP)
-        self.assertEqual(c.segment[3]._layers, 1)  # layers = 1
+        self.assertEqual(c.segment[3].layers, 1)  # layers = 1
         self.assertEqual(c.segment[3].spcod[3], 1)  # mct
         self.assertEqual(c.segment[3].spcod[4], 5)  # level
-        self.assertEqual(tuple(c.segment[3]._code_block_size),
+        self.assertEqual(tuple(c.segment[3].code_block_size),
                          (64, 64))  # cblk
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[3].spcod[7] & 0x01)
@@ -6227,9 +6227,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (8, 8, 8))
+        self.assertEqual(c.segment[1].bitdepth, (8, 8, 8))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False, False, False))
+        self.assertEqual(c.segment[1].signed, (False, False, False))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1), (2, 1), (2, 1)])
@@ -6238,10 +6238,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)  # no sop
         self.assertFalse(c.segment[2].scod & 4)  # no eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-        self.assertEqual(c.segment[2]._layers, 1)  # layers = 1
+        self.assertEqual(c.segment[2].layers, 1)  # layers = 1
         self.assertEqual(c.segment[2].spcod[3], 0)  # mct
         self.assertEqual(c.segment[2].spcod[4], 5)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size),
+        self.assertEqual(tuple(c.segment[2].code_block_size),
                          (32, 128))  # cblk
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
@@ -6381,9 +6381,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (8,))
+        self.assertEqual(c.segment[1].bitdepth, (8,))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False,))
+        self.assertEqual(c.segment[1].signed, (False,))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)])
@@ -6392,10 +6392,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)  # no sop
         self.assertFalse(c.segment[2].scod & 4)  # no eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.RLCP)
-        self.assertEqual(c.segment[2]._layers, 1)  # layers = 1
+        self.assertEqual(c.segment[2].layers, 1)  # layers = 1
         self.assertEqual(c.segment[2].spcod[3], 0)  # mct
         self.assertEqual(c.segment[2].spcod[4], 5)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size),
+        self.assertEqual(tuple(c.segment[2].code_block_size),
                          (32, 32))  # cblk
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
@@ -6482,9 +6482,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (8, 8, 8))
+        self.assertEqual(c.segment[1].bitdepth, (8, 8, 8))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False, False, False))
+        self.assertEqual(c.segment[1].signed, (False, False, False))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)] * 3)
@@ -6493,10 +6493,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)  # no sop
         self.assertFalse(c.segment[2].scod & 4)  # no eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-        self.assertEqual(c.segment[2]._layers, 1)  # layers = 1
+        self.assertEqual(c.segment[2].layers, 1)  # layers = 1
         self.assertEqual(c.segment[2].spcod[3], 1)  # mct
         self.assertEqual(c.segment[2].spcod[4], 5)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size),
+        self.assertEqual(tuple(c.segment[2].code_block_size),
                          (64, 64))  # cblk
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
@@ -6581,9 +6581,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (8, 8, 8))
+        self.assertEqual(c.segment[1].bitdepth, (8, 8, 8))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False, False, False))
+        self.assertEqual(c.segment[1].signed, (False, False, False))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)] * 3)
@@ -6592,10 +6592,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)  # no sop
         self.assertFalse(c.segment[2].scod & 4)  # no eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.RLCP)
-        self.assertEqual(c.segment[2]._layers, 1)  # layers = 1
+        self.assertEqual(c.segment[2].layers, 1)  # layers = 1
         self.assertEqual(c.segment[2].spcod[3], 1)  # mct
         self.assertEqual(c.segment[2].spcod[4], 5)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size),
+        self.assertEqual(tuple(c.segment[2].code_block_size),
                          (32, 32))  # cblk
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
@@ -6685,9 +6685,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (8, 8))
+        self.assertEqual(c.segment[1].bitdepth, (8, 8))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False, False))
+        self.assertEqual(c.segment[1].signed, (False, False))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)] * 2)
@@ -6696,10 +6696,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)  # no sop
         self.assertFalse(c.segment[2].scod & 4)  # no eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-        self.assertEqual(c.segment[2]._layers, 2)  # layers = 2
+        self.assertEqual(c.segment[2].layers, 2)  # layers = 2
         self.assertEqual(c.segment[2].spcod[3], 0)  # mct
         self.assertEqual(c.segment[2].spcod[4], 5)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size),
+        self.assertEqual(tuple(c.segment[2].code_block_size),
                          (64, 64))  # cblk
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
@@ -6813,9 +6813,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (1,))
+        self.assertEqual(c.segment[1].bitdepth, (1,))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False,))
+        self.assertEqual(c.segment[1].signed, (False,))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)])
@@ -6824,10 +6824,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)  # no sop
         self.assertFalse(c.segment[2].scod & 4)  # no eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.RLCP)
-        self.assertEqual(c.segment[2]._layers, 1)  # layers = 1
+        self.assertEqual(c.segment[2].layers, 1)  # layers = 1
         self.assertEqual(c.segment[2].spcod[3], 0)  # mct
         self.assertEqual(c.segment[2].spcod[4], 5)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size),
+        self.assertEqual(tuple(c.segment[2].code_block_size),
                          (32, 32))  # cblk
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
@@ -6928,9 +6928,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (4,))
+        self.assertEqual(c.segment[1].bitdepth, (4,))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False,))
+        self.assertEqual(c.segment[1].signed, (False,))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)])
@@ -6939,10 +6939,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)  # no sop
         self.assertFalse(c.segment[2].scod & 4)  # no eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.RLCP)
-        self.assertEqual(c.segment[2]._layers, 1)  # layers = 1
+        self.assertEqual(c.segment[2].layers, 1)  # layers = 1
         self.assertEqual(c.segment[2].spcod[3], 0)  # mct
         self.assertEqual(c.segment[2].spcod[4], 5)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size),
+        self.assertEqual(tuple(c.segment[2].code_block_size),
                          (32, 32))  # cblk
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
@@ -7022,9 +7022,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (8, 8, 8))
+        self.assertEqual(c.segment[1].bitdepth, (8, 8, 8))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False, False, False))
+        self.assertEqual(c.segment[1].signed, (False, False, False))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1), (2, 1), (2, 1)])
@@ -7033,10 +7033,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)  # no sop
         self.assertFalse(c.segment[2].scod & 4)  # no eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-        self.assertEqual(c.segment[2]._layers, 1)  # layers = 1
+        self.assertEqual(c.segment[2].layers, 1)  # layers = 1
         self.assertEqual(c.segment[2].spcod[3], 0)  # mct
         self.assertEqual(c.segment[2].spcod[4], 5)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size),
+        self.assertEqual(tuple(c.segment[2].code_block_size),
                          (32, 128))  # cblk
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
@@ -7131,9 +7131,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (8, 8, 8, 8))
+        self.assertEqual(c.segment[1].bitdepth, (8, 8, 8, 8))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False, False, False, False))
+        self.assertEqual(c.segment[1].signed, (False, False, False, False))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)] * 4)
@@ -7142,10 +7142,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)  # no sop
         self.assertFalse(c.segment[2].scod & 4)  # no eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-        self.assertEqual(c.segment[2]._layers, 1)  # layers = 1
+        self.assertEqual(c.segment[2].layers, 1)  # layers = 1
         self.assertEqual(c.segment[2].spcod[3], 0)  # mct
         self.assertEqual(c.segment[2].spcod[4], 5)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size),
+        self.assertEqual(tuple(c.segment[2].code_block_size),
                          (64, 64))  # cblk
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
@@ -7231,9 +7231,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (8, 8, 8, 8))
+        self.assertEqual(c.segment[1].bitdepth, (8, 8, 8, 8))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False, False, False, False))
+        self.assertEqual(c.segment[1].signed, (False, False, False, False))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)] * 4)
@@ -7242,10 +7242,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)  # no sop
         self.assertFalse(c.segment[2].scod & 4)  # no eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-        self.assertEqual(c.segment[2]._layers, 1)  # layers = 1
+        self.assertEqual(c.segment[2].layers, 1)  # layers = 1
         self.assertEqual(c.segment[2].spcod[3], 0)  # mct
         self.assertEqual(c.segment[2].spcod[4], 5)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size),
+        self.assertEqual(tuple(c.segment[2].code_block_size),
                          (64, 64))  # cblk
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
@@ -7343,9 +7343,9 @@ class TestSuiteDump(unittest.TestCase):
         # Tile offset
         self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
         # bitdepth
-        self.assertEqual(c.segment[1]._bitdepth, (8, 8, 8))
+        self.assertEqual(c.segment[1].bitdepth, (8, 8, 8))
         # signed
-        self.assertEqual(c.segment[1]._signed, (False, False, False))
+        self.assertEqual(c.segment[1].signed, (False, False, False))
         # subsampling
         self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
                          [(1, 1)] * 3)
@@ -7354,10 +7354,10 @@ class TestSuiteDump(unittest.TestCase):
         self.assertFalse(c.segment[2].scod & 2)  # no sop
         self.assertFalse(c.segment[2].scod & 4)  # no eph
         self.assertEqual(c.segment[2].spcod[0], glymur.core.RLCP)
-        self.assertEqual(c.segment[2]._layers, 6)  # layers = 6
+        self.assertEqual(c.segment[2].layers, 6)  # layers = 6
         self.assertEqual(c.segment[2].spcod[3], 1)  # mct
         self.assertEqual(c.segment[2].spcod[4], 5)  # level
-        self.assertEqual(tuple(c.segment[2]._code_block_size),
+        self.assertEqual(tuple(c.segment[2].code_block_size),
                          (32, 32))  # cblk
         # Selective arithmetic coding bypass
         self.assertFalse(c.segment[2].spcod[7] & 0x01)
diff --git a/glymur/test/test_opj_suite_write.py b/glymur/test/test_opj_suite_write.py
index 766297b..09722dc 100644
--- a/glymur/test/test_opj_suite_write.py
+++ b/glymur/test/test_opj_suite_write.py
@@ -2,9 +2,10 @@
 The tests defined here roughly correspond to what is in the OpenJPEG test
 suite.
 """
-#pylint:  disable-all
+# C0103:  method names longer that 30 chars are ok in tests, IMHO
+# R0904:  Seems like pylint is fooled in this situation
+# pylint: disable=R0904,C0103
 import os
-import platform
 import sys
 import tempfile
 
@@ -13,10 +14,6 @@ if sys.hexversion < 0x02070000:
 else:
     import unittest
 
-import numpy as np
-
-from glymur.lib import openjp2 as opj2
-
 from .fixtures import read_image, NO_READ_BACKEND, NO_READ_BACKEND_MSG
 
 from glymur import Jp2k
@@ -37,7 +34,11 @@ except:
 @unittest.skipIf(data_root is None,
                  "OPJ_DATA_ROOT environment variable not set")
 class TestSuiteWrite(unittest.TestCase):
+    """Tests for writing with openjp2 backend.
 
+    These tests roughly correspond with those tests with similar names in the
+    OpenJPEG test suite.
+    """
     def setUp(self):
         pass
 
@@ -45,7 +46,7 @@ class TestSuiteWrite(unittest.TestCase):
         pass
 
     def test_NR_ENC_Bretagne1_ppm_1_encode(self):
-        # NR-ENC-Bretagne1.ppm-1-encode
+        """NR-ENC-Bretagne1.ppm-1-encode"""
         infile = os.path.join(data_root, 'input/nonregression/Bretagne1.ppm')
         data = read_image(infile)
         with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
@@ -53,57 +54,63 @@ class TestSuiteWrite(unittest.TestCase):
             j.write(data, cratios=[200, 100, 50])
 
             # Should be three layers.
-            c = j.get_codestream()
+            codestream = j.get_codestream()
 
             # SIZ: Image and tile size
             # Profile:  "0" means profile 2
-            self.assertEqual(c.segment[1].rsiz, 0)
+            self.assertEqual(codestream.segment[1].rsiz, 0)
             # Reference grid size
-            self.assertEqual((c.segment[1].xsiz, c.segment[1].ysiz),
+            self.assertEqual((codestream.segment[1].xsiz,
+                              codestream.segment[1].ysiz),
                              (640, 480))
             # Reference grid offset
-            self.assertEqual((c.segment[1].xosiz, c.segment[1].yosiz), (0, 0))
+            self.assertEqual((codestream.segment[1].xosiz,
+                              codestream.segment[1].yosiz), (0, 0))
             # Tile size
-            self.assertEqual((c.segment[1].xtsiz, c.segment[1].ytsiz),
+            self.assertEqual((codestream.segment[1].xtsiz,
+                              codestream.segment[1].ytsiz),
                              (640, 480))
             # Tile offset
-            self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz),
+            self.assertEqual((codestream.segment[1].xtosiz,
+                              codestream.segment[1].ytosiz),
                              (0, 0))
             # bitdepth
-            self.assertEqual(c.segment[1]._bitdepth, (8, 8, 8))
+            self.assertEqual(codestream.segment[1].bitdepth, (8, 8, 8))
             # signed
-            self.assertEqual(c.segment[1]._signed, (False, False, False))
+            self.assertEqual(codestream.segment[1].signed,
+                             (False, False, False))
             # subsampling
-            self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
+            self.assertEqual(list(zip(codestream.segment[1].xrsiz,
+                                      codestream.segment[1].yrsiz)),
                              [(1, 1)] * 3)
 
             # COD: Coding style default
-            self.assertFalse(c.segment[2].scod & 2)  # no sop
-            self.assertFalse(c.segment[2].scod & 4)  # no eph
-            self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-            self.assertEqual(c.segment[2]._layers, 3)  # layers = 3
-            self.assertEqual(c.segment[2].spcod[3], 1)  # mct
-            self.assertEqual(c.segment[2].spcod[4], 5)  # levels
-            self.assertEqual(tuple(c.segment[2]._code_block_size),
+            self.assertFalse(codestream.segment[2].scod & 2)  # no sop
+            self.assertFalse(codestream.segment[2].scod & 4)  # no eph
+            self.assertEqual(codestream.segment[2].spcod[0], glymur.core.LRCP)
+            self.assertEqual(codestream.segment[2].layers, 3)  # layers = 3
+            self.assertEqual(codestream.segment[2].spcod[3], 1)  # mct
+            self.assertEqual(codestream.segment[2].spcod[4], 5)  # levels
+            self.assertEqual(tuple(codestream.segment[2].code_block_size),
                              (64, 64))  # cblksz
             # Selective arithmetic coding bypass
-            self.assertFalse(c.segment[2].spcod[7] & 0x01)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x01)
             # Reset context probabilities
-            self.assertFalse(c.segment[2].spcod[7] & 0x02)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x02)
             # Termination on each coding pass
-            self.assertFalse(c.segment[2].spcod[7] & 0x04)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x04)
             # Vertically causal context
-            self.assertFalse(c.segment[2].spcod[7] & 0x08)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x08)
             # Predictable termination
-            self.assertFalse(c.segment[2].spcod[7] & 0x0010)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x0010)
             # Segmentation symbols
-            self.assertFalse(c.segment[2].spcod[7] & 0x0020)
-            self.assertEqual(c.segment[2].spcod[8],
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x0020)
+            self.assertEqual(codestream.segment[2].spcod[8],
                              glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
-            self.assertEqual(len(c.segment[2].spcod), 9)
+            self.assertEqual(len(codestream.segment[2].spcod), 9)
 
     def test_NR_ENC_Bretagne1_ppm_2_encode(self):
-        # NR-ENC-Bretagne1.ppm-2-encode
+        """NR-ENC-Bretagne1.ppm-2-encode"""
         infile = os.path.join(data_root, 'input/nonregression/Bretagne1.ppm')
         data = read_image(infile)
         with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
@@ -111,57 +118,64 @@ class TestSuiteWrite(unittest.TestCase):
             j.write(data, psnr=[30, 35, 40], numres=2)
 
             # Should be three layers.
-            c = j.get_codestream()
+            codestream = j.get_codestream()
 
             # SIZ: Image and tile size
             # Profile:  "0" means profile 2
-            self.assertEqual(c.segment[1].rsiz, 0)
+            self.assertEqual(codestream.segment[1].rsiz, 0)
             # Reference grid size
-            self.assertEqual((c.segment[1].xsiz, c.segment[1].ysiz),
+            self.assertEqual((codestream.segment[1].xsiz,
+                              codestream.segment[1].ysiz),
                              (640, 480))
             # Reference grid offset
-            self.assertEqual((c.segment[1].xosiz, c.segment[1].yosiz), (0, 0))
+            self.assertEqual((codestream.segment[1].xosiz,
+                              codestream.segment[1].yosiz), (0, 0))
             # Tile size
-            self.assertEqual((c.segment[1].xtsiz, c.segment[1].ytsiz),
+            self.assertEqual((codestream.segment[1].xtsiz,
+                              codestream.segment[1].ytsiz),
                              (640, 480))
             # Tile offset
-            self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz),
+            self.assertEqual((codestream.segment[1].xtosiz,
+                              codestream.segment[1].ytosiz),
                              (0, 0))
             # bitdepth
-            self.assertEqual(c.segment[1]._bitdepth, (8, 8, 8))
+            self.assertEqual(codestream.segment[1].bitdepth,
+                             (8, 8, 8))
             # signed
-            self.assertEqual(c.segment[1]._signed, (False, False, False))
+            self.assertEqual(codestream.segment[1].signed,
+                             (False, False, False))
             # subsampling
-            self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
+            self.assertEqual(list(zip(codestream.segment[1].xrsiz,
+                                      codestream.segment[1].yrsiz)),
                              [(1, 1)] * 3)
 
             # COD: Coding style default
-            self.assertFalse(c.segment[2].scod & 2)  # no sop
-            self.assertFalse(c.segment[2].scod & 4)  # no eph
-            self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-            self.assertEqual(c.segment[2]._layers, 3)  # layers = 3
-            self.assertEqual(c.segment[2].spcod[3], 1)  # mct
-            self.assertEqual(c.segment[2].spcod[4], 1)  # levels
-            self.assertEqual(tuple(c.segment[2]._code_block_size),
+            self.assertFalse(codestream.segment[2].scod & 2)  # no sop
+            self.assertFalse(codestream.segment[2].scod & 4)  # no eph
+            self.assertEqual(codestream.segment[2].spcod[0], glymur.core.LRCP)
+            self.assertEqual(codestream.segment[2].layers, 3)  # layers = 3
+            self.assertEqual(codestream.segment[2].spcod[3], 1)  # mct
+            self.assertEqual(codestream.segment[2].spcod[4], 1)  # levels
+            self.assertEqual(tuple(codestream.segment[2].code_block_size),
                              (64, 64))  # cblksz
             # Selective arithmetic coding bypass
-            self.assertFalse(c.segment[2].spcod[7] & 0x01)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x01)
             # Reset context probabilities
-            self.assertFalse(c.segment[2].spcod[7] & 0x02)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x02)
             # Termination on each coding pass
-            self.assertFalse(c.segment[2].spcod[7] & 0x04)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x04)
             # Vertically causal context
-            self.assertFalse(c.segment[2].spcod[7] & 0x08)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x08)
             # Predictable termination
-            self.assertFalse(c.segment[2].spcod[7] & 0x0010)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x0010)
             # Segmentation symbols
-            self.assertFalse(c.segment[2].spcod[7] & 0x0020)
-            self.assertEqual(c.segment[2].spcod[8],
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x0020)
+            self.assertEqual(codestream.segment[2].spcod[8],
                              glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
-            self.assertEqual(len(c.segment[2].spcod), 9)
+            self.assertEqual(len(codestream.segment[2].spcod), 9)
 
     def test_NR_ENC_Bretagne1_ppm_3_encode(self):
-        # NR-ENC-Bretagne1.ppm-3-encode
+        """NR-ENC-Bretagne1.ppm-3-encode"""
         infile = os.path.join(data_root, 'input/nonregression/Bretagne1.ppm')
         data = read_image(infile)
         with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
@@ -170,58 +184,65 @@ class TestSuiteWrite(unittest.TestCase):
                     psizes=[(64, 64)])
 
             # Should be three layers.
-            c = j.get_codestream()
+            codestream = j.get_codestream()
 
             # SIZ: Image and tile size
             # Profile:  "0" means profile 2
-            self.assertEqual(c.segment[1].rsiz, 0)
+            self.assertEqual(codestream.segment[1].rsiz, 0)
             # Reference grid size
-            self.assertEqual((c.segment[1].xsiz, c.segment[1].ysiz),
+            self.assertEqual((codestream.segment[1].xsiz,
+                              codestream.segment[1].ysiz),
                              (640, 480))
             # Reference grid offset
-            self.assertEqual((c.segment[1].xosiz, c.segment[1].yosiz), (0, 0))
+            self.assertEqual((codestream.segment[1].xosiz,
+                              codestream.segment[1].yosiz), (0, 0))
             # Tile size
-            self.assertEqual((c.segment[1].xtsiz, c.segment[1].ytsiz),
+            self.assertEqual((codestream.segment[1].xtsiz,
+                              codestream.segment[1].ytsiz),
                              (640, 480))
             # Tile offset
-            self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz),
+            self.assertEqual((codestream.segment[1].xtosiz,
+                              codestream.segment[1].ytosiz),
                              (0, 0))
             # bitdepth
-            self.assertEqual(c.segment[1]._bitdepth, (8, 8, 8))
+            self.assertEqual(codestream.segment[1].bitdepth, (8, 8, 8))
             # signed
-            self.assertEqual(c.segment[1]._signed, (False, False, False))
+            self.assertEqual(codestream.segment[1].signed,
+                             (False, False, False))
             # subsampling
-            self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
+            self.assertEqual(list(zip(codestream.segment[1].xrsiz,
+                                      codestream.segment[1].yrsiz)),
                              [(1, 1)] * 3)
 
             # COD: Coding style default
-            self.assertFalse(c.segment[2].scod & 2)  # no sop
-            self.assertFalse(c.segment[2].scod & 4)  # no eph
-            self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-            self.assertEqual(c.segment[2]._layers, 3)  # layers = 3
-            self.assertEqual(c.segment[2].spcod[3], 1)  # mct
-            self.assertEqual(c.segment[2].spcod[4], 5)  # levels
-            self.assertEqual(tuple(c.segment[2]._code_block_size),
+            self.assertFalse(codestream.segment[2].scod & 2)  # no sop
+            self.assertFalse(codestream.segment[2].scod & 4)  # no eph
+            self.assertEqual(codestream.segment[2].spcod[0], glymur.core.LRCP)
+            self.assertEqual(codestream.segment[2].layers, 3)  # layers = 3
+            self.assertEqual(codestream.segment[2].spcod[3], 1)  # mct
+            self.assertEqual(codestream.segment[2].spcod[4], 5)  # levels
+            self.assertEqual(tuple(codestream.segment[2].code_block_size),
                              (16, 16))  # cblksz
             # Selective arithmetic coding bypass
-            self.assertFalse(c.segment[2].spcod[7] & 0x01)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x01)
             # Reset context probabilities
-            self.assertFalse(c.segment[2].spcod[7] & 0x02)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x02)
             # Termination on each coding pass
-            self.assertFalse(c.segment[2].spcod[7] & 0x04)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x04)
             # Vertically causal context
-            self.assertFalse(c.segment[2].spcod[7] & 0x08)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x08)
             # Predictable termination
-            self.assertFalse(c.segment[2].spcod[7] & 0x0010)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x0010)
             # Segmentation symbols
-            self.assertFalse(c.segment[2].spcod[7] & 0x0020)
-            self.assertEqual(c.segment[2].spcod[8],
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x0020)
+            self.assertEqual(codestream.segment[2].spcod[8],
                              glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
-            self.assertEqual(c.segment[2]._precinct_size,
+            self.assertEqual(codestream.segment[2].precinct_size,
                              [(2, 2), (4, 4), (8, 8), (16, 16), (32, 32),
                               (64, 64)])
 
     def test_NR_ENC_Bretagne2_ppm_4_encode(self):
+        """NR-ENC-Bretagne2.ppm-4-encode"""
         infile = os.path.join(data_root, 'input/nonregression/Bretagne2.ppm')
         data = read_image(infile)
         with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
@@ -233,413 +254,459 @@ class TestSuiteWrite(unittest.TestCase):
                     cbsize=(32, 32))
 
             # Should be three layers.
-            c = j.get_codestream()
+            codestream = j.get_codestream()
 
             # SIZ: Image and tile size
             # Profile:  "0" means profile 2
-            self.assertEqual(c.segment[1].rsiz, 0)
+            self.assertEqual(codestream.segment[1].rsiz, 0)
             # Reference grid size
-            self.assertEqual((c.segment[1].xsiz, c.segment[1].ysiz),
+            self.assertEqual((codestream.segment[1].xsiz,
+                              codestream.segment[1].ysiz),
                              (data.shape[1], data.shape[0]))
             # Reference grid offset
-            self.assertEqual((c.segment[1].xosiz, c.segment[1].yosiz), (0, 0))
+            self.assertEqual((codestream.segment[1].xosiz,
+                              codestream.segment[1].yosiz), (0, 0))
             # Tile size.  Reported as XY, not RC.
-            self.assertEqual((c.segment[1].xtsiz, c.segment[1].ytsiz),
+            self.assertEqual((codestream.segment[1].xtsiz,
+                              codestream.segment[1].ytsiz),
                              (640, 480))
             # Tile offset
-            self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz),
+            self.assertEqual((codestream.segment[1].xtosiz,
+                              codestream.segment[1].ytosiz),
                              (0, 0))
             # bitdepth
-            self.assertEqual(c.segment[1]._bitdepth, (8, 8, 8))
+            self.assertEqual(codestream.segment[1].bitdepth, (8, 8, 8))
             # signed
-            self.assertEqual(c.segment[1]._signed, (False, False, False))
+            self.assertEqual(codestream.segment[1].signed,
+                             (False, False, False))
             # subsampling
-            self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
+            self.assertEqual(list(zip(codestream.segment[1].xrsiz,
+                                      codestream.segment[1].yrsiz)),
                              [(1, 1)] * 3)
 
             # COD: Coding style default
-            self.assertFalse(c.segment[2].scod & 2)  # no sop
-            self.assertFalse(c.segment[2].scod & 4)  # no eph
-            self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-            self.assertEqual(c.segment[2]._layers, 3)  # layers = 3
-            self.assertEqual(c.segment[2].spcod[3], 1)  # mct
-            self.assertEqual(c.segment[2].spcod[4], 5)  # levels
-            self.assertEqual(tuple(c.segment[2]._code_block_size),
+            self.assertFalse(codestream.segment[2].scod & 2)  # no sop
+            self.assertFalse(codestream.segment[2].scod & 4)  # no eph
+            self.assertEqual(codestream.segment[2].spcod[0], glymur.core.LRCP)
+            self.assertEqual(codestream.segment[2].layers, 3)  # layers = 3
+            self.assertEqual(codestream.segment[2].spcod[3], 1)  # mct
+            self.assertEqual(codestream.segment[2].spcod[4], 5)  # levels
+            self.assertEqual(tuple(codestream.segment[2].code_block_size),
                              (32, 32))  # cblksz
             # Selective arithmetic coding bypass
-            self.assertFalse(c.segment[2].spcod[7] & 0x01)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x01)
             # Reset context probabilities
-            self.assertFalse(c.segment[2].spcod[7] & 0x02)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x02)
             # Termination on each coding pass
-            self.assertFalse(c.segment[2].spcod[7] & 0x04)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x04)
             # Vertically causal context
-            self.assertFalse(c.segment[2].spcod[7] & 0x08)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x08)
             # Predictable termination
-            self.assertFalse(c.segment[2].spcod[7] & 0x0010)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x0010)
             # Segmentation symbols
-            self.assertFalse(c.segment[2].spcod[7] & 0x0020)
-            self.assertEqual(c.segment[2].spcod[8],
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x0020)
+            self.assertEqual(codestream.segment[2].spcod[8],
                              glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
-            self.assertEqual(c.segment[2]._precinct_size,
+            self.assertEqual(codestream.segment[2].precinct_size,
                              [(16, 16), (32, 32), (64, 64)] + [(128, 128)] * 3)
 
     def test_NR_ENC_Bretagne2_ppm_5_encode(self):
-        # NR-ENC-Bretagne2.ppm-4-encode
+        """NR-ENC-Bretagne2.ppm-5-encode"""
         infile = os.path.join(data_root, 'input/nonregression/Bretagne2.ppm')
         data = read_image(infile)
         with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
             j = Jp2k(tfile.name, 'wb')
             j.write(data, tilesize=(127, 127), prog="PCRL")
 
-            c = j.get_codestream()
+            codestream = j.get_codestream()
 
             # SIZ: Image and tile size
             # Profile:  "0" means profile 2
-            self.assertEqual(c.segment[1].rsiz, 0)
+            self.assertEqual(codestream.segment[1].rsiz, 0)
             # Reference grid size
-            self.assertEqual((c.segment[1].xsiz, c.segment[1].ysiz),
+            self.assertEqual((codestream.segment[1].xsiz,
+                              codestream.segment[1].ysiz),
                              (data.shape[1], data.shape[0]))
             # Reference grid offset
-            self.assertEqual((c.segment[1].xosiz, c.segment[1].yosiz), (0, 0))
+            self.assertEqual((codestream.segment[1].xosiz,
+                              codestream.segment[1].yosiz), (0, 0))
             # Tile size
-            self.assertEqual((c.segment[1].xtsiz, c.segment[1].ytsiz),
+            self.assertEqual((codestream.segment[1].xtsiz,
+                              codestream.segment[1].ytsiz),
                              (127, 127))
             # Tile offset
-            self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz),
+            self.assertEqual((codestream.segment[1].xtosiz,
+                              codestream.segment[1].ytosiz),
                              (0, 0))
             # bitdepth
-            self.assertEqual(c.segment[1]._bitdepth, (8, 8, 8))
+            self.assertEqual(codestream.segment[1].bitdepth, (8, 8, 8))
             # signed
-            self.assertEqual(c.segment[1]._signed, (False, False, False))
+            self.assertEqual(codestream.segment[1].signed,
+                             (False, False, False))
             # subsampling
-            self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
+            self.assertEqual(list(zip(codestream.segment[1].xrsiz,
+                                      codestream.segment[1].yrsiz)),
                              [(1, 1)] * 3)
 
             # COD: Coding style default
-            self.assertFalse(c.segment[2].scod & 2)  # no sop
-            self.assertFalse(c.segment[2].scod & 4)  # no eph
-            self.assertEqual(c.segment[2].spcod[0], glymur.core.PCRL)
-            self.assertEqual(c.segment[2]._layers, 1)  # layers = 1
-            self.assertEqual(c.segment[2].spcod[3], 1)  # mct
-            self.assertEqual(c.segment[2].spcod[4], 5)  # levels
-            self.assertEqual(tuple(c.segment[2]._code_block_size),
+            self.assertFalse(codestream.segment[2].scod & 2)  # no sop
+            self.assertFalse(codestream.segment[2].scod & 4)  # no eph
+            self.assertEqual(codestream.segment[2].spcod[0], glymur.core.PCRL)
+            self.assertEqual(codestream.segment[2].layers, 1)  # layers = 1
+            self.assertEqual(codestream.segment[2].spcod[3], 1)  # mct
+            self.assertEqual(codestream.segment[2].spcod[4], 5)  # levels
+            self.assertEqual(tuple(codestream.segment[2].code_block_size),
                              (64, 64))  # cblksz
             # Selective arithmetic coding bypass
-            self.assertFalse(c.segment[2].spcod[7] & 0x01)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x01)
             # Reset context probabilities
-            self.assertFalse(c.segment[2].spcod[7] & 0x02)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x02)
             # Termination on each coding pass
-            self.assertFalse(c.segment[2].spcod[7] & 0x04)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x04)
             # Vertically causal context
-            self.assertFalse(c.segment[2].spcod[7] & 0x08)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x08)
             # Predictable termination
-            self.assertFalse(c.segment[2].spcod[7] & 0x0010)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x0010)
             # Segmentation symbols
-            self.assertFalse(c.segment[2].spcod[7] & 0x0020)
-            self.assertEqual(c.segment[2].spcod[8],
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x0020)
+            self.assertEqual(codestream.segment[2].spcod[8],
                              glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
-            self.assertEqual(len(c.segment[2].spcod), 9)
+            self.assertEqual(len(codestream.segment[2].spcod), 9)
 
     def test_NR_ENC_Bretagne2_ppm_6_encode(self):
-        # NR-ENC-Bretagne2.ppm-6-encode
+        """NR-ENC-Bretagne2.ppm-6-encode"""
         infile = os.path.join(data_root, 'input/nonregression/Bretagne2.ppm')
         data = read_image(infile)
         with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
             j = Jp2k(tfile.name, 'wb')
             j.write(data, subsam=(2, 2), sop=True)
 
-            c = j.get_codestream(header_only=False)
+            codestream = j.get_codestream(header_only=False)
 
             # SIZ: Image and tile size
             # Profile:  "0" means profile 2
-            self.assertEqual(c.segment[1].rsiz, 0)
+            self.assertEqual(codestream.segment[1].rsiz, 0)
             # Reference grid size
-            self.assertEqual((c.segment[1].xsiz, c.segment[1].ysiz),
+            self.assertEqual((codestream.segment[1].xsiz,
+                              codestream.segment[1].ysiz),
                              (5183, 3887))
             # Reference grid offset
-            self.assertEqual((c.segment[1].xosiz, c.segment[1].yosiz), (0, 0))
+            self.assertEqual((codestream.segment[1].xosiz,
+                              codestream.segment[1].yosiz), (0, 0))
             # Tile size
-            self.assertEqual((c.segment[1].xtsiz, c.segment[1].ytsiz),
+            self.assertEqual((codestream.segment[1].xtsiz,
+                              codestream.segment[1].ytsiz),
                              (5183, 3887))
             # Tile offset
-            self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz),
+            self.assertEqual((codestream.segment[1].xtosiz,
+                              codestream.segment[1].ytosiz),
                              (0, 0))
             # bitdepth
-            self.assertEqual(c.segment[1]._bitdepth, (8, 8, 8))
+            self.assertEqual(codestream.segment[1].bitdepth, (8, 8, 8))
             # signed
-            self.assertEqual(c.segment[1]._signed, (False, False, False))
+            self.assertEqual(codestream.segment[1].signed,
+                             (False, False, False))
             # subsampling
-            self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
+            self.assertEqual(list(zip(codestream.segment[1].xrsiz,
+                                      codestream.segment[1].yrsiz)),
                              [(2, 2)] * 3)
 
             # COD: Coding style default
-            self.assertTrue(c.segment[2].scod & 2)  # sop
-            self.assertFalse(c.segment[2].scod & 4)  # no eph
-            self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-            self.assertEqual(c.segment[2]._layers, 1)  # layers = 1
-            self.assertEqual(c.segment[2].spcod[3], 1)  # mct
-            self.assertEqual(c.segment[2].spcod[4], 5)  # levels
-            self.assertEqual(tuple(c.segment[2]._code_block_size),
+            self.assertTrue(codestream.segment[2].scod & 2)  # sop
+            self.assertFalse(codestream.segment[2].scod & 4)  # no eph
+            self.assertEqual(codestream.segment[2].spcod[0], glymur.core.LRCP)
+            self.assertEqual(codestream.segment[2].layers, 1)  # layers = 1
+            self.assertEqual(codestream.segment[2].spcod[3], 1)  # mct
+            self.assertEqual(codestream.segment[2].spcod[4], 5)  # levels
+            self.assertEqual(tuple(codestream.segment[2].code_block_size),
                              (64, 64))  # cblksz
             # Selective arithmetic coding bypass
-            self.assertFalse(c.segment[2].spcod[7] & 0x01)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x01)
             # Reset context probabilities
-            self.assertFalse(c.segment[2].spcod[7] & 0x02)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x02)
             # Termination on each coding pass
-            self.assertFalse(c.segment[2].spcod[7] & 0x04)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x04)
             # Vertically causal context
-            self.assertFalse(c.segment[2].spcod[7] & 0x08)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x08)
             # Predictable termination
-            self.assertFalse(c.segment[2].spcod[7] & 0x0010)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x0010)
             # Segmentation symbols
-            self.assertFalse(c.segment[2].spcod[7] & 0x0020)
-            self.assertEqual(c.segment[2].spcod[8],
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x0020)
+            self.assertEqual(codestream.segment[2].spcod[8],
                              glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
-            self.assertEqual(len(c.segment[2].spcod), 9)
+            self.assertEqual(len(codestream.segment[2].spcod), 9)
 
             # 18 SOP segments.
-            nsops = [x.nsop for x in c.segment if x.marker_id == 'SOP']
+            nsops = [x.nsop for x in codestream.segment if x.marker_id == 'SOP']
             self.assertEqual(nsops, list(range(18)))
 
     def test_NR_ENC_Bretagne2_ppm_7_encode(self):
+        """NR-ENC-Bretagne2.ppm-7-encode"""
         infile = os.path.join(data_root, 'input/nonregression/Bretagne2.ppm')
         data = read_image(infile)
         with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
             j = Jp2k(tfile.name, 'wb')
             j.write(data, modesw=38, eph=True)
 
-            c = j.get_codestream(header_only=False)
+            codestream = j.get_codestream(header_only=False)
 
             # SIZ: Image and tile size
             # Profile:  "0" means profile 2
-            self.assertEqual(c.segment[1].rsiz, 0)
+            self.assertEqual(codestream.segment[1].rsiz, 0)
             # Reference grid size
-            self.assertEqual((c.segment[1].xsiz, c.segment[1].ysiz),
+            self.assertEqual((codestream.segment[1].xsiz,
+                              codestream.segment[1].ysiz),
                              (2592, 1944))
             # Reference grid offset
-            self.assertEqual((c.segment[1].xosiz, c.segment[1].yosiz), (0, 0))
+            self.assertEqual((codestream.segment[1].xosiz,
+                              codestream.segment[1].yosiz), (0, 0))
             # Tile size
-            self.assertEqual((c.segment[1].xtsiz, c.segment[1].ytsiz),
+            self.assertEqual((codestream.segment[1].xtsiz,
+                              codestream.segment[1].ytsiz),
                              (2592, 1944))
             # Tile offset
-            self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz),
+            self.assertEqual((codestream.segment[1].xtosiz,
+                              codestream.segment[1].ytosiz),
                              (0, 0))
             # bitdepth
-            self.assertEqual(c.segment[1]._bitdepth, (8, 8, 8))
+            self.assertEqual(codestream.segment[1].bitdepth, (8, 8, 8))
             # signed
-            self.assertEqual(c.segment[1]._signed, (False, False, False))
+            self.assertEqual(codestream.segment[1].signed,
+                             (False, False, False))
             # subsampling
-            self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
+            self.assertEqual(list(zip(codestream.segment[1].xrsiz,
+                                      codestream.segment[1].yrsiz)),
                              [(1, 1)] * 3)
 
             # COD: Coding style default
-            self.assertFalse(c.segment[2].scod & 2)  # no sop
-            self.assertTrue(c.segment[2].scod & 4)  # eph
-            self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-            self.assertEqual(c.segment[2]._layers, 1)  # layers = 1
-            self.assertEqual(c.segment[2].spcod[3], 1)  # mct
-            self.assertEqual(c.segment[2].spcod[4], 5)  # levels
-            self.assertEqual(tuple(c.segment[2]._code_block_size),
+            self.assertFalse(codestream.segment[2].scod & 2)  # no sop
+            self.assertTrue(codestream.segment[2].scod & 4)  # eph
+            self.assertEqual(codestream.segment[2].spcod[0], glymur.core.LRCP)
+            self.assertEqual(codestream.segment[2].layers, 1)  # layers = 1
+            self.assertEqual(codestream.segment[2].spcod[3], 1)  # mct
+            self.assertEqual(codestream.segment[2].spcod[4], 5)  # levels
+            self.assertEqual(tuple(codestream.segment[2].code_block_size),
                             (64, 64))  # cblksz
             # Selective arithmetic coding BYPASS
-            self.assertFalse(c.segment[2].spcod[7] & 0x01)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x01)
             # RESET context probabilities (RESET)
-            self.assertTrue(c.segment[2].spcod[7] & 0x02)
+            self.assertTrue(codestream.segment[2].spcod[7] & 0x02)
             # Termination on each coding pass, RESTART(TERMALL)
-            self.assertTrue(c.segment[2].spcod[7] & 0x04)
+            self.assertTrue(codestream.segment[2].spcod[7] & 0x04)
             # Vertically causal context (VSC)
-            self.assertFalse(c.segment[2].spcod[7] & 0x08)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x08)
             # Predictable termination, ERTERM(SEGTERM)
-            self.assertFalse(c.segment[2].spcod[7] & 0x0010)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x0010)
             # Segmentation symbols, SEGMARK(SEGSYSM)
-            self.assertTrue(c.segment[2].spcod[7] & 0x0020)
-            self.assertEqual(c.segment[2].spcod[8],
+            self.assertTrue(codestream.segment[2].spcod[7] & 0x0020)
+            self.assertEqual(codestream.segment[2].spcod[8],
                              glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
-            self.assertEqual(len(c.segment[2].spcod), 9)
+            self.assertEqual(len(codestream.segment[2].spcod), 9)
 
             # 18 EPH segments.
-            ephs = [x for x in c.segment if x.marker_id == 'EPH']
+            ephs = [x for x in codestream.segment if x.marker_id == 'EPH']
             self.assertEqual(len(ephs), 18)
 
     def test_NR_ENC_Bretagne2_ppm_8_encode(self):
+        """NR-ENC-Bretagne2.ppm-8-encode"""
         infile = os.path.join(data_root, 'input/nonregression/Bretagne2.ppm')
         data = read_image(infile)
         with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
             j = Jp2k(tfile.name, 'wb')
             j.write(data, grid_offset=[300, 150], cratios=[800])
 
-            c = j.get_codestream(header_only=False)
+            codestream = j.get_codestream(header_only=False)
 
             # SIZ: Image and tile size
             # Profile:  "0" means profile 2
-            self.assertEqual(c.segment[1].rsiz, 0)
+            self.assertEqual(codestream.segment[1].rsiz, 0)
             # Reference grid size
-            self.assertEqual((c.segment[1].xsiz, c.segment[1].ysiz),
+            self.assertEqual((codestream.segment[1].xsiz,
+                              codestream.segment[1].ysiz),
                              (2742, 2244))
             # Reference grid offset
-            self.assertEqual((c.segment[1].xosiz, c.segment[1].yosiz),
+            self.assertEqual((codestream.segment[1].xosiz,
+                              codestream.segment[1].yosiz),
                              (150, 300))
             # Tile size
-            self.assertEqual((c.segment[1].xtsiz, c.segment[1].ytsiz),
+            self.assertEqual((codestream.segment[1].xtsiz,
+                              codestream.segment[1].ytsiz),
                              (2742, 2244))
             # Tile offset
-            self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz),
+            self.assertEqual((codestream.segment[1].xtosiz,
+                              codestream.segment[1].ytosiz),
                              (0, 0))
             # bitdepth
-            self.assertEqual(c.segment[1]._bitdepth, (8, 8, 8))
+            self.assertEqual(codestream.segment[1].bitdepth, (8, 8, 8))
             # signed
-            self.assertEqual(c.segment[1]._signed, (False, False, False))
+            self.assertEqual(codestream.segment[1].signed,
+                             (False, False, False))
             # subsampling
-            self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
+            self.assertEqual(list(zip(codestream.segment[1].xrsiz,
+                                      codestream.segment[1].yrsiz)),
                              [(1, 1)] * 3)
 
             # COD: Coding style default
-            self.assertFalse(c.segment[2].scod & 2)  # no sop
-            self.assertFalse(c.segment[2].scod & 4)  # no eph
-            self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-            self.assertEqual(c.segment[2]._layers, 1)  # layers = 1
-            self.assertEqual(c.segment[2].spcod[3], 1)  # mct
-            self.assertEqual(c.segment[2].spcod[4], 5)  # levels
-            self.assertEqual(tuple(c.segment[2]._code_block_size),
+            self.assertFalse(codestream.segment[2].scod & 2)  # no sop
+            self.assertFalse(codestream.segment[2].scod & 4)  # no eph
+            self.assertEqual(codestream.segment[2].spcod[0], glymur.core.LRCP)
+            self.assertEqual(codestream.segment[2].layers, 1)  # layers = 1
+            self.assertEqual(codestream.segment[2].spcod[3], 1)  # mct
+            self.assertEqual(codestream.segment[2].spcod[4], 5)  # levels
+            self.assertEqual(tuple(codestream.segment[2].code_block_size),
                              (64, 64))  # cblksz
             # Selective arithmetic coding BYPASS
-            self.assertFalse(c.segment[2].spcod[7] & 0x01)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x01)
             # RESET context probabilities (RESET)
-            self.assertFalse(c.segment[2].spcod[7] & 0x02)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x02)
             # Termination on each coding pass, RESTART(TERMALL)
-            self.assertFalse(c.segment[2].spcod[7] & 0x04)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x04)
             # Vertically causal context (VSC)
-            self.assertFalse(c.segment[2].spcod[7] & 0x08)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x08)
             # Predictable termination, ERTERM(SEGTERM)
-            self.assertFalse(c.segment[2].spcod[7] & 0x0010)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x0010)
             # Segmentation symbols, SEGMARK(SEGSYSM)
-            self.assertFalse(c.segment[2].spcod[7] & 0x0020)
-            self.assertEqual(c.segment[2].spcod[8],
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x0020)
+            self.assertEqual(codestream.segment[2].spcod[8],
                              glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
-            self.assertEqual(len(c.segment[2].spcod), 9)
+            self.assertEqual(len(codestream.segment[2].spcod), 9)
 
     def test_NR_ENC_Cevennes1_bmp_9_encode(self):
+        """NR-ENC-Cevennes1.bmp-9-encode"""
         infile = os.path.join(data_root, 'input/nonregression/Cevennes1.bmp')
         data = read_image(infile)
         with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
             j = Jp2k(tfile.name, 'wb')
             j.write(data, cratios=[800])
 
-            c = j.get_codestream(header_only=False)
+            codestream = j.get_codestream(header_only=False)
 
             # SIZ: Image and tile size
             # Profile:  "0" means profile 2
-            self.assertEqual(c.segment[1].rsiz, 0)
+            self.assertEqual(codestream.segment[1].rsiz, 0)
             # Reference grid size
-            self.assertEqual((c.segment[1].xsiz, c.segment[1].ysiz),
+            self.assertEqual((codestream.segment[1].xsiz,
+                              codestream.segment[1].ysiz),
                              (2592, 1944))
             # Reference grid offset
-            self.assertEqual((c.segment[1].xosiz, c.segment[1].yosiz), (0, 0))
+            self.assertEqual((codestream.segment[1].xosiz,
+                              codestream.segment[1].yosiz), (0, 0))
             # Tile size
-            self.assertEqual((c.segment[1].xtsiz, c.segment[1].ytsiz),
+            self.assertEqual((codestream.segment[1].xtsiz,
+                              codestream.segment[1].ytsiz),
                              (2592, 1944))
             # Tile offset
-            self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz),
+            self.assertEqual((codestream.segment[1].xtosiz,
+                              codestream.segment[1].ytosiz),
                              (0, 0))
             # bitdepth
-            self.assertEqual(c.segment[1]._bitdepth, (8, 8, 8))
+            self.assertEqual(codestream.segment[1].bitdepth, (8, 8, 8))
             # signed
-            self.assertEqual(c.segment[1]._signed, (False, False, False))
+            self.assertEqual(codestream.segment[1].signed,
+                             (False, False, False))
             # subsampling
-            self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
+            self.assertEqual(list(zip(codestream.segment[1].xrsiz,
+                                      codestream.segment[1].yrsiz)),
                              [(1, 1)] * 3)
 
             # COD: Coding style default
-            self.assertFalse(c.segment[2].scod & 2)  # no sop
-            self.assertFalse(c.segment[2].scod & 4)  # no eph
-            self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-            self.assertEqual(c.segment[2]._layers, 1)  # layers = 1
-            self.assertEqual(c.segment[2].spcod[3], 1)  # mct
-            self.assertEqual(c.segment[2].spcod[4], 5)  # levels
-            self.assertEqual(tuple(c.segment[2]._code_block_size),
+            self.assertFalse(codestream.segment[2].scod & 2)  # no sop
+            self.assertFalse(codestream.segment[2].scod & 4)  # no eph
+            self.assertEqual(codestream.segment[2].spcod[0], glymur.core.LRCP)
+            self.assertEqual(codestream.segment[2].layers, 1)  # layers = 1
+            self.assertEqual(codestream.segment[2].spcod[3], 1)  # mct
+            self.assertEqual(codestream.segment[2].spcod[4], 5)  # levels
+            self.assertEqual(tuple(codestream.segment[2].code_block_size),
                              (64, 64))  # cblksz
             # Selective arithmetic coding BYPASS
-            self.assertFalse(c.segment[2].spcod[7] & 0x01)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x01)
             # RESET context probabilities (RESET)
-            self.assertFalse(c.segment[2].spcod[7] & 0x02)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x02)
             # Termination on each coding pass, RESTART(TERMALL)
-            self.assertFalse(c.segment[2].spcod[7] & 0x04)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x04)
             # Vertically causal context (VSC)
-            self.assertFalse(c.segment[2].spcod[7] & 0x08)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x08)
             # Predictable termination, ERTERM(SEGTERM)
-            self.assertFalse(c.segment[2].spcod[7] & 0x0010)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x0010)
             # Segmentation symbols, SEGMARK(SEGSYSM)
-            self.assertFalse(c.segment[2].spcod[7] & 0x0020)
-            self.assertEqual(c.segment[2].spcod[8],
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x0020)
+            self.assertEqual(codestream.segment[2].spcod[8],
                              glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
-            self.assertEqual(len(c.segment[2].spcod), 9)
+            self.assertEqual(len(codestream.segment[2].spcod), 9)
 
     def test_NR_ENC_Cevennes2_ppm_10_encode(self):
+        """NR-ENC-Cevennes2.ppm-10-encode"""
         infile = os.path.join(data_root, 'input/nonregression/Cevennes2.ppm')
         data = read_image(infile)
         with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
             j = Jp2k(tfile.name, 'wb')
             j.write(data, cratios=[50])
 
-            c = j.get_codestream(header_only=False)
+            codestream = j.get_codestream(header_only=False)
 
             # SIZ: Image and tile size
             # Profile:  "0" means profile 2
-            self.assertEqual(c.segment[1].rsiz, 0)
+            self.assertEqual(codestream.segment[1].rsiz, 0)
             # Reference grid size
-            self.assertEqual((c.segment[1].xsiz, c.segment[1].ysiz),
+            self.assertEqual((codestream.segment[1].xsiz,
+                              codestream.segment[1].ysiz),
                              (640, 480))
             # Reference grid offset
-            self.assertEqual((c.segment[1].xosiz, c.segment[1].yosiz), (0, 0))
+            self.assertEqual((codestream.segment[1].xosiz,
+                              codestream.segment[1].yosiz), (0, 0))
             # Tile size
-            self.assertEqual((c.segment[1].xtsiz, c.segment[1].ytsiz),
+            self.assertEqual((codestream.segment[1].xtsiz,
+                              codestream.segment[1].ytsiz),
                              (640, 480))
             # Tile offset
-            self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz),
+            self.assertEqual((codestream.segment[1].xtosiz,
+                              codestream.segment[1].ytosiz),
                              (0, 0))
             # bitdepth
-            self.assertEqual(c.segment[1]._bitdepth, (8, 8, 8))
+            self.assertEqual(codestream.segment[1].bitdepth, (8, 8, 8))
             # signed
-            self.assertEqual(c.segment[1]._signed, (False, False, False))
+            self.assertEqual(codestream.segment[1].signed,
+                             (False, False, False))
             # subsampling
-            self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
+            self.assertEqual(list(zip(codestream.segment[1].xrsiz,
+                                      codestream.segment[1].yrsiz)),
                              [(1, 1)] * 3)
 
             # COD: Coding style default
-            self.assertFalse(c.segment[2].scod & 2)  # no sop
-            self.assertFalse(c.segment[2].scod & 4)  # no eph
-            self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-            self.assertEqual(c.segment[2]._layers, 1)  # layers = 1
-            self.assertEqual(c.segment[2].spcod[3], 1)  # mct
-            self.assertEqual(c.segment[2].spcod[4], 5)  # levels
-            self.assertEqual(tuple(c.segment[2]._code_block_size),
+            self.assertFalse(codestream.segment[2].scod & 2)  # no sop
+            self.assertFalse(codestream.segment[2].scod & 4)  # no eph
+            self.assertEqual(codestream.segment[2].spcod[0], glymur.core.LRCP)
+            self.assertEqual(codestream.segment[2].layers, 1)  # layers = 1
+            self.assertEqual(codestream.segment[2].spcod[3], 1)  # mct
+            self.assertEqual(codestream.segment[2].spcod[4], 5)  # levels
+            self.assertEqual(tuple(codestream.segment[2].code_block_size),
                              (64, 64))  # cblksz
             # Selective arithmetic coding BYPASS
-            self.assertFalse(c.segment[2].spcod[7] & 0x01)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x01)
             # RESET context probabilities (RESET)
-            self.assertFalse(c.segment[2].spcod[7] & 0x02)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x02)
             # Termination on each coding pass, RESTART(TERMALL)
-            self.assertFalse(c.segment[2].spcod[7] & 0x04)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x04)
             # Vertically causal context (VSC)
-            self.assertFalse(c.segment[2].spcod[7] & 0x08)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x08)
             # Predictable termination, ERTERM(SEGTERM)
-            self.assertFalse(c.segment[2].spcod[7] & 0x0010)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x0010)
             # Segmentation symbols, SEGMARK(SEGSYSM)
-            self.assertFalse(c.segment[2].spcod[7] & 0x0020)
-            self.assertEqual(c.segment[2].spcod[8],
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x0020)
+            self.assertEqual(codestream.segment[2].spcod[8],
                              glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
-            self.assertEqual(len(c.segment[2].spcod), 9)
+            self.assertEqual(len(codestream.segment[2].spcod), 9)
 
     def test_NR_ENC_Rome_bmp_11_encode(self):
-        infile = os.path.join(data_root, 'input/nonregression/Rome.bmp')
-        data = read_image(infile)
+        """NR-ENC-Rome.bmp-11-encode"""
+        data = read_image(os.path.join(data_root,
+                                       'input/nonregression/Rome.bmp'))
         with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile:
             jp2 = Jp2k(tfile.name, 'wb')
             jp2.write(data, psnr=[30, 35, 50], prog='LRCP', numres=3)
 
             ids = [box.box_id for box in jp2.box]
-            lst = ['jP  ', 'ftyp', 'jp2h', 'jp2c']
-            self.assertEqual(ids, lst)
+            self.assertEqual(ids, ['jP  ', 'ftyp', 'jp2h', 'jp2c'])
 
             ids = [box.box_id for box in jp2.box[2].box]
             self.assertEqual(ids, ['ihdr', 'colr'])
@@ -671,58 +738,65 @@ class TestSuiteWrite(unittest.TestCase):
             self.assertIsNone(jp2.box[2].box[1].icc_profile)
             self.assertEqual(jp2.box[2].box[1].colorspace, glymur.core.SRGB)
 
-            c = jp2.box[3].main_header
+            codestream = jp2.box[3].main_header
 
             # SIZ: Image and tile size
             # Profile:  "0" means profile 2
-            self.assertEqual(c.segment[1].rsiz, 0)
+            self.assertEqual(codestream.segment[1].rsiz, 0)
             # Reference grid size
-            self.assertEqual((c.segment[1].xsiz, c.segment[1].ysiz),
+            self.assertEqual((codestream.segment[1].xsiz,
+                              codestream.segment[1].ysiz),
                              (640, 480))
             # Reference grid offset
-            self.assertEqual((c.segment[1].xosiz, c.segment[1].yosiz),
+            self.assertEqual((codestream.segment[1].xosiz,
+                              codestream.segment[1].yosiz),
                              (0, 0))
             # Tile size
-            self.assertEqual((c.segment[1].xtsiz, c.segment[1].ytsiz),
+            self.assertEqual((codestream.segment[1].xtsiz,
+                              codestream.segment[1].ytsiz),
                              (640, 480))
             # Tile offset
-            self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz),
+            self.assertEqual((codestream.segment[1].xtosiz,
+                              codestream.segment[1].ytosiz),
                              (0, 0))
             # bitdepth
-            self.assertEqual(c.segment[1]._bitdepth, (8, 8, 8))
+            self.assertEqual(codestream.segment[1].bitdepth, (8, 8, 8))
             # signed
-            self.assertEqual(c.segment[1]._signed, (False, False, False))
+            self.assertEqual(codestream.segment[1].signed,
+                             (False, False, False))
             # subsampling
-            self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
+            self.assertEqual(list(zip(codestream.segment[1].xrsiz,
+                                      codestream.segment[1].yrsiz)),
                              [(1, 1)] * 3)
 
             # COD: Coding style default
-            self.assertFalse(c.segment[2].scod & 2)  # no sop
-            self.assertFalse(c.segment[2].scod & 4)  # no eph
-            self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-            self.assertEqual(c.segment[2]._layers, 3)  # layers = 3
-            self.assertEqual(c.segment[2].spcod[3], 1)  # mct
-            self.assertEqual(c.segment[2].spcod[4], 2)  # levels
-            self.assertEqual(tuple(c.segment[2]._code_block_size),
+            self.assertFalse(codestream.segment[2].scod & 2)  # no sop
+            self.assertFalse(codestream.segment[2].scod & 4)  # no eph
+            self.assertEqual(codestream.segment[2].spcod[0], glymur.core.LRCP)
+            self.assertEqual(codestream.segment[2].layers, 3)  # layers = 3
+            self.assertEqual(codestream.segment[2].spcod[3], 1)  # mct
+            self.assertEqual(codestream.segment[2].spcod[4], 2)  # levels
+            self.assertEqual(tuple(codestream.segment[2].code_block_size),
                              (64, 64))  # cblksz
             # Selective arithmetic coding BYPASS
-            self.assertFalse(c.segment[2].spcod[7] & 0x01)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x01)
             # RESET context probabilities (RESET)
-            self.assertFalse(c.segment[2].spcod[7] & 0x02)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x02)
             # Termination on each coding pass, RESTART(TERMALL)
-            self.assertFalse(c.segment[2].spcod[7] & 0x04)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x04)
             # Vertically causal context (VSC)
-            self.assertFalse(c.segment[2].spcod[7] & 0x08)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x08)
             # Predictable termination, ERTERM(SEGTERM)
-            self.assertFalse(c.segment[2].spcod[7] & 0x0010)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x0010)
             # Segmentation symbols, SEGMARK(SEGSYSM)
-            self.assertFalse(c.segment[2].spcod[7] & 0x0020)
-            self.assertEqual(c.segment[2].spcod[8],
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x0020)
+            self.assertEqual(codestream.segment[2].spcod[8],
                              glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
-            self.assertEqual(len(c.segment[2].spcod), 9)
+            self.assertEqual(len(codestream.segment[2].spcod), 9)
 
     @unittest.skip("Known failure in openjpeg test suite.")
     def test_NR_ENC_random_issue_0005_tif_12_encode(self):
+        """NR-ENC-random-issue-0005.tif-12-encode"""
         # opj_decompress has trouble reading it, but that is not an issue here.
         # The nature of the image itself seems to give the compressor trouble.
         infile = os.path.join(data_root,
@@ -732,54 +806,59 @@ class TestSuiteWrite(unittest.TestCase):
             j = Jp2k(tfile.name, 'wb')
             j.write(data)
 
-            c = j.get_codestream(header_only=False)
+            codestream = j.get_codestream(header_only=False)
 
             # SIZ: Image and tile size
             # Profile:  "0" means profile 2
-            self.assertEqual(c.segment[1].rsiz, 0)
+            self.assertEqual(codestream.segment[1].rsiz, 0)
             # Reference grid size
-            self.assertEqual((c.segment[1].xsiz, c.segment[1].ysiz),
+            self.assertEqual((codestream.segment[1].xsiz,
+                              codestream.segment[1].ysiz),
                              (1024, 1024))
             # Reference grid offset
-            self.assertEqual((c.segment[1].xosiz, c.segment[1].yosiz), (0, 0))
+            self.assertEqual((codestream.segment[1].xosiz,
+                              codestream.segment[1].yosiz), (0, 0))
             # Tile size
-            self.assertEqual((c.segment[1].xtsiz, c.segment[1].ytsiz),
+            self.assertEqual((codestream.segment[1].xtsiz,
+                              codestream.segment[1].ytsiz),
                              (1024, 1024))
             # Tile offset
-            self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz),
+            self.assertEqual((codestream.segment[1].xtosiz,
+                              codestream.segment[1].ytosiz),
                              (0, 0))
             # bitdepth
-            self.assertEqual(c.segment[1]._bitdepth, (16,))
+            self.assertEqual(codestream.segment[1].bitdepth, (16,))
             # signed
-            self.assertEqual(c.segment[1]._signed, (False,))
+            self.assertEqual(codestream.segment[1].signed, (False,))
             # subsampling
-            self.assertEqual(list(zip(c.segment[1].xrsiz, c.segment[1].yrsiz)),
+            self.assertEqual(list(zip(codestream.segment[1].xrsiz,
+                                      codestream.segment[1].yrsiz)),
                              [(1, 1)])
 
             # COD: Coding style default
-            self.assertFalse(c.segment[2].scod & 2)  # no sop
-            self.assertFalse(c.segment[2].scod & 4)  # no eph
-            self.assertEqual(c.segment[2].spcod[0], glymur.core.LRCP)
-            self.assertEqual(c.segment[2]._layers, 1)  # layers = 1
-            self.assertEqual(c.segment[2].spcod[3], 0)  # mct
-            self.assertEqual(c.segment[2].spcod[4], 5)  # levels
-            self.assertEqual(tuple(c.segment[2]._code_block_size),
+            self.assertFalse(codestream.segment[2].scod & 2)  # no sop
+            self.assertFalse(codestream.segment[2].scod & 4)  # no eph
+            self.assertEqual(codestream.segment[2].spcod[0], glymur.core.LRCP)
+            self.assertEqual(codestream.segment[2].layers, 1)  # layers = 1
+            self.assertEqual(codestream.segment[2].spcod[3], 0)  # mct
+            self.assertEqual(codestream.segment[2].spcod[4], 5)  # levels
+            self.assertEqual(tuple(codestream.segment[2].code_block_size),
                              (64, 64))  # cblksz
             # Selective arithmetic coding BYPASS
-            self.assertFalse(c.segment[2].spcod[7] & 0x01)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x01)
             # RESET context probabilities (RESET)
-            self.assertFalse(c.segment[2].spcod[7] & 0x02)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x02)
             # Termination on each coding pass, RESTART(TERMALL)
-            self.assertFalse(c.segment[2].spcod[7] & 0x04)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x04)
             # Vertically causal context (VSC)
-            self.assertFalse(c.segment[2].spcod[7] & 0x08)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x08)
             # Predictable termination, ERTERM(SEGTERM)
-            self.assertFalse(c.segment[2].spcod[7] & 0x0010)
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x0010)
             # Segmentation symbols, SEGMARK(SEGSYSM)
-            self.assertFalse(c.segment[2].spcod[7] & 0x0020)
-            self.assertEqual(c.segment[2].spcod[8],
+            self.assertFalse(codestream.segment[2].spcod[7] & 0x0020)
+            self.assertEqual(codestream.segment[2].spcod[8],
                              glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
-            self.assertEqual(len(c.segment[2].spcod), 9)
+            self.assertEqual(len(codestream.segment[2].spcod), 9)
 
 if __name__ == "__main__":
     unittest.main()