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 openjpeg as openjpeg
from . import c
__all__ = [openjp2, openjpeg, c]

44
glymur/lib/config.py
View file

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

50
glymur/lib/openjpeg.py
View file

@ -6,8 +6,6 @@
import ctypes
import sys
import numpy as np
from .config import glymur_config
_, OPENJPEG = glymur_config()
@ -364,9 +362,9 @@ class DecompressionParametersType(ctypes.Structure):
class ImageComptParmType(ctypes.Structure):
"""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
("dx", ctypes.c_int),
# YRsiz: vertical separation of a sample of ith component with
# respect to the reference grid */
@ -527,50 +525,6 @@ def 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):
"""Wrapper for openjpeg library function opj_image_create.
"""

22
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.
WINDOWS_TMP_FILE_MSG = "cannot use NamedTemporaryFile like this in windows"
class MetadataBase(unittest.TestCase):
"""
Base class for testing metadata.
@ -101,8 +102,8 @@ class MetadataBase(unittest.TestCase):
"""
verify the fields of a RGN segment
"""
self.assertEqual(actual.crgn, expected.crgn) # 0 = component
self.assertEqual(actual.srgn, expected.srgn) # 0 = implicit
self.assertEqual(actual.crgn, expected.crgn) # 0 = component
self.assertEqual(actual.srgn, expected.srgn) # 0 = implicit
self.assertEqual(actual.sprgn, expected.sprgn)
def verifySOTsegment(self, actual, expected):
@ -125,8 +126,9 @@ class MetadataBase(unittest.TestCase):
"""
Verify the fields of the SIZ segment.
"""
for field in ['rsiz', 'xsiz', 'ysiz', 'xosiz', 'yosiz', 'xtsiz',
'ytsiz', 'xtosiz', 'ytosiz', 'bitdepth', 'xrsiz', 'yrsiz']:
for field in ['rsiz', 'xsiz', 'ysiz', 'xosiz', 'yosiz', 'xtsiz',
'ytsiz', 'xtosiz', 'ytosiz', 'bitdepth',
'xrsiz', 'yrsiz']:
self.assertEqual(getattr(actual, field), getattr(expected, field))
def verifyImageHeaderBox(self, box1, box2):
@ -153,7 +155,7 @@ class MetadataBase(unittest.TestCase):
else:
self.assertEqual(actual.colorspace, expected.colorspace)
self.assertIsNone(actual.icc_profile)
# The Python XMP Toolkit may be used for XMP UUIDs, but only if available and
# if the version is at least 2.0.0.
@ -183,7 +185,7 @@ except:
# The Cinema2K/4K tests seem to need the freeimage backend to skimage.io
# in order to work. Unfortunately, scikit-image/freeimage is about as wonky as
# it gets. Anaconda can get totally weirded out on versions up through 3.6.4
# on Python3 with scikit-image up through version 0.10.0.
# on Python3 with scikit-image up through version 0.10.0.
NO_SKIMAGE_FREEIMAGE_SUPPORT = False
try:
import skimage
@ -211,7 +213,7 @@ def _indent(textstr):
String to be indented.
indent_level : str
Number of spaces of indentation to add.
Returns
-------
indented_string : str
@ -600,7 +602,6 @@ Contiguous Codestream Box (jp2c) @ (3223, 1132296)
"Created by OpenJPEG version 2.0.0"'''
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)
File Type Box (ftyp) @ (12, 20)
@ -613,7 +614,7 @@ Contiguous Codestream Box (jp2c) @ (3223, 1132296)"""
nemo_dump_no_xml = '''JPEG 2000 Signature Box (jP ) @ (0, 12)
Signature: 0d0a870a
File Type Box (ftyp) @ (12, 20)
Brand: jp2
Brand: jp2
Compatibility: ['jp2 ']
JP2 Header Box (jp2h) @ (32, 45)
Image Header Box (ihdr) @ (40, 22)
@ -743,7 +744,7 @@ issue_183_colr = """Colour Specification Box (colr) @ (62, 12)
Method: restricted ICC profile
Precedence: 0
ICC Profile: None"""
# Progression order is invalid.
issue_186_progression_order = """COD marker segment @ (174, 12)
@ -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)]
SOD marker segment @ (164, 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
class TestCallbacks(unittest.TestCase):
"""Test suite for callbacks."""
@ -46,7 +47,7 @@ class TestCallbacks(unittest.TestCase):
tiledata = j.read(tile=0)
with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile:
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()
expected = '[INFO] tile number 1 / 1'
self.assertEqual(actual, expected)
@ -60,7 +61,7 @@ class TestCallbacks(unittest.TestCase):
tiledata = j[:]
with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile:
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()
expected = '[INFO] tile number 1 / 1'
self.assertEqual(actual, expected)

47
glymur/test/test_config.py
View file

@ -10,7 +10,7 @@ OPENJP2 may be present in some form or other.
# unittest.mock only in Python 3.3 (python2.7/pylint import issue)
# pylint: disable=E0611,F0401
import contextlib
import contextlib
import ctypes
import imp
import os
@ -26,41 +26,42 @@ else:
import glymur
from glymur import Jp2k
from .fixtures import (
WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG,
WINDOWS_TMP_FILE_MSG
)
from .fixtures import (WARNING_INFRASTRUCTURE_ISSUE,
WARNING_INFRASTRUCTURE_MSG,
WINDOWS_TMP_FILE_MSG)
def openjpeg_not_found_by_ctypes():
"""
Need to know if openjpeg library can be picked right up by ctypes for one
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:
return True
else:
return False
@contextlib.contextmanager
def chdir(dirname=None):
@contextlib.contextmanager
def chdir(dirname=None):
"""
This context manager restores the value of the current working directory
(cwd) after the enclosed code block completes or raises an exception. If a
directory name is supplied to the context manager then the cwd is changed
prior to running the code block.
prior to running the code block.
Shamelessly lifted from
http://www.astropython.org/snippet/2009/10/chdir-context-manager
"""
curdir = os.getcwd()
try:
if dirname is not None:
os.chdir(dirname)
yield
finally:
os.chdir(curdir)
curdir = os.getcwd()
try:
if dirname is not None:
os.chdir(dirname)
yield
finally:
os.chdir(curdir)
@unittest.skipIf(sys.hexversion < 0x03020000,
@ -130,7 +131,7 @@ class TestSuite(unittest.TestCase):
"Needs openjp2 and openjpeg before this test make sense.")
@unittest.skipIf(os.name == "nt", WINDOWS_TMP_FILE_MSG)
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:
configdir = os.path.join(tdir, 'glymur')
os.mkdir(configdir)
@ -140,7 +141,9 @@ class TestSuite(unittest.TestCase):
# openjpeg instead.
fptr.write('[library]\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()
with patch.dict('os.environ', {'XDG_CONFIG_HOME': tdir}):
imp.reload(glymur.lib.openjp2)
@ -149,18 +152,17 @@ class TestSuite(unittest.TestCase):
@unittest.skipIf(glymur.lib.openjp2.OPENJPEG is None,
"Needs openjpeg before this test make sense.")
@unittest.skipIf(openjpeg_not_found_by_ctypes(),
"OpenJPEG must be easily found before this test can work.")
@unittest.skipIf(openjpeg_not_found_by_ctypes(),
"OpenJPEG must be found before this test can work.")
@unittest.skipIf(os.name == "nt", WINDOWS_TMP_FILE_MSG)
def test_config_dir_but_no_config_file(self):
with tempfile.TemporaryDirectory() as tdir:
configdir = os.path.join(tdir, 'glymur')
os.mkdir(configdir)
fname = os.path.join(configdir, 'glymurrc')
with patch.dict('os.environ', {'XDG_CONFIG_HOME': tdir}):
# Should still be able to load openjpeg, despite the
# configuration file being empty.
# configuration file not being there
imp.reload(glymur.lib.openjpeg)
self.assertIsNotNone(glymur.lib.openjp2.OPENJPEG)
@ -178,4 +180,3 @@ class TestSuite(unittest.TestCase):
# Should be able to load openjp2 as before.
imp.reload(glymur.lib.openjp2)
self.assertEqual(glymur.lib.openjp2.OPENJP2._name, libloc)

21
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.
# pylint: disable=R0904
import platform
import os
import re
import struct
import sys
import tempfile
import unittest
import six
from glymur import Jp2k
import glymur
from .fixtures import opj_data_file, OPJ_DATA_ROOT
from .fixtures import WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG
@unittest.skipIf(OPJ_DATA_ROOT is None,
"OPJ_DATA_ROOT environment variable not set")
@unittest.skipIf(WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG)
@ -53,12 +50,11 @@ class TestWarnings(unittest.TestCase):
"""
relpath = 'input/nonregression/issue188_beach_64bitsbox.jp2'
jfile = opj_data_file(relpath)
regex = re.compile(r"""Unrecognized\sbox\s\(b'XML\s'\)\sencountered.""",
re.VERBOSE)
pattern = r"""Unrecognized\sbox\s\(b'XML\s'\)\sencountered."""
regex = re.compile(pattern, re.VERBOSE)
with self.assertWarnsRegex(UserWarning, regex):
Jp2k(jfile)
def test_NR_gdal_fuzzer_unchecked_numresolutions_dump(self):
"""
Has an invalid number of resolutions.
@ -119,7 +115,7 @@ class TestWarnings(unittest.TestCase):
\(\d+\)''',
re.VERBOSE)
with self.assertWarnsRegex(UserWarning, regex):
jp2 = Jp2k(jfile)
Jp2k(jfile)
def test_NR_broken2_jp2_dump(self):
"""
@ -127,7 +123,7 @@ class TestWarnings(unittest.TestCase):
"""
jfile = opj_data_file('input/nonregression/broken2.jp2')
regex = re.compile(r'''Invalid\smarker\sid\sencountered\sat\sbyte\s
\d+\sin\scodestream:\s*"0x[a-fA-F0-9]{4}"''',
\d+\sin\scodestream:\s*"0x[a-fA-F0-9]{4}"''',
re.VERBOSE)
with self.assertWarnsRegex(UserWarning, regex):
Jp2k(jfile)
@ -152,7 +148,8 @@ class TestWarnings(unittest.TestCase):
def test_tile_height_is_zero(self):
"""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'):
Jp2k(filename)
@ -177,9 +174,9 @@ class TestWarnings(unittest.TestCase):
read_buffer = ifile.read()
tfile.write(read_buffer)
tfile.flush()
with self.assertWarnsRegex(UserWarning, 'Unrecognized marker'):
codestream = Jp2k(tfile.name).get_codestream()
Jp2k(tfile.name).get_codestream()
if __name__ == "__main__":

2
glymur/test/test_icc.py
View file

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

64
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 RED, GREEN, BLUE, GREY, WHOLE_IMAGE
from .fixtures import (
WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG,
WINDOWS_TMP_FILE_MSG, MetadataBase
)
from .fixtures import (WARNING_INFRASTRUCTURE_ISSUE,
WARNING_INFRASTRUCTURE_MSG,
WINDOWS_TMP_FILE_MSG, MetadataBase)
def load_tests(loader, tests, ignore):
"""Run doc tests as well."""
@ -48,13 +48,15 @@ def load_tests(loader, tests, ignore):
tests.addTests(doctest.DocTestSuite('glymur.jp2box'))
return tests
@unittest.skipIf(os.name == "nt", WINDOWS_TMP_FILE_MSG)
class TestDataEntryURL(unittest.TestCase):
"""Test suite for DataEntryURL boxes."""
def setUp(self):
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")
def test_wrap_greyscale(self):
"""A single component should be wrapped as GREYSCALE."""
@ -70,7 +72,7 @@ class TestDataEntryURL(unittest.TestCase):
with tempfile.NamedTemporaryFile(suffix=".jp2") as tfile2:
jp2 = j2k.wrap(tfile2.name)
self.assertEqual(jp2.box[2].box[1].colorspace,
glymur.core.GREYSCALE)
glymur.core.GREYSCALE)
def test_basic_url(self):
"""Just your most basic URL box."""
@ -92,7 +94,7 @@ class TestDataEntryURL(unittest.TestCase):
self.assertEqual(jp22.box[4].url, url)
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)
url = 'http://glymur.readthedocs.org'
@ -103,12 +105,15 @@ class TestDataEntryURL(unittest.TestCase):
jp22 = jp2.wrap(tfile.name, boxes=boxes)
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:
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_url = read_buffer.decode('utf-8')
self.assertEqual(url + chr(0), read_url)
@ -128,18 +133,18 @@ class TestChannelDefinition(unittest.TestCase):
data = j2k[:]
# Write the first component back out to file.
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
# Write the first two components back out to file.
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
# Write four components back out to file.
with tempfile.NamedTemporaryFile(suffix=".j2k", delete=False) as tfile:
shape = (data.shape[0], data.shape[1], 1)
alpha = np.zeros((shape), dtype=data.dtype)
data4 = np.concatenate((data, alpha), axis=2)
rgba_jp2 = Jp2k(tfile.name, data=data4)
Jp2k(tfile.name, data=data4)
cls.four_planes = tfile.name
@classmethod
@ -392,7 +397,7 @@ class TestFileTypeBox(unittest.TestCase):
ftyp = glymur.jp2box.FileTypeBox(brand='jp3')
with self.assertRaises(IOError):
with tempfile.TemporaryFile() as tfile:
ftyp.write(tfile)
ftyp.write(tfile)
@unittest.skipIf(WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG)
def test_cl_entry_unknown(self):
@ -402,7 +407,8 @@ class TestFileTypeBox(unittest.TestCase):
ftyp = glymur.jp2box.FileTypeBox(compatibility_list=['jp3'])
with self.assertRaises(IOError):
with tempfile.TemporaryFile() as tfile:
ftyp.write(tfile)
ftyp.write(tfile)
class TestColourSpecificationBox(unittest.TestCase):
"""Test suite for colr box instantiation."""
@ -525,8 +531,8 @@ class TestPaletteBox(unittest.TestCase):
bps = (8, 8, 8)
signed = (False, False)
with self.assertWarns(UserWarning):
pclr = glymur.jp2box.PaletteBox(palette, bits_per_component=bps,
signed=signed)
glymur.jp2box.PaletteBox(palette, bits_per_component=bps,
signed=signed)
@unittest.skipIf(WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG)
def test_mismatched_signed_palette(self):
@ -535,8 +541,8 @@ class TestPaletteBox(unittest.TestCase):
bps = (8, 8, 8, 8)
signed = (False, False, False, False)
with self.assertWarns(UserWarning):
pclr = glymur.jp2box.PaletteBox(palette, bits_per_component=bps,
signed=signed)
glymur.jp2box.PaletteBox(palette, bits_per_component=bps,
signed=signed)
def test_writing_with_different_bitdepths(self):
"""Bitdepths must be the same when writing."""
@ -792,7 +798,7 @@ class TestWrap(unittest.TestCase):
# list to trigger the error.
boxes[2].box = []
with self.assertRaises(IOError):
jp22 = jp2.wrap(tfile.name, boxes=boxes)
jp2.wrap(tfile.name, boxes=boxes)
def test_default_layout_with_boxes(self):
"""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."""
palette = np.array([[255, 0, 255], [0, 255, 0]], dtype=np.int32)
bps = (8, 8, 8)
signed = (True, False, True)
pclr = glymur.jp2box.PaletteBox(palette=palette, bits_per_component=bps,
pclr = glymur.jp2box.PaletteBox(palette=palette,
bits_per_component=bps,
signed=(True, False, True))
j2k = Jp2k(self.j2kfile)
@ -970,7 +976,8 @@ class TestWrap(unittest.TestCase):
"""Rewrap a jpx file."""
with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile1:
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]
jpx2 = jpx.wrap(tfile1.name, boxes=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):
"""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,
j.box[5].offset + 8)
@ -1240,7 +1247,6 @@ class TestRepr(MetadataBase):
"""Verify Palette box repr."""
palette = np.array([[255, 0, 1000], [0, 255, 0]], dtype=np.int32)
bps = (8, 8, 16)
signed = (True, False, True)
box = glymur.jp2box.PaletteBox(palette=palette, bits_per_component=bps,
signed=(True, False, True))
@ -1290,7 +1296,8 @@ class TestRepr(MetadataBase):
# 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()).
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>\)"""
if sys.hexversion < 0x03000000:
@ -1307,7 +1314,8 @@ class TestRepr(MetadataBase):
# 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()).
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>\)"""
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 os
import struct
import sys
import tempfile
import unittest
@ -20,6 +19,7 @@ from glymur.jp2box import ColourSpecificationBox
from .fixtures import WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG
@unittest.skipIf(os.name == "nt", "Temporary file issue on window.")
class TestJPXWrap(unittest.TestCase):
"""Test suite for wrapping JPX files."""
@ -184,7 +184,7 @@ class TestJPXWrap(unittest.TestCase):
with tempfile.NamedTemporaryFile(suffix=".jpx") as tfile:
with self.assertRaises(IOError):
jpx = jp2.wrap(tfile.name, boxes=boxes)
jp2.wrap(tfile.name, boxes=boxes)
def test_cgrp_neg(self):
"""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 self.assertRaises(IOError):
jpx = jp2.wrap(tfile.name, boxes=boxes)
jp2.wrap(tfile.name, boxes=boxes)
def test_ftbl(self):
"""Write a fragment table box."""
@ -484,7 +484,7 @@ class TestJPX(unittest.TestCase):
ftbl.write(tfile)
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
version = (0, 0, 0)
url1 = 'file:////usr/local/bin'
@ -574,7 +574,7 @@ class TestJPX(unittest.TestCase):
131072, 65536, 32768, 16384, 8192]
for j in range(len(standard_flags)):
mask = (standard_masks[j] >> 16,
standard_masks[j] & 0x0000ffff>> 8,
standard_masks[j] & 0x0000ffff >> 8,
standard_masks[j] & 0x000000ff)
struct.pack_into('>HBBB', rreq_buffer, 17 + j * 5,
standard_flags[j], *mask)
@ -599,7 +599,6 @@ class TestJPX(unittest.TestCase):
self.assertEqual(jpx.box[2].standard_flag,
(5, 42, 45, 2, 18, 19, 1, 8, 12, 31, 20))
def test_nlst(self):
"""Verify that we can handle a number list box."""
j = Jp2k(self.jpxfile)

24
glymur/test/test_jp2box_uuid.py
View file

@ -11,7 +11,6 @@
# pylint: disable=R0904
import os
import re
import shutil
import struct
import sys
@ -23,29 +22,15 @@ if sys.hexversion < 0x02070000:
else:
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
from .fixtures import (HAS_PYTHON_XMP_TOOLKIT, OPJ_DATA_ROOT,
WARNING_INFRASTRUCTURE_ISSUE,
from .fixtures import (WARNING_INFRASTRUCTURE_ISSUE,
WARNING_INFRASTRUCTURE_MSG,
WINDOWS_TMP_FILE_MSG)
if HAS_PYTHON_XMP_TOOLKIT:
from libxmp import XMPMeta
import glymur
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)
@ -103,6 +88,7 @@ class TestSuite(unittest.TestCase):
jp2 = glymur.Jp2k(tfile.name)
self.assertEqual(jp2.box[-1].data['Make'], "HTC")
@unittest.skipIf(WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG)
@unittest.skipIf(os.name == "nt", WINDOWS_TMP_FILE_MSG)
class TestSuiteWarns(unittest.TestCase):
@ -113,7 +99,7 @@ class TestSuiteWarns(unittest.TestCase):
def tearDown(self):
pass
def test_unrecognized_exif_tag(self):
"""Verify warning in case of unrecognized tag."""
with tempfile.NamedTemporaryFile(suffix='.jp2', mode='wb') as tfile:
@ -137,7 +123,7 @@ class TestSuiteWarns(unittest.TestCase):
tfile.flush()
with self.assertWarnsRegex(UserWarning, 'Unrecognized Exif tag'):
j = glymur.Jp2k(tfile.name)
glymur.Jp2k(tfile.name)
def test_bad_tag_datatype(self):
"""Only certain datatypes are allowable"""

22
glymur/test/test_jp2box_xml.py
View file

@ -17,20 +17,9 @@ Test suite specifically targeting JP2 box layout.
import os
import re
import struct
import sys
import tempfile
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 glymur
@ -43,6 +32,7 @@ from .fixtures import OPJ_DATA_ROOT, opj_data_file
from .fixtures import WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG
from . import fixtures
@unittest.skipIf(os.name == "nt", fixtures.WINDOWS_TMP_FILE_MSG)
class TestXML(unittest.TestCase):
"""Test suite for XML boxes."""
@ -167,7 +157,6 @@ class TestXML(unittest.TestCase):
u'<country>Россия</country>')
class TestJp2kBadXmlFile(unittest.TestCase):
"""Test suite for bad XML box situations"""
@ -293,22 +282,19 @@ class TestXML_OpjDataRoot(unittest.TestCase):
'nonregression',
'issue171.jp2'))
msg = 'An illegal BOM \(byte order marker\) was detected and removed '
msg += 'from the XML contents in the box starting at byte offset \d+'
msg += 'from the XML contents in the box starting at byte offset \d+'
with self.assertWarnsRegex(UserWarning, re.compile(msg)):
jp2 = Jp2k(filename)
self.assertIsNotNone(jp2.box[3].xml)
def test_invalid_utf8(self):
"""Bad byte sequence that cannot be parsed."""
relname = '26ccf3651020967f7778238ef5af08af.SIGFPE.d25.527.jp2'
filename = opj_data_file(os.path.join('input',
'nonregression',
'26ccf3651020967f7778238ef5af08af.SIGFPE.d25.527.jp2'))
relname))
with self.assertWarns((UserWarning, UserWarning)):
jp2 = Jp2k(filename)
self.assertIsNone(jp2.box[3].box[1].box[1].xml)

243
glymur/test/test_jp2k.py
View file

@ -13,7 +13,6 @@ Tests for general glymur functionality.
import doctest
import os
import re
import shutil
import struct
import sys
import tempfile
@ -45,6 +44,7 @@ if HAS_PYTHON_XMP_TOOLKIT:
from .fixtures import OPJ_DATA_ROOT, opj_data_file
from . import fixtures
# Doc tests should be run as well.
def load_tests(loader, tests, ignore):
# 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_r5 = self.j2k[::32, ::32]
@unittest.skipIf(OPENJPEG_NOT_AVAILABLE, OPENJPEG_NOT_AVAILABLE_MSG)
@unittest.skipIf(re.match("1.5|2", glymur.version.openjpeg_version) is None,
"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)
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):
with self.assertRaises(IndexError):
# Strides in x/y directions cannot differ.
@ -169,8 +165,8 @@ class TestSliceProtocolRead(SliceProtocolBase):
np.testing.assert_array_equal(self.j2k_data[:, :, j], band)
def test_slice_in_third_dimension(self):
actual = self.j2k[:,:,1:3]
expected = self.j2k_data[:,:,1:3]
actual = self.j2k[:, :, 1:3]
expected = self.j2k_data[:, :, 1:3]
np.testing.assert_array_equal(actual, expected)
def test_reduce_resolution_and_slice_in_third_dimension(self):
@ -184,12 +180,12 @@ class TestSliceProtocolRead(SliceProtocolBase):
np.testing.assert_array_equal(actual, expected)
def test_retrieve_single_pixel(self):
actual = self.jp2[0,0]
actual = self.jp2[0, 0]
expected = self.jp2_data[0, 0]
np.testing.assert_array_equal(actual, expected)
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]
np.testing.assert_array_equal(actual, expected)
@ -226,7 +222,7 @@ class TestSliceProtocolRead(SliceProtocolBase):
def test_single_slice(self):
rows = slice(3, 8)
actual = self.j2k[rows]
expected = self.j2k_data[3:8, :,:]
expected = self.j2k_data[3:8, :, :]
np.testing.assert_array_equal(actual, expected)
@unittest.skipIf(re.match("0|1", glymur.version.openjpeg_version),
@ -235,7 +231,7 @@ class TestSliceProtocolRead(SliceProtocolBase):
"""
maximim rlevel
There seems to be a difference between version of openjpeg, as
There seems to be a difference between version of openjpeg, as
openjp2 produces an image of size (16, 13, 3) and openjpeg produced
(17, 12, 3).
"""
@ -243,6 +239,7 @@ class TestSliceProtocolRead(SliceProtocolBase):
expected = self.j2k_data_r5[1:17, 1:14]
np.testing.assert_array_equal(actual, expected)
class TestJp2k(unittest.TestCase):
"""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(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,
"Mysteriously fails in 1.5.1 and 1.5.2")
def test_no_cxform_pclr_jpx(self):
@ -638,7 +635,7 @@ class TestJp2k(unittest.TestCase):
self.assertEqual(ET.tostring(jp2k.box[3].xml.getroot()),
b'<test>this is a test</test>')
@unittest.skipIf(not HAS_PYTHON_XMP_TOOLKIT,
@unittest.skipIf(not HAS_PYTHON_XMP_TOOLKIT,
"Requires Python XMP Toolkit >= 2.0")
def test_xmp_attribute(self):
"""Verify the XMP packet in the shipping example file can be read."""
@ -654,8 +651,9 @@ class TestJp2k(unittest.TestCase):
xmp = XMPMeta()
xmp.parse_from_str(j.box[3].raw_data.decode('utf-8'),
xmpmeta_wrap=False)
creator_tool = xmp.get_property(libxmp.consts.XMP_NS_XMP, 'CreatorTool')
self.assertEqual(creator_tool, 'Google')
creator_tool = xmp.get_property(libxmp.consts.XMP_NS_XMP,
'CreatorTool')
self.assertEqual(creator_tool, 'Google')
@unittest.skipIf(OPENJPEG_NOT_AVAILABLE, OPENJPEG_NOT_AVAILABLE_MSG)
@unittest.skipIf(re.match(r'''(1|2.0.0)''',
@ -674,6 +672,7 @@ class TestJp2k(unittest.TestCase):
with self.assertRaises(RuntimeError):
glymur.Jp2k(self.jp2file).read_bands()
@unittest.skipIf(OPENJPEG_NOT_AVAILABLE, OPENJPEG_NOT_AVAILABLE_MSG)
@unittest.skipIf(re.match('1.[0-4]', openjpeg_version) is not None,
"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)
with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
with self.assertRaises(IOError):
j = Jp2k(tfile.name, data=data,
cbsize=(16, 16), psizes=[(16, 16)])
Jp2k(tfile.name, data=data,
cbsize=(16, 16), psizes=[(16, 16)])
def test_precinct_size_not_power_of_two(self):
"""must be power of two"""
data = np.zeros((640, 480), dtype=np.uint8)
with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
with self.assertRaises(IOError):
j = Jp2k(tfile.name, data=data,
cbsize=(16, 16), psizes=[(48, 48)])
Jp2k(tfile.name, data=data,
cbsize=(16, 16), psizes=[(48, 48)])
def test_unsupported_int32(self):
"""Should raise a runtime error if trying to write int32"""
data = np.zeros((128, 128), dtype=np.int32)
with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
with self.assertRaises(RuntimeError):
j = Jp2k(tfile.name, data=data)
Jp2k(tfile.name, data=data)
def test_unsupported_uint32(self):
"""Should raise a runtime error if trying to write uint32"""
data = np.zeros((128, 128), dtype=np.uint32)
with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
with self.assertRaises(RuntimeError):
j = Jp2k(tfile.name, data=data)
Jp2k(tfile.name, data=data)
def test_write_with_version_too_early(self):
"""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 tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
with self.assertRaises(RuntimeError):
j = Jp2k(tfile.name, data=data)
Jp2k(tfile.name, data=data)
def test_cblkh_different_than_width(self):
"""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."""
with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
with self.assertRaises(IOError):
j = Jp2k(tfile.name,
data=np.zeros((128, 128, 2, 2), dtype=np.uint8))
Jp2k(tfile.name,
data=np.zeros((128, 128, 2, 2), dtype=np.uint8))
def test_2d_rgb(self):
"""RGB must have at least 3 components."""
with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile:
with self.assertRaises(IOError):
j = Jp2k(tfile.name,
data=np.zeros((128, 128, 2), dtype=np.uint8),
colorspace='rgb')
Jp2k(tfile.name,
data=np.zeros((128, 128, 2), dtype=np.uint8),
colorspace='rgb')
def test_colorspace_with_j2k(self):
"""Specifying a colorspace with J2K does not make sense"""
with tempfile.NamedTemporaryFile(suffix='.j2k') as tfile:
with self.assertRaises(IOError):
j = Jp2k(tfile.name,
data=np.zeros((128, 128, 3), dtype=np.uint8),
colorspace='rgb')
Jp2k(tfile.name,
data=np.zeros((128, 128, 3), dtype=np.uint8),
colorspace='rgb')
def test_specify_rgb(self):
"""specify RGB explicitly"""
with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile:
j = Jp2k(tfile.name,
data=np.zeros((128, 128, 3), dtype=np.uint8),
colorspace='rgb')
data=np.zeros((128, 128, 3), dtype=np.uint8),
colorspace='rgb')
self.assertEqual(j.box[2].box[1].colorspace, glymur.core.SRGB)
def test_specify_gray(self):
@ -804,7 +803,7 @@ class TestJp2k_write(unittest.TestCase):
with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile:
with self.assertRaises(IOError):
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):
"""should be able to write with JP2 suffix."""
@ -833,7 +832,7 @@ class TestJp2k_write(unittest.TestCase):
expdata = j2k[:]
with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile:
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):
"""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:
data = np.zeros((128, 128, 3), dtype=np.uint8)
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)
def test_asoc_label_box(self):
@ -933,7 +932,7 @@ class TestJp2k_2_0(unittest.TestCase):
# OpenJPEG doesn't have such a file.
data = Jp2k(self.jp2file)[::2, ::2]
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:
@ -1041,12 +1040,15 @@ class TestJp2k_2_1(unittest.TestCase):
Invalid\svalues\sfor\scomp\s=\s0\s+
:\sdx=1\sdy=0''', re.VERBOSE)
if sys.hexversion < 0x03020000:
with self.assertRaisesRegexp((IOError, OSError), regexp):
with self.assertRaisesRegexp((IOError, OSError),
regexp):
j[::2, ::2]
else:
with self.assertRaisesRegex((IOError, OSError), regexp):
with self.assertRaisesRegex((IOError, OSError),
regexp):
j[::2, ::2]
@unittest.skipIf(OPJ_DATA_ROOT is None,
"OPJ_DATA_ROOT environment variable not set")
class TestParsing(unittest.TestCase):
@ -1064,22 +1066,23 @@ class TestParsing(unittest.TestCase):
"""Should not warn if RSIZ when parsing is turned off."""
filename = opj_data_file('input/nonregression/edf_c2_1002767.jp2')
glymur.set_parseoptions(codestream=False)
j = Jp2k(filename)
Jp2k(filename)
glymur.set_parseoptions(codestream=True)
with self.assertWarnsRegex(UserWarning, 'Invalid profile'):
jp2 = Jp2k(filename)
Jp2k(filename)
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.
glymur.set_parseoptions(codestream=False)
jp2 = Jp2k(self.jp2file)
jp2c = jp2.box[4]
self.assertIsNone(jp2c._main_header)
main_header = jp2c.main_header
jp2c.main_header
self.assertIsNotNone(jp2c._main_header)
@unittest.skipIf(WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG)
@unittest.skipIf(OPJ_DATA_ROOT is None,
"OPJ_DATA_ROOT environment variable not set")
@ -1101,13 +1104,13 @@ class TestJp2kOpjDataRootWarnings(unittest.TestCase):
"""Should warn in case of bad ftyp brand."""
filename = opj_data_file('input/nonregression/edf_c2_1000290.jp2')
with self.assertWarns(UserWarning):
jp2 = Jp2k(filename)
Jp2k(filename)
def test_invalid_approximation(self):
"""Should warn in case of invalid approximation."""
filename = opj_data_file('input/nonregression/edf_c2_1015644.jp2')
with self.assertWarnsRegex(UserWarning, 'Invalid approximation'):
jp2 = Jp2k(filename)
Jp2k(filename)
def test_invalid_colorspace(self):
"""
@ -1117,13 +1120,13 @@ class TestJp2kOpjDataRootWarnings(unittest.TestCase):
"""
filename = opj_data_file('input/nonregression/edf_c2_1103421.jp2')
with self.assertWarns(UserWarning):
jp2 = Jp2k(filename)
Jp2k(filename)
def test_stupid_windows_eol_at_end(self):
"""Garbage characters at the end of the file."""
filename = opj_data_file('input/nonregression/issue211.jp2')
with self.assertWarns(UserWarning):
jp2 = Jp2k(filename)
Jp2k(filename)
@unittest.skipIf(OPJ_DATA_ROOT is None,
@ -1148,7 +1151,7 @@ class TestJp2kOpjDataRoot(unittest.TestCase):
actdata = j[:]
self.assertTrue(fixtures.mse(actdata, expdata) < 250)
@unittest.skipIf(WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG)
def test_no_cxform_pclr_jp2(self):
"""Indices for pclr jpxfile if no color transform"""
@ -1180,7 +1183,7 @@ class TestJp2kOpjDataRoot(unittest.TestCase):
j = Jp2k(filename)
with self.assertRaises(RuntimeError):
j[:]
@unittest.skipIf(WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG)
def test_no_cxform_cmap(self):
"""Bands as physically ordered, not as physically intended"""
@ -1196,31 +1199,11 @@ class TestJp2kOpjDataRoot(unittest.TestCase):
expected = np.zeros(ycbcr.shape, ycbcr.dtype)
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)
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,
"OPJ_DATA_ROOT environment variable not set")
class TestCodestreamOpjData(unittest.TestCase):
@ -1274,7 +1257,6 @@ class TestCodestreamOpjData(unittest.TestCase):
# 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')
@ -1329,6 +1311,16 @@ class TestCodestreamRepr(unittest.TestCase):
self.assertEqual(newseg.bitdepth, (8, 8, 8))
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):
"""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
# whether or not it is signed.
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))

31
glymur/test/test_opj_suite.py
View file

@ -38,12 +38,11 @@ import glymur
from glymur import Jp2k
from glymur.jp2box import FileTypeBox, ImageHeaderBox, ColourSpecificationBox
from .fixtures import (
OPJ_DATA_ROOT, MetadataBase,
WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG,
mse, peak_tolerance, read_pgx, opj_data_file,
OPENJPEG_NOT_AVAILABLE, OPENJPEG_NOT_AVAILABLE_MSG
)
from .fixtures import (OPJ_DATA_ROOT, MetadataBase,
WARNING_INFRASTRUCTURE_ISSUE,
WARNING_INFRASTRUCTURE_MSG,
mse, peak_tolerance, read_pgx, opj_data_file,
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)
kwargs = {'rsiz': 0, 'xysiz': (203, 152), 'xyosiz': (0, 0),
'xytsiz': (203, 152), 'xytosiz': (0, 0), 'bitdepth': (8, 8, 8),
'signed': (False, False, False),
'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
'xytsiz': (203, 152), 'xytosiz': (0, 0),
'bitdepth': (8, 8, 8),
'signed': (False, False, False),
'xyrsiz': [(1, 1, 1), (1, 1, 1)]}
self.verifySizSegment(c.segment[1],
glymur.codestream.SIZsegment(**kwargs))
glymur.codestream.SIZsegment(**kwargs))
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],
glymur.codestream.CMEsegment(*pargs))
glymur.codestream.CMEsegment(*pargs))
# COD: Coding style default
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),
(64, 64)) # cblk
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],
glymur.core.WAVELET_XFORM_5X3_REVERSIBLE)
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):
jfile = opj_data_file('input/conformance/p1_04.j2k')
jp2k = Jp2k(jfile)
tdata = jp2k[896:1024, 896:1024] # last tile
tdata = jp2k[896:1024, 896:1024] # last tile
odata = jp2k[:]
np.testing.assert_array_equal(tdata, odata[896:1024, 896:1024])
@ -798,6 +798,7 @@ class TestSuite2point1(unittest.TestCase):
with self.assertRaises(IOError):
j[:]
@unittest.skipIf(OPJ_DATA_ROOT is None,
"OPJ_DATA_ROOT environment variable not set")
@unittest.skipIf(re.match(r'''0|1|2.0.0''',
@ -806,7 +807,7 @@ class TestSuite2point1(unittest.TestCase):
class TestReadArea(unittest.TestCase):
"""
Runs tests introduced in version 2.0+ or that pass only in 2.0+
Specifically for read method with area parameter.
"""
@classmethod

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

203
glymur/test/test_opj_suite_write.py
View file

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

55
glymur/test/test_printing.py
View file

@ -32,11 +32,12 @@ import lxml.etree as ET
import glymur
from glymur import Jp2k, command_line
from . import fixtures
from .fixtures import (
OPJ_DATA_ROOT, opj_data_file,
WARNING_INFRASTRUCTURE_ISSUE, WARNING_INFRASTRUCTURE_MSG,
WINDOWS_TMP_FILE_MSG, text_gbr_27, text_gbr_33, text_gbr_34
)
from .fixtures import (OPJ_DATA_ROOT, opj_data_file,
WARNING_INFRASTRUCTURE_ISSUE,
WARNING_INFRASTRUCTURE_MSG,
WINDOWS_TMP_FILE_MSG,
text_gbr_27, text_gbr_33, text_gbr_34)
@unittest.skipIf(os.name == "nt", WINDOWS_TMP_FILE_MSG)
class TestPrinting(unittest.TestCase):
@ -52,23 +53,11 @@ class TestPrinting(unittest.TestCase):
def tearDown(self):
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):
"""Should be able to print(glymur.version.info)"""
with patch('sys.stdout', new=StringIO()) as fake_out:
print(glymur.version.info)
actual = fake_out.getvalue().strip()
fake_out.getvalue().strip()
self.assertTrue(True)
@ -78,7 +67,7 @@ class TestPrinting(unittest.TestCase):
with tempfile.NamedTemporaryFile(suffix='.jpx') as tfile:
with open(self.jpxfile, 'rb') as ifile:
tfile.write(ifile.read())
# Add the header for an unknown superbox.
write_buffer = struct.pack('>I4s', 20, 'grp '.encode())
tfile.write(write_buffer)
@ -107,7 +96,8 @@ class TestPrinting(unittest.TestCase):
with self.assertRaises(TypeError):
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")
def test_asoc_label_box(self):
"""verify printing of asoc, label boxes"""
@ -115,9 +105,8 @@ class TestPrinting(unittest.TestCase):
# OpenJPEG doesn't have such a file.
data = glymur.Jp2k(self.jp2file)[::2, ::2]
with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile:
j = glymur.Jp2k(tfile.name, data=data)
with tempfile.NamedTemporaryFile(suffix='.jp2') as tfile2:
j = glymur.Jp2k(tfile.name, data=data)
# Offset of the codestream is where we start.
wbuffer = tfile.read(77)
@ -419,7 +408,7 @@ class TestPrinting(unittest.TestCase):
@unittest.skipIf(sys.hexversion < 0x03000000,
"Only trusting python3 for printing non-ascii chars")
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
# as to what gets printed.
#
@ -437,7 +426,8 @@ class TestPrinting(unittest.TestCase):
actual = fake_out.getvalue().strip()
if sys.hexversion < 0x03000000:
lines = ["XML Box (xml ) @ (-1, 0)",
" <country>&#1056;&#1086;&#1089;&#1089;&#1080;&#1103;</country>"]
(" <country>&#1056;&#1086;&#1089;&#1089;",
"&#1080;&#1103;</country>")]
else:
lines = ["XML Box (xml ) @ (-1, 0)",
" <country>Россия</country>"]
@ -613,12 +603,14 @@ class TestPrinting(unittest.TestCase):
lines = ["UUID Box (uuid) @ (1135519, 76)",
" 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)
self.assertEqual(actual, expected)
@unittest.skipIf(OPJ_DATA_ROOT is None,
"OPJ_DATA_ROOT environment variable not set")
@unittest.skipIf(os.name == "nt", "Temporary file issue on window.")
@ -826,6 +818,7 @@ class TestPrintingOpjDataRoot(unittest.TestCase):
expected = '\n'.join(lines)
self.assertEqual(actual, expected)
@unittest.skipIf(OPJ_DATA_ROOT is None,
"OPJ_DATA_ROOT environment variable not set")
@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')
with self.assertWarns(UserWarning):
jp2 = Jp2k(filename)
with patch('sys.stdout', new=StringIO()) as fake_out:
with patch('sys.stdout', new=StringIO()):
print(jp2)
def test_bad_rsiz(self):
@ -860,7 +853,7 @@ class TestPrintingOpjDataRootWarns(unittest.TestCase):
filename = opj_data_file('input/nonregression/edf_c2_1002767.jp2')
with self.assertWarns(UserWarning):
j = Jp2k(filename)
with patch('sys.stdout', new=StringIO()) as fake_out:
with patch('sys.stdout', new=StringIO()):
print(j)
def test_bad_wavelet_transform(self):
@ -868,7 +861,7 @@ class TestPrintingOpjDataRootWarns(unittest.TestCase):
filename = opj_data_file('input/nonregression/edf_c2_10025.jp2')
with self.assertWarns(UserWarning):
jp2 = Jp2k(filename)
with patch('sys.stdout', new=StringIO()) as fake_out:
with patch('sys.stdout', new=StringIO()):
print(jp2)
def test_invalid_progression_order(self):
@ -1029,7 +1022,7 @@ class TestPrintingOpjDataRootWarns(unittest.TestCase):
'issue171.jp2'))
with self.assertWarns(UserWarning):
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.
print(jp2)
@ -1069,7 +1062,8 @@ class TestJp2dump(unittest.TestCase):
"""Verify dumping with -c 0, supressing all codestream details."""
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):
"""Verify dumping with -c 1, print just the header."""
@ -1112,4 +1106,3 @@ class TestJp2dump(unittest.TestCase):
command_line.main()
actual = fake_out.getvalue().strip()
self.assertRegex(actual, "File: .*")