From cbdd6200b6feee7daf65e83ffca7a6525d3141b0 Mon Sep 17 00:00:00 2001 From: John Evans Date: Tue, 13 Jan 2015 14:44:03 -0500 Subject: [PATCH 1/7] reduce cyclomatic complexity where possible --- glymur/jp2k.py | 242 ++++++++++++++++++++++++++++++------------------- 1 file changed, 147 insertions(+), 95 deletions(-) diff --git a/glymur/jp2k.py b/glymur/jp2k.py index ee6eedc..3633657 100644 --- a/glymur/jp2k.py +++ b/glymur/jp2k.py @@ -363,7 +363,11 @@ class Jp2k(Jp2kBox): # 2.1 API self._cparams.rsiz = core.OPJ_PROFILE_CINEMA_4K - def _populate_cparams(self, img_array, **kwargs): + def _populate_cparams(self, img_array, mct=None, cratios=None, psnr=None, + cinema2k=None, cinema4k=None, irreversible=None, + cbsize=None, eph=None, grid_offset=None, modesw=None, + numres=None, prog=None, psizes=None, sop=None, + subsam=None, tilesize=None, colorspace=None): """Directs processing of write method arguments. Parameters @@ -373,12 +377,14 @@ class Jp2k(Jp2kBox): kwargs : dictionary non-image keyword inputs provided to write method """ - if ((('cinema2k' in kwargs or 'cinema4k' in kwargs) and - (len(set(kwargs)) > 1))): + other_args = (mct, cratios, psnr, irreversible, cbsize, eph, + grid_offset, modesw, numres, prog, psizes, sop, subsam) + if (((cinema2k is not None or cinema4k is not None) and + (not all([arg is None for arg in other_args])))): msg = "Cannot specify cinema2k/cinema4k along with other options." raise IOError(msg) - if 'cratios' in kwargs and 'psnr' in kwargs: + if cratios is not None and psnr is not None: msg = "Cannot specify cratios and psnr together." raise IOError(msg) @@ -402,90 +408,81 @@ class Jp2k(Jp2kBox): cparams.tcp_numlayers = 1 cparams.cp_disto_alloc = 1 - if 'irreversible' in kwargs and kwargs['irreversible'] is True: - cparams.irreversible = 1 + cparams.irreversible = 1 if irreversible else 0 - if 'cinema2k' in kwargs: + if cinema2k is not None: self._cparams = cparams - self._set_cinema_params('cinema2k', kwargs['cinema2k']) + self._set_cinema_params('cinema2k', cinema2k) return - if 'cinema4k' in kwargs: + if cinema4k is not None: self._cparams = cparams - self._set_cinema_params('cinema4k', kwargs['cinema4k']) + self._set_cinema_params('cinema4k', cinema4k) return - if 'cbsize' in kwargs: - cparams.cblockw_init = kwargs['cbsize'][1] - cparams.cblockh_init = kwargs['cbsize'][0] + if cbsize is not None: + cparams.cblockw_init = cbsize[1] + cparams.cblockh_init = cbsize[0] - if 'cratios' in kwargs: - cparams.tcp_numlayers = len(kwargs['cratios']) - for j, cratio in enumerate(kwargs['cratios']): + if cratios is not None: + cparams.tcp_numlayers = len(cratios) + for j, cratio in enumerate(cratios): cparams.tcp_rates[j] = cratio cparams.cp_disto_alloc = 1 - if 'eph' in kwargs: - cparams.csty |= 0x04 + cparams.csty |= 0x02 if sop else 0 + cparams.csty |= 0x04 if eph else 0 - if 'grid_offset' in kwargs: - cparams.image_offset_x0 = kwargs['grid_offset'][1] - cparams.image_offset_y0 = kwargs['grid_offset'][0] + if grid_offset is not None: + cparams.image_offset_x0 = grid_offset[1] + cparams.image_offset_y0 = grid_offset[0] - if 'modesw' in kwargs: + if modesw is not None: for shift in range(6): power_of_two = 1 << shift - if kwargs['modesw'] & power_of_two: + if modesw & power_of_two: cparams.mode |= power_of_two - if 'numres' in kwargs: - cparams.numresolution = kwargs['numres'] + if numres is not None: + cparams.numresolution = numres - if 'prog' in kwargs: - prog = kwargs['prog'].upper() - cparams.prog_order = core.PROGRESSION_ORDER[prog] + if prog is not None: + cparams.prog_order = core.PROGRESSION_ORDER[prog.upper()] - if 'psnr' in kwargs: - cparams.tcp_numlayers = len(kwargs['psnr']) - for j, snr_layer in enumerate(kwargs['psnr']): + if psnr is not None: + cparams.tcp_numlayers = len(psnr) + for j, snr_layer in enumerate(psnr): cparams.tcp_distoratio[j] = snr_layer cparams.cp_fixed_quality = 1 - if 'psizes' in kwargs: - for j, (prch, prcw) in enumerate(kwargs['psizes']): + if psizes is not None: + for j, (prch, prcw) in enumerate(psizes): cparams.prcw_init[j] = prcw cparams.prch_init[j] = prch cparams.csty |= 0x01 - cparams.res_spec = len(kwargs['psizes']) + cparams.res_spec = len(psizes) - if 'sop' in kwargs: - cparams.csty |= 0x02 + if subsam is not None: + cparams.subsampling_dy = subsam[0] + cparams.subsampling_dx = subsam[1] - if 'subsam' in kwargs: - cparams.subsampling_dy = kwargs['subsam'][0] - cparams.subsampling_dx = kwargs['subsam'][1] - - if 'tilesize' in kwargs: - cparams.cp_tdx = kwargs['tilesize'][1] - cparams.cp_tdy = kwargs['tilesize'][0] + if tilesize is not None: + cparams.cp_tdx = tilesize[1] + cparams.cp_tdy = tilesize[0] cparams.tile_size_on = opj2.TRUE - try: - mct = kwargs['mct'] - if mct and self._colorspace == opj2.CLRSPC_GRAY: + if mct is None: + # If the multi component transform was not specified, we infer + # that it should be used if the color space is RGB. + cparams.tcp_mct = 1 if self._colorspace == opj2.CLRSPC_SRGB else 0 + else: + if self._colorspace == opj2.CLRSPC_GRAY: msg = "Cannot specify usage of the multi component transform " msg += "if the colorspace is gray." raise IOError(msg) cparams.tcp_mct = 1 if mct else 0 - except KeyError: - # If the multi component transform was not specified, we infer - # that it should be used if the color space is RGB. - if self._colorspace == opj2.CLRSPC_SRGB: - cparams.tcp_mct = 1 - else: - cparams.tcp_mct = 0 - self._validate_compression_params(img_array, cparams, **kwargs) + self._validate_compression_params(img_array, cparams, colorspace) self._cparams = cparams @@ -576,29 +573,26 @@ class Jp2k(Jp2kBox): self.parse() - def _validate_compression_params(self, img_array, cparams, **kwargs): - """Check that the compression parameters are valid. - - Parameters - ---------- - img_array : ndarray - Image data to be written to file. - cparams : CompressionParametersType(ctypes.Structure) - Corresponds to cparameters_t type in openjp2 headers. + def _validate_j2k_colorspace(self, cparams, colorspace): """ - # Cannot specify a colorspace with J2K. - if cparams.codec_fmt == opj2.CODEC_J2K and 'colorspace' in kwargs: + Cannot specify a colorspace with J2K. + """ + if cparams.codec_fmt == opj2.CODEC_J2K and colorspace is not None: msg = 'Do not specify a colorspace when writing a raw ' msg += 'codestream.' raise IOError(msg) - # Code block size - code_block_specified = False + def _validate_codeblock_size(self, cparams): + """ + Code block dimensions must satisfy certain restrictions. + + They must both be a power of 2 and the total area defined by the width + and height cannot be either too great or too small for the codec. + """ if cparams.cblockw_init != 0 and cparams.cblockh_init != 0: # These fields ARE zero if uninitialized. width = cparams.cblockw_init height = cparams.cblockh_init - code_block_specified = True if height * width > 4096 or height < 4 or width < 4: msg = "Code block area cannot exceed 4096. " msg += "Code block height and width must be larger than 4." @@ -609,7 +603,17 @@ class Jp2k(Jp2kBox): msg += "must be powers of 2." raise IOError(msg.format(height, width)) - # Precinct size + def _validate_precinct_size(self, cparams): + """ + Precinct dimensions must satisfy certain restrictions if specified. + + They must both be a power of 2 and must both be at least twice the + size of their codeblock size counterparts. + """ + code_block_specified = False + if cparams.cblockw_init != 0 and cparams.cblockh_init != 0: + code_block_specified = True + if cparams.res_spec != 0: # precinct size was not specified if this field is zero. for j in range(cparams.res_spec): @@ -627,11 +631,18 @@ class Jp2k(Jp2kBox): msg += "must be powers of 2." raise IOError(msg.format(prch, prcw)) - # What would the point of 1D images be? + def _validate_image_rank(self, img_array): + """ + Images must be either 2D or 3D. + """ if img_array.ndim == 1 or img_array.ndim > 3: msg = "{0}D imagery is not allowed.".format(img_array.ndim) raise IOError(msg) + def _validate_v2_0_0_images(self, img_array): + """ + Version 2.0.0 is restricted to only the most common images. + """ if re.match("2.0.0", version.openjpeg_version) is not None: if (((img_array.ndim != 2) and (img_array.shape[2] != 1 and img_array.shape[2] != 3))): @@ -641,11 +652,32 @@ class Jp2k(Jp2kBox): msg += "release." raise IOError(msg) + def _validate_image_datatype(self, img_array): + """ + Only uint8 and uint16 images are currently supported. + """ if img_array.dtype != np.uint8 and img_array.dtype != np.uint16: msg = "Only uint8 and uint16 datatypes are currently supported " msg += "when writing." raise RuntimeError(msg) + def _validate_compression_params(self, img_array, cparams, colorspace): + """Check that the compression parameters are valid. + + Parameters + ---------- + img_array : ndarray + Image data to be written to file. + cparams : CompressionParametersType(ctypes.Structure) + Corresponds to cparameters_t type in openjp2 headers. + """ + self._validate_j2k_colorspace(cparams, colorspace) + self._validate_codeblock_size(cparams) + self._validate_precinct_size(cparams) + self._validate_image_rank(img_array) + self._validate_v2_0_0_images(img_array) + self._validate_image_datatype(img_array) + def _determine_colorspace(self, colorspace=None, **kwargs): """Determine the colorspace from the supplied inputs. @@ -916,6 +948,47 @@ class Jp2k(Jp2kBox): msg = "Partial write operations are currently not allowed." raise TypeError(msg) + def _remove_ellipsis(self, index, numrows, numcols, numbands): + """ + resolve the first ellipsis in the index so that it references the image + + Parameters + ---------- + index : tuple + tuple of index arguments, presumably one of them is the Ellipsis + numrows, numcols, numbands : int + image dimensions + + Returns + ------- + newindex : tuple + Same as index, except that the first Ellipsis is replaced with + a proper slice whose start and stop members are not None + """ + # Remove the first ellipsis we find. + rows = slice(0, numrows) + cols = slice(0, numcols) + bands = slice(0, numbands) + if index[0] is Ellipsis: + if len(index) == 2: + # jp2k[..., other_slice] + newindex = (rows, cols, index[1]) + else: + # jp2k[..., cols, bands] + newindex = (rows, index[1], index[2]) + elif index[1] is Ellipsis: + if len(index) == 2: + # jp2k[rows, ...] + newindex = (index[0], cols, bands) + else: + # jp2k[rows, ..., bands] + newindex = (index[0], cols, index[2]) + else: + # Assume that we don't have 4D imagery, of course. + newindex = (index[0], index[1], bands) + + return newindex + def __getitem__(self, pargs): """ Slicing protocol. @@ -950,23 +1023,7 @@ class Jp2k(Jp2kBox): pargs = (pargs, Ellipsis) if isinstance(pargs, tuple) and any(x is Ellipsis for x in pargs): - # Remove the first ellipsis we find. - rows = slice(0, numrows) - cols = slice(0, numcols) - bands = slice(0, numbands) - if pargs[0] is Ellipsis: - if len(pargs) == 2: - newindex = (rows, cols, pargs[1]) - else: - newindex = (rows, pargs[1], pargs[2]) - elif pargs[1] is Ellipsis: - if len(pargs) == 2: - newindex = (pargs[0], cols, bands) - else: - newindex = (pargs[0], cols, pargs[2]) - else: - # Assume that we don't have 4D imagery, of course. - newindex = (pargs[0], pargs[1], bands) + newindex = self._remove_ellipsis(pargs, numrows, numcols, numbands) # Run once again because it is possible that there's another # Ellipsis object in the 2nd or 3rd position. @@ -1279,12 +1336,11 @@ class Jp2k(Jp2kBox): infile += b'0' * nelts dparam.infile = infile - if self.ignore_pclr_cmap_cdef: - # Return raw codestream components. - dparam.flags |= 1 + # Return raw codestream components instead of "interpolating" the + # colormap? + dparam.flags |= 1 if self.ignore_pclr_cmap_cdef else 0 dparam.decod_format = self._codec_format - dparam.cp_layer = self._layer # Must check the specified rlevel against the maximum. @@ -1315,10 +1371,6 @@ class Jp2k(Jp2kBox): dparam.tile_index = tile dparam.nb_tile_to_decode = 1 - if self.ignore_pclr_cmap_cdef: - # Return raw codestream components. - dparam.flags |= 1 - self._dparams = dparam def read_bands(self, rlevel=0, layer=None, area=None, tile=None, From fdbbf999ca82c6c26a45e5d980de65a7d22b4621 Mon Sep 17 00:00:00 2001 From: jevans Date: Mon, 26 Jan 2015 19:13:29 -0500 Subject: [PATCH 2/7] Refactor ColourSpecificationsBox __str__ method --- glymur/jp2box.py | 32 +++++++++++++++++++++----------- 1 file changed, 21 insertions(+), 11 deletions(-) diff --git a/glymur/jp2box.py b/glymur/jp2box.py index 98b0e6a..8aac99a 100644 --- a/glymur/jp2box.py +++ b/glymur/jp2box.py @@ -356,35 +356,45 @@ class ColourSpecificationBox(Jp2kBox): return msg def __str__(self): - msg = Jp2kBox.__str__(self) + title = Jp2kBox.__str__(self) if _printoptions['short'] is True: - return msg + return title - msg += '\n Method: {0}'.format(_METHOD_DISPLAY[self.method]) - msg += '\n Precedence: {0}'.format(self.precedence) + lst = [] + text = 'Method: {0}'.format(_METHOD_DISPLAY[self.method]) + lst.append(text) + text = 'Precedence: {0}'.format(self.precedence) + lst.append(text) if self.approximation is not 0: dispvalue = _APPROX_DISPLAY[self.approximation] - msg += '\n Approximation: {0}'.format(dispvalue) + text = 'Approximation: {0}'.format(dispvalue) + lst.append(text) if self.colorspace is not None: dispvalue = _COLORSPACE_MAP_DISPLAY[self.colorspace] - msg += '\n Colorspace: {0}'.format(dispvalue) + text = 'Colorspace: {0}'.format(dispvalue) else: # 2.7 has trouble pretty-printing ordered dicts so we just have # to print as a regular dict in this case. if self.icc_profile is None: - msg += '\n ICC Profile: None' + text = 'ICC Profile: None' else: if sys.hexversion < 0x03000000: icc_profile = dict(self.icc_profile) else: icc_profile = self.icc_profile - dispvalue = pprint.pformat(icc_profile) - lines = [' ' * 8 + y for y in dispvalue.split('\n')] - msg += '\n ICC Profile:\n{0}'.format('\n'.join(lines)) + text = pprint.pformat(icc_profile) + text = self._indent(text) + text = '\n'.join(['ICC Profile:', text]) - return msg + lst.append(text) + + text = '\n'.join(lst) + + text = '\n'.join([title, self._indent(text)]) + + return text def write(self, fptr): """Write an Colour Specification box to file. From 256ebbf9eca4f7e56bdafa1ed031bb43060fd7e6 Mon Sep 17 00:00:00 2001 From: jevans Date: Mon, 26 Jan 2015 19:32:24 -0500 Subject: [PATCH 3/7] Refactor ChannelDefinitionBox __str__ method --- glymur/jp2box.py | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) diff --git a/glymur/jp2box.py b/glymur/jp2box.py index 8aac99a..5e06280 100644 --- a/glymur/jp2box.py +++ b/glymur/jp2box.py @@ -630,19 +630,26 @@ class ChannelDefinitionBox(Jp2kBox): self._dispatch_validation_error(msg, writing=writing) def __str__(self): - msg = Jp2kBox.__str__(self) + title = Jp2kBox.__str__(self) if _printoptions['short'] is True: - return msg + return title + lst = [] for j in range(len(self.association)): color_type_string = _COLOR_TYPE_MAP_DISPLAY[self.channel_type[j]] if self.association[j] == 0: assn = 'whole image' else: assn = str(self.association[j]) - msg += '\n Channel {0} ({1}) ==> ({2})' - msg = msg.format(self.index[j], color_type_string, assn) - return msg + text = 'Channel {0} ({1}) ==> ({2})'.format(self.index[j], + color_type_string, + assn) + lst.append(text) + + text = '\n'.join(lst) + text = self._indent(text) + text = '\n'.join([title, text]) + return text def __repr__(self): msg = "glymur.jp2box.ChannelDefinitionBox(" From ab75ffdca31041fa04cee1f1823f726021a6a1ae Mon Sep 17 00:00:00 2001 From: jevans Date: Mon, 26 Jan 2015 20:06:41 -0500 Subject: [PATCH 4/7] componentmapping box --- glymur/jp2box.py | 23 +++++++++++++++-------- 1 file changed, 15 insertions(+), 8 deletions(-) diff --git a/glymur/jp2box.py b/glymur/jp2box.py index 5e06280..21decc7 100644 --- a/glymur/jp2box.py +++ b/glymur/jp2box.py @@ -946,19 +946,26 @@ class ComponentMappingBox(Jp2kBox): return msg def __str__(self): - msg = Jp2kBox.__str__(self) + title = Jp2kBox.__str__(self) if _printoptions['short'] is True: - return msg + return title + lst = [] for k in range(len(self.component_index)): if self.mapping_type[k] == 1: - msg += '\n Component {0} ==> palette column {1}' - msg = msg.format(self.component_index[k], - self.palette_index[k]) + text = 'Component {0} ==> palette column {1}' + text = text.format(self.component_index[k], + self.palette_index[k]) else: - msg += '\n Component {0} ==> {1}' - msg = msg.format(self.component_index[k], k) - return msg + text = 'Component {0} ==> {1}' + text = text.format(self.component_index[k], k) + lst.append(text) + + text = '\n'.join(lst) + text = self._indent(text) + text = '\n'.join([title, text]) + + return text def write(self, fptr): """Write a Component Mapping box to file. From 5f013fa7858c1c9e53c79be009fdd1c90566583f Mon Sep 17 00:00:00 2001 From: jevans Date: Mon, 26 Jan 2015 21:59:26 -0500 Subject: [PATCH 5/7] progress --- glymur/jp2box.py | 185 ++++++++++++++++++++++++++++++----------------- 1 file changed, 119 insertions(+), 66 deletions(-) diff --git a/glymur/jp2box.py b/glymur/jp2box.py index 21decc7..fc37098 100644 --- a/glymur/jp2box.py +++ b/glymur/jp2box.py @@ -1065,16 +1065,20 @@ class ContiguousCodestreamBox(Jp2kBox): return msg.format(repr(self.codestream)) def __str__(self): - msg = Jp2kBox.__str__(self) + title = Jp2kBox.__str__(self) if _printoptions['short'] is True: - return msg + return title if _printoptions['codestream'] is False: - return msg + return title + lst = [] for segment in self.codestream.segment: - msg += '\n' + self._indent(str(segment), indent_level=4) + lst.append(str(segment)) - return msg + text = '\n'.join(lst) + text = self._indent(text) + text = '\n'.join([title, text]) + return text @classmethod def parse(cls, fptr, offset=0, length=0): @@ -1173,13 +1177,18 @@ class DataReferenceBox(Jp2kBox): fptr.seek(end_pos) def __str__(self): - msg = Jp2kBox.__str__(self) + title = Jp2kBox.__str__(self) if _printoptions['short'] is True: - return msg + return title + lst = [] for box in self.DR: - msg += '\n ' + str(box) - return msg + lst.append(str(box)) + text = '\n'.join(lst) + text = self._indent(text) + + text = '\n'.join([title, text]) + return text def __repr__(self): msg = 'glymur.jp2box.DataReferenceBox()' @@ -1276,17 +1285,22 @@ class FileTypeBox(Jp2kBox): return msg def __str__(self): - msg = Jp2kBox.__str__(self) + title = Jp2kBox.__str__(self) if _printoptions['short'] is True: - return msg + return title - lst = [msg, - ' Brand: {0}', - ' Compatibility: {1}'] - msg = '\n'.join(lst) - msg = msg.format(self.brand, self.compatibility_list) + lst = [] + text = 'Brand: {0}'.format(self.brand) + lst.append(text) + text = 'Compatibility: {0}'.format(self.compatibility_list) + lst.append(text) - return msg + text = '\n'.join(lst) + text = self._indent(text) + + text = '\n'.join([title, text]) + + return text def _validate(self, writing=False): """Validate the box before writing to file.""" @@ -1408,19 +1422,24 @@ class FragmentListBox(Jp2kBox): return msg def __str__(self): - msg = Jp2kBox.__str__(self) + title = Jp2kBox.__str__(self) if _printoptions['short'] is True: - return msg + return title + lst = [] for j in range(len(self.fragment_offset)): - msg += "\n Offset {0}: {1}" - msg += "\n Fragment Length {2}: {3}" - msg += "\n Data Reference {4}: {5}" - msg = msg.format(j, self.fragment_offset[j], - j, self.fragment_length[j], - j, self.data_reference[j]) + text = "Offset {0}: {1}".format(j, self.fragment_offset[j]) + lst.append(text) + text = "Fragment Length {0}: {1}".format(j, + self.fragment_length[j]) + lst.append(text) + text = "Data Reference {0}: {1}".format(j, self.data_reference[j]) + lst.append(text) - return msg + text = '\n'.join(lst) + text = self._indent(text) + text = '\n'.join([title, text]) + return text def write(self, fptr): """Write a fragment list box to file. @@ -1570,11 +1589,7 @@ class FreeBox(Jp2kBox): return msg def __str__(self): - msg = Jp2kBox.__str__(self) - if _printoptions['short'] is True: - return msg - - return msg + return Jp2kBox.__str__(self) @classmethod def parse(cls, fptr, offset, length): @@ -1666,23 +1681,34 @@ class ImageHeaderBox(Jp2kBox): return msg def __str__(self): - msg = Jp2kBox.__str__(self) + title = Jp2kBox.__str__(self) if _printoptions['short'] is True: - return msg + return title - msg = "{0}" - msg += '\n Size: [{1} {2} {3}]' - msg += '\n Bitdepth: {4}' - msg += '\n Signed: {5}' - msg += '\n Compression: {6}' - msg += '\n Colorspace Unknown: {7}' - msg = msg.format(Jp2kBox.__str__(self), - self.height, self.width, self.num_components, - self.bits_per_component, - self.signed, - 'wavelet' if self.compression == 7 else 'unknown', - self.colorspace_unknown) - return msg + lst = [] + + text = 'Size: [{0} {1} {2}]' + text = text.format(self.height, self.width, self.num_components) + lst.append(text) + + text = 'Bitdepth: {0}'.format(self.bits_per_component) + lst.append(text) + + text = 'Signed: {0}'.format(self.signed) + lst.append(text) + + text = 'Compression: {0}' + text = text.format('wavelet' if self.compression == 7 else 'unknown') + lst.append(text) + + text = 'Colorspace Unknown: {0}'.format(self.colorspace_unknown) + lst.append(text) + + text = '\n'.join(lst) + text = self._indent(text) + text = '\n'.join([title, text]) + + return text def write(self, fptr): """Write an Image Header box to file. @@ -1897,14 +1923,16 @@ class JPEG2000SignatureBox(Jp2kBox): return 'glymur.jp2box.JPEG2000SignatureBox()' def __str__(self): - msg = Jp2kBox.__str__(self) + title = Jp2kBox.__str__(self) if _printoptions['short'] is True: - return msg + return title - msg += '\n Signature: {0:02x}{1:02x}{2:02x}{3:02x}' - msg = msg.format(self.signature[0], self.signature[1], - self.signature[2], self.signature[3]) - return msg + body = 'Signature: {0:02x}{1:02x}{2:02x}{3:02x}' + body = body.format(self.signature[0], self.signature[1], + self.signature[2], self.signature[3]) + body = self._indent(body) + text = '\n'.join([title, body]) + return text def write(self, fptr): """Write a JPEG 2000 Signature box to file. @@ -1986,12 +2014,15 @@ class PaletteBox(Jp2kBox): return msg def __str__(self): - msg = Jp2kBox.__str__(self) + title = Jp2kBox.__str__(self) if _printoptions['short'] is True: - return msg + return title - msg += '\n Size: ({0} x {1})'.format(*self.palette.shape) - return msg + body = 'Size: ({0} x {1})'.format(*self.palette.shape) + body = self._indent(body) + + text = '\n'.join([title, body]) + return text def write(self, fptr): """Write a Palette box to file. @@ -2235,25 +2266,47 @@ class ReaderRequirementsBox(Jp2kBox): return msg def __str__(self): - msg = Jp2kBox.__str__(self) + title = Jp2kBox.__str__(self) if _printoptions['short'] is True: - return msg + return title - msg += '\n Fully Understands Aspect Mask: 0x{0:x}' - msg = msg.format(self.fuam) - msg += '\n Display Completely Mask: 0x{0:x}'.format(self.dcm) + lst = [] - msg += '\n Standard Features and Masks:' + text = 'Fully Understands Aspect Mask: 0x{0:x}'.format(self.fuam) + lst.append(text) + + text = 'Display Completely Mask: 0x{0:x}'.format(self.dcm) + lst.append(text) + + text = 'Standard Features and Masks:' + lst.append(text) + + lst2 = [] for j in range(len(self.standard_flag)): args = (self.standard_flag[j], self.standard_mask[j], _READER_REQUIREMENTS_DISPLAY[self.standard_flag[j]]) - msg += '\n Feature {0:03d}: 0x{1:x} {2}'.format(*args) + text = 'Feature {0:03d}: 0x{1:x} {2}'.format(*args) + lst2.append(text) + text = '\n'.join(lst2) + text = self._indent(text) + lst.append(text) - msg += '\n Vendor Features:' + text = 'Vendor Features:' + lst.append(text) + + lst2 = [] for j in range(len(self.vendor_feature)): - msg += '\n UUID {0}'.format(self.vendor_feature[j]) + text = 'UUID {0}'.format(self.vendor_feature[j]) + lst2.append(text) + text = '\n'.join(lst2) + text = self._indent(text) + lst.append(text) - return msg + text = '\n'.join(lst) + text = self._indent(text) + text = '\n'.join([title, text]) + + return text @classmethod def parse(cls, fptr, offset, length): From 7ac25f29358d0e993f68ac9eb37eff14bc1bd86f Mon Sep 17 00:00:00 2001 From: jevans Date: Thu, 29 Jan 2015 20:38:00 -0500 Subject: [PATCH 6/7] boxes all done, codestream printing is broken though --- glymur/jp2box.py | 168 +++++++++++++++++++++-------------- glymur/test/test_printing.py | 1 + 2 files changed, 104 insertions(+), 65 deletions(-) diff --git a/glymur/jp2box.py b/glymur/jp2box.py index fc37098..db48f82 100644 --- a/glymur/jp2box.py +++ b/glymur/jp2box.py @@ -2577,13 +2577,21 @@ class CaptureResolutionBox(Jp2kBox): return msg def __str__(self): - msg = Jp2kBox.__str__(self) + title = Jp2kBox.__str__(self) if _printoptions['short'] is True: - return msg + return title - msg += '\n VCR: {0}'.format(self.vertical_resolution) - msg += '\n HCR: {0}'.format(self.horizontal_resolution) - return msg + lst = [] + text = 'VCR: {0}'.format(self.vertical_resolution) + lst.append(text) + text = 'HCR: {0}'.format(self.horizontal_resolution) + lst.append(text) + + text = '\n'.join(lst) + body = self._indent(text) + + text = '\n'.join([title, body]) + return text @classmethod def parse(cls, fptr, offset, length): @@ -2643,13 +2651,21 @@ class DisplayResolutionBox(Jp2kBox): return msg def __str__(self): - msg = Jp2kBox.__str__(self) + title = Jp2kBox.__str__(self) if _printoptions['short'] is True: - return msg + return title - msg += '\n VDR: {0}'.format(self.vertical_resolution) - msg += '\n HDR: {0}'.format(self.horizontal_resolution) - return msg + lst = [] + text = 'VDR: {0}'.format(self.vertical_resolution) + lst.append(text) + text = 'HDR: {0}'.format(self.horizontal_resolution) + lst.append(text) + + text = '\n'.join(lst) + body = self._indent(text) + + text = '\n'.join([title, body]) + return text @classmethod def parse(cls, fptr, offset, length): @@ -2703,12 +2719,15 @@ class LabelBox(Jp2kBox): self.offset = offset def __str__(self): - msg = Jp2kBox.__str__(self) + title = Jp2kBox.__str__(self) if _printoptions['short'] is True: - return msg + return title - msg += '\n Label: {0}'.format(self.label) - return msg + text = 'Label: {0}'.format(self.label) + body = self._indent(text) + + text = '\n'.join([title, body]) + return text def __repr__(self): msg = 'glymur.jp2box.LabelBox("{0}")'.format(self.label) @@ -2771,25 +2790,30 @@ class NumberListBox(Jp2kBox): self.offset = offset def __str__(self): - msg = Jp2kBox.__str__(self) + title = Jp2kBox.__str__(self) if _printoptions['short'] is True: - return msg + return title + lst = [] for j, association in enumerate(self.associations): - msg += '\n Association[{0}]: '.format(j) + text = 'Association[{0}]: '.format(j) if association == 0: - msg += 'the rendered result' + text += 'the rendered result' elif (association >> 24) == 1: idx = association & 0x00FFFFFF - msg += 'codestream {0}' - msg = msg.format(idx) + text += 'codestream {0}'.format(idx) elif (association >> 24) == 2: idx = association & 0x00FFFFFF - msg += 'compositing layer {0}' - msg = msg.format(idx) + text += 'compositing layer {0}'.format(idx) else: - msg += 'unrecognized' - return msg + text += 'unrecognized' + lst.append(text) + + body = '\n'.join(lst) + body = self._indent(body) + + text = '\n'.join([title, body]) + return text def __repr__(self): msg = 'glymur.jp2box.NumberListBox(associations={0})' @@ -2874,21 +2898,22 @@ class XMLBox(Jp2kBox): return "glymur.jp2box.XMLBox(xml={0})".format(self.xml) def __str__(self): - msg = Jp2kBox.__str__(self) + title = Jp2kBox.__str__(self) if _printoptions['short'] is True: - return msg + return title if _printoptions['xml'] is False: - return msg + return title - msg += '\n' if self.xml is not None: - xmlstring = ET.tostring(self.xml, - encoding='utf-8', - pretty_print=True).decode('utf-8') + body = ET.tostring(self.xml, + encoding='utf-8', + pretty_print=True).decode('utf-8') else: - xmlstring = 'None' - msg += self._indent(xmlstring) - return msg + body = 'None' + body = self._indent(body) + + text = '\n'.join([title, body]) + return text def write(self, fptr): """Write an XML box to file. @@ -2995,13 +3020,19 @@ class UUIDListBox(Jp2kBox): return msg def __str__(self): - msg = Jp2kBox.__str__(self) + title = Jp2kBox.__str__(self) if _printoptions['short'] is True: - return msg + return title + lst = [] for j, uuid_item in enumerate(self.ulst): - msg += '\n UUID[{0}]: {1}'.format(j, uuid_item) - return msg + text = 'UUID[{0}]: {1}'.format(j, uuid_item) + lst.append(text) + body = '\n'.join(lst) + body = self._indent(body) + + text = '\n'.join([title, body]) + return text @classmethod def parse(cls, fptr, offset, length): @@ -3147,20 +3178,21 @@ class DataEntryURLBox(Jp2kBox): return msg def __str__(self): - msg = Jp2kBox.__str__(self) + title = Jp2kBox.__str__(self) if _printoptions['short'] is True: - return msg + return title - msg += '\n ' + lst = ['Version: {0}', + 'Flag: {1} {2} {3}', + 'URL: "{4}"'] + body = '\n'.join(lst) + body = body.format(self.version, + self.flag[0], self.flag[1], self.flag[2], + self.url) + body = self._indent(body) - lines = ['Version: {0}', - 'Flag: {1} {2} {3}', - 'URL: "{4}"'] - msg += '\n '.join(lines) - msg = msg.format(self.version, - self.flag[0], self.flag[1], self.flag[2], - self.url) - return msg + text = '\n'.join([title, body]) + return text @classmethod def parse(cls, fptr, offset, length): @@ -3299,38 +3331,44 @@ class UUIDBox(Jp2kBox): return msg.format(repr(self.uuid), len(self.raw_data)) def __str__(self): - msg = Jp2kBox.__str__(self) + title = Jp2kBox.__str__(self) if _printoptions['short'] is True: - return msg + return title - msg = '{0}\n UUID: {1}'.format(msg, self.uuid) + text = 'UUID: {0}'.format(self.uuid) if self.uuid == UUID('be7acfcb-97a9-42e8-9c71-999491e3afac'): - msg += ' (XMP)' + text += ' (XMP)' elif self.uuid.bytes == b'JpgTiffExif->JP2': - msg += ' (EXIF)' + text += ' (EXIF)' else: - msg += ' (unknown)' + text += ' (unknown)' + + lst = [text] if (((_printoptions['xml'] is False) and (self.uuid == UUID('be7acfcb-97a9-42e8-9c71-999491e3afac')))): # If it's an XMP UUID, don't print the XML contents. - return msg + pass - if self.uuid == UUID('be7acfcb-97a9-42e8-9c71-999491e3afac'): - line = '\n UUID Data:\n{0}' + elif self.uuid == UUID('be7acfcb-97a9-42e8-9c71-999491e3afac'): + line = 'UUID Data:\n{0}' xmlstring = ET.tostring(self.data, encoding='utf-8', pretty_print=True).decode('utf-8') - # indent it a bit - xmlstring = self._indent(xmlstring.rstrip()) - msg += line.format(xmlstring) + text = line.format(xmlstring) + lst.append(text) elif self.uuid.bytes == b'JpgTiffExif->JP2': - msg += '\n UUID Data: {0}'.format(str(self.data)) + text = 'UUID Data: {0}'.format(str(self.data)) + lst.append(text) else: - line = '\n UUID Data: {0} bytes' - msg += line.format(len(self.raw_data)) + text = 'UUID Data: {0} bytes'.format(len(self.raw_data)) + lst.append(text) - return msg + body = '\n'.join(lst) + body = self._indent(body) + + text = '\n'.join([title, body]) + return text def write(self, fptr): """Write a UUID box to file. diff --git a/glymur/test/test_printing.py b/glymur/test/test_printing.py index bccaa00..ad60f29 100644 --- a/glymur/test/test_printing.py +++ b/glymur/test/test_printing.py @@ -1125,6 +1125,7 @@ class TestJp2dump(unittest.TestCase): def test_suppress_xml(self): """Verify dumping with -x, suppress XML.""" + self.maxDiff = None actual = self.run_jp2dump(['', '-x', self.jp2file]) # shave off the XML and non-main-header segments From 2ef8052a2213c8c1922d7f3cdfa5c3359de69e93 Mon Sep 17 00:00:00 2001 From: John Evans Date: Fri, 30 Jan 2015 08:22:52 -0500 Subject: [PATCH 7/7] Fix UUIDBox printing --- glymur/jp2box.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/glymur/jp2box.py b/glymur/jp2box.py index db48f82..ddcd19c 100644 --- a/glymur/jp2box.py +++ b/glymur/jp2box.py @@ -3355,6 +3355,8 @@ class UUIDBox(Jp2kBox): xmlstring = ET.tostring(self.data, encoding='utf-8', pretty_print=True).decode('utf-8') + # Remove any trailing newline + xmlstring = xmlstring.rstrip() text = line.format(xmlstring) lst.append(text) elif self.uuid.bytes == b'JpgTiffExif->JP2':