jyapayne/glymur
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

pep8 work

Browse source
This commit is contained in:
jevans 2014-12-22 23:20:48 -05:00 • committed by John Evans
commit 13cc6aa7e5
19 changed files with 822 additions and 925 deletions
Download patch file Download diff file Expand all files Collapse all files

2
glymur/lib/__init__.py
View file

@ -2,3 +2,5 @@
from . import openjp2 as openjp2 from . import openjp2 as openjp2
from . import openjpeg as openjpeg from . import openjpeg as openjpeg
from . import c from . import c
__all__ = [openjp2, openjpeg, c]

42
glymur/lib/config.py
View file

@ -19,18 +19,21 @@ else:
from configparser import NoOptionError from configparser import NoOptionError
# default library locations for MacPorts # default library locations for MacPorts
_macports_default_location = { _macports_default_location = {'openjp2': '/opt/local/lib/libopenjp2.dylib',
'openjp2': '/opt/local/lib/libopenjp2.dylib', 'openjpeg': '/opt/local/lib/libopenjpeg.dylib'}
'openjpeg': '/opt/local/lib/libopenjpeg.dylib'
}
# default library locations on Windows # default library locations on Windows
_windows_default_location = { _windows_default_location = {'openjp2': os.path.join('C:\\',
'openjp2': os.path.join('C:\\', 'Program files', 'OpenJPEG 2.0', 'Program files',
'bin', 'openjp2.dll'), 'OpenJPEG 2.0',
'openjpeg': os.path.join('C:\\', 'Program files', 'OpenJPEG 1.5', 'bin',
'bin', 'openjpeg.dll') 'openjp2.dll'),
} 'openjpeg': os.path.join('C:\\',
'Program files',
'OpenJPEG 1.5',
'bin',
'openjpeg.dll')}
def glymurrc_fname(): def glymurrc_fname():
"""Return the path to the configuration file. """Return the path to the configuration file.
@ -55,6 +58,7 @@ def glymurrc_fname():
# didn't find a configuration file. # didn't find a configuration file.
return None return None
def load_openjpeg_library(libname): def load_openjpeg_library(libname):
path = read_config_file(libname) path = read_config_file(libname)
@ -79,13 +83,15 @@ def load_openjpeg_library(libname):
return load_library_handle(path) return load_library_handle(path)
def load_library_handle(path): def load_library_handle(path):
"""Load the library, return the ctypes handle.""" """Load the library, return the ctypes handle."""
if path is None or path in ['None', 'none']: if path is None or path in ['None', 'none']:
# Either could not find a library via ctypes or user-configuration-file, # Either could not find a library via ctypes or
# or we could not find it in any of the default locations, or possibly # user-configuration-file, or we could not find it in any of the
# the user intentionally does not want one of the libraries to load. # default locations, or possibly the user intentionally does not want
# one of the libraries to load.
return None return None
try: try:
@ -94,10 +100,10 @@ def load_library_handle(path):
else: else:
opj_lib = ctypes.CDLL(path) opj_lib = ctypes.CDLL(path)
except (TypeError, OSError): except (TypeError, OSError):
msg = 'The library specified by configuration file at {0} could not be ' msg = 'The library specified by configuration file at {0} could not '
msg += 'loaded.' msg += 'be loaded.'
warnings.warn(msg.format(path), UserWarning) warnings.warn(msg.format(path), UserWarning)
opj_lib = None opj_lib = None
return opj_lib return opj_lib
@ -130,6 +136,7 @@ def read_config_file(libname):
path = None path = None
return path return path
def glymur_config(): def glymur_config():
""" """
Try to ascertain locations of openjp2, openjpeg libraries. Try to ascertain locations of openjp2, openjpeg libraries.
@ -147,6 +154,7 @@ def glymur_config():
warnings.warn(msg) warnings.warn(msg)
return tuple(lst) return tuple(lst)
def get_configdir(): def get_configdir():
"""Return string representing the configuration directory. """Return string representing the configuration directory.

40
glymur/lib/openjp2.py
View file

@ -410,7 +410,6 @@ class CompressionParametersType(ctypes.Structure):
for j in range(self.numpocs): for j in range(self.numpocs):
msg += " [#{0}]:".format(j) msg += " [#{0}]:".format(j)
msg += " {0}".format(str(self.poc[j])) msg += " {0}".format(str(self.poc[j]))
msg += textwrap.indent(textstr, ' ' * 12)
elif field_name in ['tcp_rates', 'tcp_distoratio']: elif field_name in ['tcp_rates', 'tcp_distoratio']:
lst = [] lst = []
@ -740,28 +739,6 @@ def encode(codec, stream):
OPENJP2.opj_encode(codec, stream) OPENJP2.opj_encode(codec, stream)
def get_cstr_info(codec):
"""get the codestream information from the codec
Wraps the openjp2 library function opj_get_cstr_info.
Parameters
----------
codec : CODEC_TYPE
The jpeg2000 codec.
Returns
-------
cstr_info_p : CodestreamInfoV2
Reference to codestream information.
"""
OPENJP2.opj_get_cstr_info.argtypes = [CODEC_TYPE]
OPENJP2.opj_get_cstr_info.restype = ctypes.POINTER(CodestreamInfoV2)
cstr_info_p = OPENJP2.opj_get_cstr_info(codec)
return cstr_info_p
def get_decoded_tile(codec, stream, imagep, tile_index): def get_decoded_tile(codec, stream, imagep, tile_index):
"""get the decoded tile from the codec """get the decoded tile from the codec
@ -792,23 +769,6 @@ def get_decoded_tile(codec, stream, imagep, tile_index):
OPENJP2.opj_get_decoded_tile(codec, stream, imagep, tile_index) OPENJP2.opj_get_decoded_tile(codec, stream, imagep, tile_index)
def destroy_cstr_info(cstr_info_p):
"""destroy codestream information after compression or decompression
Wraps the openjp2 library function opj_destroy_cstr_info.
Parameters
----------
cstr_info_p : CodestreamInfoV2 pointer
Pointer to codestream info structure.
"""
ARGTYPES = [ctypes.POINTER(ctypes.POINTER(CodestreamInfoV2))]
OPENJP2.opj_destroy_cstr_info.argtypes = ARGTYPES
OPENJP2.opj_destroy_cstr_info.restype = ctypes.c_void_p
OPENJP2.opj_destroy_cstr_info(ctypes.byref(cstr_info_p))
def end_compress(codec, stream): def end_compress(codec, stream):
"""End of compressing the current image. """End of compressing the current image.

50
glymur/lib/openjpeg.py
View file

@ -6,8 +6,6 @@
import ctypes import ctypes
import sys import sys
import numpy as np
from .config import glymur_config from .config import glymur_config
_, OPENJPEG = glymur_config() _, OPENJPEG = glymur_config()
@ -364,9 +362,9 @@ class DecompressionParametersType(ctypes.Structure):
class ImageComptParmType(ctypes.Structure): class ImageComptParmType(ctypes.Structure):
"""Component parameters structure used by the opj_image_create function. """Component parameters structure used by the opj_image_create function.
""" """
_fields_ = [# XRsiz: horizontal separation of a sample of ith component _fields_ = [("dx", ctypes.c_int),
# XRsiz: horizontal separation of a sample of ith component
# with respect to the reference grid # with respect to the reference grid
("dx", ctypes.c_int),
# YRsiz: vertical separation of a sample of ith component with # YRsiz: vertical separation of a sample of ith component with
# respect to the reference grid */ # respect to the reference grid */
@ -527,50 +525,6 @@ def destroy_decompress(dinfo):
OPENJPEG.opj_destroy_decompress(dinfo) OPENJPEG.opj_destroy_decompress(dinfo)
def image_cmptparm_t_from_np(np_image):
"""Return appropriate image_cmptparm_t based on given numpy array.
"""
try:
num_comps = np_image.shape[2]
except IndexError:
num_comps = 1
cmpt_parm_array_t = ImageCmptparmType * num_comps
tarr = cmpt_parm_array_t()
if np_image.dtype == np.uint8:
prec = 8
bpp = 8
sgnd = 0
elif np_image.dtype == np.int8:
prec = 8
bpp = 8
sgnd = 1
elif np_image.dtype == np.uint16:
prec = 16
bpp = 16
sgnd = 0
elif np_image.dtype == np.int16:
prec = 16
bpp = 16
sgnd = 1
else:
raise(TypeError("unhandled"))
for j in range(0, num_comps):
tarr[j].dx = 1
tarr[j].dy = 1
tarr[j].w = np_image.shape[1]
tarr[j].h = np_image.shape[0]
tarr[j].x0 = 0
tarr[j].y0 = 0
tarr[j].prec = prec
tarr[j].bpp = bpp
tarr[j].sgnd = sgnd
return(tarr)
def image_create(cmptparms, cspace): def image_create(cmptparms, cspace):
"""Wrapper for openjpeg library function opj_image_create. """Wrapper for openjpeg library function opj_image_create.
""" """

10
glymur/test/fixtures.py
View file

@ -37,6 +37,7 @@ elif re.match('1.[0-6]', six.__version__) is not None:
# Cannot reopen a named temporary file in windows. # Cannot reopen a named temporary file in windows.
WINDOWS_TMP_FILE_MSG = "cannot use NamedTemporaryFile like this in windows" WINDOWS_TMP_FILE_MSG = "cannot use NamedTemporaryFile like this in windows"
class MetadataBase(unittest.TestCase): class MetadataBase(unittest.TestCase):
""" """
Base class for testing metadata. Base class for testing metadata.
@ -101,8 +102,8 @@ class MetadataBase(unittest.TestCase):
""" """
verify the fields of a RGN segment verify the fields of a RGN segment
""" """
self.assertEqual(actual.crgn, expected.crgn) # 0 = component self.assertEqual(actual.crgn, expected.crgn) # 0 = component
self.assertEqual(actual.srgn, expected.srgn) # 0 = implicit self.assertEqual(actual.srgn, expected.srgn) # 0 = implicit
self.assertEqual(actual.sprgn, expected.sprgn) self.assertEqual(actual.sprgn, expected.sprgn)
def verifySOTsegment(self, actual, expected): def verifySOTsegment(self, actual, expected):
@ -126,7 +127,8 @@ class MetadataBase(unittest.TestCase):
Verify the fields of the SIZ segment. Verify the fields of the SIZ segment.
""" """
for field in ['rsiz', 'xsiz', 'ysiz', 'xosiz', 'yosiz', 'xtsiz', for field in ['rsiz', 'xsiz', 'ysiz', 'xosiz', 'yosiz', 'xtsiz',
'ytsiz', 'xtosiz', 'ytosiz', 'bitdepth', 'xrsiz', 'yrsiz']: 'ytsiz', 'xtosiz', 'ytosiz', 'bitdepth',
'xrsiz', 'yrsiz']:
self.assertEqual(getattr(actual, field), getattr(expected, field)) self.assertEqual(getattr(actual, field), getattr(expected, field))
def verifyImageHeaderBox(self, box1, box2): def verifyImageHeaderBox(self, box1, box2):
@ -600,7 +602,6 @@ Contiguous Codestream Box (jp2c) @ (3223, 1132296)
"Created by OpenJPEG version 2.0.0"''' "Created by OpenJPEG version 2.0.0"'''
nemo_with_codestream_header = dump.format(_indent(nemo_xmp)) nemo_with_codestream_header = dump.format(_indent(nemo_xmp))
#nemo_dump_full = dump.format(_indent(nemo_xmp))
nemo_dump_short = r"""JPEG 2000 Signature Box (jP ) @ (0, 12) nemo_dump_short = r"""JPEG 2000 Signature Box (jP ) @ (0, 12)
File Type Box (ftyp) @ (12, 20) File Type Box (ftyp) @ (12, 20)
@ -908,4 +909,3 @@ goodstuff_with_full_header = r"""Codestream:
Step size: [(0, 8), (0, 9), (0, 9), (0, 10), (0, 9), (0, 9), (0, 10), (0, 9), (0, 9), (0, 10), (0, 9), (0, 9), (0, 10), (0, 9), (0, 9), (0, 10)] Step size: [(0, 8), (0, 9), (0, 9), (0, 10), (0, 9), (0, 9), (0, 10), (0, 9), (0, 9), (0, 10), (0, 9), (0, 9), (0, 10), (0, 9), (0, 9), (0, 10)]
SOD marker segment @ (164, 0) SOD marker segment @ (164, 0)
EOC marker segment @ (115218, 0)""" EOC marker segment @ (115218, 0)"""

5
glymur/test/test_callbacks.py
View file

@ -25,6 +25,7 @@ import glymur
from .fixtures import WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG from .fixtures import WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG
class TestCallbacks(unittest.TestCase): class TestCallbacks(unittest.TestCase):
"""Test suite for callbacks.""" """Test suite for callbacks."""
@ -46,7 +47,7 @@ class TestCallbacks(unittest.TestCase):
tiledata = j.read(tile=0) tiledata = j.read(tile=0)
with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile: with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile:
with patch('sys.stdout', new=StringIO()) as fake_out: with patch('sys.stdout', new=StringIO()) as fake_out:
j = glymur.Jp2k(tfile.name, data=tiledata, verbose=True) glymur.Jp2k(tfile.name, data=tiledata, verbose=True)
actual = fake_out.getvalue().strip() actual = fake_out.getvalue().strip()
expected = '[INFO] tile number 1 / 1' expected = '[INFO] tile number 1 / 1'
self.assertEqual(actual, expected) self.assertEqual(actual, expected)
@ -60,7 +61,7 @@ class TestCallbacks(unittest.TestCase):
tiledata = j[:] tiledata = j[:]
with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile: with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile:
with patch('sys.stdout', new=StringIO()) as fake_out: with patch('sys.stdout', new=StringIO()) as fake_out:
jp2 = glymur.Jp2k(tfile.name, data=tiledata, verbose=True) glymur.Jp2k(tfile.name, data=tiledata, verbose=True)
actual = fake_out.getvalue().strip() actual = fake_out.getvalue().strip()
expected = '[INFO] tile number 1 / 1' expected = '[INFO] tile number 1 / 1'
self.assertEqual(actual, expected) self.assertEqual(actual, expected)

23
glymur/test/test_config.py
View file

@ -26,17 +26,18 @@ else:
import glymur import glymur
from glymur import Jp2k from glymur import Jp2k
from .fixtures import ( from .fixtures import (WARNING_INFRASTRUCTURE_ISSUE,
WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG, WARNING_INFRASTRUCTURE_MSG,
WINDOWS_TMP_FILE_MSG WINDOWS_TMP_FILE_MSG)
)
def openjpeg_not_found_by_ctypes(): def openjpeg_not_found_by_ctypes():
""" """
Need to know if openjpeg library can be picked right up by ctypes for one Need to know if openjpeg library can be picked right up by ctypes for one
of the tests. of the tests.
""" """
with patch.dict('os.environ', {'DYLD_FALLBACK_LIBRARY_PATH': '/opt/local/lib'}): with patch.dict('os.environ',
{'DYLD_FALLBACK_LIBRARY_PATH': '/opt/local/lib'}):
if ctypes.util.find_library('openjpeg') is None: if ctypes.util.find_library('openjpeg') is None:
return True return True
else: else:
@ -130,7 +131,7 @@ class TestSuite(unittest.TestCase):
"Needs openjp2 and openjpeg before this test make sense.") "Needs openjp2 and openjpeg before this test make sense.")
@unittest.skipIf(os.name == "nt", WINDOWS_TMP_FILE_MSG) @unittest.skipIf(os.name == "nt", WINDOWS_TMP_FILE_MSG)
def test_library_specified_as_None(self): def test_library_specified_as_None(self):
"""Verify that we can stop a library from being loaded by using None.""" """Verify that we can stop library from being loaded by using None."""
with tempfile.TemporaryDirectory() as tdir: with tempfile.TemporaryDirectory() as tdir:
configdir = os.path.join(tdir, 'glymur') configdir = os.path.join(tdir, 'glymur')
os.mkdir(configdir) os.mkdir(configdir)
@ -140,7 +141,9 @@ class TestSuite(unittest.TestCase):
# openjpeg instead. # openjpeg instead.
fptr.write('[library]\n') fptr.write('[library]\n')
fptr.write('openjp2: None\n') fptr.write('openjp2: None\n')
fptr.write('openjpeg: {0}\n'.format(glymur.lib.openjp2.OPENJPEG._name)) msg = 'openjpeg: {0}\n'
msg = msg.format(glymur.lib.openjp2.OPENJPEG._name)
fptr.write(msg)
fptr.flush() fptr.flush()
with patch.dict('os.environ', {'XDG_CONFIG_HOME': tdir}): with patch.dict('os.environ', {'XDG_CONFIG_HOME': tdir}):
imp.reload(glymur.lib.openjp2) imp.reload(glymur.lib.openjp2)
@ -150,17 +153,16 @@ class TestSuite(unittest.TestCase):
@unittest.skipIf(glymur.lib.openjp2.OPENJPEG is None, @unittest.skipIf(glymur.lib.openjp2.OPENJPEG is None,
"Needs openjpeg before this test make sense.") "Needs openjpeg before this test make sense.")
@unittest.skipIf(openjpeg_not_found_by_ctypes(), @unittest.skipIf(openjpeg_not_found_by_ctypes(),
"OpenJPEG must be easily found before this test can work.") "OpenJPEG must be found before this test can work.")
@unittest.skipIf(os.name == "nt", WINDOWS_TMP_FILE_MSG) @unittest.skipIf(os.name == "nt", WINDOWS_TMP_FILE_MSG)
def test_config_dir_but_no_config_file(self): def test_config_dir_but_no_config_file(self):
with tempfile.TemporaryDirectory() as tdir: with tempfile.TemporaryDirectory() as tdir:
configdir = os.path.join(tdir, 'glymur') configdir = os.path.join(tdir, 'glymur')
os.mkdir(configdir) os.mkdir(configdir)
fname = os.path.join(configdir, 'glymurrc')
with patch.dict('os.environ', {'XDG_CONFIG_HOME': tdir}): with patch.dict('os.environ', {'XDG_CONFIG_HOME': tdir}):
# Should still be able to load openjpeg, despite the # Should still be able to load openjpeg, despite the
# configuration file being empty. # configuration file not being there
imp.reload(glymur.lib.openjpeg) imp.reload(glymur.lib.openjpeg)
self.assertIsNotNone(glymur.lib.openjp2.OPENJPEG) self.assertIsNotNone(glymur.lib.openjp2.OPENJPEG)
@ -178,4 +180,3 @@ class TestSuite(unittest.TestCase):
# Should be able to load openjp2 as before. # Should be able to load openjp2 as before.
imp.reload(glymur.lib.openjp2) imp.reload(glymur.lib.openjp2)
self.assertEqual(glymur.lib.openjp2.OPENJP2._name, libloc) self.assertEqual(glymur.lib.openjp2.OPENJP2._name, libloc)

17
glymur/test/test_glymur_warnings.py
View file

@ -5,22 +5,19 @@ Test suite for warnings issued by glymur.
# unittest doesn't work well with R0904. # unittest doesn't work well with R0904.
# pylint: disable=R0904 # pylint: disable=R0904
import platform
import os import os
import re import re
import struct import struct
import sys
import tempfile import tempfile
import unittest import unittest
import six
from glymur import Jp2k from glymur import Jp2k
import glymur import glymur
from .fixtures import opj_data_file, OPJ_DATA_ROOT from .fixtures import opj_data_file, OPJ_DATA_ROOT
from .fixtures import WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG from .fixtures import WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG
@unittest.skipIf(OPJ_DATA_ROOT is None, @unittest.skipIf(OPJ_DATA_ROOT is None,
"OPJ_DATA_ROOT environment variable not set") "OPJ_DATA_ROOT environment variable not set")
@unittest.skipIf(WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG) @unittest.skipIf(WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG)
@ -53,12 +50,11 @@ class TestWarnings(unittest.TestCase):
""" """
relpath = 'input/nonregression/issue188_beach_64bitsbox.jp2' relpath = 'input/nonregression/issue188_beach_64bitsbox.jp2'
jfile = opj_data_file(relpath) jfile = opj_data_file(relpath)
regex = re.compile(r"""Unrecognized\sbox\s\(b'XML\s'\)\sencountered.""", pattern = r"""Unrecognized\sbox\s\(b'XML\s'\)\sencountered."""
re.VERBOSE) regex = re.compile(pattern, re.VERBOSE)
with self.assertWarnsRegex(UserWarning, regex): with self.assertWarnsRegex(UserWarning, regex):
Jp2k(jfile) Jp2k(jfile)
def test_NR_gdal_fuzzer_unchecked_numresolutions_dump(self): def test_NR_gdal_fuzzer_unchecked_numresolutions_dump(self):
""" """
Has an invalid number of resolutions. Has an invalid number of resolutions.
@ -119,7 +115,7 @@ class TestWarnings(unittest.TestCase):
\(\d+\)''', \(\d+\)''',
re.VERBOSE) re.VERBOSE)
with self.assertWarnsRegex(UserWarning, regex): with self.assertWarnsRegex(UserWarning, regex):
jp2 = Jp2k(jfile) Jp2k(jfile)
def test_NR_broken2_jp2_dump(self): def test_NR_broken2_jp2_dump(self):
""" """
@ -152,7 +148,8 @@ class TestWarnings(unittest.TestCase):
def test_tile_height_is_zero(self): def test_tile_height_is_zero(self):
"""Zero tile height should not cause an exception.""" """Zero tile height should not cause an exception."""
filename = opj_data_file('input/nonregression/2539.pdf.SIGFPE.706.1712.jp2') filename = 'input/nonregression/2539.pdf.SIGFPE.706.1712.jp2'
filename = opj_data_file(filename)
with self.assertWarnsRegex(UserWarning, 'Invalid tile dimensions'): with self.assertWarnsRegex(UserWarning, 'Invalid tile dimensions'):
Jp2k(filename) Jp2k(filename)
@ -179,7 +176,7 @@ class TestWarnings(unittest.TestCase):
tfile.flush() tfile.flush()
with self.assertWarnsRegex(UserWarning, 'Unrecognized marker'): with self.assertWarnsRegex(UserWarning, 'Unrecognized marker'):
codestream = Jp2k(tfile.name).get_codestream() Jp2k(tfile.name).get_codestream()
if __name__ == "__main__": if __name__ == "__main__":

2
glymur/test/test_icc.py
View file

@ -6,8 +6,6 @@ ICC profile tests.
# pylint: disable=R0904 # pylint: disable=R0904
import datetime import datetime
import os
import sys
import unittest import unittest
import numpy as np import numpy as np

56
glymur/test/test_jp2box.py
View file

@ -35,10 +35,10 @@ from glymur.jp2box import JPEG2000SignatureBox
from glymur.core import COLOR, OPACITY from glymur.core import COLOR, OPACITY
from glymur.core import RED, GREEN, BLUE, GREY, WHOLE_IMAGE from glymur.core import RED, GREEN, BLUE, GREY, WHOLE_IMAGE
from .fixtures import ( from .fixtures import (WARNING_INFRASTRUCTURE_ISSUE,
WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG, WARNING_INFRASTRUCTURE_MSG,
WINDOWS_TMP_FILE_MSG, MetadataBase WINDOWS_TMP_FILE_MSG, MetadataBase)
)
def load_tests(loader, tests, ignore): def load_tests(loader, tests, ignore):
"""Run doc tests as well.""" """Run doc tests as well."""
@ -48,13 +48,15 @@ def load_tests(loader, tests, ignore):
tests.addTests(doctest.DocTestSuite('glymur.jp2box')) tests.addTests(doctest.DocTestSuite('glymur.jp2box'))
return tests return tests
@unittest.skipIf(os.name == "nt", WINDOWS_TMP_FILE_MSG) @unittest.skipIf(os.name == "nt", WINDOWS_TMP_FILE_MSG)
class TestDataEntryURL(unittest.TestCase): class TestDataEntryURL(unittest.TestCase):
"""Test suite for DataEntryURL boxes.""" """Test suite for DataEntryURL boxes."""
def setUp(self): def setUp(self):
self.jp2file = glymur.data.nemo() self.jp2file = glymur.data.nemo()
@unittest.skipIf(re.match("1.5|2", glymur.version.openjpeg_version) is None, @unittest.skipIf(re.match("1.5|2",
glymur.version.openjpeg_version) is None,
"Must have openjpeg 1.5 or higher to run") "Must have openjpeg 1.5 or higher to run")
def test_wrap_greyscale(self): def test_wrap_greyscale(self):
"""A single component should be wrapped as GREYSCALE.""" """A single component should be wrapped as GREYSCALE."""
@ -70,7 +72,7 @@ class TestDataEntryURL(unittest.TestCase):
with tempfile.NamedTemporaryFile(suffix=".jp2") as tfile2: with tempfile.NamedTemporaryFile(suffix=".jp2") as tfile2:
jp2 = j2k.wrap(tfile2.name) jp2 = j2k.wrap(tfile2.name)
self.assertEqual(jp2.box[2].box[1].colorspace, self.assertEqual(jp2.box[2].box[1].colorspace,
glymur.core.GREYSCALE) glymur.core.GREYSCALE)
def test_basic_url(self): def test_basic_url(self):
"""Just your most basic URL box.""" """Just your most basic URL box."""
@ -92,7 +94,7 @@ class TestDataEntryURL(unittest.TestCase):
self.assertEqual(jp22.box[4].url, url) self.assertEqual(jp22.box[4].url, url)
def test_null_termination(self): def test_null_termination(self):
"""I.9.3.2 specifies that the location field must be null terminated.""" """I.9.3.2 specifies that location field must be null terminated."""
jp2 = Jp2k(self.jp2file) jp2 = Jp2k(self.jp2file)
url = 'http://glymur.readthedocs.org' url = 'http://glymur.readthedocs.org'
@ -104,11 +106,14 @@ class TestDataEntryURL(unittest.TestCase):
self.assertEqual(jp22.box[-1].length, 42) self.assertEqual(jp22.box[-1].length, 42)
# Go to the last box. Seek past the L, T, version, and flag fields. # Go to the last box. Seek past the L, T, version,
# and flag fields.
with open(tfile.name, 'rb') as fptr: with open(tfile.name, 'rb') as fptr:
fptr.seek(jp22.box[-1].offset + 4 + 4 + 1 + 3) fptr.seek(jp22.box[-1].offset + 4 + 4 + 1 + 3)
nbytes = jp22.box[-1].offset + jp22.box[-1].length - fptr.tell() nbytes = (jp22.box[-1].offset +
jp22.box[-1].length -
fptr.tell())
read_buffer = fptr.read(nbytes) read_buffer = fptr.read(nbytes)
read_url = read_buffer.decode('utf-8') read_url = read_buffer.decode('utf-8')
self.assertEqual(url + chr(0), read_url) self.assertEqual(url + chr(0), read_url)
@ -128,18 +133,18 @@ class TestChannelDefinition(unittest.TestCase):
data = j2k[:] data = j2k[:]
# Write the first component back out to file. # Write the first component back out to file.
with tempfile.NamedTemporaryFile(suffix=".j2k", delete=False) as tfile: with tempfile.NamedTemporaryFile(suffix=".j2k", delete=False) as tfile:
grey_j2k = Jp2k(tfile.name, data=data[:, :, 0]) Jp2k(tfile.name, data=data[:, :, 0])
cls.one_plane = tfile.name cls.one_plane = tfile.name
# Write the first two components back out to file. # Write the first two components back out to file.
with tempfile.NamedTemporaryFile(suffix=".j2k", delete=False) as tfile: with tempfile.NamedTemporaryFile(suffix=".j2k", delete=False) as tfile:
grey_j2k = Jp2k(tfile.name, data=data[:, :, 0:1]) Jp2k(tfile.name, data=data[:, :, 0:1])
cls.two_planes = tfile.name cls.two_planes = tfile.name
# Write four components back out to file. # Write four components back out to file.
with tempfile.NamedTemporaryFile(suffix=".j2k", delete=False) as tfile: with tempfile.NamedTemporaryFile(suffix=".j2k", delete=False) as tfile:
shape = (data.shape[0], data.shape[1], 1) shape = (data.shape[0], data.shape[1], 1)
alpha = np.zeros((shape), dtype=data.dtype) alpha = np.zeros((shape), dtype=data.dtype)
data4 = np.concatenate((data, alpha), axis=2) data4 = np.concatenate((data, alpha), axis=2)
rgba_jp2 = Jp2k(tfile.name, data=data4) Jp2k(tfile.name, data=data4)
cls.four_planes = tfile.name cls.four_planes = tfile.name
@classmethod @classmethod
@ -404,6 +409,7 @@ class TestFileTypeBox(unittest.TestCase):
with tempfile.TemporaryFile() as tfile: with tempfile.TemporaryFile() as tfile:
ftyp.write(tfile) ftyp.write(tfile)
class TestColourSpecificationBox(unittest.TestCase): class TestColourSpecificationBox(unittest.TestCase):
"""Test suite for colr box instantiation.""" """Test suite for colr box instantiation."""
@ -525,8 +531,8 @@ class TestPaletteBox(unittest.TestCase):
bps = (8, 8, 8) bps = (8, 8, 8)
signed = (False, False) signed = (False, False)
with self.assertWarns(UserWarning): with self.assertWarns(UserWarning):
pclr = glymur.jp2box.PaletteBox(palette, bits_per_component=bps, glymur.jp2box.PaletteBox(palette, bits_per_component=bps,
signed=signed) signed=signed)
@unittest.skipIf(WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG) @unittest.skipIf(WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG)
def test_mismatched_signed_palette(self): def test_mismatched_signed_palette(self):
@ -535,8 +541,8 @@ class TestPaletteBox(unittest.TestCase):
bps = (8, 8, 8, 8) bps = (8, 8, 8, 8)
signed = (False, False, False, False) signed = (False, False, False, False)
with self.assertWarns(UserWarning): with self.assertWarns(UserWarning):
pclr = glymur.jp2box.PaletteBox(palette, bits_per_component=bps, glymur.jp2box.PaletteBox(palette, bits_per_component=bps,
signed=signed) signed=signed)
def test_writing_with_different_bitdepths(self): def test_writing_with_different_bitdepths(self):
"""Bitdepths must be the same when writing.""" """Bitdepths must be the same when writing."""
@ -792,7 +798,7 @@ class TestWrap(unittest.TestCase):
# list to trigger the error. # list to trigger the error.
boxes[2].box = [] boxes[2].box = []
with self.assertRaises(IOError): with self.assertRaises(IOError):
jp22 = jp2.wrap(tfile.name, boxes=boxes) jp2.wrap(tfile.name, boxes=boxes)
def test_default_layout_with_boxes(self): def test_default_layout_with_boxes(self):
"""basic test for rewrapping a jp2 file, boxes specified""" """basic test for rewrapping a jp2 file, boxes specified"""
@ -857,8 +863,8 @@ class TestWrap(unittest.TestCase):
"""A palette box must reside in a JP2 header box.""" """A palette box must reside in a JP2 header box."""
palette = np.array([[255, 0, 255], [0, 255, 0]], dtype=np.int32) palette = np.array([[255, 0, 255], [0, 255, 0]], dtype=np.int32)
bps = (8, 8, 8) bps = (8, 8, 8)
signed = (True, False, True) pclr = glymur.jp2box.PaletteBox(palette=palette,
pclr = glymur.jp2box.PaletteBox(palette=palette, bits_per_component=bps, bits_per_component=bps,
signed=(True, False, True)) signed=(True, False, True))
j2k = Jp2k(self.j2kfile) j2k = Jp2k(self.j2kfile)
@ -970,7 +976,8 @@ class TestWrap(unittest.TestCase):
"""Rewrap a jpx file.""" """Rewrap a jpx file."""
with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile1: with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile1:
jpx = Jp2k(self.jpxfile) jpx = Jp2k(self.jpxfile)
idx = list(range(5)) + list(range(9, 12)) + list(range(6, 9)) + [12] idx = (list(range(5)) +
list(range(9, 12)) + list(range(6, 9))) + [12]
boxes = [jpx.box[j] for j in idx] boxes = [jpx.box[j] for j in idx]
jpx2 = jpx.wrap(tfile1.name, boxes=boxes) jpx2 = jpx.wrap(tfile1.name, boxes=boxes)
exp_ids = [box.box_id for box in boxes] exp_ids = [box.box_id for box in boxes]
@ -1026,7 +1033,7 @@ class TestJp2Boxes(unittest.TestCase):
def test_codestream_main_header_offset(self): def test_codestream_main_header_offset(self):
"""main_header_offset is an attribute of the CCS box""" """main_header_offset is an attribute of the CCS box"""
j = Jp2k(self.jpxfile); j = Jp2k(self.jpxfile)
self.assertEqual(j.box[5].main_header_offset, self.assertEqual(j.box[5].main_header_offset,
j.box[5].offset + 8) j.box[5].offset + 8)
@ -1240,7 +1247,6 @@ class TestRepr(MetadataBase):
"""Verify Palette box repr.""" """Verify Palette box repr."""
palette = np.array([[255, 0, 1000], [0, 255, 0]], dtype=np.int32) palette = np.array([[255, 0, 1000], [0, 255, 0]], dtype=np.int32)
bps = (8, 8, 16) bps = (8, 8, 16)
signed = (True, False, True)
box = glymur.jp2box.PaletteBox(palette=palette, bits_per_component=bps, box = glymur.jp2box.PaletteBox(palette=palette, bits_per_component=bps,
signed=(True, False, True)) signed=(True, False, True))
@ -1290,7 +1296,8 @@ class TestRepr(MetadataBase):
# Since the raw_data parameter is a sequence of bytes which could be # Since the raw_data parameter is a sequence of bytes which could be
# quite long, don't bother trying to make it conform to eval(repr()). # quite long, don't bother trying to make it conform to eval(repr()).
regexp = r"""glymur.jp2box.UUIDBox\(""" regexp = r"""glymur.jp2box.UUIDBox\("""
regexp += """the_uuid=UUID\('00000000-0000-0000-0000-000000000000'\),\s""" regexp += """the_uuid="""
regexp += """UUID\('00000000-0000-0000-0000-000000000000'\),\s"""
regexp += """raw_data=<byte\sarray\s10\selements>\)""" regexp += """raw_data=<byte\sarray\s10\selements>\)"""
if sys.hexversion < 0x03000000: if sys.hexversion < 0x03000000:
@ -1307,7 +1314,8 @@ class TestRepr(MetadataBase):
# Since the raw_data parameter is a sequence of bytes which could be # Since the raw_data parameter is a sequence of bytes which could be
# quite long, don't bother trying to make it conform to eval(repr()). # quite long, don't bother trying to make it conform to eval(repr()).
regexp = r"""glymur.jp2box.UUIDBox\(""" regexp = r"""glymur.jp2box.UUIDBox\("""
regexp += """the_uuid=UUID\('be7acfcb-97a9-42e8-9c71-999491e3afac'\),\s""" regexp += """the_uuid="""
regexp += """UUID\('be7acfcb-97a9-42e8-9c71-999491e3afac'\),\s"""
regexp += """raw_data=<byte\sarray\s3122\selements>\)""" regexp += """raw_data=<byte\sarray\s3122\selements>\)"""
if sys.hexversion < 0x03000000: if sys.hexversion < 0x03000000:

11
glymur/test/test_jp2box_jpx.py
View file

@ -6,7 +6,6 @@ Test suite specifically targeting JPX box layout.
import ctypes import ctypes
import os import os
import struct import struct
import sys
import tempfile import tempfile
import unittest import unittest
@ -20,6 +19,7 @@ from glymur.jp2box import ColourSpecificationBox
from .fixtures import WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG from .fixtures import WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG
@unittest.skipIf(os.name == "nt", "Temporary file issue on window.") @unittest.skipIf(os.name == "nt", "Temporary file issue on window.")
class TestJPXWrap(unittest.TestCase): class TestJPXWrap(unittest.TestCase):
"""Test suite for wrapping JPX files.""" """Test suite for wrapping JPX files."""
@ -184,7 +184,7 @@ class TestJPXWrap(unittest.TestCase):
with tempfile.NamedTemporaryFile(suffix=".jpx") as tfile: with tempfile.NamedTemporaryFile(suffix=".jpx") as tfile:
with self.assertRaises(IOError): with self.assertRaises(IOError):
jpx = jp2.wrap(tfile.name, boxes=boxes) jp2.wrap(tfile.name, boxes=boxes)
def test_cgrp_neg(self): def test_cgrp_neg(self):
"""Can't write a cgrp with anything but colr sub boxes""" """Can't write a cgrp with anything but colr sub boxes"""
@ -204,7 +204,7 @@ class TestJPXWrap(unittest.TestCase):
with tempfile.NamedTemporaryFile(suffix=".jpx") as tfile: with tempfile.NamedTemporaryFile(suffix=".jpx") as tfile:
with self.assertRaises(IOError): with self.assertRaises(IOError):
jpx = jp2.wrap(tfile.name, boxes=boxes) jp2.wrap(tfile.name, boxes=boxes)
def test_ftbl(self): def test_ftbl(self):
"""Write a fragment table box.""" """Write a fragment table box."""
@ -484,7 +484,7 @@ class TestJPX(unittest.TestCase):
ftbl.write(tfile) ftbl.write(tfile)
def test_data_reference_requires_dtbl(self): def test_data_reference_requires_dtbl(self):
"""The existance of a data reference box requires a ftbl box as well.""" """The existance of data reference box requires a ftbl box as well."""
flag = 0 flag = 0
version = (0, 0, 0) version = (0, 0, 0)
url1 = 'file:////usr/local/bin' url1 = 'file:////usr/local/bin'
@ -574,7 +574,7 @@ class TestJPX(unittest.TestCase):
131072, 65536, 32768, 16384, 8192] 131072, 65536, 32768, 16384, 8192]
for j in range(len(standard_flags)): for j in range(len(standard_flags)):
mask = (standard_masks[j] >> 16, mask = (standard_masks[j] >> 16,
standard_masks[j] & 0x0000ffff>> 8, standard_masks[j] & 0x0000ffff >> 8,
standard_masks[j] & 0x000000ff) standard_masks[j] & 0x000000ff)
struct.pack_into('>HBBB', rreq_buffer, 17 + j * 5, struct.pack_into('>HBBB', rreq_buffer, 17 + j * 5,
standard_flags[j], *mask) standard_flags[j], *mask)
@ -599,7 +599,6 @@ class TestJPX(unittest.TestCase):
self.assertEqual(jpx.box[2].standard_flag, self.assertEqual(jpx.box[2].standard_flag,
(5, 42, 45, 2, 18, 19, 1, 8, 12, 31, 20)) (5, 42, 45, 2, 18, 19, 1, 8, 12, 31, 20))
def test_nlst(self): def test_nlst(self):
"""Verify that we can handle a number list box.""" """Verify that we can handle a number list box."""
j = Jp2k(self.jpxfile) j = Jp2k(self.jpxfile)

22
glymur/test/test_jp2box_uuid.py
View file

@ -11,7 +11,6 @@
# pylint: disable=R0904 # pylint: disable=R0904
import os import os
import re
import shutil import shutil
import struct import struct
import sys import sys
@ -23,29 +22,15 @@ if sys.hexversion < 0x02070000:
else: else:
import unittest import unittest
if sys.hexversion < 0x03000000:
from StringIO import StringIO
else:
from io import StringIO
if sys.hexversion <= 0x03030000:
from mock import patch
else:
from unittest.mock import patch
import lxml.etree import lxml.etree
from .fixtures import (HAS_PYTHON_XMP_TOOLKIT, OPJ_DATA_ROOT, from .fixtures import (WARNING_INFRASTRUCTURE_ISSUE,
WARNING_INFRASTRUCTURE_ISSUE,
WARNING_INFRASTRUCTURE_MSG, WARNING_INFRASTRUCTURE_MSG,
WINDOWS_TMP_FILE_MSG) WINDOWS_TMP_FILE_MSG)
if HAS_PYTHON_XMP_TOOLKIT:
from libxmp import XMPMeta
import glymur import glymur
from glymur import Jp2k from glymur import Jp2k
from .fixtures import OPJ_DATA_ROOT, opj_data_file, SimpleRDF from .fixtures import SimpleRDF
@unittest.skipIf(os.name == "nt", WINDOWS_TMP_FILE_MSG) @unittest.skipIf(os.name == "nt", WINDOWS_TMP_FILE_MSG)
@ -103,6 +88,7 @@ class TestSuite(unittest.TestCase):
jp2 = glymur.Jp2k(tfile.name) jp2 = glymur.Jp2k(tfile.name)
self.assertEqual(jp2.box[-1].data['Make'], "HTC") self.assertEqual(jp2.box[-1].data['Make'], "HTC")
@unittest.skipIf(WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG) @unittest.skipIf(WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG)
@unittest.skipIf(os.name == "nt", WINDOWS_TMP_FILE_MSG) @unittest.skipIf(os.name == "nt", WINDOWS_TMP_FILE_MSG)
class TestSuiteWarns(unittest.TestCase): class TestSuiteWarns(unittest.TestCase):
@ -137,7 +123,7 @@ class TestSuiteWarns(unittest.TestCase):
tfile.flush() tfile.flush()
with self.assertWarnsRegex(UserWarning, 'Unrecognized Exif tag'): with self.assertWarnsRegex(UserWarning, 'Unrecognized Exif tag'):
j = glymur.Jp2k(tfile.name) glymur.Jp2k(tfile.name)
def test_bad_tag_datatype(self): def test_bad_tag_datatype(self):
"""Only certain datatypes are allowable""" """Only certain datatypes are allowable"""

20
glymur/test/test_jp2box_xml.py
View file

@ -17,20 +17,9 @@ Test suite specifically targeting JP2 box layout.
import os import os
import re import re
import struct import struct
import sys
import tempfile import tempfile
import unittest import unittest
if sys.hexversion < 0x03000000:
from StringIO import StringIO
else:
from io import StringIO
if sys.hexversion <= 0x03030000:
from mock import patch
else:
from unittest.mock import patch
import lxml.etree as ET import lxml.etree as ET
import glymur import glymur
@ -43,6 +32,7 @@ from .fixtures import OPJ_DATA_ROOT, opj_data_file
from .fixtures import WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG from .fixtures import WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG
from . import fixtures from . import fixtures
@unittest.skipIf(os.name == "nt", fixtures.WINDOWS_TMP_FILE_MSG) @unittest.skipIf(os.name == "nt", fixtures.WINDOWS_TMP_FILE_MSG)
class TestXML(unittest.TestCase): class TestXML(unittest.TestCase):
"""Test suite for XML boxes.""" """Test suite for XML boxes."""
@ -167,7 +157,6 @@ class TestXML(unittest.TestCase):
u'<country>Россия</country>') u'<country>Россия</country>')
class TestJp2kBadXmlFile(unittest.TestCase): class TestJp2kBadXmlFile(unittest.TestCase):
"""Test suite for bad XML box situations""" """Test suite for bad XML box situations"""
@ -299,16 +288,13 @@ class TestXML_OpjDataRoot(unittest.TestCase):
self.assertIsNotNone(jp2.box[3].xml) self.assertIsNotNone(jp2.box[3].xml)
def test_invalid_utf8(self): def test_invalid_utf8(self):
"""Bad byte sequence that cannot be parsed.""" """Bad byte sequence that cannot be parsed."""
relname = '26ccf3651020967f7778238ef5af08af.SIGFPE.d25.527.jp2'
filename = opj_data_file(os.path.join('input', filename = opj_data_file(os.path.join('input',
'nonregression', 'nonregression',
'26ccf3651020967f7778238ef5af08af.SIGFPE.d25.527.jp2')) relname))
with self.assertWarns((UserWarning, UserWarning)): with self.assertWarns((UserWarning, UserWarning)):
jp2 = Jp2k(filename) jp2 = Jp2k(filename)
self.assertIsNone(jp2.box[3].box[1].box[1].xml) self.assertIsNone(jp2.box[3].box[1].box[1].xml)

233
glymur/test/test_jp2k.py
View file

@ -13,7 +13,6 @@ Tests for general glymur functionality.
import doctest import doctest
import os import os
import re import re
import shutil
import struct import struct
import sys import sys
import tempfile import tempfile
@ -45,6 +44,7 @@ if HAS_PYTHON_XMP_TOOLKIT:
from .fixtures import OPJ_DATA_ROOT, opj_data_file from .fixtures import OPJ_DATA_ROOT, opj_data_file
from . import fixtures from . import fixtures
# Doc tests should be run as well. # Doc tests should be run as well.
def load_tests(loader, tests, ignore): def load_tests(loader, tests, ignore):
# W0613: "loader" and "ignore" are necessary for the protocol # W0613: "loader" and "ignore" are necessary for the protocol
@ -77,6 +77,7 @@ class SliceProtocolBase(unittest.TestCase):
self.j2k_data_r1 = self.j2k[::2, ::2] self.j2k_data_r1 = self.j2k[::2, ::2]
self.j2k_data_r5 = self.j2k[::32, ::32] self.j2k_data_r5 = self.j2k[::32, ::32]
@unittest.skipIf(OPENJPEG_NOT_AVAILABLE, OPENJPEG_NOT_AVAILABLE_MSG) @unittest.skipIf(OPENJPEG_NOT_AVAILABLE, OPENJPEG_NOT_AVAILABLE_MSG)
@unittest.skipIf(re.match("1.5|2", glymur.version.openjpeg_version) is None, @unittest.skipIf(re.match("1.5|2", glymur.version.openjpeg_version) is None,
"Must have openjpeg 1.5 or higher to run") "Must have openjpeg 1.5 or higher to run")
@ -148,11 +149,6 @@ class TestSliceProtocolBaseWrite(SliceProtocolBase):
@unittest.skipIf(OPENJPEG_NOT_AVAILABLE, OPENJPEG_NOT_AVAILABLE_MSG) @unittest.skipIf(OPENJPEG_NOT_AVAILABLE, OPENJPEG_NOT_AVAILABLE_MSG)
class TestSliceProtocolRead(SliceProtocolBase): class TestSliceProtocolRead(SliceProtocolBase):
def test_resolution_strides_cannot_differ(self):
with self.assertRaises(IndexError):
# Strides in x/y directions cannot differ.
self.j2k[::2, ::3]
def test_resolution_strides_cannot_differ(self): def test_resolution_strides_cannot_differ(self):
with self.assertRaises(IndexError): with self.assertRaises(IndexError):
# Strides in x/y directions cannot differ. # Strides in x/y directions cannot differ.
@ -169,8 +165,8 @@ class TestSliceProtocolRead(SliceProtocolBase):
np.testing.assert_array_equal(self.j2k_data[:, :, j], band) np.testing.assert_array_equal(self.j2k_data[:, :, j], band)
def test_slice_in_third_dimension(self): def test_slice_in_third_dimension(self):
actual = self.j2k[:,:,1:3] actual = self.j2k[:, :, 1:3]
expected = self.j2k_data[:,:,1:3] expected = self.j2k_data[:, :, 1:3]
np.testing.assert_array_equal(actual, expected) np.testing.assert_array_equal(actual, expected)
def test_reduce_resolution_and_slice_in_third_dimension(self): def test_reduce_resolution_and_slice_in_third_dimension(self):
@ -184,12 +180,12 @@ class TestSliceProtocolRead(SliceProtocolBase):
np.testing.assert_array_equal(actual, expected) np.testing.assert_array_equal(actual, expected)
def test_retrieve_single_pixel(self): def test_retrieve_single_pixel(self):
actual = self.jp2[0,0] actual = self.jp2[0, 0]
expected = self.jp2_data[0, 0] expected = self.jp2_data[0, 0]
np.testing.assert_array_equal(actual, expected) np.testing.assert_array_equal(actual, expected)
def test_retrieve_single_component(self): def test_retrieve_single_component(self):
actual = self.jp2[20,20,2] actual = self.jp2[20, 20, 2]
expected = self.jp2_data[20, 20, 2] expected = self.jp2_data[20, 20, 2]
np.testing.assert_array_equal(actual, expected) np.testing.assert_array_equal(actual, expected)
@ -226,7 +222,7 @@ class TestSliceProtocolRead(SliceProtocolBase):
def test_single_slice(self): def test_single_slice(self):
rows = slice(3, 8) rows = slice(3, 8)
actual = self.j2k[rows] actual = self.j2k[rows]
expected = self.j2k_data[3:8, :,:] expected = self.j2k_data[3:8, :, :]
np.testing.assert_array_equal(actual, expected) np.testing.assert_array_equal(actual, expected)
@unittest.skipIf(re.match("0|1", glymur.version.openjpeg_version), @unittest.skipIf(re.match("0|1", glymur.version.openjpeg_version),
@ -243,6 +239,7 @@ class TestSliceProtocolRead(SliceProtocolBase):
expected = self.j2k_data_r5[1:17, 1:14] expected = self.j2k_data_r5[1:17, 1:14]
np.testing.assert_array_equal(actual, expected) np.testing.assert_array_equal(actual, expected)
class TestJp2k(unittest.TestCase): class TestJp2k(unittest.TestCase):
"""These tests should be run by just about all configuration.""" """These tests should be run by just about all configuration."""
@ -319,7 +316,7 @@ class TestJp2k(unittest.TestCase):
@unittest.skipIf(OPENJPEG_NOT_AVAILABLE, OPENJPEG_NOT_AVAILABLE_MSG) @unittest.skipIf(OPENJPEG_NOT_AVAILABLE, OPENJPEG_NOT_AVAILABLE_MSG)
@unittest.skipIf(re.match('1.[0-4]', openjpeg_version) is not None, @unittest.skipIf(re.match('1.[0-4]', openjpeg_version) is not None,
"Not supported with OpenJPEG {0}".format(openjpeg_version)) "Not supported on OpenJPEG {0}".format(openjpeg_version))
@unittest.skipIf(re.match('1.5.(1|2)', openjpeg_version) is not None, @unittest.skipIf(re.match('1.5.(1|2)', openjpeg_version) is not None,
"Mysteriously fails in 1.5.1 and 1.5.2") "Mysteriously fails in 1.5.1 and 1.5.2")
def test_no_cxform_pclr_jpx(self): def test_no_cxform_pclr_jpx(self):
@ -654,7 +651,8 @@ class TestJp2k(unittest.TestCase):
xmp = XMPMeta() xmp = XMPMeta()
xmp.parse_from_str(j.box[3].raw_data.decode('utf-8'), xmp.parse_from_str(j.box[3].raw_data.decode('utf-8'),
xmpmeta_wrap=False) xmpmeta_wrap=False)
creator_tool = xmp.get_property(libxmp.consts.XMP_NS_XMP, 'CreatorTool') creator_tool = xmp.get_property(libxmp.consts.XMP_NS_XMP,
'CreatorTool')
self.assertEqual(creator_tool, 'Google') self.assertEqual(creator_tool, 'Google')
@unittest.skipIf(OPENJPEG_NOT_AVAILABLE, OPENJPEG_NOT_AVAILABLE_MSG) @unittest.skipIf(OPENJPEG_NOT_AVAILABLE, OPENJPEG_NOT_AVAILABLE_MSG)
@ -674,6 +672,7 @@ class TestJp2k(unittest.TestCase):
with self.assertRaises(RuntimeError): with self.assertRaises(RuntimeError):
glymur.Jp2k(self.jp2file).read_bands() glymur.Jp2k(self.jp2file).read_bands()
@unittest.skipIf(OPENJPEG_NOT_AVAILABLE, OPENJPEG_NOT_AVAILABLE_MSG) @unittest.skipIf(OPENJPEG_NOT_AVAILABLE, OPENJPEG_NOT_AVAILABLE_MSG)
@unittest.skipIf(re.match('1.[0-4]', openjpeg_version) is not None, @unittest.skipIf(re.match('1.[0-4]', openjpeg_version) is not None,
"Not supported with OpenJPEG {0}".format(openjpeg_version)) "Not supported with OpenJPEG {0}".format(openjpeg_version))
@ -693,30 +692,30 @@ class TestJp2k_write(unittest.TestCase):
data = np.zeros((640, 480), dtype=np.uint8) data = np.zeros((640, 480), dtype=np.uint8)
with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile: with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
with self.assertRaises(IOError): with self.assertRaises(IOError):
j = Jp2k(tfile.name, data=data, Jp2k(tfile.name, data=data,
cbsize=(16, 16), psizes=[(16, 16)]) cbsize=(16, 16), psizes=[(16, 16)])
def test_precinct_size_not_power_of_two(self): def test_precinct_size_not_power_of_two(self):
"""must be power of two""" """must be power of two"""
data = np.zeros((640, 480), dtype=np.uint8) data = np.zeros((640, 480), dtype=np.uint8)
with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile: with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
with self.assertRaises(IOError): with self.assertRaises(IOError):
j = Jp2k(tfile.name, data=data, Jp2k(tfile.name, data=data,
cbsize=(16, 16), psizes=[(48, 48)]) cbsize=(16, 16), psizes=[(48, 48)])
def test_unsupported_int32(self): def test_unsupported_int32(self):
"""Should raise a runtime error if trying to write int32""" """Should raise a runtime error if trying to write int32"""
data = np.zeros((128, 128), dtype=np.int32) data = np.zeros((128, 128), dtype=np.int32)
with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile: with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
with self.assertRaises(RuntimeError): with self.assertRaises(RuntimeError):
j = Jp2k(tfile.name, data=data) Jp2k(tfile.name, data=data)
def test_unsupported_uint32(self): def test_unsupported_uint32(self):
"""Should raise a runtime error if trying to write uint32""" """Should raise a runtime error if trying to write uint32"""
data = np.zeros((128, 128), dtype=np.uint32) data = np.zeros((128, 128), dtype=np.uint32)
with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile: with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
with self.assertRaises(RuntimeError): with self.assertRaises(RuntimeError):
j = Jp2k(tfile.name, data=data) Jp2k(tfile.name, data=data)
def test_write_with_version_too_early(self): def test_write_with_version_too_early(self):
"""Should raise a runtime error if trying to write with version 1.3""" """Should raise a runtime error if trying to write with version 1.3"""
@ -726,7 +725,7 @@ class TestJp2k_write(unittest.TestCase):
with patch('glymur.version.openjpeg_version', new=version): with patch('glymur.version.openjpeg_version', new=version):
with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile: with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
with self.assertRaises(RuntimeError): with self.assertRaises(RuntimeError):
j = Jp2k(tfile.name, data=data) Jp2k(tfile.name, data=data)
def test_cblkh_different_than_width(self): def test_cblkh_different_than_width(self):
"""Verify that we can set a code block size where height does not equal """Verify that we can set a code block size where height does not equal
@ -745,31 +744,31 @@ class TestJp2k_write(unittest.TestCase):
"""OpenJP2 only allows 2D or 3D images.""" """OpenJP2 only allows 2D or 3D images."""
with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile: with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
with self.assertRaises(IOError): with self.assertRaises(IOError):
j = Jp2k(tfile.name, Jp2k(tfile.name,
data=np.zeros((128, 128, 2, 2), dtype=np.uint8)) data=np.zeros((128, 128, 2, 2), dtype=np.uint8))
def test_2d_rgb(self): def test_2d_rgb(self):
"""RGB must have at least 3 components.""" """RGB must have at least 3 components."""
with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile: with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile:
with self.assertRaises(IOError): with self.assertRaises(IOError):
j = Jp2k(tfile.name, Jp2k(tfile.name,
data=np.zeros((128, 128, 2), dtype=np.uint8), data=np.zeros((128, 128, 2), dtype=np.uint8),
colorspace='rgb') colorspace='rgb')
def test_colorspace_with_j2k(self): def test_colorspace_with_j2k(self):
"""Specifying a colorspace with J2K does not make sense""" """Specifying a colorspace with J2K does not make sense"""
with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile: with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
with self.assertRaises(IOError): with self.assertRaises(IOError):
j = Jp2k(tfile.name, Jp2k(tfile.name,
data=np.zeros((128, 128, 3), dtype=np.uint8), data=np.zeros((128, 128, 3), dtype=np.uint8),
colorspace='rgb') colorspace='rgb')
def test_specify_rgb(self): def test_specify_rgb(self):
"""specify RGB explicitly""" """specify RGB explicitly"""
with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile: with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile:
j = Jp2k(tfile.name, j = Jp2k(tfile.name,
data=np.zeros((128, 128, 3), dtype=np.uint8), data=np.zeros((128, 128, 3), dtype=np.uint8),
colorspace='rgb') colorspace='rgb')
self.assertEqual(j.box[2].box[1].colorspace, glymur.core.SRGB) self.assertEqual(j.box[2].box[1].colorspace, glymur.core.SRGB)
def test_specify_gray(self): def test_specify_gray(self):
@ -804,7 +803,7 @@ class TestJp2k_write(unittest.TestCase):
with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile: with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile:
with self.assertRaises(IOError): with self.assertRaises(IOError):
data = np.zeros((128, 128, 3), dtype=np.uint8) data = np.zeros((128, 128, 3), dtype=np.uint8)
j = Jp2k(tfile.name, data=data, colorspace='ycc') Jp2k(tfile.name, data=data, colorspace='ycc')
def test_write_with_jp2_in_caps(self): def test_write_with_jp2_in_caps(self):
"""should be able to write with JP2 suffix.""" """should be able to write with JP2 suffix."""
@ -833,7 +832,7 @@ class TestJp2k_write(unittest.TestCase):
expdata = j2k[:] expdata = j2k[:]
with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile: with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile:
with self.assertRaises(IOError): with self.assertRaises(IOError):
ofile = Jp2k(tfile.name, data=expdata[:, :, 0], mct=True) Jp2k(tfile.name, data=expdata[:, :, 0], mct=True)
def test_write_cprl(self): def test_write_cprl(self):
"""Must be able to write a CPRL progression order file""" """Must be able to write a CPRL progression order file"""
@ -924,7 +923,7 @@ class TestJp2k_2_0(unittest.TestCase):
with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile: with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile:
data = np.zeros((128, 128, 3), dtype=np.uint8) data = np.zeros((128, 128, 3), dtype=np.uint8)
with self.assertRaises(IOError): with self.assertRaises(IOError):
j = Jp2k(tfile.name, data=data, colorspace='cmyk') Jp2k(tfile.name, data=data, colorspace='cmyk')
@unittest.skipIf(os.name == "nt", fixtures.WINDOWS_TMP_FILE_MSG) @unittest.skipIf(os.name == "nt", fixtures.WINDOWS_TMP_FILE_MSG)
def test_asoc_label_box(self): def test_asoc_label_box(self):
@ -933,7 +932,7 @@ class TestJp2k_2_0(unittest.TestCase):
# OpenJPEG doesn't have such a file. # OpenJPEG doesn't have such a file.
data = Jp2k(self.jp2file)[::2, ::2] data = Jp2k(self.jp2file)[::2, ::2]
with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile: with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile:
j = Jp2k(tfile.name, data=data) Jp2k(tfile.name, data=data)
with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile2: with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile2:
@ -1041,12 +1040,15 @@ class TestJp2k_2_1(unittest.TestCase):
Invalid\svalues\sfor\scomp\s=\s0\s+ Invalid\svalues\sfor\scomp\s=\s0\s+
:\sdx=1\sdy=0''', re.VERBOSE) :\sdx=1\sdy=0''', re.VERBOSE)
if sys.hexversion < 0x03020000: if sys.hexversion < 0x03020000:
with self.assertRaisesRegexp((IOError, OSError), regexp): with self.assertRaisesRegexp((IOError, OSError),
regexp):
j[::2, ::2] j[::2, ::2]
else: else:
with self.assertRaisesRegex((IOError, OSError), regexp): with self.assertRaisesRegex((IOError, OSError),
regexp):
j[::2, ::2] j[::2, ::2]
@unittest.skipIf(OPJ_DATA_ROOT is None, @unittest.skipIf(OPJ_DATA_ROOT is None,
"OPJ_DATA_ROOT environment variable not set") "OPJ_DATA_ROOT environment variable not set")
class TestParsing(unittest.TestCase): class TestParsing(unittest.TestCase):
@ -1064,22 +1066,23 @@ class TestParsing(unittest.TestCase):
"""Should not warn if RSIZ when parsing is turned off.""" """Should not warn if RSIZ when parsing is turned off."""
filename = opj_data_file('input/nonregression/edf_c2_1002767.jp2') filename = opj_data_file('input/nonregression/edf_c2_1002767.jp2')
glymur.set_parseoptions(codestream=False) glymur.set_parseoptions(codestream=False)
j = Jp2k(filename) Jp2k(filename)
glymur.set_parseoptions(codestream=True) glymur.set_parseoptions(codestream=True)
with self.assertWarnsRegex(UserWarning, 'Invalid profile'): with self.assertWarnsRegex(UserWarning, 'Invalid profile'):
jp2 = Jp2k(filename) Jp2k(filename)
def test_main_header(self): def test_main_header(self):
"""Verify that the main header is not loaded when parsing turned off.""" """Verify that the main header isn't loaded when parsing turned off."""
# The hidden _main_header attribute should show up after accessing it. # The hidden _main_header attribute should show up after accessing it.
glymur.set_parseoptions(codestream=False) glymur.set_parseoptions(codestream=False)
jp2 = Jp2k(self.jp2file) jp2 = Jp2k(self.jp2file)
jp2c = jp2.box[4] jp2c = jp2.box[4]
self.assertIsNone(jp2c._main_header) self.assertIsNone(jp2c._main_header)
main_header = jp2c.main_header jp2c.main_header
self.assertIsNotNone(jp2c._main_header) self.assertIsNotNone(jp2c._main_header)
@unittest.skipIf(WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG) @unittest.skipIf(WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG)
@unittest.skipIf(OPJ_DATA_ROOT is None, @unittest.skipIf(OPJ_DATA_ROOT is None,
"OPJ_DATA_ROOT environment variable not set") "OPJ_DATA_ROOT environment variable not set")
@ -1101,13 +1104,13 @@ class TestJp2kOpjDataRootWarnings(unittest.TestCase):
"""Should warn in case of bad ftyp brand.""" """Should warn in case of bad ftyp brand."""
filename = opj_data_file('input/nonregression/edf_c2_1000290.jp2') filename = opj_data_file('input/nonregression/edf_c2_1000290.jp2')
with self.assertWarns(UserWarning): with self.assertWarns(UserWarning):
jp2 = Jp2k(filename) Jp2k(filename)
def test_invalid_approximation(self): def test_invalid_approximation(self):
"""Should warn in case of invalid approximation.""" """Should warn in case of invalid approximation."""
filename = opj_data_file('input/nonregression/edf_c2_1015644.jp2') filename = opj_data_file('input/nonregression/edf_c2_1015644.jp2')
with self.assertWarnsRegex(UserWarning, 'Invalid approximation'): with self.assertWarnsRegex(UserWarning, 'Invalid approximation'):
jp2 = Jp2k(filename) Jp2k(filename)
def test_invalid_colorspace(self): def test_invalid_colorspace(self):
""" """
@ -1117,13 +1120,13 @@ class TestJp2kOpjDataRootWarnings(unittest.TestCase):
""" """
filename = opj_data_file('input/nonregression/edf_c2_1103421.jp2') filename = opj_data_file('input/nonregression/edf_c2_1103421.jp2')
with self.assertWarns(UserWarning): with self.assertWarns(UserWarning):
jp2 = Jp2k(filename) Jp2k(filename)
def test_stupid_windows_eol_at_end(self): def test_stupid_windows_eol_at_end(self):
"""Garbage characters at the end of the file.""" """Garbage characters at the end of the file."""
filename = opj_data_file('input/nonregression/issue211.jp2') filename = opj_data_file('input/nonregression/issue211.jp2')
with self.assertWarns(UserWarning): with self.assertWarns(UserWarning):
jp2 = Jp2k(filename) Jp2k(filename)
@unittest.skipIf(OPJ_DATA_ROOT is None, @unittest.skipIf(OPJ_DATA_ROOT is None,
@ -1196,31 +1199,11 @@ class TestJp2kOpjDataRoot(unittest.TestCase):
expected = np.zeros(ycbcr.shape, ycbcr.dtype) expected = np.zeros(ycbcr.shape, ycbcr.dtype)
for k in range(crcby.shape[2]): for k in range(crcby.shape[2]):
expected[:,:,crcby.shape[2] - k - 1] = crcby[:,:,k] expected[:, :, crcby.shape[2] - k - 1] = crcby[:, :, k]
np.testing.assert_array_equal(ycbcr, expected) np.testing.assert_array_equal(ycbcr, expected)
class TestCodestream(unittest.TestCase):
"""Test suite for unusual codestream cases."""
def setUp(self):
self.jp2file = glymur.data.nemo()
def tearDown(self):
pass
def test_siz_segment_ssiz_unsigned(self):
"""ssiz attribute to be removed in future release"""
j = Jp2k(self.jp2file)
codestream = j.get_codestream()
# The ssiz attribute was simply a tuple of raw bytes.
# The first 7 bits are interpreted as the bitdepth, the MSB determines
# whether or not it is signed.
self.assertEqual(codestream.segment[1].ssiz, (7, 7, 7))
@unittest.skipIf(OPJ_DATA_ROOT is None, @unittest.skipIf(OPJ_DATA_ROOT is None,
"OPJ_DATA_ROOT environment variable not set") "OPJ_DATA_ROOT environment variable not set")
class TestCodestreamOpjData(unittest.TestCase): class TestCodestreamOpjData(unittest.TestCase):
@ -1274,7 +1257,6 @@ class TestCodestreamOpjData(unittest.TestCase):
# codestream, so the last one is EOC. # codestream, so the last one is EOC.
self.assertEqual(codestream.segment[-1].marker_id, 'EOC') self.assertEqual(codestream.segment[-1].marker_id, 'EOC')
def test_siz_segment_ssiz_signed(self): def test_siz_segment_ssiz_signed(self):
"""ssiz attribute to be removed in future release""" """ssiz attribute to be removed in future release"""
filename = os.path.join(OPJ_DATA_ROOT, 'input/conformance/p0_03.j2k') filename = os.path.join(OPJ_DATA_ROOT, 'input/conformance/p0_03.j2k')
@ -1329,6 +1311,16 @@ class TestCodestreamRepr(unittest.TestCase):
self.assertEqual(newseg.bitdepth, (8, 8, 8)) self.assertEqual(newseg.bitdepth, (8, 8, 8))
self.assertEqual(newseg.signed, (False, False, False)) self.assertEqual(newseg.signed, (False, False, False))
def test_siz_segment_ssiz_unsigned(self):
"""ssiz attribute to be removed in future release"""
j = Jp2k(self.jp2file)
codestream = j.get_codestream()
# The ssiz attribute was simply a tuple of raw bytes.
# The first 7 bits are interpreted as the bitdepth, the MSB determines
# whether or not it is signed.
self.assertEqual(codestream.segment[1].ssiz, (7, 7, 7))
class TestCodestream(unittest.TestCase): class TestCodestream(unittest.TestCase):
"""Test suite for unusual codestream cases.""" """Test suite for unusual codestream cases."""
@ -1348,112 +1340,3 @@ class TestCodestream(unittest.TestCase):
# The first 7 bits are interpreted as the bitdepth, the MSB determines # The first 7 bits are interpreted as the bitdepth, the MSB determines
# whether or not it is signed. # whether or not it is signed.
self.assertEqual(codestream.segment[1].ssiz, (7, 7, 7)) self.assertEqual(codestream.segment[1].ssiz, (7, 7, 7))
@unittest.skipIf(OPJ_DATA_ROOT is None,
"OPJ_DATA_ROOT environment variable not set")
class TestCodestreamOpjData(unittest.TestCase):
"""Test suite for unusual codestream cases. Uses OPJ_DATA_ROOT"""
def setUp(self):
self.jp2file = glymur.data.nemo()
def tearDown(self):
pass
@unittest.skipIf(os.name == "nt", "Temporary file issue on window.")
def test_reserved_marker_segment(self):
"""Reserved marker segments are ok."""
# Some marker segments were reserved in FCD15444-1. Since that
# standard is old, some of them may have come into use.
#
# Let's inject a reserved marker segment into a file that
# we know something about to make sure we can still parse it.
filename = os.path.join(OPJ_DATA_ROOT, 'input/conformance/p0_01.j2k')
with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
with open(filename, 'rb') as ifile:
# Everything up until the first QCD marker.
read_buffer = ifile.read(45)
tfile.write(read_buffer)
# Write the new marker segment, 0xff6f = 65391
read_buffer = struct.pack('>HHB', int(65391), int(3), int(0))
tfile.write(read_buffer)
# Get the rest of the input file.
read_buffer = ifile.read()
tfile.write(read_buffer)
tfile.flush()
codestream = Jp2k(tfile.name).get_codestream()
self.assertEqual(codestream.segment[2].marker_id, '0xff6f')
self.assertEqual(codestream.segment[2].length, 3)
self.assertEqual(codestream.segment[2].data, b'\x00')
def test_psot_is_zero(self):
"""Psot=0 in SOT is perfectly legal. Issue #78."""
filename = os.path.join(OPJ_DATA_ROOT,
'input/nonregression/123.j2c')
j = Jp2k(filename)
codestream = j.get_codestream(header_only=False)
# The codestream is valid, so we should be able to get the entire
# codestream, so the last one is EOC.
self.assertEqual(codestream.segment[-1].marker_id, 'EOC')
def test_siz_segment_ssiz_signed(self):
"""ssiz attribute to be removed in future release"""
filename = os.path.join(OPJ_DATA_ROOT, 'input/conformance/p0_03.j2k')
j = Jp2k(filename)
codestream = j.get_codestream()
# The ssiz attribute was simply a tuple of raw bytes.
# The first 7 bits are interpreted as the bitdepth, the MSB determines
# whether or not it is signed.
self.assertEqual(codestream.segment[1].ssiz, (131,))
class TestCodestreamRepr(unittest.TestCase):
def setUp(self):
self.jp2file = glymur.data.nemo()
def tearDown(self):
pass
def test_soc(self):
"""Test SOC segment repr"""
segment = glymur.codestream.SOCsegment()
newseg = eval(repr(segment))
self.assertEqual(newseg.marker_id, 'SOC')
def test_siz(self):
"""Test SIZ segment repr"""
kwargs = {'rsiz': 0,
'xysiz': (2592, 1456),
'xyosiz': (0, 0),
'xytsiz': (2592, 1456),
'xytosiz': (0, 0),
'Csiz': 3,
'bitdepth': (8, 8, 8),
'signed': (False, False, False),
'xyrsiz': ((1, 1, 1), (1, 1, 1))}
segment = glymur.codestream.SIZsegment(**kwargs)
newseg = eval(repr(segment))
self.assertEqual(newseg.marker_id, 'SIZ')
self.assertEqual(newseg.xsiz, 2592)
self.assertEqual(newseg.ysiz, 1456)
self.assertEqual(newseg.xosiz, 0)
self.assertEqual(newseg.yosiz, 0)
self.assertEqual(newseg.xtsiz, 2592)
self.assertEqual(newseg.ytsiz, 1456)
self.assertEqual(newseg.xtosiz, 0)
self.assertEqual(newseg.ytosiz, 0)
self.assertEqual(newseg.xrsiz, (1, 1, 1))
self.assertEqual(newseg.yrsiz, (1, 1, 1))
self.assertEqual(newseg.bitdepth, (8, 8, 8))
self.assertEqual(newseg.signed, (False, False, False))

29
glymur/test/test_opj_suite.py
View file

@ -38,12 +38,11 @@ import glymur
from glymur import Jp2k from glymur import Jp2k
from glymur.jp2box import FileTypeBox, ImageHeaderBox, ColourSpecificationBox from glymur.jp2box import FileTypeBox, ImageHeaderBox, ColourSpecificationBox
from .fixtures import ( from .fixtures import (OPJ_DATA_ROOT, MetadataBase,
OPJ_DATA_ROOT, MetadataBase, WARNING_INFRASTRUCTURE_ISSUE,
WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG, WARNING_INFRASTRUCTURE_MSG,
mse, peak_tolerance, read_pgx, opj_data_file, mse, peak_tolerance, read_pgx, opj_data_file,
OPENJPEG_NOT_AVAILABLE, OPENJPEG_NOT_AVAILABLE_MSG OPENJPEG_NOT_AVAILABLE, OPENJPEG_NOT_AVAILABLE_MSG)
)
@unittest.skipIf(OPENJPEG_NOT_AVAILABLE, OPENJPEG_NOT_AVAILABLE_MSG) @unittest.skipIf(OPENJPEG_NOT_AVAILABLE, OPENJPEG_NOT_AVAILABLE_MSG)
@ -415,16 +414,17 @@ class TestSuiteWarns(MetadataBase):
self.assertEqual(ids, expected) self.assertEqual(ids, expected)
kwargs = {'rsiz': 0, 'xysiz': (203, 152), 'xyosiz': (0, 0), kwargs = {'rsiz': 0, 'xysiz': (203, 152), 'xyosiz': (0, 0),
'xytsiz': (203, 152), 'xytosiz': (0, 0), 'bitdepth': (8, 8, 8), 'xytsiz': (203, 152), 'xytosiz': (0, 0),
'signed': (False, False, False), 'bitdepth': (8, 8, 8),
'xyrsiz': [(1, 1, 1), (1, 1, 1)]} 'signed': (False, False, False),
'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
self.verifySizSegment(c.segment[1], self.verifySizSegment(c.segment[1],
glymur.codestream.SIZsegment(**kwargs)) glymur.codestream.SIZsegment(**kwargs))
pargs = (glymur.core.RCME_ISO_8859_1, pargs = (glymur.core.RCME_ISO_8859_1,
"Creator: JasPer Version 1.701.0".encode()) "Creator: JasPer Version 1.701.0".encode())
self.verifyCMEsegment(c.segment[2], self.verifyCMEsegment(c.segment[2],
glymur.codestream.CMEsegment(*pargs)) glymur.codestream.CMEsegment(*pargs))
# COD: Coding style default # COD: Coding style default
self.assertFalse(c.segment[3].scod & 2) # no sop self.assertFalse(c.segment[3].scod & 2) # no sop
@ -436,7 +436,7 @@ class TestSuiteWarns(MetadataBase):
self.assertEqual(tuple(c.segment[3].code_block_size), self.assertEqual(tuple(c.segment[3].code_block_size),
(64, 64)) # cblk (64, 64)) # cblk
self.verify_codeblock_style(c.segment[3].spcod[7], self.verify_codeblock_style(c.segment[3].spcod[7],
[False, False, False, False, False, False]) [False, False, False, False, False, False])
self.assertEqual(c.segment[3].spcod[8], self.assertEqual(c.segment[3].spcod[8],
glymur.core.WAVELET_XFORM_5X3_REVERSIBLE) glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
self.assertEqual(len(c.segment[3].spcod), 9) self.assertEqual(len(c.segment[3].spcod), 9)
@ -726,7 +726,7 @@ class TestSuite2point1(unittest.TestCase):
def test_NR_DEC_p1_04_j2k_57_decode(self): def test_NR_DEC_p1_04_j2k_57_decode(self):
jfile = opj_data_file('input/conformance/p1_04.j2k') jfile = opj_data_file('input/conformance/p1_04.j2k')
jp2k = Jp2k(jfile) jp2k = Jp2k(jfile)
tdata = jp2k[896:1024, 896:1024] # last tile tdata = jp2k[896:1024, 896:1024] # last tile
odata = jp2k[:] odata = jp2k[:]
np.testing.assert_array_equal(tdata, odata[896:1024, 896:1024]) np.testing.assert_array_equal(tdata, odata[896:1024, 896:1024])
@ -798,6 +798,7 @@ class TestSuite2point1(unittest.TestCase):
with self.assertRaises(IOError): with self.assertRaises(IOError):
j[:] j[:]
@unittest.skipIf(OPJ_DATA_ROOT is None, @unittest.skipIf(OPJ_DATA_ROOT is None,
"OPJ_DATA_ROOT environment variable not set") "OPJ_DATA_ROOT environment variable not set")
@unittest.skipIf(re.match(r'''0|1|2.0.0''', @unittest.skipIf(re.match(r'''0|1|2.0.0''',

834
glymur/test/test_opj_suite_dump.py
View file

File diff suppressed because it is too large Load diff

23
glymur/test/test_opj_suite_neg.py
View file

@ -10,7 +10,6 @@ seem like logical negative tests to add.
import os import os
import re import re
import sys
import tempfile import tempfile
import unittest import unittest
@ -88,7 +87,6 @@ class TestSuiteNegativeWrite(unittest.TestCase):
def tearDown(self): def tearDown(self):
pass pass
@unittest.skipIf(NO_SKIMAGE_FREEIMAGE_SUPPORT, @unittest.skipIf(NO_SKIMAGE_FREEIMAGE_SUPPORT,
"Cannot read input image without scikit-image/freeimage") "Cannot read input image without scikit-image/freeimage")
def test_cinema2K_bad_frame_rate(self): def test_cinema2K_bad_frame_rate(self):
@ -98,8 +96,7 @@ class TestSuiteNegativeWrite(unittest.TestCase):
data = skimage.io.imread(infile) data = skimage.io.imread(infile)
with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile: with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
with self.assertRaises(IOError): with self.assertRaises(IOError):
j = Jp2k(tfile.name, data=data, cinema2k=36) Jp2k(tfile.name, data=data, cinema2k=36)
@unittest.skipIf(NO_READ_BACKEND, NO_READ_BACKEND_MSG) @unittest.skipIf(NO_READ_BACKEND, NO_READ_BACKEND_MSG)
def test_psnr_with_cratios(self): def test_psnr_with_cratios(self):
@ -109,8 +106,8 @@ class TestSuiteNegativeWrite(unittest.TestCase):
data = read_image(infile) data = read_image(infile)
with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile: with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
with self.assertRaises(IOError): with self.assertRaises(IOError):
j = Jp2k(tfile.name, Jp2k(tfile.name,
data=data, psnr=[30, 35, 40], cratios=[2, 3, 4]) data=data, psnr=[30, 35, 40], cratios=[2, 3, 4])
def test_code_block_dimensions(self): def test_code_block_dimensions(self):
"""don't allow extreme codeblock sizes""" """don't allow extreme codeblock sizes"""
@ -120,13 +117,13 @@ class TestSuiteNegativeWrite(unittest.TestCase):
with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile: with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
# opj_compress doesn't allow code block area to exceed 4096. # opj_compress doesn't allow code block area to exceed 4096.
with self.assertRaises(IOError): with self.assertRaises(IOError):
j = Jp2k(tfile.name, data=data, cbsize=(256, 256)) Jp2k(tfile.name, data=data, cbsize=(256, 256))
# opj_compress doesn't allow either dimension to be less than 4. # opj_compress doesn't allow either dimension to be less than 4.
with self.assertRaises(IOError): with self.assertRaises(IOError):
j = Jp2k(tfile.name, data=data, cbsize=(2048, 2)) Jp2k(tfile.name, data=data, cbsize=(2048, 2))
with self.assertRaises(IOError): with self.assertRaises(IOError):
j = Jp2k(tfile.name, data=data, cbsize=(2, 2048)) Jp2k(tfile.name, data=data, cbsize=(2, 2048))
def test_precinct_size_not_p2(self): def test_precinct_size_not_p2(self):
"""precinct sizes should be powers of two.""" """precinct sizes should be powers of two."""
@ -134,7 +131,7 @@ class TestSuiteNegativeWrite(unittest.TestCase):
data = ifile[::4, ::4] data = ifile[::4, ::4]
with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile: with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile:
with self.assertRaises(IOError): with self.assertRaises(IOError):
ofile = Jp2k(tfile.name, data=data, psizes=[(13, 13)]) Jp2k(tfile.name, data=data, psizes=[(13, 13)])
def test_cblk_size_not_power_of_two(self): def test_cblk_size_not_power_of_two(self):
"""code block sizes should be powers of two.""" """code block sizes should be powers of two."""
@ -142,7 +139,7 @@ class TestSuiteNegativeWrite(unittest.TestCase):
data = ifile[::4, ::4] data = ifile[::4, ::4]
with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile: with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile:
with self.assertRaises(IOError): with self.assertRaises(IOError):
ofile = Jp2k(tfile.name, data=data, cbsize=(13, 12)) Jp2k(tfile.name, data=data, cbsize=(13, 12))
def test_cblk_size_precinct_size(self): def test_cblk_size_precinct_size(self):
"""code block sizes should never exceed half that of precinct size.""" """code block sizes should never exceed half that of precinct size."""
@ -150,6 +147,4 @@ class TestSuiteNegativeWrite(unittest.TestCase):
data = ifile[::4, ::4] data = ifile[::4, ::4]
with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile: with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile:
with self.assertRaises(IOError): with self.assertRaises(IOError):
ofile = Jp2k(tfile.name, Jp2k(tfile.name, data=data, cbsize=(64, 64), psizes=[(64, 64)])
data=data, cbsize=(64, 64), psizes=[(64, 64)])

201
glymur/test/test_opj_suite_write.py
View file

@ -34,6 +34,7 @@ from glymur import Jp2k
from glymur.codestream import SIZsegment from glymur.codestream import SIZsegment
from glymur.version import openjpeg_version from glymur.version import openjpeg_version
class CinemaBase(fixtures.MetadataBase): class CinemaBase(fixtures.MetadataBase):
def verify_cinema_cod(self, cod_segment): def verify_cinema_cod(self, cod_segment):
@ -44,14 +45,14 @@ class CinemaBase(fixtures.MetadataBase):
self.assertEqual(cod_segment.layers, 1) self.assertEqual(cod_segment.layers, 1)
self.assertEqual(cod_segment.spcod[3], 1) # mct self.assertEqual(cod_segment.spcod[3], 1) # mct
self.assertEqual(cod_segment.spcod[4], 5) # levels self.assertEqual(cod_segment.spcod[4], 5) # levels
self.assertEqual(tuple(cod_segment.code_block_size), (32, 32)) # cblksz self.assertEqual(tuple(cod_segment.code_block_size), (32, 32))
def check_cinema4k_codestream(self, codestream, image_size): def check_cinema4k_codestream(self, codestream, image_size):
kwargs = {'rsiz': 4, 'xysiz': image_size, 'xyosiz': (0, 0), kwargs = {'rsiz': 4, 'xysiz': image_size, 'xyosiz': (0, 0),
'xytsiz': image_size, 'xytosiz': (0, 0), 'xytsiz': image_size, 'xytosiz': (0, 0),
'bitdepth': (12, 12, 12), 'signed': (False, False, False), 'bitdepth': (12, 12, 12), 'signed': (False, False, False),
'xyrsiz': [(1, 1, 1), (1, 1, 1)]} 'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
self.verifySizSegment(codestream.segment[1], SIZsegment(**kwargs)) self.verifySizSegment(codestream.segment[1], SIZsegment(**kwargs))
self.verify_cinema_cod(codestream.segment[2]) self.verify_cinema_cod(codestream.segment[2])
@ -59,9 +60,9 @@ class CinemaBase(fixtures.MetadataBase):
def check_cinema2k_codestream(self, codestream, image_size): def check_cinema2k_codestream(self, codestream, image_size):
kwargs = {'rsiz': 3, 'xysiz': image_size, 'xyosiz': (0, 0), kwargs = {'rsiz': 3, 'xysiz': image_size, 'xyosiz': (0, 0),
'xytsiz': image_size, 'xytosiz': (0, 0), 'xytsiz': image_size, 'xytosiz': (0, 0),
'bitdepth': (12, 12, 12), 'signed': (False, False, False), 'bitdepth': (12, 12, 12), 'signed': (False, False, False),
'xyrsiz': [(1, 1, 1), (1, 1, 1)]} 'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
self.verifySizSegment(codestream.segment[1], SIZsegment(**kwargs)) self.verifySizSegment(codestream.segment[1], SIZsegment(**kwargs))
self.verify_cinema_cod(codestream.segment[2]) self.verify_cinema_cod(codestream.segment[2])
@ -88,8 +89,8 @@ class WriteCinema(CinemaBase):
data = skimage.io.imread(infile) data = skimage.io.imread(infile)
with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile: with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
with self.assertRaises(IOError): with self.assertRaises(IOError):
j = Jp2k(tfile.name, data=data, Jp2k(tfile.name, data=data,
cinema2k=48, cratios=[200, 100, 50]) cinema2k=48, cratios=[200, 100, 50])
def test_cinema4K_with_others(self): def test_cinema4K_with_others(self):
"""Can't specify cinema4k with any other options.""" """Can't specify cinema4k with any other options."""
@ -98,8 +99,8 @@ class WriteCinema(CinemaBase):
data = skimage.io.imread(infile) data = skimage.io.imread(infile)
with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile: with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
with self.assertRaises(IOError): with self.assertRaises(IOError):
j = Jp2k(tfile.name, data=data, Jp2k(tfile.name, data=data,
cinema4k=True, cratios=[200, 100, 50]) cinema4k=True, cratios=[200, 100, 50])
@unittest.skipIf(WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG) @unittest.skipIf(WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG)
@ -135,7 +136,8 @@ class WriteCinemaWarns(CinemaBase):
infile = opj_data_file(relfile) infile = opj_data_file(relfile)
data = skimage.io.imread(infile) data = skimage.io.imread(infile)
with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile: with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
with self.assertWarnsRegex(UserWarning, 'OpenJPEG library warning'): with self.assertWarnsRegex(UserWarning,
'OpenJPEG library warning'):
j = Jp2k(tfile.name, data=data, cinema2k=48) j = Jp2k(tfile.name, data=data, cinema2k=48)
codestream = j.get_codestream() codestream = j.get_codestream()
@ -146,7 +148,8 @@ class WriteCinemaWarns(CinemaBase):
infile = opj_data_file(relfile) infile = opj_data_file(relfile)
data = skimage.io.imread(infile) data = skimage.io.imread(infile)
with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile: with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
with self.assertWarnsRegex(UserWarning, 'OpenJPEG library warning'): with self.assertWarnsRegex(UserWarning,
'OpenJPEG library warning'):
j = Jp2k(tfile.name, data=data, cinema2k=48) j = Jp2k(tfile.name, data=data, cinema2k=48)
codestream = j.get_codestream() codestream = j.get_codestream()
@ -157,7 +160,8 @@ class WriteCinemaWarns(CinemaBase):
infile = opj_data_file(relfile) infile = opj_data_file(relfile)
data = skimage.io.imread(infile) data = skimage.io.imread(infile)
with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile: with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
with self.assertWarnsRegex(UserWarning, 'OpenJPEG library warning'): with self.assertWarnsRegex(UserWarning,
'OpenJPEG library warning'):
j = Jp2k(tfile.name, data=data, cinema2k=24) j = Jp2k(tfile.name, data=data, cinema2k=24)
codestream = j.get_codestream() codestream = j.get_codestream()
@ -168,7 +172,8 @@ class WriteCinemaWarns(CinemaBase):
infile = opj_data_file(relfile) infile = opj_data_file(relfile)
data = skimage.io.imread(infile) data = skimage.io.imread(infile)
with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile: with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
with self.assertWarnsRegex(UserWarning, 'OpenJPEG library warning'): with self.assertWarnsRegex(UserWarning,
'OpenJPEG library warning'):
# OpenJPEG library warning: The desired maximum codestream # OpenJPEG library warning: The desired maximum codestream
# size has limited at least one of the desired quality layers # size has limited at least one of the desired quality layers
j = Jp2k(tfile.name, data=data, cinema2k=24) j = Jp2k(tfile.name, data=data, cinema2k=24)
@ -216,7 +221,7 @@ class TestNegative2pointzero(unittest.TestCase):
with patch('glymur.version.openjpeg_version', new=version): with patch('glymur.version.openjpeg_version', new=version):
with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile: with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
with self.assertRaises(IOError): with self.assertRaises(IOError):
j = Jp2k(tfile.name, data=data, cinema2k=48) Jp2k(tfile.name, data=data, cinema2k=48)
@unittest.skipIf(re.match(r'''1.[0-4]''', openjpeg_version) is not None, @unittest.skipIf(re.match(r'''1.[0-4]''', openjpeg_version) is not None,
@ -248,7 +253,6 @@ class TestSuiteWrite(fixtures.MetadataBase):
self.assertEqual(codestream.segment[2].spcod[8], self.assertEqual(codestream.segment[2].spcod[8],
glymur.core.WAVELET_XFORM_9X7_IRREVERSIBLE) glymur.core.WAVELET_XFORM_9X7_IRREVERSIBLE)
def test_NR_ENC_Bretagne1_ppm_1_encode(self): def test_NR_ENC_Bretagne1_ppm_1_encode(self):
"""NR-ENC-Bretagne1.ppm-1-encode""" """NR-ENC-Bretagne1.ppm-1-encode"""
infile = opj_data_file('input/nonregression/Bretagne1.ppm') infile = opj_data_file('input/nonregression/Bretagne1.ppm')
@ -260,10 +264,11 @@ class TestSuiteWrite(fixtures.MetadataBase):
c = j.get_codestream() c = j.get_codestream()
kwargs = {'rsiz': 0, 'xysiz': (640, 480), 'xyosiz': (0, 0), kwargs = {'rsiz': 0, 'xysiz': (640, 480), 'xyosiz': (0, 0),
'xytsiz': (640, 480), 'xytosiz': (0, 0), 'xytsiz': (640, 480), 'xytosiz': (0, 0),
'bitdepth': (8, 8, 8), 'signed': (False, False, False), 'bitdepth': (8, 8, 8), 'signed': (False, False, False),
'xyrsiz': [(1, 1, 1), (1, 1, 1)]} 'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
self.verifySizSegment(c.segment[1], glymur.codestream.SIZsegment(**kwargs)) self.verifySizSegment(c.segment[1],
glymur.codestream.SIZsegment(**kwargs))
# COD: Coding style default # COD: Coding style default
self.assertFalse(c.segment[2].scod & 2) # no sop self.assertFalse(c.segment[2].scod & 2) # no sop
@ -275,7 +280,7 @@ class TestSuiteWrite(fixtures.MetadataBase):
self.assertEqual(tuple(c.segment[2].code_block_size), self.assertEqual(tuple(c.segment[2].code_block_size),
(64, 64)) # cblksz (64, 64)) # cblksz
self.verify_codeblock_style(c.segment[2].spcod[7], self.verify_codeblock_style(c.segment[2].spcod[7],
[False, False, False, False, False, False]) [False, False, False, False, False, False])
self.assertEqual(c.segment[2].spcod[8], self.assertEqual(c.segment[2].spcod[8],
glymur.core.WAVELET_XFORM_5X3_REVERSIBLE) glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
self.assertEqual(len(c.segment[2].spcod), 9) self.assertEqual(len(c.segment[2].spcod), 9)
@ -291,10 +296,11 @@ class TestSuiteWrite(fixtures.MetadataBase):
codestream = j.get_codestream() codestream = j.get_codestream()
kwargs = {'rsiz': 0, 'xysiz': (640, 480), 'xyosiz': (0, 0), kwargs = {'rsiz': 0, 'xysiz': (640, 480), 'xyosiz': (0, 0),
'xytsiz': (640, 480), 'xytosiz': (0, 0), 'xytsiz': (640, 480), 'xytosiz': (0, 0),
'bitdepth': (8, 8, 8), 'signed': (False, False, False), 'bitdepth': (8, 8, 8), 'signed': (False, False, False),
'xyrsiz': [(1, 1, 1), (1, 1, 1)]} 'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
self.verifySizSegment(codestream.segment[1], glymur.codestream.SIZsegment(**kwargs)) self.verifySizSegment(codestream.segment[1],
glymur.codestream.SIZsegment(**kwargs))
# COD: Coding style default # COD: Coding style default
self.assertFalse(codestream.segment[2].scod & 2) # no sop self.assertFalse(codestream.segment[2].scod & 2) # no sop
@ -306,7 +312,8 @@ class TestSuiteWrite(fixtures.MetadataBase):
self.assertEqual(tuple(codestream.segment[2].code_block_size), self.assertEqual(tuple(codestream.segment[2].code_block_size),
(64, 64)) # cblksz (64, 64)) # cblksz
self.verify_codeblock_style(codestream.segment[2].spcod[7], self.verify_codeblock_style(codestream.segment[2].spcod[7],
[False, False, False, False, False, False]) [False, False,
False, False, False, False])
self.assertEqual(codestream.segment[2].spcod[8], self.assertEqual(codestream.segment[2].spcod[8],
glymur.core.WAVELET_XFORM_5X3_REVERSIBLE) glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
self.assertEqual(len(codestream.segment[2].spcod), 9) self.assertEqual(len(codestream.segment[2].spcod), 9)
@ -317,17 +324,18 @@ class TestSuiteWrite(fixtures.MetadataBase):
data = read_image(infile) data = read_image(infile)
with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile: with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
j = Jp2k(tfile.name, j = Jp2k(tfile.name,
data=data, data=data,
psnr=[30, 35, 40], cbsize=(16, 16), psizes=[(64, 64)]) psnr=[30, 35, 40], cbsize=(16, 16), psizes=[(64, 64)])
# Should be three layers. # Should be three layers.
codestream = j.get_codestream() codestream = j.get_codestream()
kwargs = {'rsiz': 0, 'xysiz': (640, 480), 'xyosiz': (0, 0), kwargs = {'rsiz': 0, 'xysiz': (640, 480), 'xyosiz': (0, 0),
'xytsiz': (640, 480), 'xytosiz': (0, 0), 'xytsiz': (640, 480), 'xytosiz': (0, 0),
'bitdepth': (8, 8, 8), 'signed': (False, False, False), 'bitdepth': (8, 8, 8), 'signed': (False, False, False),
'xyrsiz': [(1, 1, 1), (1, 1, 1)]} 'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
self.verifySizSegment(codestream.segment[1], glymur.codestream.SIZsegment(**kwargs)) self.verifySizSegment(codestream.segment[1],
glymur.codestream.SIZsegment(**kwargs))
# COD: Coding style default # COD: Coding style default
self.assertFalse(codestream.segment[2].scod & 2) # no sop self.assertFalse(codestream.segment[2].scod & 2) # no sop
@ -339,7 +347,8 @@ class TestSuiteWrite(fixtures.MetadataBase):
self.assertEqual(tuple(codestream.segment[2].code_block_size), self.assertEqual(tuple(codestream.segment[2].code_block_size),
(16, 16)) # cblksz (16, 16)) # cblksz
self.verify_codeblock_style(codestream.segment[2].spcod[7], self.verify_codeblock_style(codestream.segment[2].spcod[7],
[False, False, False, False, False, False]) [False, False,
False, False, False, False])
self.assertEqual(codestream.segment[2].spcod[8], self.assertEqual(codestream.segment[2].spcod[8],
glymur.core.WAVELET_XFORM_5X3_REVERSIBLE) glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
self.assertEqual(codestream.segment[2].precinct_size, self.assertEqual(codestream.segment[2].precinct_size,
@ -352,20 +361,21 @@ class TestSuiteWrite(fixtures.MetadataBase):
data = read_image(infile) data = read_image(infile)
with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile: with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
j = Jp2k(tfile.name, j = Jp2k(tfile.name,
data=data, data=data,
psizes=[(128, 128)] * 3, psizes=[(128, 128)] * 3,
cratios=[100, 20, 2], cratios=[100, 20, 2],
tilesize=(480, 640), tilesize=(480, 640),
cbsize=(32, 32)) cbsize=(32, 32))
# Should be three layers. # Should be three layers.
codestream = j.get_codestream() codestream = j.get_codestream()
kwargs = {'rsiz': 0, 'xysiz': (2592, 1944), 'xyosiz': (0, 0), kwargs = {'rsiz': 0, 'xysiz': (2592, 1944), 'xyosiz': (0, 0),
'xytsiz': (640, 480), 'xytosiz': (0, 0), 'xytsiz': (640, 480), 'xytosiz': (0, 0),
'bitdepth': (8, 8, 8), 'signed': (False, False, False), 'bitdepth': (8, 8, 8), 'signed': (False, False, False),
'xyrsiz': [(1, 1, 1), (1, 1, 1)]} 'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
self.verifySizSegment(codestream.segment[1], glymur.codestream.SIZsegment(**kwargs)) self.verifySizSegment(codestream.segment[1],
glymur.codestream.SIZsegment(**kwargs))
# COD: Coding style default # COD: Coding style default
self.assertFalse(codestream.segment[2].scod & 2) # no sop self.assertFalse(codestream.segment[2].scod & 2) # no sop
@ -377,7 +387,8 @@ class TestSuiteWrite(fixtures.MetadataBase):
self.assertEqual(tuple(codestream.segment[2].code_block_size), self.assertEqual(tuple(codestream.segment[2].code_block_size),
(32, 32)) # cblksz (32, 32)) # cblksz
self.verify_codeblock_style(codestream.segment[2].spcod[7], self.verify_codeblock_style(codestream.segment[2].spcod[7],
[False, False, False, False, False, False]) [False, False,
False, False, False, False])
self.assertEqual(codestream.segment[2].spcod[8], self.assertEqual(codestream.segment[2].spcod[8],
glymur.core.WAVELET_XFORM_5X3_REVERSIBLE) glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
self.assertEqual(codestream.segment[2].precinct_size, self.assertEqual(codestream.segment[2].precinct_size,
@ -393,10 +404,11 @@ class TestSuiteWrite(fixtures.MetadataBase):
codestream = j.get_codestream() codestream = j.get_codestream()
kwargs = {'rsiz': 0, 'xysiz': (2592, 1944), 'xyosiz': (0, 0), kwargs = {'rsiz': 0, 'xysiz': (2592, 1944), 'xyosiz': (0, 0),
'xytsiz': (127, 127), 'xytosiz': (0, 0), 'xytsiz': (127, 127), 'xytosiz': (0, 0),
'bitdepth': (8, 8, 8), 'signed': (False, False, False), 'bitdepth': (8, 8, 8), 'signed': (False, False, False),
'xyrsiz': [(1, 1, 1), (1, 1, 1)]} 'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
self.verifySizSegment(codestream.segment[1], glymur.codestream.SIZsegment(**kwargs)) self.verifySizSegment(codestream.segment[1],
glymur.codestream.SIZsegment(**kwargs))
# COD: Coding style default # COD: Coding style default
self.assertFalse(codestream.segment[2].scod & 2) # no sop self.assertFalse(codestream.segment[2].scod & 2) # no sop
@ -408,7 +420,8 @@ class TestSuiteWrite(fixtures.MetadataBase):
self.assertEqual(tuple(codestream.segment[2].code_block_size), self.assertEqual(tuple(codestream.segment[2].code_block_size),
(64, 64)) # cblksz (64, 64)) # cblksz
self.verify_codeblock_style(codestream.segment[2].spcod[7], self.verify_codeblock_style(codestream.segment[2].spcod[7],
[False, False, False, False, False, False]) [False, False,
False, False, False, False])
self.assertEqual(codestream.segment[2].spcod[8], self.assertEqual(codestream.segment[2].spcod[8],
glymur.core.WAVELET_XFORM_5X3_REVERSIBLE) glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
self.assertEqual(len(codestream.segment[2].spcod), 9) self.assertEqual(len(codestream.segment[2].spcod), 9)
@ -423,10 +436,11 @@ class TestSuiteWrite(fixtures.MetadataBase):
codestream = j.get_codestream(header_only=False) codestream = j.get_codestream(header_only=False)
kwargs = {'rsiz': 0, 'xysiz': (5183, 3887), 'xyosiz': (0, 0), kwargs = {'rsiz': 0, 'xysiz': (5183, 3887), 'xyosiz': (0, 0),
'xytsiz': (5183, 3887), 'xytosiz': (0, 0), 'xytsiz': (5183, 3887), 'xytosiz': (0, 0),
'bitdepth': (8, 8, 8), 'signed': (False, False, False), 'bitdepth': (8, 8, 8), 'signed': (False, False, False),
'xyrsiz': [(2, 2, 2), (2, 2, 2)]} 'xyrsiz': [(2, 2, 2), (2, 2, 2)]}
self.verifySizSegment(codestream.segment[1], glymur.codestream.SIZsegment(**kwargs)) self.verifySizSegment(codestream.segment[1],
glymur.codestream.SIZsegment(**kwargs))
# COD: Coding style default # COD: Coding style default
self.assertTrue(codestream.segment[2].scod & 2) # sop self.assertTrue(codestream.segment[2].scod & 2) # sop
@ -438,7 +452,8 @@ class TestSuiteWrite(fixtures.MetadataBase):
self.assertEqual(tuple(codestream.segment[2].code_block_size), self.assertEqual(tuple(codestream.segment[2].code_block_size),
(64, 64)) # cblksz (64, 64)) # cblksz
self.verify_codeblock_style(codestream.segment[2].spcod[7], self.verify_codeblock_style(codestream.segment[2].spcod[7],
[False, False, False, False, False, False]) [False, False, False,
False, False, False])
self.assertEqual(codestream.segment[2].spcod[8], self.assertEqual(codestream.segment[2].spcod[8],
glymur.core.WAVELET_XFORM_5X3_REVERSIBLE) glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
self.assertEqual(len(codestream.segment[2].spcod), 9) self.assertEqual(len(codestream.segment[2].spcod), 9)
@ -458,10 +473,11 @@ class TestSuiteWrite(fixtures.MetadataBase):
codestream = j.get_codestream(header_only=False) codestream = j.get_codestream(header_only=False)
kwargs = {'rsiz': 0, 'xysiz': (2592, 1944), 'xyosiz': (0, 0), kwargs = {'rsiz': 0, 'xysiz': (2592, 1944), 'xyosiz': (0, 0),
'xytsiz': (2592, 1944), 'xytosiz': (0, 0), 'xytsiz': (2592, 1944), 'xytosiz': (0, 0),
'bitdepth': (8, 8, 8), 'signed': (False, False, False), 'bitdepth': (8, 8, 8), 'signed': (False, False, False),
'xyrsiz': [(1, 1, 1), (1, 1, 1)]} 'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
self.verifySizSegment(codestream.segment[1], glymur.codestream.SIZsegment(**kwargs)) self.verifySizSegment(codestream.segment[1],
glymur.codestream.SIZsegment(**kwargs))
# COD: Coding style default # COD: Coding style default
self.assertFalse(codestream.segment[2].scod & 2) # no sop self.assertFalse(codestream.segment[2].scod & 2) # no sop
@ -471,9 +487,10 @@ class TestSuiteWrite(fixtures.MetadataBase):
self.assertEqual(codestream.segment[2].spcod[3], 1) # mct self.assertEqual(codestream.segment[2].spcod[3], 1) # mct
self.assertEqual(codestream.segment[2].spcod[4], 5) # levels self.assertEqual(codestream.segment[2].spcod[4], 5) # levels
self.assertEqual(tuple(codestream.segment[2].code_block_size), self.assertEqual(tuple(codestream.segment[2].code_block_size),
(64, 64)) # cblksz (64, 64)) # cblksz
self.verify_codeblock_style(codestream.segment[2].spcod[7], self.verify_codeblock_style(codestream.segment[2].spcod[7],
[False, True, True, False, False, True]) [False, True, True,
False, False, True])
self.assertEqual(codestream.segment[2].spcod[8], self.assertEqual(codestream.segment[2].spcod[8],
glymur.core.WAVELET_XFORM_5X3_REVERSIBLE) glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
self.assertEqual(len(codestream.segment[2].spcod), 9) self.assertEqual(len(codestream.segment[2].spcod), 9)
@ -488,15 +505,16 @@ class TestSuiteWrite(fixtures.MetadataBase):
data = read_image(infile) data = read_image(infile)
with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile: with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
j = Jp2k(tfile.name, j = Jp2k(tfile.name,
data=data, grid_offset=[300, 150], cratios=[800]) data=data, grid_offset=[300, 150], cratios=[800])
codestream = j.get_codestream(header_only=False) codestream = j.get_codestream(header_only=False)
kwargs = {'rsiz': 0, 'xysiz': (2742, 2244), 'xyosiz': (150, 300), kwargs = {'rsiz': 0, 'xysiz': (2742, 2244), 'xyosiz': (150, 300),
'xytsiz': (2742, 2244), 'xytosiz': (0, 0), 'xytsiz': (2742, 2244), 'xytosiz': (0, 0),
'bitdepth': (8, 8, 8), 'signed': (False, False, False), 'bitdepth': (8, 8, 8), 'signed': (False, False, False),
'xyrsiz': [(1, 1, 1), (1, 1, 1)]} 'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
self.verifySizSegment(codestream.segment[1], glymur.codestream.SIZsegment(**kwargs)) self.verifySizSegment(codestream.segment[1],
glymur.codestream.SIZsegment(**kwargs))
# COD: Coding style default # COD: Coding style default
self.assertFalse(codestream.segment[2].scod & 2) # no sop self.assertFalse(codestream.segment[2].scod & 2) # no sop
@ -508,7 +526,8 @@ class TestSuiteWrite(fixtures.MetadataBase):
self.assertEqual(tuple(codestream.segment[2].code_block_size), self.assertEqual(tuple(codestream.segment[2].code_block_size),
(64, 64)) # cblksz (64, 64)) # cblksz
self.verify_codeblock_style(codestream.segment[2].spcod[7], self.verify_codeblock_style(codestream.segment[2].spcod[7],
[False, False, False, False, False, False]) [False, False, False,
False, False, False])
self.assertEqual(codestream.segment[2].spcod[8], self.assertEqual(codestream.segment[2].spcod[8],
glymur.core.WAVELET_XFORM_5X3_REVERSIBLE) glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
self.assertEqual(len(codestream.segment[2].spcod), 9) self.assertEqual(len(codestream.segment[2].spcod), 9)
@ -523,10 +542,11 @@ class TestSuiteWrite(fixtures.MetadataBase):
codestream = j.get_codestream(header_only=False) codestream = j.get_codestream(header_only=False)
kwargs = {'rsiz': 0, 'xysiz': (2592, 1944), 'xyosiz': (0, 0), kwargs = {'rsiz': 0, 'xysiz': (2592, 1944), 'xyosiz': (0, 0),
'xytsiz': (2592, 1944), 'xytosiz': (0, 0), 'xytsiz': (2592, 1944), 'xytosiz': (0, 0),
'bitdepth': (8, 8, 8), 'signed': (False, False, False), 'bitdepth': (8, 8, 8), 'signed': (False, False, False),
'xyrsiz': [(1, 1, 1), (1, 1, 1)]} 'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
self.verifySizSegment(codestream.segment[1], glymur.codestream.SIZsegment(**kwargs)) self.verifySizSegment(codestream.segment[1],
glymur.codestream.SIZsegment(**kwargs))
# COD: Coding style default # COD: Coding style default
self.assertFalse(codestream.segment[2].scod & 2) # no sop self.assertFalse(codestream.segment[2].scod & 2) # no sop
@ -538,7 +558,8 @@ class TestSuiteWrite(fixtures.MetadataBase):
self.assertEqual(tuple(codestream.segment[2].code_block_size), self.assertEqual(tuple(codestream.segment[2].code_block_size),
(64, 64)) # cblksz (64, 64)) # cblksz
self.verify_codeblock_style(codestream.segment[2].spcod[7], self.verify_codeblock_style(codestream.segment[2].spcod[7],
[False, False, False, False, False, False]) [False, False, False,
False, False, False])
self.assertEqual(codestream.segment[2].spcod[8], self.assertEqual(codestream.segment[2].spcod[8],
glymur.core.WAVELET_XFORM_5X3_REVERSIBLE) glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
self.assertEqual(len(codestream.segment[2].spcod), 9) self.assertEqual(len(codestream.segment[2].spcod), 9)
@ -553,10 +574,11 @@ class TestSuiteWrite(fixtures.MetadataBase):
codestream = j.get_codestream(header_only=False) codestream = j.get_codestream(header_only=False)
kwargs = {'rsiz': 0, 'xysiz': (640, 480), 'xyosiz': (0, 0), kwargs = {'rsiz': 0, 'xysiz': (640, 480), 'xyosiz': (0, 0),
'xytsiz': (640, 480), 'xytosiz': (0, 0), 'xytsiz': (640, 480), 'xytosiz': (0, 0),
'bitdepth': (8, 8, 8), 'signed': (False, False, False), 'bitdepth': (8, 8, 8), 'signed': (False, False, False),
'xyrsiz': [(1, 1, 1), (1, 1, 1)]} 'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
self.verifySizSegment(codestream.segment[1], glymur.codestream.SIZsegment(**kwargs)) self.verifySizSegment(codestream.segment[1],
glymur.codestream.SIZsegment(**kwargs))
# COD: Coding style default # COD: Coding style default
self.assertFalse(codestream.segment[2].scod & 2) # no sop self.assertFalse(codestream.segment[2].scod & 2) # no sop
@ -568,7 +590,8 @@ class TestSuiteWrite(fixtures.MetadataBase):
self.assertEqual(tuple(codestream.segment[2].code_block_size), self.assertEqual(tuple(codestream.segment[2].code_block_size),
(64, 64)) # cblksz (64, 64)) # cblksz
self.verify_codeblock_style(codestream.segment[2].spcod[7], self.verify_codeblock_style(codestream.segment[2].spcod[7],
[False, False, False, False, False, False]) [False, False, False,
False, False, False])
self.assertEqual(codestream.segment[2].spcod[8], self.assertEqual(codestream.segment[2].spcod[8],
glymur.core.WAVELET_XFORM_5X3_REVERSIBLE) glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
self.assertEqual(len(codestream.segment[2].spcod), 9) self.assertEqual(len(codestream.segment[2].spcod), 9)
@ -578,7 +601,7 @@ class TestSuiteWrite(fixtures.MetadataBase):
data = read_image(opj_data_file('input/nonregression/Rome.bmp')) data = read_image(opj_data_file('input/nonregression/Rome.bmp'))
with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile: with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile:
jp2 = Jp2k(tfile.name, jp2 = Jp2k(tfile.name,
data=data, psnr=[30, 35, 50], prog='LRCP', numres=3) data=data, psnr=[30, 35, 50], prog='LRCP', numres=3)
ids = [box.box_id for box in jp2.box] ids = [box.box_id for box in jp2.box]
self.assertEqual(ids, ['jP ', 'ftyp', 'jp2h', 'jp2c']) self.assertEqual(ids, ['jP ', 'ftyp', 'jp2h', 'jp2c'])
@ -616,10 +639,11 @@ class TestSuiteWrite(fixtures.MetadataBase):
codestream = jp2.box[3].main_header codestream = jp2.box[3].main_header
kwargs = {'rsiz': 0, 'xysiz': (640, 480), 'xyosiz': (0, 0), kwargs = {'rsiz': 0, 'xysiz': (640, 480), 'xyosiz': (0, 0),
'xytsiz': (640, 480), 'xytosiz': (0, 0), 'xytsiz': (640, 480), 'xytosiz': (0, 0),
'bitdepth': (8, 8, 8), 'signed': (False, False, False), 'bitdepth': (8, 8, 8), 'signed': (False, False, False),
'xyrsiz': [(1, 1, 1), (1, 1, 1)]} 'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
self.verifySizSegment(codestream.segment[1], glymur.codestream.SIZsegment(**kwargs)) self.verifySizSegment(codestream.segment[1],
glymur.codestream.SIZsegment(**kwargs))
# COD: Coding style default # COD: Coding style default
self.assertFalse(codestream.segment[2].scod & 2) # no sop self.assertFalse(codestream.segment[2].scod & 2) # no sop
@ -631,7 +655,8 @@ class TestSuiteWrite(fixtures.MetadataBase):
self.assertEqual(tuple(codestream.segment[2].code_block_size), self.assertEqual(tuple(codestream.segment[2].code_block_size),
(64, 64)) # cblksz (64, 64)) # cblksz
self.verify_codeblock_style(codestream.segment[2].spcod[7], self.verify_codeblock_style(codestream.segment[2].spcod[7],
[False, False, False, False, False, False]) [False, False, False,
False, False, False])
self.assertEqual(codestream.segment[2].spcod[8], self.assertEqual(codestream.segment[2].spcod[8],
glymur.core.WAVELET_XFORM_5X3_REVERSIBLE) glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
self.assertEqual(len(codestream.segment[2].spcod), 9) self.assertEqual(len(codestream.segment[2].spcod), 9)
@ -648,10 +673,11 @@ class TestSuiteWrite(fixtures.MetadataBase):
codestream = j.get_codestream(header_only=False) codestream = j.get_codestream(header_only=False)
kwargs = {'rsiz': 0, 'xysiz': (1024, 1024), 'xyosiz': (0, 0), kwargs = {'rsiz': 0, 'xysiz': (1024, 1024), 'xyosiz': (0, 0),
'xytsiz': (1024, 1024), 'xytosiz': (0, 0), 'xytsiz': (1024, 1024), 'xytosiz': (0, 0),
'bitdepth': (16,), 'signed': (False,), 'bitdepth': (16,), 'signed': (False,),
'xyrsiz': [(1,), (1,)]} 'xyrsiz': [(1,), (1,)]}
self.verifySizSegment(codestream.segment[1], glymur.codestream.SIZsegment(**kwargs)) self.verifySizSegment(codestream.segment[1],
glymur.codestream.SIZsegment(**kwargs))
# COD: Coding style default # COD: Coding style default
self.assertFalse(codestream.segment[2].scod & 2) # no sop self.assertFalse(codestream.segment[2].scod & 2) # no sop
@ -663,7 +689,8 @@ class TestSuiteWrite(fixtures.MetadataBase):
self.assertEqual(tuple(codestream.segment[2].code_block_size), self.assertEqual(tuple(codestream.segment[2].code_block_size),
(64, 64)) # cblksz (64, 64)) # cblksz
self.verify_codeblock_style(codestream.segment[2].spcod[7], self.verify_codeblock_style(codestream.segment[2].spcod[7],
[False, False, False, False, False, False]) [False, False, False,
False, False, False])
self.assertEqual(codestream.segment[2].spcod[8], self.assertEqual(codestream.segment[2].spcod[8],
glymur.core.WAVELET_XFORM_5X3_REVERSIBLE) glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
self.assertEqual(len(codestream.segment[2].spcod), 9) self.assertEqual(len(codestream.segment[2].spcod), 9)

53
glymur/test/test_printing.py
View file

@ -32,11 +32,12 @@ import lxml.etree as ET
import glymur import glymur
from glymur import Jp2k, command_line from glymur import Jp2k, command_line
from . import fixtures from . import fixtures
from .fixtures import ( from .fixtures import (OPJ_DATA_ROOT, opj_data_file,
OPJ_DATA_ROOT, opj_data_file, WARNING_INFRASTRUCTURE_ISSUE,
WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG, WARNING_INFRASTRUCTURE_MSG,
WINDOWS_TMP_FILE_MSG, text_gbr_27, text_gbr_33, text_gbr_34 WINDOWS_TMP_FILE_MSG,
) text_gbr_27, text_gbr_33, text_gbr_34)
@unittest.skipIf(os.name == "nt", WINDOWS_TMP_FILE_MSG) @unittest.skipIf(os.name == "nt", WINDOWS_TMP_FILE_MSG)
class TestPrinting(unittest.TestCase): class TestPrinting(unittest.TestCase):
@ -52,23 +53,11 @@ class TestPrinting(unittest.TestCase):
def tearDown(self): def tearDown(self):
pass pass
def test_codestream(self):
"""Should be able to print a raw codestream."""
j = glymur.Jp2k(self.j2kfile)
with patch('sys.stdout', new=StringIO()) as fake_out:
print(j)
actual = fake_out.getvalue().strip()
# Remove the file line, as that is filesystem-dependent.
lines = actual.split('\n')
actual = '\n'.join(lines[1:])
self.assertEqual(actual, fixtures.codestream)
def test_version_info(self): def test_version_info(self):
"""Should be able to print(glymur.version.info)""" """Should be able to print(glymur.version.info)"""
with patch('sys.stdout', new=StringIO()) as fake_out: with patch('sys.stdout', new=StringIO()) as fake_out:
print(glymur.version.info) print(glymur.version.info)
actual = fake_out.getvalue().strip() fake_out.getvalue().strip()
self.assertTrue(True) self.assertTrue(True)
@ -107,7 +96,8 @@ class TestPrinting(unittest.TestCase):
with self.assertRaises(TypeError): with self.assertRaises(TypeError):
glymur.set_printoptions(hi='low') glymur.set_printoptions(hi='low')
@unittest.skipIf(re.match("1.5|2", glymur.version.openjpeg_version) is None, @unittest.skipIf(re.match("1.5|2",
glymur.version.openjpeg_version) is None,
"Must have openjpeg 1.5 or higher to run") "Must have openjpeg 1.5 or higher to run")
def test_asoc_label_box(self): def test_asoc_label_box(self):
"""verify printing of asoc, label boxes""" """verify printing of asoc, label boxes"""
@ -115,9 +105,8 @@ class TestPrinting(unittest.TestCase):
# OpenJPEG doesn't have such a file. # OpenJPEG doesn't have such a file.
data = glymur.Jp2k(self.jp2file)[::2, ::2] data = glymur.Jp2k(self.jp2file)[::2, ::2]
with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile: with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile:
j = glymur.Jp2k(tfile.name, data=data)
with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile2: with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile2:
j = glymur.Jp2k(tfile.name, data=data)
# Offset of the codestream is where we start. # Offset of the codestream is where we start.
wbuffer = tfile.read(77) wbuffer = tfile.read(77)
@ -419,7 +408,7 @@ class TestPrinting(unittest.TestCase):
@unittest.skipIf(sys.hexversion < 0x03000000, @unittest.skipIf(sys.hexversion < 0x03000000,
"Only trusting python3 for printing non-ascii chars") "Only trusting python3 for printing non-ascii chars")
def test_xml_cyrrilic(self): def test_xml_cyrrilic(self):
"""Should be able to print an XMLBox with utf-8 encoding (cyrrillic).""" """Should be able to print XMLBox with utf-8 encoding (cyrrillic)."""
# Seems to be inconsistencies between different versions of python2.x # Seems to be inconsistencies between different versions of python2.x
# as to what gets printed. # as to what gets printed.
# #
@ -437,7 +426,8 @@ class TestPrinting(unittest.TestCase):
actual = fake_out.getvalue().strip() actual = fake_out.getvalue().strip()
if sys.hexversion < 0x03000000: if sys.hexversion < 0x03000000:
lines = ["XML Box (xml ) @ (-1, 0)", lines = ["XML Box (xml ) @ (-1, 0)",
" <country>&#1056;&#1086;&#1089;&#1089;&#1080;&#1103;</country>"] (" <country>&#1056;&#1086;&#1089;&#1089;",
"&#1080;&#1103;</country>")]
else: else:
lines = ["XML Box (xml ) @ (-1, 0)", lines = ["XML Box (xml ) @ (-1, 0)",
" <country>Россия</country>"] " <country>Россия</country>"]
@ -613,12 +603,14 @@ class TestPrinting(unittest.TestCase):
lines = ["UUID Box (uuid) @ (1135519, 76)", lines = ["UUID Box (uuid) @ (1135519, 76)",
" UUID: 4a706754-6966-6645-7869-662d3e4a5032 (EXIF)", " UUID: 4a706754-6966-6645-7869-662d3e4a5032 (EXIF)",
" UUID Data: OrderedDict([('ImageWidth', 256), ('ImageLength', 512), ('Make', 'HTC')])"] (" UUID Data: OrderedDict([('ImageWidth', 256),"
" ('ImageLength', 512), ('Make', 'HTC')])")]
expected = '\n'.join(lines) expected = '\n'.join(lines)
self.assertEqual(actual, expected) self.assertEqual(actual, expected)
@unittest.skipIf(OPJ_DATA_ROOT is None, @unittest.skipIf(OPJ_DATA_ROOT is None,
"OPJ_DATA_ROOT environment variable not set") "OPJ_DATA_ROOT environment variable not set")
@unittest.skipIf(os.name == "nt", "Temporary file issue on window.") @unittest.skipIf(os.name == "nt", "Temporary file issue on window.")
@ -826,6 +818,7 @@ class TestPrintingOpjDataRoot(unittest.TestCase):
expected = '\n'.join(lines) expected = '\n'.join(lines)
self.assertEqual(actual, expected) self.assertEqual(actual, expected)
@unittest.skipIf(OPJ_DATA_ROOT is None, @unittest.skipIf(OPJ_DATA_ROOT is None,
"OPJ_DATA_ROOT environment variable not set") "OPJ_DATA_ROOT environment variable not set")
@unittest.skipIf(os.name == "nt", "Temporary file issue on window.") @unittest.skipIf(os.name == "nt", "Temporary file issue on window.")
@ -852,7 +845,7 @@ class TestPrintingOpjDataRootWarns(unittest.TestCase):
filename = opj_data_file('input/nonregression/edf_c2_1103421.jp2') filename = opj_data_file('input/nonregression/edf_c2_1103421.jp2')
with self.assertWarns(UserWarning): with self.assertWarns(UserWarning):
jp2 = Jp2k(filename) jp2 = Jp2k(filename)
with patch('sys.stdout', new=StringIO()) as fake_out: with patch('sys.stdout', new=StringIO()):
print(jp2) print(jp2)
def test_bad_rsiz(self): def test_bad_rsiz(self):
@ -860,7 +853,7 @@ class TestPrintingOpjDataRootWarns(unittest.TestCase):
filename = opj_data_file('input/nonregression/edf_c2_1002767.jp2') filename = opj_data_file('input/nonregression/edf_c2_1002767.jp2')
with self.assertWarns(UserWarning): with self.assertWarns(UserWarning):
j = Jp2k(filename) j = Jp2k(filename)
with patch('sys.stdout', new=StringIO()) as fake_out: with patch('sys.stdout', new=StringIO()):
print(j) print(j)
def test_bad_wavelet_transform(self): def test_bad_wavelet_transform(self):
@ -868,7 +861,7 @@ class TestPrintingOpjDataRootWarns(unittest.TestCase):
filename = opj_data_file('input/nonregression/edf_c2_10025.jp2') filename = opj_data_file('input/nonregression/edf_c2_10025.jp2')
with self.assertWarns(UserWarning): with self.assertWarns(UserWarning):
jp2 = Jp2k(filename) jp2 = Jp2k(filename)
with patch('sys.stdout', new=StringIO()) as fake_out: with patch('sys.stdout', new=StringIO()):
print(jp2) print(jp2)
def test_invalid_progression_order(self): def test_invalid_progression_order(self):
@ -1029,7 +1022,7 @@ class TestPrintingOpjDataRootWarns(unittest.TestCase):
'issue171.jp2')) 'issue171.jp2'))
with self.assertWarns(UserWarning): with self.assertWarns(UserWarning):
jp2 = Jp2k(filename) jp2 = Jp2k(filename)
with patch('sys.stdout', new=StringIO()) as fake_out: with patch('sys.stdout', new=StringIO()):
# No need to verify, it's enough that we don't error out. # No need to verify, it's enough that we don't error out.
print(jp2) print(jp2)
@ -1069,7 +1062,8 @@ class TestJp2dump(unittest.TestCase):
"""Verify dumping with -c 0, supressing all codestream details.""" """Verify dumping with -c 0, supressing all codestream details."""
actual = self.run_jp2dump(['', '-c', '0', self.jp2file]) actual = self.run_jp2dump(['', '-c', '0', self.jp2file])
self.assertEqual(actual, fixtures.nemo_dump_no_codestream) expected = fixtures.nemo_dump_no_codestream
self.assertEqual(actual, expected)
def test_codestream_1(self): def test_codestream_1(self):
"""Verify dumping with -c 1, print just the header.""" """Verify dumping with -c 1, print just the header."""
@ -1112,4 +1106,3 @@ class TestJp2dump(unittest.TestCase):
command_line.main() command_line.main()
actual = fake_out.getvalue().strip() actual = fake_out.getvalue().strip()
self.assertRegex(actual, "File: .*") self.assertRegex(actual, "File: .*")