refactor of test suite
This commit is contained in:
John Evans
jevans
parent
3366812936
commit
82466f2b80
6 changed files with 483 additions and 1812 deletions
|
|
@ -642,7 +642,7 @@ class Codestream(object):
|
|||
srgn = data[1]
|
||||
sprgn = data[2]
|
||||
|
||||
return RGNsegment(length, offset, crgn, srgn, sprgn)
|
||||
return RGNsegment(crgn, srgn, sprgn, length, offset)
|
||||
|
||||
def _parse_siz_segment(self, fptr):
|
||||
"""Parse the SIZ segment.
|
||||
|
|
@ -1463,7 +1463,7 @@ class RGNsegment(Segment):
|
|||
15444-1:2004 - Information technology -- JPEG 2000 image coding system:
|
||||
Core coding system
|
||||
"""
|
||||
def __init__(self, length, offset, crgn, srgn, sprgn):
|
||||
def __init__(self, crgn, srgn, sprgn, length=-1, offset=-1):
|
||||
Segment.__init__(self, marker_id='RGN')
|
||||
self.length = length
|
||||
self.offset = offset
|
||||
|
|
@ -1726,7 +1726,7 @@ class SOTsegment(Segment):
|
|||
15444-1:2004 - Information technology -- JPEG 2000 image coding system:
|
||||
Core coding system
|
||||
"""
|
||||
def __init__(self, isot, psot, tpsot, tnsot, length, offset):
|
||||
def __init__(self, isot, psot, tpsot, tnsot, length=-1, offset=-1):
|
||||
Segment.__init__(self, marker_id='SOT')
|
||||
self.isot = isot
|
||||
self.psot = psot
|
||||
|
|
|
|||
|
|
@ -5,6 +5,7 @@ import os
|
|||
import re
|
||||
import sys
|
||||
import textwrap
|
||||
import unittest
|
||||
import warnings
|
||||
|
||||
import numpy as np
|
||||
|
|
@ -24,6 +25,124 @@ elif re.match('1.[0-6]', six.__version__) is not None:
|
|||
WARNING_INFRASTRUCTURE_ISSUE = True
|
||||
WARNING_INFRASTRUCTURE_MSG = "Cannot use with this version of six"
|
||||
|
||||
class MetadataBase(unittest.TestCase):
|
||||
"""
|
||||
Base class for testing metadata.
|
||||
|
||||
This class has helper routines defined for testing metadata so that it can
|
||||
be subclassed and used easily.
|
||||
"""
|
||||
|
||||
def setUp(self):
|
||||
pass
|
||||
|
||||
def tearDown(self):
|
||||
pass
|
||||
|
||||
def verify_codeblock_style(self, actual, style):
|
||||
"""
|
||||
Verify the code-block style for SPcod and SPcoc parameters.
|
||||
|
||||
This information is stored in a single byte. Please reference
|
||||
Table A-17 in FCD15444-1
|
||||
"""
|
||||
expected = 0
|
||||
if style[0]:
|
||||
# Selective arithmetic coding bypass
|
||||
expected |= 0x01
|
||||
if style[1]:
|
||||
# Reset context probabilities
|
||||
expected |= 0x02
|
||||
if style[2]:
|
||||
# Termination on each coding pass
|
||||
expected |= 0x04
|
||||
if style[3]:
|
||||
# Vertically causal context
|
||||
expected |= 0x08
|
||||
if style[4]:
|
||||
# Predictable termination
|
||||
expected |= 0x10
|
||||
if style[5]:
|
||||
# Segmentation symbols
|
||||
expected |= 0x20
|
||||
self.assertEqual(actual, expected)
|
||||
|
||||
def verifySignatureBox(self, box):
|
||||
"""
|
||||
The signature box is a constant.
|
||||
"""
|
||||
self.assertEqual(box.signature, (13, 10, 135, 10))
|
||||
|
||||
def verify_filetype_box(self, actual, expected):
|
||||
"""
|
||||
All JP2 files should have a brand reading 'jp2 ' and just a single
|
||||
entry in the compatibility list, also 'jp2 '. JPX files can have more
|
||||
compatibility items.
|
||||
"""
|
||||
self.assertEqual(actual.brand, expected.brand)
|
||||
self.assertEqual(actual.minor_version, expected.minor_version)
|
||||
self.assertEqual(actual.minor_version, 0)
|
||||
for cl in expected.compatibility_list:
|
||||
self.assertIn(cl, actual.compatibility_list)
|
||||
|
||||
def verifyRGNsegment(self, actual, expected):
|
||||
"""
|
||||
verify the fields of a RGN segment
|
||||
"""
|
||||
self.assertEqual(actual.crgn, expected.crgn) # 0 = component
|
||||
self.assertEqual(actual.srgn, expected.srgn) # 0 = implicit
|
||||
self.assertEqual(actual.sprgn, expected.sprgn)
|
||||
|
||||
def verifySOTsegment(self, actual, expected):
|
||||
"""
|
||||
verify the fields of a SOT (start of tile) segment
|
||||
"""
|
||||
self.assertEqual(actual.isot, expected.isot)
|
||||
self.assertEqual(actual.psot, expected.psot)
|
||||
self.assertEqual(actual.tpsot, expected.tpsot)
|
||||
self.assertEqual(actual.tnsot, expected.tnsot)
|
||||
|
||||
def verifyCMEsegment(self, actual, expected):
|
||||
"""
|
||||
verify the fields of a CME (comment) segment
|
||||
"""
|
||||
self.assertEqual(actual.rcme, expected.rcme)
|
||||
self.assertEqual(actual.ccme, expected.ccme)
|
||||
|
||||
def verifySizSegment(self, actual, expected):
|
||||
"""
|
||||
Verify the fields of the SIZ segment.
|
||||
"""
|
||||
for field in ['rsiz', 'xsiz', 'ysiz', 'xosiz', 'yosiz', 'xtsiz',
|
||||
'ytsiz', 'xtosiz', 'ytosiz', 'bitdepth', 'xrsiz', 'yrsiz']:
|
||||
self.assertEqual(getattr(actual, field), getattr(expected, field))
|
||||
|
||||
def verifyImageHeaderBox(self, box1, box2):
|
||||
self.assertEqual(box1.height, box2.height)
|
||||
self.assertEqual(box1.width, box2.width)
|
||||
self.assertEqual(box1.num_components, box2.num_components)
|
||||
self.assertEqual(box1.bits_per_component, box2.bits_per_component)
|
||||
self.assertEqual(box1.signed, box2.signed)
|
||||
self.assertEqual(box1.compression, box2.compression)
|
||||
self.assertEqual(box1.colorspace_unknown, box2.colorspace_unknown)
|
||||
self.assertEqual(box1.ip_provided, box2.ip_provided)
|
||||
|
||||
def verifyColourSpecificationBox(self, actual, expected):
|
||||
"""
|
||||
Does not currently check icc profiles.
|
||||
"""
|
||||
self.assertEqual(actual.method, expected.method)
|
||||
self.assertEqual(actual.precedence, expected.precedence)
|
||||
self.assertEqual(actual.approximation, expected.approximation)
|
||||
|
||||
if expected.colorspace is None:
|
||||
self.assertIsNone(actual.colorspace)
|
||||
self.assertIsNotNone(actual.icc_profile)
|
||||
else:
|
||||
self.assertEqual(actual.colorspace, expected.colorspace)
|
||||
self.assertIsNone(actual.icc_profile)
|
||||
|
||||
|
||||
# The Python XMP Toolkit may be used for XMP UUIDs, but only if available and
|
||||
# if the version is at least 2.0.0.
|
||||
try:
|
||||
|
|
|
|||
|
|
@ -35,8 +35,10 @@ from glymur.jp2box import JPEG2000SignatureBox
|
|||
from glymur.core import COLOR, OPACITY
|
||||
from glymur.core import RED, GREEN, BLUE, GREY, WHOLE_IMAGE
|
||||
|
||||
from .fixtures import opj_data_file
|
||||
from .fixtures import WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG
|
||||
from .fixtures import (
|
||||
WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG,
|
||||
MetadataBase
|
||||
)
|
||||
|
||||
try:
|
||||
FORMAT_CORPUS_DATA_ROOT = os.environ['FORMAT_CORPUS_DATA_ROOT']
|
||||
|
|
@ -1039,7 +1041,7 @@ class TestJp2Boxes(unittest.TestCase):
|
|||
j.box[5].offset + 8)
|
||||
|
||||
|
||||
class TestRepr(unittest.TestCase):
|
||||
class TestRepr(MetadataBase):
|
||||
"""Tests for __repr__ methods."""
|
||||
def test_default_jp2k(self):
|
||||
"""Should be able to eval a JPEG2000SignatureBox"""
|
||||
|
|
@ -1109,10 +1111,7 @@ class TestRepr(unittest.TestCase):
|
|||
|
||||
# Test the representation instantiation.
|
||||
newbox = eval(repr(ftyp))
|
||||
self.assertTrue(isinstance(newbox, glymur.jp2box.FileTypeBox))
|
||||
self.assertEqual(newbox.brand, 'jp2 ')
|
||||
self.assertEqual(newbox.minor_version, 0)
|
||||
self.assertEqual(newbox.compatibility_list, ['jp2 '])
|
||||
self.verify_filetype_box(newbox, FileTypeBox())
|
||||
|
||||
def test_colourspecification_box(self):
|
||||
"""Verify __repr__ method on colr box."""
|
||||
|
|
|
|||
|
|
@ -33,12 +33,15 @@ import unittest
|
|||
|
||||
import numpy as np
|
||||
|
||||
from glymur import Jp2k
|
||||
import glymur
|
||||
from glymur import Jp2k
|
||||
from glymur.jp2box import FileTypeBox, ImageHeaderBox, ColourSpecificationBox
|
||||
|
||||
from .fixtures import OPJ_DATA_ROOT
|
||||
from .fixtures import WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG
|
||||
from .fixtures import mse, peak_tolerance, read_pgx, opj_data_file
|
||||
from .fixtures import (
|
||||
OPJ_DATA_ROOT, MetadataBase,
|
||||
WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG,
|
||||
mse, peak_tolerance, read_pgx, opj_data_file
|
||||
)
|
||||
|
||||
|
||||
@unittest.skipIf(OPJ_DATA_ROOT is None,
|
||||
|
|
@ -298,7 +301,7 @@ class TestSuite(unittest.TestCase):
|
|||
@unittest.skipIf(OPJ_DATA_ROOT is None,
|
||||
"OPJ_DATA_ROOT environment variable not set")
|
||||
@unittest.skipIf(WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG)
|
||||
class TestSuiteWarns(unittest.TestCase):
|
||||
class TestSuiteWarns(MetadataBase):
|
||||
"""
|
||||
Identical setup to above, but these tests issue warnings.
|
||||
"""
|
||||
|
|
@ -394,30 +397,13 @@ class TestSuiteWarns(unittest.TestCase):
|
|||
|
||||
# Signature box. Check for corruption.
|
||||
self.assertEqual(jp2.box[0].signature, (13, 10, 135, 10))
|
||||
self.verify_filetype_box(jp2.box[1], FileTypeBox())
|
||||
|
||||
# File type box.
|
||||
self.assertEqual(jp2.box[1].brand, 'jp2 ')
|
||||
self.assertEqual(jp2.box[1].minor_version, 0)
|
||||
self.assertEqual(jp2.box[1].compatibility_list[0], 'jp2 ')
|
||||
expected = ImageHeaderBox(152, 203, num_components=3)
|
||||
self.verifyImageHeaderBox(jp2.box[2].box[0], expected)
|
||||
|
||||
# Jp2 Header
|
||||
# Image header
|
||||
self.assertEqual(jp2.box[2].box[0].height, 152)
|
||||
self.assertEqual(jp2.box[2].box[0].width, 203)
|
||||
self.assertEqual(jp2.box[2].box[0].num_components, 3)
|
||||
self.assertEqual(jp2.box[2].box[0].bits_per_component, 8)
|
||||
self.assertEqual(jp2.box[2].box[0].signed, False)
|
||||
self.assertEqual(jp2.box[2].box[0].compression, 7) # wavelet
|
||||
self.assertEqual(jp2.box[2].box[0].colorspace_unknown, False)
|
||||
self.assertEqual(jp2.box[2].box[0].ip_provided, False)
|
||||
|
||||
# Jp2 Header
|
||||
# Colour specification
|
||||
self.assertEqual(jp2.box[2].box[1].method,
|
||||
glymur.core.ENUMERATED_COLORSPACE)
|
||||
self.assertEqual(jp2.box[2].box[1].precedence, 0)
|
||||
self.assertEqual(jp2.box[2].box[1].approximation, 0) # not allowed?
|
||||
self.assertEqual(jp2.box[2].box[1].colorspace, glymur.core.SRGB)
|
||||
expected = ColourSpecificationBox(colorspace=glymur.core.SRGB)
|
||||
self.verifyColourSpecificationBox(jp2.box[2].box[1], expected)
|
||||
|
||||
c = jp2.box[3].main_header
|
||||
|
||||
|
|
@ -425,32 +411,17 @@ class TestSuiteWarns(unittest.TestCase):
|
|||
expected = ['SOC', 'SIZ', 'CME', 'COD', 'QCD', 'QCC', 'QCC']
|
||||
self.assertEqual(ids, expected)
|
||||
|
||||
# SIZ: Image and tile size
|
||||
# Profile:
|
||||
self.assertEqual(c.segment[1].rsiz, 0)
|
||||
# Reference grid size
|
||||
self.assertEqual(c.segment[1].xsiz, 203)
|
||||
self.assertEqual(c.segment[1].ysiz, 152)
|
||||
# Reference grid offset
|
||||
self.assertEqual((c.segment[1].xosiz, c.segment[1].yosiz), (0, 0))
|
||||
# Tile size
|
||||
self.assertEqual((c.segment[1].xtsiz, c.segment[1].ytsiz), (203, 152))
|
||||
# Tile offset
|
||||
self.assertEqual((c.segment[1].xtosiz, c.segment[1].ytosiz), (0, 0))
|
||||
# bitdepth
|
||||
self.assertEqual(c.segment[1].bitdepth, (8, 8, 8))
|
||||
# signed
|
||||
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)
|
||||
kwargs = {'rsiz': 0, 'xysiz': (203, 152), 'xyosiz': (0, 0),
|
||||
'xytsiz': (203, 152), 'xytosiz': (0, 0), 'bitdepth': (8, 8, 8),
|
||||
'signed': (False, False, False),
|
||||
'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
|
||||
self.verifySizSegment(c.segment[1],
|
||||
glymur.codestream.SIZsegment(**kwargs))
|
||||
|
||||
# COM: comment
|
||||
# Registration
|
||||
self.assertEqual(c.segment[2].rcme, glymur.core.RCME_ISO_8859_1)
|
||||
# Comment value
|
||||
self.assertEqual(c.segment[2].ccme.decode('latin-1'),
|
||||
"Creator: JasPer Version 1.701.0")
|
||||
pargs = (glymur.core.RCME_ISO_8859_1,
|
||||
"Creator: JasPer Version 1.701.0".encode())
|
||||
self.verifyCMEsegment(c.segment[2],
|
||||
glymur.codestream.CMEsegment(*pargs))
|
||||
|
||||
# COD: Coding style default
|
||||
self.assertFalse(c.segment[3].scod & 2) # no sop
|
||||
|
|
@ -461,18 +432,8 @@ class TestSuiteWarns(unittest.TestCase):
|
|||
self.assertEqual(c.segment[3].spcod[4], 5) # level
|
||||
self.assertEqual(tuple(c.segment[3].code_block_size),
|
||||
(64, 64)) # cblk
|
||||
# Selective arithmetic coding bypass
|
||||
self.assertFalse(c.segment[3].spcod[7] & 0x01)
|
||||
# Reset context probabilities
|
||||
self.assertFalse(c.segment[3].spcod[7] & 0x02)
|
||||
# Termination on each coding pass
|
||||
self.assertFalse(c.segment[3].spcod[7] & 0x04)
|
||||
# Vertically causal context
|
||||
self.assertFalse(c.segment[3].spcod[7] & 0x08)
|
||||
# Predictable termination
|
||||
self.assertFalse(c.segment[3].spcod[7] & 0x0010)
|
||||
# Segmentation symbols
|
||||
self.assertFalse(c.segment[3].spcod[7] & 0x0020)
|
||||
self.verify_codeblock_style(c.segment[3].spcod[7],
|
||||
[False, False, False, False, False, False])
|
||||
self.assertEqual(c.segment[3].spcod[8],
|
||||
glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
|
||||
self.assertEqual(len(c.segment[3].spcod), 9)
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -27,90 +27,37 @@ from . import fixtures
|
|||
from glymur import Jp2k
|
||||
import glymur
|
||||
|
||||
class CinemaBase(unittest.TestCase):
|
||||
class CinemaBase(fixtures.MetadataBase):
|
||||
|
||||
def verify_cinema_cod(self, cod_segment):
|
||||
|
||||
self.assertFalse(cod_segment.scod & 2) # no sop
|
||||
self.assertFalse(cod_segment.scod & 4) # no eph
|
||||
self.assertEqual(cod_segment.spcod[0], glymur.core.CPRL)
|
||||
self.assertEqual(cod_segment.layers, 1)
|
||||
self.assertEqual(cod_segment.spcod[3], 1) # mct
|
||||
self.assertEqual(cod_segment.spcod[4], 5) # levels
|
||||
self.assertEqual(tuple(cod_segment.code_block_size), (32, 32)) # cblksz
|
||||
|
||||
def check_cinema4k_codestream(self, codestream, image_size):
|
||||
"""Common out for cinema2k tests."""
|
||||
# SIZ: Image and tile size
|
||||
# Profile: "3" means cinema2K
|
||||
self.assertEqual(codestream.segment[1].rsiz, 4)
|
||||
# Reference grid size
|
||||
self.assertEqual((codestream.segment[1].xsiz,
|
||||
codestream.segment[1].ysiz),
|
||||
image_size)
|
||||
# Reference grid offset
|
||||
self.assertEqual((codestream.segment[1].xosiz,
|
||||
codestream.segment[1].yosiz), (0, 0))
|
||||
# Tile size
|
||||
self.assertEqual((codestream.segment[1].xtsiz,
|
||||
codestream.segment[1].ytsiz),
|
||||
image_size)
|
||||
# Tile offset
|
||||
self.assertEqual((codestream.segment[1].xtosiz,
|
||||
codestream.segment[1].ytosiz),
|
||||
(0, 0))
|
||||
# bitdepth
|
||||
self.assertEqual(codestream.segment[1].bitdepth, (12, 12, 12))
|
||||
# signed
|
||||
self.assertEqual(codestream.segment[1].signed,
|
||||
(False, False, False))
|
||||
# subsampling
|
||||
self.assertEqual(list(zip(codestream.segment[1].xrsiz,
|
||||
codestream.segment[1].yrsiz)),
|
||||
[(1, 1)] * 3)
|
||||
|
||||
# COD: Coding style default
|
||||
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.CPRL)
|
||||
self.assertEqual(codestream.segment[2].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),
|
||||
(32, 32)) # cblksz
|
||||
|
||||
kwargs = {'rsiz': 4, 'xysiz': image_size, 'xyosiz': (0, 0),
|
||||
'xytsiz': image_size, 'xytosiz': (0, 0),
|
||||
'bitdepth': (12, 12, 12), 'signed': (False, False, False),
|
||||
'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
|
||||
self.verifySizSegment(c.segment[1], glymur.codestream.SIZsegment(**kwargs))
|
||||
|
||||
self.verify_cinema_cod(codestream.segment[2])
|
||||
|
||||
def check_cinema2k_codestream(self, codestream, image_size):
|
||||
"""Common out for cinema2k tests."""
|
||||
# SIZ: Image and tile size
|
||||
# Profile: "3" means cinema2K
|
||||
self.assertEqual(codestream.segment[1].rsiz, 3)
|
||||
# Reference grid size
|
||||
self.assertEqual((codestream.segment[1].xsiz,
|
||||
codestream.segment[1].ysiz),
|
||||
image_size)
|
||||
# Reference grid offset
|
||||
self.assertEqual((codestream.segment[1].xosiz,
|
||||
codestream.segment[1].yosiz), (0, 0))
|
||||
# Tile size
|
||||
self.assertEqual((codestream.segment[1].xtsiz,
|
||||
codestream.segment[1].ytsiz),
|
||||
image_size)
|
||||
# Tile offset
|
||||
self.assertEqual((codestream.segment[1].xtosiz,
|
||||
codestream.segment[1].ytosiz),
|
||||
(0, 0))
|
||||
# bitdepth
|
||||
self.assertEqual(codestream.segment[1].bitdepth, (12, 12, 12))
|
||||
# signed
|
||||
self.assertEqual(codestream.segment[1].signed,
|
||||
(False, False, False))
|
||||
# subsampling
|
||||
self.assertEqual(list(zip(codestream.segment[1].xrsiz,
|
||||
codestream.segment[1].yrsiz)),
|
||||
[(1, 1)] * 3)
|
||||
|
||||
# COD: Coding style default
|
||||
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.CPRL)
|
||||
self.assertEqual(codestream.segment[2].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),
|
||||
(32, 32)) # cblksz
|
||||
kwargs = {'rsiz': 3, 'xysiz': image_size, 'xyosiz': (0, 0),
|
||||
'xytsiz': image_size, 'xytosiz': (0, 0),
|
||||
'bitdepth': (12, 12, 12), 'signed': (False, False, False),
|
||||
'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
|
||||
self.verifySizSegment(c.segment[1], glymur.codestream.SIZsegment(**kwargs))
|
||||
|
||||
self.verify_cinema_cod(codestream.segment[2])
|
||||
|
||||
|
||||
@unittest.skipIf(NO_SKIMAGE_FREEIMAGE_SUPPORT,
|
||||
|
|
@ -274,7 +221,7 @@ class TestSuiteNegative2pointzero(unittest.TestCase):
|
|||
@unittest.skipIf(NO_READ_BACKEND, NO_READ_BACKEND_MSG)
|
||||
@unittest.skipIf(OPJ_DATA_ROOT is None,
|
||||
"OPJ_DATA_ROOT environment variable not set")
|
||||
class TestSuiteWrite(unittest.TestCase):
|
||||
class TestSuiteWrite(fixtures.MetadataBase):
|
||||
"""Tests for writing with openjp2 backend.
|
||||
|
||||
These tests either roughly correspond with those tests with similar names
|
||||
|
|
@ -308,60 +255,28 @@ class TestSuiteWrite(unittest.TestCase):
|
|||
j.write(data, cratios=[200, 100, 50])
|
||||
|
||||
# Should be three layers.
|
||||
codestream = j.get_codestream()
|
||||
c = j.get_codestream()
|
||||
|
||||
# SIZ: Image and tile size
|
||||
# Profile: "0" means profile 2
|
||||
self.assertEqual(codestream.segment[1].rsiz, 0)
|
||||
# Reference grid size
|
||||
self.assertEqual((codestream.segment[1].xsiz,
|
||||
codestream.segment[1].ysiz),
|
||||
(640, 480))
|
||||
# Reference grid offset
|
||||
self.assertEqual((codestream.segment[1].xosiz,
|
||||
codestream.segment[1].yosiz), (0, 0))
|
||||
# Tile size
|
||||
self.assertEqual((codestream.segment[1].xtsiz,
|
||||
codestream.segment[1].ytsiz),
|
||||
(640, 480))
|
||||
# Tile offset
|
||||
self.assertEqual((codestream.segment[1].xtosiz,
|
||||
codestream.segment[1].ytosiz),
|
||||
(0, 0))
|
||||
# bitdepth
|
||||
self.assertEqual(codestream.segment[1].bitdepth, (8, 8, 8))
|
||||
# signed
|
||||
self.assertEqual(codestream.segment[1].signed,
|
||||
(False, False, False))
|
||||
# subsampling
|
||||
self.assertEqual(list(zip(codestream.segment[1].xrsiz,
|
||||
codestream.segment[1].yrsiz)),
|
||||
[(1, 1)] * 3)
|
||||
kwargs = {'rsiz': 0, 'xysiz': (640, 480), 'xyosiz': (0, 0),
|
||||
'xytsiz': (640, 480), 'xytosiz': (0, 0),
|
||||
'bitdepth': (8, 8, 8), 'signed': (False, False, False),
|
||||
'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
|
||||
self.verifySizSegment(c.segment[1], glymur.codestream.SIZsegment(**kwargs))
|
||||
|
||||
# COD: Coding style default
|
||||
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(codestream.segment[2].spcod[7] & 0x01)
|
||||
# Reset context probabilities
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x02)
|
||||
# Termination on each coding pass
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x04)
|
||||
# Vertically causal context
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x08)
|
||||
# Predictable termination
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x0010)
|
||||
# Segmentation symbols
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x0020)
|
||||
self.assertEqual(codestream.segment[2].spcod[8],
|
||||
glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
|
||||
self.assertEqual(len(codestream.segment[2].spcod), 9)
|
||||
# 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),
|
||||
(64, 64)) # cblksz
|
||||
self.verify_codeblock_style(c.segment[2].spcod[7],
|
||||
[False, False, False, False, False, False])
|
||||
self.assertEqual(c.segment[2].spcod[8],
|
||||
glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
|
||||
self.assertEqual(len(c.segment[2].spcod), 9)
|
||||
|
||||
def test_NR_ENC_Bretagne1_ppm_2_encode(self):
|
||||
"""NR-ENC-Bretagne1.ppm-2-encode"""
|
||||
|
|
@ -374,34 +289,11 @@ class TestSuiteWrite(unittest.TestCase):
|
|||
# Should be three layers.
|
||||
codestream = j.get_codestream()
|
||||
|
||||
# SIZ: Image and tile size
|
||||
# Profile: "0" means profile 2
|
||||
self.assertEqual(codestream.segment[1].rsiz, 0)
|
||||
# Reference grid size
|
||||
self.assertEqual((codestream.segment[1].xsiz,
|
||||
codestream.segment[1].ysiz),
|
||||
(640, 480))
|
||||
# Reference grid offset
|
||||
self.assertEqual((codestream.segment[1].xosiz,
|
||||
codestream.segment[1].yosiz), (0, 0))
|
||||
# Tile size
|
||||
self.assertEqual((codestream.segment[1].xtsiz,
|
||||
codestream.segment[1].ytsiz),
|
||||
(640, 480))
|
||||
# Tile offset
|
||||
self.assertEqual((codestream.segment[1].xtosiz,
|
||||
codestream.segment[1].ytosiz),
|
||||
(0, 0))
|
||||
# bitdepth
|
||||
self.assertEqual(codestream.segment[1].bitdepth,
|
||||
(8, 8, 8))
|
||||
# signed
|
||||
self.assertEqual(codestream.segment[1].signed,
|
||||
(False, False, False))
|
||||
# subsampling
|
||||
self.assertEqual(list(zip(codestream.segment[1].xrsiz,
|
||||
codestream.segment[1].yrsiz)),
|
||||
[(1, 1)] * 3)
|
||||
kwargs = {'rsiz': 0, 'xysiz': (640, 480), 'xyosiz': (0, 0),
|
||||
'xytsiz': (640, 480), 'xytosiz': (0, 0),
|
||||
'bitdepth': (8, 8, 8), 'signed': (False, False, False),
|
||||
'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
|
||||
self.verifySizSegment(codestream.segment[1], glymur.codestream.SIZsegment(**kwargs))
|
||||
|
||||
# COD: Coding style default
|
||||
self.assertFalse(codestream.segment[2].scod & 2) # no sop
|
||||
|
|
@ -412,18 +304,8 @@ class TestSuiteWrite(unittest.TestCase):
|
|||
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(codestream.segment[2].spcod[7] & 0x01)
|
||||
# Reset context probabilities
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x02)
|
||||
# Termination on each coding pass
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x04)
|
||||
# Vertically causal context
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x08)
|
||||
# Predictable termination
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x0010)
|
||||
# Segmentation symbols
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x0020)
|
||||
self.verify_codeblock_style(codestream.segment[2].spcod[7],
|
||||
[False, False, False, False, False, False])
|
||||
self.assertEqual(codestream.segment[2].spcod[8],
|
||||
glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
|
||||
self.assertEqual(len(codestream.segment[2].spcod), 9)
|
||||
|
|
@ -440,33 +322,11 @@ class TestSuiteWrite(unittest.TestCase):
|
|||
# Should be three layers.
|
||||
codestream = j.get_codestream()
|
||||
|
||||
# SIZ: Image and tile size
|
||||
# Profile: "0" means profile 2
|
||||
self.assertEqual(codestream.segment[1].rsiz, 0)
|
||||
# Reference grid size
|
||||
self.assertEqual((codestream.segment[1].xsiz,
|
||||
codestream.segment[1].ysiz),
|
||||
(640, 480))
|
||||
# Reference grid offset
|
||||
self.assertEqual((codestream.segment[1].xosiz,
|
||||
codestream.segment[1].yosiz), (0, 0))
|
||||
# Tile size
|
||||
self.assertEqual((codestream.segment[1].xtsiz,
|
||||
codestream.segment[1].ytsiz),
|
||||
(640, 480))
|
||||
# Tile offset
|
||||
self.assertEqual((codestream.segment[1].xtosiz,
|
||||
codestream.segment[1].ytosiz),
|
||||
(0, 0))
|
||||
# bitdepth
|
||||
self.assertEqual(codestream.segment[1].bitdepth, (8, 8, 8))
|
||||
# signed
|
||||
self.assertEqual(codestream.segment[1].signed,
|
||||
(False, False, False))
|
||||
# subsampling
|
||||
self.assertEqual(list(zip(codestream.segment[1].xrsiz,
|
||||
codestream.segment[1].yrsiz)),
|
||||
[(1, 1)] * 3)
|
||||
kwargs = {'rsiz': 0, 'xysiz': (640, 480), 'xyosiz': (0, 0),
|
||||
'xytsiz': (640, 480), 'xytosiz': (0, 0),
|
||||
'bitdepth': (8, 8, 8), 'signed': (False, False, False),
|
||||
'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
|
||||
self.verifySizSegment(codestream.segment[1], glymur.codestream.SIZsegment(**kwargs))
|
||||
|
||||
# COD: Coding style default
|
||||
self.assertFalse(codestream.segment[2].scod & 2) # no sop
|
||||
|
|
@ -477,18 +337,8 @@ class TestSuiteWrite(unittest.TestCase):
|
|||
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(codestream.segment[2].spcod[7] & 0x01)
|
||||
# Reset context probabilities
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x02)
|
||||
# Termination on each coding pass
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x04)
|
||||
# Vertically causal context
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x08)
|
||||
# Predictable termination
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x0010)
|
||||
# Segmentation symbols
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x0020)
|
||||
self.verify_codeblock_style(codestream.segment[2].spcod[7],
|
||||
[False, False, False, False, False, False])
|
||||
self.assertEqual(codestream.segment[2].spcod[8],
|
||||
glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
|
||||
self.assertEqual(codestream.segment[2].precinct_size,
|
||||
|
|
@ -510,33 +360,11 @@ class TestSuiteWrite(unittest.TestCase):
|
|||
# Should be three layers.
|
||||
codestream = j.get_codestream()
|
||||
|
||||
# SIZ: Image and tile size
|
||||
# Profile: "0" means profile 2
|
||||
self.assertEqual(codestream.segment[1].rsiz, 0)
|
||||
# Reference grid size
|
||||
self.assertEqual((codestream.segment[1].xsiz,
|
||||
codestream.segment[1].ysiz),
|
||||
(data.shape[1], data.shape[0]))
|
||||
# Reference grid offset
|
||||
self.assertEqual((codestream.segment[1].xosiz,
|
||||
codestream.segment[1].yosiz), (0, 0))
|
||||
# Tile size. Reported as XY, not RC.
|
||||
self.assertEqual((codestream.segment[1].xtsiz,
|
||||
codestream.segment[1].ytsiz),
|
||||
(640, 480))
|
||||
# Tile offset
|
||||
self.assertEqual((codestream.segment[1].xtosiz,
|
||||
codestream.segment[1].ytosiz),
|
||||
(0, 0))
|
||||
# bitdepth
|
||||
self.assertEqual(codestream.segment[1].bitdepth, (8, 8, 8))
|
||||
# signed
|
||||
self.assertEqual(codestream.segment[1].signed,
|
||||
(False, False, False))
|
||||
# subsampling
|
||||
self.assertEqual(list(zip(codestream.segment[1].xrsiz,
|
||||
codestream.segment[1].yrsiz)),
|
||||
[(1, 1)] * 3)
|
||||
kwargs = {'rsiz': 0, 'xysiz': (2592, 1944), 'xyosiz': (0, 0),
|
||||
'xytsiz': (640, 480), 'xytosiz': (0, 0),
|
||||
'bitdepth': (8, 8, 8), 'signed': (False, False, False),
|
||||
'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
|
||||
self.verifySizSegment(codestream.segment[1], glymur.codestream.SIZsegment(**kwargs))
|
||||
|
||||
# COD: Coding style default
|
||||
self.assertFalse(codestream.segment[2].scod & 2) # no sop
|
||||
|
|
@ -547,18 +375,8 @@ class TestSuiteWrite(unittest.TestCase):
|
|||
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(codestream.segment[2].spcod[7] & 0x01)
|
||||
# Reset context probabilities
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x02)
|
||||
# Termination on each coding pass
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x04)
|
||||
# Vertically causal context
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x08)
|
||||
# Predictable termination
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x0010)
|
||||
# Segmentation symbols
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x0020)
|
||||
self.verify_codeblock_style(codestream.segment[2].spcod[7],
|
||||
[False, False, False, False, False, False])
|
||||
self.assertEqual(codestream.segment[2].spcod[8],
|
||||
glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
|
||||
self.assertEqual(codestream.segment[2].precinct_size,
|
||||
|
|
@ -574,33 +392,11 @@ class TestSuiteWrite(unittest.TestCase):
|
|||
|
||||
codestream = j.get_codestream()
|
||||
|
||||
# SIZ: Image and tile size
|
||||
# Profile: "0" means profile 2
|
||||
self.assertEqual(codestream.segment[1].rsiz, 0)
|
||||
# Reference grid size
|
||||
self.assertEqual((codestream.segment[1].xsiz,
|
||||
codestream.segment[1].ysiz),
|
||||
(data.shape[1], data.shape[0]))
|
||||
# Reference grid offset
|
||||
self.assertEqual((codestream.segment[1].xosiz,
|
||||
codestream.segment[1].yosiz), (0, 0))
|
||||
# Tile size
|
||||
self.assertEqual((codestream.segment[1].xtsiz,
|
||||
codestream.segment[1].ytsiz),
|
||||
(127, 127))
|
||||
# Tile offset
|
||||
self.assertEqual((codestream.segment[1].xtosiz,
|
||||
codestream.segment[1].ytosiz),
|
||||
(0, 0))
|
||||
# bitdepth
|
||||
self.assertEqual(codestream.segment[1].bitdepth, (8, 8, 8))
|
||||
# signed
|
||||
self.assertEqual(codestream.segment[1].signed,
|
||||
(False, False, False))
|
||||
# subsampling
|
||||
self.assertEqual(list(zip(codestream.segment[1].xrsiz,
|
||||
codestream.segment[1].yrsiz)),
|
||||
[(1, 1)] * 3)
|
||||
kwargs = {'rsiz': 0, 'xysiz': (2592, 1944), 'xyosiz': (0, 0),
|
||||
'xytsiz': (127, 127), 'xytosiz': (0, 0),
|
||||
'bitdepth': (8, 8, 8), 'signed': (False, False, False),
|
||||
'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
|
||||
self.verifySizSegment(codestream.segment[1], glymur.codestream.SIZsegment(**kwargs))
|
||||
|
||||
# COD: Coding style default
|
||||
self.assertFalse(codestream.segment[2].scod & 2) # no sop
|
||||
|
|
@ -611,18 +407,8 @@ class TestSuiteWrite(unittest.TestCase):
|
|||
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(codestream.segment[2].spcod[7] & 0x01)
|
||||
# Reset context probabilities
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x02)
|
||||
# Termination on each coding pass
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x04)
|
||||
# Vertically causal context
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x08)
|
||||
# Predictable termination
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x0010)
|
||||
# Segmentation symbols
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x0020)
|
||||
self.verify_codeblock_style(codestream.segment[2].spcod[7],
|
||||
[False, False, False, False, False, False])
|
||||
self.assertEqual(codestream.segment[2].spcod[8],
|
||||
glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
|
||||
self.assertEqual(len(codestream.segment[2].spcod), 9)
|
||||
|
|
@ -637,33 +423,11 @@ class TestSuiteWrite(unittest.TestCase):
|
|||
|
||||
codestream = j.get_codestream(header_only=False)
|
||||
|
||||
# SIZ: Image and tile size
|
||||
# Profile: "0" means profile 2
|
||||
self.assertEqual(codestream.segment[1].rsiz, 0)
|
||||
# Reference grid size
|
||||
self.assertEqual((codestream.segment[1].xsiz,
|
||||
codestream.segment[1].ysiz),
|
||||
(5183, 3887))
|
||||
# Reference grid offset
|
||||
self.assertEqual((codestream.segment[1].xosiz,
|
||||
codestream.segment[1].yosiz), (0, 0))
|
||||
# Tile size
|
||||
self.assertEqual((codestream.segment[1].xtsiz,
|
||||
codestream.segment[1].ytsiz),
|
||||
(5183, 3887))
|
||||
# Tile offset
|
||||
self.assertEqual((codestream.segment[1].xtosiz,
|
||||
codestream.segment[1].ytosiz),
|
||||
(0, 0))
|
||||
# bitdepth
|
||||
self.assertEqual(codestream.segment[1].bitdepth, (8, 8, 8))
|
||||
# signed
|
||||
self.assertEqual(codestream.segment[1].signed,
|
||||
(False, False, False))
|
||||
# subsampling
|
||||
self.assertEqual(list(zip(codestream.segment[1].xrsiz,
|
||||
codestream.segment[1].yrsiz)),
|
||||
[(2, 2)] * 3)
|
||||
kwargs = {'rsiz': 0, 'xysiz': (5183, 3887), 'xyosiz': (0, 0),
|
||||
'xytsiz': (5183, 3887), 'xytosiz': (0, 0),
|
||||
'bitdepth': (8, 8, 8), 'signed': (False, False, False),
|
||||
'xyrsiz': [(2, 2, 2), (2, 2, 2)]}
|
||||
self.verifySizSegment(codestream.segment[1], glymur.codestream.SIZsegment(**kwargs))
|
||||
|
||||
# COD: Coding style default
|
||||
self.assertTrue(codestream.segment[2].scod & 2) # sop
|
||||
|
|
@ -674,18 +438,8 @@ class TestSuiteWrite(unittest.TestCase):
|
|||
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(codestream.segment[2].spcod[7] & 0x01)
|
||||
# Reset context probabilities
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x02)
|
||||
# Termination on each coding pass
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x04)
|
||||
# Vertically causal context
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x08)
|
||||
# Predictable termination
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x0010)
|
||||
# Segmentation symbols
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x0020)
|
||||
self.verify_codeblock_style(codestream.segment[2].spcod[7],
|
||||
[False, False, False, False, False, False])
|
||||
self.assertEqual(codestream.segment[2].spcod[8],
|
||||
glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
|
||||
self.assertEqual(len(codestream.segment[2].spcod), 9)
|
||||
|
|
@ -705,33 +459,11 @@ class TestSuiteWrite(unittest.TestCase):
|
|||
|
||||
codestream = j.get_codestream(header_only=False)
|
||||
|
||||
# SIZ: Image and tile size
|
||||
# Profile: "0" means profile 2
|
||||
self.assertEqual(codestream.segment[1].rsiz, 0)
|
||||
# Reference grid size
|
||||
self.assertEqual((codestream.segment[1].xsiz,
|
||||
codestream.segment[1].ysiz),
|
||||
(2592, 1944))
|
||||
# Reference grid offset
|
||||
self.assertEqual((codestream.segment[1].xosiz,
|
||||
codestream.segment[1].yosiz), (0, 0))
|
||||
# Tile size
|
||||
self.assertEqual((codestream.segment[1].xtsiz,
|
||||
codestream.segment[1].ytsiz),
|
||||
(2592, 1944))
|
||||
# Tile offset
|
||||
self.assertEqual((codestream.segment[1].xtosiz,
|
||||
codestream.segment[1].ytosiz),
|
||||
(0, 0))
|
||||
# bitdepth
|
||||
self.assertEqual(codestream.segment[1].bitdepth, (8, 8, 8))
|
||||
# signed
|
||||
self.assertEqual(codestream.segment[1].signed,
|
||||
(False, False, False))
|
||||
# subsampling
|
||||
self.assertEqual(list(zip(codestream.segment[1].xrsiz,
|
||||
codestream.segment[1].yrsiz)),
|
||||
[(1, 1)] * 3)
|
||||
kwargs = {'rsiz': 0, 'xysiz': (2592, 1944), 'xyosiz': (0, 0),
|
||||
'xytsiz': (2592, 1944), 'xytosiz': (0, 0),
|
||||
'bitdepth': (8, 8, 8), 'signed': (False, False, False),
|
||||
'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
|
||||
self.verifySizSegment(codestream.segment[1], glymur.codestream.SIZsegment(**kwargs))
|
||||
|
||||
# COD: Coding style default
|
||||
self.assertFalse(codestream.segment[2].scod & 2) # no sop
|
||||
|
|
@ -742,18 +474,8 @@ class TestSuiteWrite(unittest.TestCase):
|
|||
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(codestream.segment[2].spcod[7] & 0x01)
|
||||
# RESET context probabilities (RESET)
|
||||
self.assertTrue(codestream.segment[2].spcod[7] & 0x02)
|
||||
# Termination on each coding pass, RESTART(TERMALL)
|
||||
self.assertTrue(codestream.segment[2].spcod[7] & 0x04)
|
||||
# Vertically causal context (VSC)
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x08)
|
||||
# Predictable termination, ERTERM(SEGTERM)
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x0010)
|
||||
# Segmentation symbols, SEGMARK(SEGSYSM)
|
||||
self.assertTrue(codestream.segment[2].spcod[7] & 0x0020)
|
||||
self.verify_codeblock_style(codestream.segment[2].spcod[7],
|
||||
[False, True, True, False, False, True])
|
||||
self.assertEqual(codestream.segment[2].spcod[8],
|
||||
glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
|
||||
self.assertEqual(len(codestream.segment[2].spcod), 9)
|
||||
|
|
@ -772,34 +494,11 @@ class TestSuiteWrite(unittest.TestCase):
|
|||
|
||||
codestream = j.get_codestream(header_only=False)
|
||||
|
||||
# SIZ: Image and tile size
|
||||
# Profile: "0" means profile 2
|
||||
self.assertEqual(codestream.segment[1].rsiz, 0)
|
||||
# Reference grid size
|
||||
self.assertEqual((codestream.segment[1].xsiz,
|
||||
codestream.segment[1].ysiz),
|
||||
(2742, 2244))
|
||||
# Reference grid offset
|
||||
self.assertEqual((codestream.segment[1].xosiz,
|
||||
codestream.segment[1].yosiz),
|
||||
(150, 300))
|
||||
# Tile size
|
||||
self.assertEqual((codestream.segment[1].xtsiz,
|
||||
codestream.segment[1].ytsiz),
|
||||
(2742, 2244))
|
||||
# Tile offset
|
||||
self.assertEqual((codestream.segment[1].xtosiz,
|
||||
codestream.segment[1].ytosiz),
|
||||
(0, 0))
|
||||
# bitdepth
|
||||
self.assertEqual(codestream.segment[1].bitdepth, (8, 8, 8))
|
||||
# signed
|
||||
self.assertEqual(codestream.segment[1].signed,
|
||||
(False, False, False))
|
||||
# subsampling
|
||||
self.assertEqual(list(zip(codestream.segment[1].xrsiz,
|
||||
codestream.segment[1].yrsiz)),
|
||||
[(1, 1)] * 3)
|
||||
kwargs = {'rsiz': 0, 'xysiz': (2742, 2244), 'xyosiz': (150, 300),
|
||||
'xytsiz': (2742, 2244), 'xytosiz': (0, 0),
|
||||
'bitdepth': (8, 8, 8), 'signed': (False, False, False),
|
||||
'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
|
||||
self.verifySizSegment(codestream.segment[1], glymur.codestream.SIZsegment(**kwargs))
|
||||
|
||||
# COD: Coding style default
|
||||
self.assertFalse(codestream.segment[2].scod & 2) # no sop
|
||||
|
|
@ -810,18 +509,8 @@ class TestSuiteWrite(unittest.TestCase):
|
|||
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(codestream.segment[2].spcod[7] & 0x01)
|
||||
# RESET context probabilities (RESET)
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x02)
|
||||
# Termination on each coding pass, RESTART(TERMALL)
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x04)
|
||||
# Vertically causal context (VSC)
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x08)
|
||||
# Predictable termination, ERTERM(SEGTERM)
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x0010)
|
||||
# Segmentation symbols, SEGMARK(SEGSYSM)
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x0020)
|
||||
self.verify_codeblock_style(codestream.segment[2].spcod[7],
|
||||
[False, False, False, False, False, False])
|
||||
self.assertEqual(codestream.segment[2].spcod[8],
|
||||
glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
|
||||
self.assertEqual(len(codestream.segment[2].spcod), 9)
|
||||
|
|
@ -836,33 +525,11 @@ class TestSuiteWrite(unittest.TestCase):
|
|||
|
||||
codestream = j.get_codestream(header_only=False)
|
||||
|
||||
# SIZ: Image and tile size
|
||||
# Profile: "0" means profile 2
|
||||
self.assertEqual(codestream.segment[1].rsiz, 0)
|
||||
# Reference grid size
|
||||
self.assertEqual((codestream.segment[1].xsiz,
|
||||
codestream.segment[1].ysiz),
|
||||
(2592, 1944))
|
||||
# Reference grid offset
|
||||
self.assertEqual((codestream.segment[1].xosiz,
|
||||
codestream.segment[1].yosiz), (0, 0))
|
||||
# Tile size
|
||||
self.assertEqual((codestream.segment[1].xtsiz,
|
||||
codestream.segment[1].ytsiz),
|
||||
(2592, 1944))
|
||||
# Tile offset
|
||||
self.assertEqual((codestream.segment[1].xtosiz,
|
||||
codestream.segment[1].ytosiz),
|
||||
(0, 0))
|
||||
# bitdepth
|
||||
self.assertEqual(codestream.segment[1].bitdepth, (8, 8, 8))
|
||||
# signed
|
||||
self.assertEqual(codestream.segment[1].signed,
|
||||
(False, False, False))
|
||||
# subsampling
|
||||
self.assertEqual(list(zip(codestream.segment[1].xrsiz,
|
||||
codestream.segment[1].yrsiz)),
|
||||
[(1, 1)] * 3)
|
||||
kwargs = {'rsiz': 0, 'xysiz': (2592, 1944), 'xyosiz': (0, 0),
|
||||
'xytsiz': (2592, 1944), 'xytosiz': (0, 0),
|
||||
'bitdepth': (8, 8, 8), 'signed': (False, False, False),
|
||||
'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
|
||||
self.verifySizSegment(codestream.segment[1], glymur.codestream.SIZsegment(**kwargs))
|
||||
|
||||
# COD: Coding style default
|
||||
self.assertFalse(codestream.segment[2].scod & 2) # no sop
|
||||
|
|
@ -873,18 +540,8 @@ class TestSuiteWrite(unittest.TestCase):
|
|||
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(codestream.segment[2].spcod[7] & 0x01)
|
||||
# RESET context probabilities (RESET)
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x02)
|
||||
# Termination on each coding pass, RESTART(TERMALL)
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x04)
|
||||
# Vertically causal context (VSC)
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x08)
|
||||
# Predictable termination, ERTERM(SEGTERM)
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x0010)
|
||||
# Segmentation symbols, SEGMARK(SEGSYSM)
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x0020)
|
||||
self.verify_codeblock_style(codestream.segment[2].spcod[7],
|
||||
[False, False, False, False, False, False])
|
||||
self.assertEqual(codestream.segment[2].spcod[8],
|
||||
glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
|
||||
self.assertEqual(len(codestream.segment[2].spcod), 9)
|
||||
|
|
@ -899,33 +556,11 @@ class TestSuiteWrite(unittest.TestCase):
|
|||
|
||||
codestream = j.get_codestream(header_only=False)
|
||||
|
||||
# SIZ: Image and tile size
|
||||
# Profile: "0" means profile 2
|
||||
self.assertEqual(codestream.segment[1].rsiz, 0)
|
||||
# Reference grid size
|
||||
self.assertEqual((codestream.segment[1].xsiz,
|
||||
codestream.segment[1].ysiz),
|
||||
(640, 480))
|
||||
# Reference grid offset
|
||||
self.assertEqual((codestream.segment[1].xosiz,
|
||||
codestream.segment[1].yosiz), (0, 0))
|
||||
# Tile size
|
||||
self.assertEqual((codestream.segment[1].xtsiz,
|
||||
codestream.segment[1].ytsiz),
|
||||
(640, 480))
|
||||
# Tile offset
|
||||
self.assertEqual((codestream.segment[1].xtosiz,
|
||||
codestream.segment[1].ytosiz),
|
||||
(0, 0))
|
||||
# bitdepth
|
||||
self.assertEqual(codestream.segment[1].bitdepth, (8, 8, 8))
|
||||
# signed
|
||||
self.assertEqual(codestream.segment[1].signed,
|
||||
(False, False, False))
|
||||
# subsampling
|
||||
self.assertEqual(list(zip(codestream.segment[1].xrsiz,
|
||||
codestream.segment[1].yrsiz)),
|
||||
[(1, 1)] * 3)
|
||||
kwargs = {'rsiz': 0, 'xysiz': (640, 480), 'xyosiz': (0, 0),
|
||||
'xytsiz': (640, 480), 'xytosiz': (0, 0),
|
||||
'bitdepth': (8, 8, 8), 'signed': (False, False, False),
|
||||
'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
|
||||
self.verifySizSegment(codestream.segment[1], glymur.codestream.SIZsegment(**kwargs))
|
||||
|
||||
# COD: Coding style default
|
||||
self.assertFalse(codestream.segment[2].scod & 2) # no sop
|
||||
|
|
@ -936,18 +571,8 @@ class TestSuiteWrite(unittest.TestCase):
|
|||
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(codestream.segment[2].spcod[7] & 0x01)
|
||||
# RESET context probabilities (RESET)
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x02)
|
||||
# Termination on each coding pass, RESTART(TERMALL)
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x04)
|
||||
# Vertically causal context (VSC)
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x08)
|
||||
# Predictable termination, ERTERM(SEGTERM)
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x0010)
|
||||
# Segmentation symbols, SEGMARK(SEGSYSM)
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x0020)
|
||||
self.verify_codeblock_style(codestream.segment[2].spcod[7],
|
||||
[False, False, False, False, False, False])
|
||||
self.assertEqual(codestream.segment[2].spcod[8],
|
||||
glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
|
||||
self.assertEqual(len(codestream.segment[2].spcod), 9)
|
||||
|
|
@ -994,34 +619,11 @@ class TestSuiteWrite(unittest.TestCase):
|
|||
|
||||
codestream = jp2.box[3].main_header
|
||||
|
||||
# SIZ: Image and tile size
|
||||
# Profile: "0" means profile 2
|
||||
self.assertEqual(codestream.segment[1].rsiz, 0)
|
||||
# Reference grid size
|
||||
self.assertEqual((codestream.segment[1].xsiz,
|
||||
codestream.segment[1].ysiz),
|
||||
(640, 480))
|
||||
# Reference grid offset
|
||||
self.assertEqual((codestream.segment[1].xosiz,
|
||||
codestream.segment[1].yosiz),
|
||||
(0, 0))
|
||||
# Tile size
|
||||
self.assertEqual((codestream.segment[1].xtsiz,
|
||||
codestream.segment[1].ytsiz),
|
||||
(640, 480))
|
||||
# Tile offset
|
||||
self.assertEqual((codestream.segment[1].xtosiz,
|
||||
codestream.segment[1].ytosiz),
|
||||
(0, 0))
|
||||
# bitdepth
|
||||
self.assertEqual(codestream.segment[1].bitdepth, (8, 8, 8))
|
||||
# signed
|
||||
self.assertEqual(codestream.segment[1].signed,
|
||||
(False, False, False))
|
||||
# subsampling
|
||||
self.assertEqual(list(zip(codestream.segment[1].xrsiz,
|
||||
codestream.segment[1].yrsiz)),
|
||||
[(1, 1)] * 3)
|
||||
kwargs = {'rsiz': 0, 'xysiz': (640, 480), 'xyosiz': (0, 0),
|
||||
'xytsiz': (640, 480), 'xytosiz': (0, 0),
|
||||
'bitdepth': (8, 8, 8), 'signed': (False, False, False),
|
||||
'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
|
||||
self.verifySizSegment(codestream.segment[1], glymur.codestream.SIZsegment(**kwargs))
|
||||
|
||||
# COD: Coding style default
|
||||
self.assertFalse(codestream.segment[2].scod & 2) # no sop
|
||||
|
|
@ -1032,18 +634,8 @@ class TestSuiteWrite(unittest.TestCase):
|
|||
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(codestream.segment[2].spcod[7] & 0x01)
|
||||
# RESET context probabilities (RESET)
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x02)
|
||||
# Termination on each coding pass, RESTART(TERMALL)
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x04)
|
||||
# Vertically causal context (VSC)
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x08)
|
||||
# Predictable termination, ERTERM(SEGTERM)
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x0010)
|
||||
# Segmentation symbols, SEGMARK(SEGSYSM)
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x0020)
|
||||
self.verify_codeblock_style(codestream.segment[2].spcod[7],
|
||||
[False, False, False, False, False, False])
|
||||
self.assertEqual(codestream.segment[2].spcod[8],
|
||||
glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
|
||||
self.assertEqual(len(codestream.segment[2].spcod), 9)
|
||||
|
|
@ -1060,32 +652,11 @@ class TestSuiteWrite(unittest.TestCase):
|
|||
|
||||
codestream = j.get_codestream(header_only=False)
|
||||
|
||||
# SIZ: Image and tile size
|
||||
# Profile: "0" means profile 2
|
||||
self.assertEqual(codestream.segment[1].rsiz, 0)
|
||||
# Reference grid size
|
||||
self.assertEqual((codestream.segment[1].xsiz,
|
||||
codestream.segment[1].ysiz),
|
||||
(1024, 1024))
|
||||
# Reference grid offset
|
||||
self.assertEqual((codestream.segment[1].xosiz,
|
||||
codestream.segment[1].yosiz), (0, 0))
|
||||
# Tile size
|
||||
self.assertEqual((codestream.segment[1].xtsiz,
|
||||
codestream.segment[1].ytsiz),
|
||||
(1024, 1024))
|
||||
# Tile offset
|
||||
self.assertEqual((codestream.segment[1].xtosiz,
|
||||
codestream.segment[1].ytosiz),
|
||||
(0, 0))
|
||||
# bitdepth
|
||||
self.assertEqual(codestream.segment[1].bitdepth, (16,))
|
||||
# signed
|
||||
self.assertEqual(codestream.segment[1].signed, (False,))
|
||||
# subsampling
|
||||
self.assertEqual(list(zip(codestream.segment[1].xrsiz,
|
||||
codestream.segment[1].yrsiz)),
|
||||
[(1, 1)])
|
||||
kwargs = {'rsiz': 0, 'xysiz': (1024, 1024), 'xyosiz': (0, 0),
|
||||
'xytsiz': (1024, 1024), 'xytosiz': (0, 0),
|
||||
'bitdepth': (16,), 'signed': (False,),
|
||||
'xyrsiz': [(1,), (1,)]}
|
||||
self.verifySizSegment(codestream.segment[1], glymur.codestream.SIZsegment(**kwargs))
|
||||
|
||||
# COD: Coding style default
|
||||
self.assertFalse(codestream.segment[2].scod & 2) # no sop
|
||||
|
|
@ -1096,18 +667,8 @@ class TestSuiteWrite(unittest.TestCase):
|
|||
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(codestream.segment[2].spcod[7] & 0x01)
|
||||
# RESET context probabilities (RESET)
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x02)
|
||||
# Termination on each coding pass, RESTART(TERMALL)
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x04)
|
||||
# Vertically causal context (VSC)
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x08)
|
||||
# Predictable termination, ERTERM(SEGTERM)
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x0010)
|
||||
# Segmentation symbols, SEGMARK(SEGSYSM)
|
||||
self.assertFalse(codestream.segment[2].spcod[7] & 0x0020)
|
||||
self.verify_codeblock_style(codestream.segment[2].spcod[7],
|
||||
[False, False, False, False, False, False])
|
||||
self.assertEqual(codestream.segment[2].spcod[8],
|
||||
glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
|
||||
self.assertEqual(len(codestream.segment[2].spcod), 9)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue