o iO @s UdZddlmZmZmZddlZddlmZddlm Z m Z ddl Z ddl m Z mZmZmZzddlZdZWn eyBdZYnwdd lmZdd lmZmZdd lmZdd lmZmZmZm Z m!Z"dd l#m$Z$ddl%m&Z&m'Z'ddl(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>e?e@ZAeeBdgeBeCBfZDeddeEeFeFeGBfgdfZHGdddeddZIdddddeEeFeFeGBfddfddZJ d2dddddeKddfddZLd3dd ZMeJgZNeOeHePd!<Gd"ddeZQGd#d$d$e ZReRe)ZSeRe*ZTeRe+ZUeRe,ZVeRe-ZWeWXgd%eRe.ZYeYXgd%eRe/ZZeZXd&d'geRe0Z[e[Xd&d'geRe1Z\e\Xgd(eRe2Z]e]Xgd(eRe3Z^e^Xgd%eRe4Z_e_Xgd%eRe5Z`e`ad)d*eRe6Zbebad)d*eRe7Zcecad)d*eRe8ZdedXd'd+gie)eSd,fe*eTd,fe,eVd,fe+eUd,fe-eWd,fe.eYd,fe/eZd,fe0e[d,fe1e\d,fe2e]d,fe3e^d,fe4e_d,fe5e`d,fe6ebd,fe7ecd,fe8edd,fZed4d-d.Zfefd/eFdeRfd0d1ZgdS)5zPixel data decoding.)CallableIteratorIterableN)BufferedIOBase)ceilfloor)AnyBinaryIOcast TYPE_CHECKINGTF)config) get_framegenerate_frames) warn_and_log)Buffer RunnerBase RunnerOptions CoderBasePhotometricInterpretation)convert_color_space)_get_jpg_parametersget_j2k_parameters)ImplicitVRLittleEndianExplicitVRLittleEndianExplicitVRBigEndianDeflatedExplicitVRLittleEndianJPEGBaseline8BitJPEGExtended12Bit JPEGLosslessJPEGLosslessSV1JPEGLSLosslessJPEGLSNearLosslessJPEG2000LosslessJPEG2000 HTJ2KLosslessHTJ2KLosslessRPCLHTJ2K RLELosslessUIDJPEG2000TransferSyntaxesJPEGLSTransferSyntaxesJPEGTransferSyntaxesDataset DecodeRunner np.ndarrayc@sreZdZUdZeed<eed<eed<eed<eed<eed<eed<eed <eed <eed <eed <eed <dS) DecodeOptionsz5Options accepted by DecodeRunner and decoding pluginspixel_vrallow_excess_framescorrect_unused_bits view_only be_swap_owrle_segment_order byteorderapply_jls_sign_correctionapply_j2k_sign_correctionas_rgb force_rgb force_ybrN)__name__ __module__ __qualname____doc__str__annotations__boolrDrDR/mnt/sdb/aimis/docanh/lib/python3.10/site-packages/pydicom/pixels/decoders/base.pyr0Es  r0)totalarrrunnerchangesreturncCs|dd}|dd}|r|rtd|jtjtjfvo"|ddp$|}|jjs<|s-|r<|ddr8t d| }|rMt |tj tj}tj|d<|S|r\t |tjtj }tj |d<|S) z4Convert `arr` to a given color space, typically RGB.r<Fr;z/'force_ybr' and 'force_rgb' cannot both be Truer:r4zeUnable to return an ndarray that's a view on the original buffer if applying a color space conversionphotometric_interpretation) get_option ValueErrorrKPIYBR_FULL YBR_FULL_422flags writeableLOGGERwarningcopyrRGB)rGrHrIr<r;to_rgbrDrDrE_process_color_spaceks.      rX log_warningcCsj|r|ddr|jjs|jjstd|jjs|}|j|j }t j |||dt j |||d|S)zFPerform a bit-shift correction on `arr` to avoid using any unused bitsr4Fa4Unable to return an ndarray that's a view on the original buffer when (0028,0101) 'Bits Stored' doesn't equal (0028,0100) 'Bits Allocated' and 'correct_unused_bits=True'. In most cases you can pass 'correct_unused_bits=False' instead to get a view if the uncorrected array is equivalent to the corrected one.out) rLtransfer_syntaxis_encapsulatedrQrRrSrTrUbits_allocated bits_storednp left_shift right_shift)rGrHrY bit_shiftrDrDrE_correct_unused_bitss"   rdcCs|jtvr4|d|j}|d|j}d|jj|}|r2||jkr2tj|||dtj |||d|S|jt vrZ|d|j}d|jj|}|rZtj|||dtj |||d|S)zMConvert `arr` to match the signedness required by the 'pixel_representation'. j2k_is_signed j2k_precisionrZ jls_precision) r\r)rLpixel_representationr_dtypeitemsizer`rarbr*)rGrH j2k_signed precisionrcrDrDrE_apply_sign_corrections  rn PROCESSORSc seZdZdZdeddfddZdeeefddfdd Z d e de e Bfd d Z d e de e BfddZd eeBde de de fddZd e ddfddZdee e BfddZedfd*d+ Zd?d-d.ZedeeBfd/d0Z defd1d2Z!d3edefd4d5Z"d@d6d7Z#d@d8d9Z$d@fd:d; Z%Z&S)Ar.a Class for managing the pixel data decoding process. .. versionadded:: 3.0 This class is not intended to be used directly. For decoding pixel data use the :class:`~pydicom.pixels.decoders.base.Decoder` instance corresponding to the transfer syntax of the pixel data. tsyntaxrJNcCs|||ddd|_d|_i|_||jjr|ddn|dd|jtvr1|ddd S|jtvr>|d dd S|d dd S) zCreate a new runner for decoding data encoded as `tsyntax`. Parameters ---------- tsyntax : pydicom.uid.UID The transfer syntax UID corresponding to the pixel data to be decoded. T)transfer_syntax_uidr:r2)rq pixel_keywordrr PixelDatar4Fr9r8r3N)_opts _undeletable _decodersr\r] set_optionr)r*)selfrprDrDrE__init__s"    zDecodeRunner.__init__infocCs|jdkrdS|j}|ddgdgdfv}|r0|tjkr0|dtjtd|ddS|jtkr8tj ntj }|d i D]}| d rbd |vrb|d|td|d |d dSqCdS)zConform the photometric interpretation to the JPEG/JPEG-LS codestream. Parameters ---------- info : dict[str, Any] A dictionary containing JPEG/JPEG-LS codestream metadata. N component_ids)RGB)rgbrKz7The (0028,0004) 'Photometric Interpretation' value is 'z\' however the encoded image's codestream uses component IDs that indicate it should be 'RGB'appsJFIFYBRzb' however the encoded image's codestream contains a JFIF APP marker which indicates it should be '') samples_per_pixelrKgetrNrVrwrr\rrPrOvalues startswith)rxrzpi has_rgb_idscsmarkerrDrDrE_conform_jpg_colorspaces2   z$DecodeRunner._conform_jpg_colorspaceindexcCs*t|j||j|jd}||||S)aDecode the frame of pixel data at `index`. Parameters ---------- index : int The index of the frame to be decoded. Returns ------- bytes | bytearray The decoded frame of pixel data. number_of_framesextended_offsets)r srcrr_get_frame_info _decode_frame)rxrrrDrDrEdecode5s  zDecodeRunner.decoderc Csg}|jD]Q\}}z,|||}t|dr.|jd|kr.td|jdd|d|d||f|_|WStyX}zt|||d|WYd }~qd }~wwd |}t d |) aReturn a decoded frame of pixel data. Parameters ---------- src : bytes An encoded frame of pixel data to be passed to the decoding plugins. Returns ------- bytes | bytearray The decoded frame. _previousz&The decoding plugin has changed from 'rz' to 'zq' during the decoding process - you may get inconsistent inter-frame results, consider passing 'decoding_plugin="z "' instead: Nz zGUnable to decode as exceptions were raised by all available plugins: ) rvitemshasattrrr ExceptionrS exceptionappendjoin RuntimeError)rxrfailure_messagesnamefuncframeexcmessagesrDrDrErNs2      zDecodeRunner._decode_frameoffsetlengthcCsZ|js|jrtt|}||||Stt|}|}||||}|||S)afReturn `length` bytes from `src`, starting at `offset`. Parameters ---------- src : buffer-like | file-like The source of the data to be returned. If a file-like then the file position after reading will returned to the original offset. offset : int The starting offset of the data in `src`. length : int The number of bytes to try to return. Returns ------- bytes The data from `src`, may return fewer bytes if the end of `src` is reached before ``offset + length``. ) is_dataset is_bufferr rr tellseekread)rxrrr file_offsetbufferrDrDrEget_data{s      zDecodeRunner.get_datacCs|jtvr!t|}|d|d|j|d|d|jdS|jtvr|jd d kr>||jd 7}zt|}WntyTtd |d w|j j t j d kkrc| d}|S)z^Return a :class:`numpy.dtype` suitable for containing the decoded pixel data. z0NumPy is required for 'DecodeRunner.pixel_dtype'FloatPixelDatafloat32DoubleFloatPixelDatafloat64uiru1rrgzThe data type 'z<' needed to contain the pixel data is not supported by NumPylittleS)HAVE_NP ImportErrorrrr`rjrir^ TypeErrorNotImplementedErrorr\is_little_endiansysr7 newbyteorder)rxrrrj dtype_strrDrDrE pixel_dtypes,       zDecodeRunner.pixel_dtypeFas_framecCsr|j|j|s |jndt|j|j|jd}|jdkr|j|d<|jdkr.|j |d<|j |d<t t ttt Bf|S)a Return a dict containing the :dcm:`Image Pixel ` module related properties. Parameters ---------- as_frame : bool, optional If ``True`` then don't include properties that aren't appropriate for a single frame. Default ``False``. Returns ------- dict[str, str | int] A dict containing the values for: * `bits_allocated` * `bits_stored` * `columns` * `photometric_interpretation` * `samples_per_pixel` * `rows` * `number_of_frames` * `planar_configuration` (if `samples_per_pixel` > 1) * `pixel_representation` (if the pixel keyword is ``"PixelData"``) The returned values depend on whether or not this method is called before or after decoding the pixel data, as the decoding plugins and image processing functions may update the values as needed to reflect the corresponding decoded data. For example, if the pixel data is converted from the YCbCr to RGB color space then the `photometric_interpretation` value will be changed to match after the data has been decoded. r)r^columnsrrKrowsrplanar_configurationrsr_ri)r^rrrArKrrrrrr_rir dictint)rxrdrDrDrEpixel_propertiess"     zDecodeRunner.pixel_propertiesrGr/cCs"i}tD]}||||}q||fS)aLReturn `arr` after applying zero or more processing operations. Returns ------- numpy.ndarray The array with the applied processing. dict[str, int | str] A :class:`dict` containing any required changes to the image pixel properties due to the processing. )ro)rxrGrIrrDrDrEprocess-s zDecodeRunner.processcCs|j}|j}|j}|j}|s:|dkr:|dkr||||S|jdkr*|||||S|||||}|ddddS|dkrD|||S|jdkrP||||S||||}|dddS)aReturn a reshaped :class:`~numpy.ndarray` `arr`. Parameters ---------- arr : np.ndarray The 1D array to be reshaped. as_frame : bool, optional If ``True`` then treat `arr` as only containing a single frame's worth of pixel data, otherwise treat `arr` as containing the full amount of pixel data (default). Returns ------- np.ndarray A view of the input `arr` reshaped to: * (rows, columns) for single frame, single sample data * (rows, columns, samples) for single frame, multi-sample data * (frames, rows, columns) for multi-frame, single sample data * (frames, rows, columns, samples) for multi-frame, multi-sample data rrr{)rrrrreshaper transpose)rxrGrrrrrrDrDrEr>s"    zDecodeRunner.reshapedecoderscCs||_t|dr |`dSdS)zSet the decoders use for decoding compressed pixel data. Parameters ---------- decoders : dict[str, DecodeFunction] A dict of {name: decoder function}. rN)rvrr)rxrrDrDrE set_decodersrs zDecodeRunner.set_decodersdsr-csttdi}|dd}r"||jkr"td|jdgd}fdd|D}|s5td t|d kr?td | d |d | d|d j dS)zSet options using a dataset. Parameters ---------- ds : pydicom.dataset.Dataset The dataset to use. file_metaTransferSyntaxUIDNzThe dataset's transfer syntax 'z&' doesn't match the pixel data decoder)rsrrcsg|]}|vr|qSrDrD).0kwrrDrE sz0DecodeRunner._set_options_ds..zqThe dataset has no 'Pixel Data', 'Float Pixel Data' or 'Double Float Pixel Data' element, no pixel data to decoderzoOne and only one of 'Pixel Data', 'Float Pixel Data' or 'Double Float Pixel Data' may be present in the datasetrrrr1) super_set_options_dsrrr\rMrAttributeErrorlenrwVR)rxrrrpkeywords px_keyword __class__rrEr~s&     zDecodeRunner._set_options_dsBuffer | Dataset | BinaryIOcCsxddlm}t||r'||||jj|_t|jtr"d|_dSd|_dSt |dr4||_d|_dS||_d|_dS)a^Set the pixel data to be decoded. Parameters ---------- src : bytes | bytearray | memoryview | pydicom.dataset.Dataset If a buffer-like then the encoded pixel data, otherwise the :class:`~pydicom.dataset.Dataset` containing the pixel data and associated group ``0x0028`` elements. rr,r r-rrN) pydicom.datasetr- isinstancerrrvalue_srcr _src_typer)rxrr-rDrDrE set_sources        zDecodeRunner.set_sourcecCs|jS)zFReturn the buffer-like or file-like containing the encoded pixel data.)rrxrDrDrErszDecodeRunner.srccCsfd|jjdg}|d|dd|jD|jr.|d|dd|jDd|S) z)Return nice string output for the runner.zDecodeRunner for 'rOptionscSs g|] \}}d|d|qS) rrD)rrrrDrDrErs z(DecodeRunner.__str__..DecoderscSsg|]}d|qS)rrD)rrrDrDrErs )r\rrextendoptionsrrvr)rxsrDrDrE__str__s   zDecodeRunner.__str__testcCs|dkr#|dr dS|jj o"|jddko"|jdko"|ddkS|dkrO|jtvo:|jtjtj fvo:|d d }|jt voJ|j dkoJ|d d }|pN|S|d krd|d d oc|jdkoc|j|j kSt d|d)z-Return the result of `test` as :class:`bool`.r5Trgrrsr1OWsign_correctionr9Fr8shift_correctionr3zUnknown test 'r)rLr\rr^rrr)rKrN MONOCHROME1 MONOCHROME2r*rir_rM)rxruse_j2k_correctionuse_jls_correctionrDrDrE _test_fors:          zDecodeRunner._test_forcCs$||js |jr|dSdS)z9Validate the decoding options and source buffer (if any).N)_validate_optionsrr_validate_bufferrrDrDrEvalidates  zDecodeRunner.validatecCs@|jdd}t||j}ttt|j}|jjr)||||dfvr't ddS||d}||krD||krBt d|d|ddS||kr|j t j krh|dd }|||dkrgt d |d|d n'|d d r||}||jkrt d|d|jd|jd|d|dSt d|d||ddSdS)z"Validate the supplied buffer data.bytesunitrzThe number of bytes of compressed pixel data matches the expected number for uncompressed data - check that the transfer syntax has been set correctlyNz9The number of bytes of pixel data is less than expected (z vs zy bytes) - the dataset may be corrupted, have an invalid group 0028 element value, or the transfer syntax may be incorrectr{zCThe number of bytes of pixel data is a third larger than expected (z bytes) which indicates the set (0028,0004) 'Photometric Interpretation' value of 'YBR_FULL_422' is incorrect and may need to be changed to either 'RGB' or 'YBR_FULL'r2Fz;The number of bytes of pixel data is sufficient to contain zO frames which is larger than the given (0028,0008) 'Number of Frames' value of . The returned data will include these extra frames and if it's correct then you should update 'Number of Frames' accordingly, otherwise pass 'allow_excess_frames=False' to return only the first  frames.rzThe pixel data is z) bytes long, which indicates it contains z& bytes of excess padding to be removed) frame_lengthrrrr rrr\r]rrMrKrNrPrLrw)rxr expectedactualpadded ybr_length whole_framesrDrDrErsh       zDecodeRunner._validate_buffercsJt|jr!t|jdt|jdkr#td|ddSdSdS)zGValidate the supplied options to ensure they meet minimum requirements.rrzThe number of items in (7FE0,0001) 'Extended Offset Table' and (7FE0,0002) 'Extended Offset Table Lengths' don't match - the extended offset table will be ignoredrN)rrrrr del_optionrrrDrEr4s zDecodeRunner._validate_options)rJr)F)rr-rJN)rrrJNrJN)'r=r>r?r@r(ryrrArrrr bytearrayrrrr rrrrpropertyrrCrtuplerrDecodeFunctionrrrrrrrrr __classcell__rDrDrrEr.s0  '-"  *&34 # $ ?cseZdZdZdeddffdd Zdddd d d d d edBdededede de de eeeBfffddZ e ded edBddfddZe ded edBddfddZddd dd d d edBdededede ee eeeBfff ddZe ded edBdeeBfddZe ded edBdefdd Zdddd d!d d d"eedBdededededee de eeeBfffd#d$Zddd d%d d d"eedBdedededee ee eeeBfff d&d'ZZS)(DecoderaPFactory class for pixel data decoders. Every available ``Decoder`` instance in *pydicom* corresponds directly to a single DICOM *Transfer Syntax UID*, and provides a mechanism for decoding encoded source data using one or more :doc:`decoding plugins `. .. versionadded:: 3.0 uidrJNcstj|dddS)zCreate a new data decoder. Parameters ---------- uid : pydicom.uid.UID The *Transfer Syntax UID* that the decoder supports. T)decoderN)rry)rxrrrDrEryOszDecoder.__init__TF)rrrawdecoding_pluginrzDataset | Buffer | BinaryIOrrrrkwargsr/cKsLtstd|dur|dkrtdt|j}|||jdi||tt t df| |t j r;t||rA||jrO|j}|dd } n|j}d} |du} |j|||| d } |d rmt| |} n |d rwt| |} i} |s|| \} } | jjs| r| n| } |jd krd| d <|j| d } | | | | fS)aReturn decoded pixel data as :class:`~numpy.ndarray`. .. warning:: This method requires `NumPy `_ and may require the installation of additional packages to perform the actual pixel data decoding. See the :doc:`pixel data decompression documentation ` for more information. **Processing** The following processing operations on the raw pixel data are always performed: * Natively encoded bit-packed pixel data for a :ref:`bits allocated ` of ``1`` will be unpacked. * Natively encoded pixel data with a :ref:`photometric interpretation ` of ``"YBR_FULL_422"`` will have it's sub-sampling removed. * The output array will be reshaped to the specified dimensions. * JPEG-LS or JPEG 2000 encoded data whose signedness doesn't match the expected :ref:`pixel representation` will be converted to match. If ``raw = False`` (the default) then the following processing operation will also be performed: * Pixel data with a :ref:`photometric interpretation ` of ``"YBR_FULL"`` or ``"YBR_FULL_422"`` will be converted to RGB. Parameters ---------- src : :class:`~pydicom.dataset.Dataset` | buffer-like | file-like Single or multi-frame pixel data as one of the following: * :class:`~pydicom.dataset.Dataset`: a dataset containing the pixel data to be decoded and the corresponding *Image Pixel* module elements. * :class:`bytes` | :class:`bytearray` | :class:`memoryview`: the encoded (and possibly encapsulated) pixel data to be decoded. * :class:`~typing.BinaryIO`: a file-like positioned at the start of the pixel data element's value. The position will be returned to the starting offset prior to returning the array. When `src` is not a :class:`~pydicom.dataset.Dataset` then a number of keyword parameters are also required. Please see the :doc:`decoding options documentation` for more information. index : int | None, optional If ``None`` (default) then return an array containing all the frames in the pixel data, otherwise return one containing only the frame from the specified `index`, which starts at 0 for the first frame. raw : bool, optional If ``True`` then return the decoded pixel data after only minimal processing (see the processing section above). If ``False`` (default) then additional processing may be applied to convert the pixel data to it's most commonly used form (such as converting from YCbCr to RGB). To return the raw pixel data with no processing whatsoever, use the :meth:`~pydicom.pixels.decoders.base.Decoder.as_buffer` method. validate : bool, optional If ``True`` (default) then validate the supplied decoding options and encoded pixel data prior to decoding, otherwise if ``False`` no validation will be performed. decoding_plugin : str, optional The name of the decoding plugin to use when decoding compressed pixel data. If no `decoding_plugin` is specified (default) then all available plugins will be tried and the result from the first successful one returned. For information on the available plugins for each decoder see the :doc:`API documentation`. **kwargs Optional keyword parameters for controlling decoding are also available, please see the :doc:`decoding options documentation ` for more information. Returns ------- numpy.ndarray One or more frames of decoded pixel data shaped as: * (rows, columns) for single frame, single sample data * (rows, columns, samples) for single frame, multi-sample data * (frames, rows, columns) for multi-frame, single sample data * (frames, rows, columns, samples) for multi-frame, multi-sample data The :class:`~numpy.dtype` for the array will have an :attr:`~numpy.dtype.itemsize` sufficient to contain pixels of at least :ref:`bits allocated`. A writeable :class:`~numpy.ndarray` is returned by default. For native transfer syntaxes with ``view_only=True``, a read-only :class:`~numpy.ndarray` will be returned if `src` is immutable. dict[str, str | int] The :dcm:`Image Pixel` module element values resulting from the decoding process that describe the array. See :meth:`DecodeRunner.pixel_properties() ` for the possible contents. :NumPy is required when converting pixel data to an ndarrayNrz*'index' must be greater than or equal to 0rr4FTrrrrrrD) rrrMr.r(r set_optionsrr rrA_validate_pluginsr debuggingrSdebugr is_native_as_array_nativerL_as_array_encapsulatedrrrnrdrrQrRrUrrupdate)rxrrrrrrrHr as_writeablerrG overridesrrDrDrEas_arrayYsNo           zDecoder.as_arrayrHc CsZ|j}tt|jdd}|durdn|j}tj|||jd}|dur;tj|j |d|jd|dd<| d||S| }t |jD]}t |}||} tj||jd|| | |<qD|dd rg} |j} |D]}t||jd dkr| t||j| d |jdqj| rtt| | d | d | dt|g| }| d||S)aReturn compressed and encapsulated pixel data as :class:`~numpy.ndarray`. Parameters ---------- runner : pydicom.pixels.decoders.base.DecodeRunner The runner with the encoded data and decoding options. index : int | None The index of the frame to be returned, or ``None`` if all frames are to be returned Returns ------- numpy.ndarray A 1D array containing the pixel data. pixelsrNrrjrr^r2Frr frames have been found in the encapsulated pixel data, which is larger than the given (0028,0008) 'Number of Frames' value of r r )r^r rr rr`emptyr frombufferrrwrrangenextrLrrr concatenate) rHroriginal_bits_allocatedpixels_per_framerrGframe_generatoridxrstartexcessoriginal_nr_framesrDrDrEr'sD    zDecoder._as_array_encapsulatedcCs|jdd}t|jdd}|j}|js|jr&ttt|j}d}t |}ntt |j}| }||j }| dr|ddrEtdtt|}tt|}|d ur|||}||||krktd |d d |d dkr||||} tj| dd} | |} n|d } |||| |d } tj| dd} | || | rd nd} ng||j 9}|||||d } tj| dd} | |d |} nD|d urt|||}||||krtd |d d |||t|} tj| |d} n||j 9}|||t|} tj| |d} |jd krO|ddr&tdd} |d ur3||j 9}n||d} tj| dt|dd}|| | |}|S|jtjkrX| S|ddrdtdtj| jdd d|d}| d d d|d d d<| d d d|dd d<| d d d| d d d|d d d<|dd d<| dd d| dd d|d d d<|dd d<| dtj!|S)aReturn natively encoded pixel data from a buffer-like as :class:`~numpy.ndarray`. Parameters ---------- runner : pydicom.pixels.decoders.base.DecodeRunner The runner with the encoded data and decoding options. index : int | None The index of the frame to be returned, or ``None`` if all frames are to be returned Returns ------- numpy.ndarray A 1D array containing the pixel data. rrr,rr5r4FzUnable to return an ndarray that's a view on the original buffer for 8-bit pixel data encoded as OW with 'Explicit VR Big Endian'N,There is insufficient pixel data to contain r framesru2r-zZUnable to return an ndarray that's a view on the original buffer for bit-packed pixel datargr)bitordercountzUnable to return an ndarray that's a view on the original buffer for uncompressed pixel data with a photometric interpretation of 'YBR_FULL_422'r{rK)"r rrrr memoryviewr rrrr rrrrLrSrTrMrr`r1byteswapviewrrr^ unpackbitsrKrNrPr0shaperwrO)rHr length_bytes length_pixelsrjrr length_source start_offsetrrG odd_indexrbit_offset_startunpackedr[rDrDrEr&Ks                  22zDecoder._as_array_native)rrrcKst|j}|||jdi||tttdf|||r'| |j r1| ||}n| ||}||j |dudfS)a[Return the raw decoded pixel data as a buffer-like. .. warning:: This method should only be used by advanced users who understand the intricacies of converting raw decoded DICOM pixel data to a usable form. It may also require the installation of additional packages to perform the actual pixel data decoding (see the :doc:`pixel data decompression documentation` for more information). Parameters ---------- src : :class:`~pydicom.dataset.Dataset` | buffer-like | file-like Single or multi-frame pixel data as one of the following: * :class:`~pydicom.dataset.Dataset`: a dataset containing the pixel data to be decoded and the corresponding *Image Pixel* module elements. * :class:`bytes` | :class:`bytearray` | :class:`memoryview`: the encoded (and possibly encapsulated) pixel data to be decoded. * :class:`~typing.BinaryIO`: a file-like positioned at the start of the pixel data element's value. The position will be returned to the starting offset prior to returning the buffer. When `src` is not a :class:`~pydicom.dataset.Dataset` then a number of keyword parameters are also required. Please see the :doc:`decoding options documentation` for more information. index : int | None, optional If ``None`` (default) then return a buffer-like containing all the frames in the pixel data, otherwise return one containing only the frame from the specified `index`, which starts at 0 for the first frame. validate : bool, optional If ``True`` (default) then validate the supplied decoding options and encoded pixel data prior to decoding, otherwise if ``False`` no validation will be performed. decoding_plugin : str, optional The name of the decoding plugin to use when decoding compressed pixel data. If no `decoding_plugin` is specified (default) then all available plugins will be tried and the result from the first successful one returned. For information on the available plugins for each decoder see the :doc:`API documentation`. **kwargs Optional keyword parameters for controlling decoding are also available, please see the :doc:`decoding options documentation ` for more information. Returns ------- bytes | bytearray | memoryview One or more frames of raw decoded pixel data. For natively encoded pixel data when `src` is a buffer-like the same type in `src` will be returned, except if `view_only` is ``True`` in which case a :class:`memoryview` on the original buffer will be returned instead. If `src` is a file-like then :class:`bytes` will always be returned. 8-bit pixel data encoded as **OW** using *Explicit VR Big Endian* will be returned as-is and may need byte-swapping. To facilitate this an extra byte before the expected start (for an odd `index`) or after the expected end (for an even `index`) is returned if the frame contains an odd number of pixels. dict[str, str | int] The :dcm:`Image Pixel` module element values resulting from the decoding process that describe the decoded pixel data. See :meth:`DecodeRunner.pixel_properties() ` for the possible contents. rNr rD)r.r(rr!rr rrAr"rr%_as_buffer_native_as_buffer_encapsulatedr)rxrrrrrrHrrDrDrE as_buffers Q   zDecoder.as_bufferc Cs&|dur(|j|d}|jdd}t|}|kr&td|d|d|d|Sg}g}|}t|jD]-}t|}||j |jdd}t|}|kr]td|d|d|d||q5| d d rg} |j} |D] }t||jddkr| || d |jd ||j qp| rt t| t|d | d| d| | tt|d kr t|} | d} tt||D]?\}\}}|| krtd|d|d| d|d} tt|| | }t| D]}||d| ||d| <q|||<q| d| ddd|DS)a "Return the raw decoded pixel data as a buffer-like. Parameters ---------- runner : pydicom.pixels.decoders.base.DecodeRunner The runner with the encoded data and decoding options. index : int | None The index of the frame to be returned, or ``None`` if all frames are to be returned Returns ------- bytes | bytearray A buffer-like containing the decoded pixel data. Nr.rrz;Unexpected number of bytes in the decoded frame with index z (z bytes actual vs z expected)r2Frrr/r r rgzPadding frame z from z to z-bitr^css|]}|VqdS)NrD)rbrDrDrE sz2Decoder._as_buffer_encapsulated..)rr rrMrr2rr3rr^rLrwrrsetmaxrziprSr$rr)rHrrrJr framesr^r7r8r:r;target target_step actual_stepr[rrDrDrErRGs            zDecoder._as_buffer_encapsulatedcCs|jdd}|js |jr(|ddrttt|j}ntt|j}d}t|}ntt |j}| }||j }| drtt |}tt |}|dur||||}||||krbtd|d d |d dkro||||S||||d |d S||j 9}|||||d S|durt|||}||||krtd|d d |||t|S||j 9}|||t|S) a0 "Return the raw encoded pixel data as a buffer-like. Parameters ---------- runner : pydicom.pixels.decoders.base.DecodeRunner The runner with the encoded data and decoding options. index : int | None The index of the frame to be returned, or ``None`` if all frames are to be returned Returns ------- bytes | bytearray | memoryview A buffer-like containing the decoded pixel data. Will return the same type as in the buffer containing the pixel data unless `view_only` is ``True`` in which case a :class:`memoryview` of the original buffer will be returned instead. Notes ----- For certain images, those with BitsAllocated=1, multiple frames and number of pixels per frame that is not a multiple of 8, it is not possible to isolate a buffer to a single frame because frame boundaries may occur within the middle a byte. If a single frame is requested (via ``index``) for these cases, the buffer returned will consist of the smallest set of bytes required to entirely contain the requested frame. However, the first and last byte may also contain information on pixel values in neighboring frames. rrr4Frr5Nr<rr=r)r rrrLrEr rrrr rrrrrMrrr)rHrrJrrrLrMrDrDrErQsB              zDecoder._as_buffer_native)indicesrrrr^cks$tstdt|j}|||jdi||ttt df| |t j r0t ||r6||jrD|j}|dd } n|j}d} d} |jr|s|D]X} tj| |jd} |j| dd} |drpt| |} n|d r~t| || d } d} i} |s|| \} } | jjr| n| } |j!d krd | d <|j"dd}|#| | |fVqTdS|r|nt$|j%}|D]U}|j|||dd} |drt| |} n|d rt| || d } d} i} |s|| \} } | jjs| r| n| } |j!d krd | d <|j"dd}|#| | |fVqdS)aYield pixel data frames as :class:`~numpy.ndarray`. .. warning:: This method requires `NumPy `_ and may require the installation of additional packages to perform the actual pixel data decoding. See the :doc:`pixel data decompression documentation ` for more information. **Processing** The following processing operations on the raw pixel data are always performed: * Natively encoded bit-packed pixel data for a :ref:`bits allocated ` of ``1`` will be unpacked. * Natively encoded pixel data with a :ref:`photometric interpretation ` of ``"YBR_FULL_422"`` will have it's sub-sampling removed. * The output array will be reshaped to the specified dimensions. * JPEG-LS or JPEG 2000 encoded data whose signedness doesn't match the expected :ref:`pixel representation` will be converted to match. If ``raw = False`` (the default) then the following processing operation will also be performed: * Pixel data with a :ref:`photometric interpretation ` of ``"YBR_FULL"`` or ``"YBR_FULL_422"`` will be converted to ``"RGB"``. Parameters ---------- src : :class:`~pydicom.dataset.Dataset` | buffer-like | file-like Single or multi-frame pixel data as one of the following: * :class:`~pydicom.dataset.Dataset`: a dataset containing the pixel data to be decoded and the corresponding *Image Pixel* module elements. * :class:`bytes` | :class:`bytearray` | :class:`memoryview`: the encoded (and possibly encapsulated) pixel data to be decoded. * :class:`~typing.BinaryIO`: a file-like positioned at the start of the pixel data element's value. The position will be returned to the starting offset only after all frames have been yielded. When `src` is not a :class:`~pydicom.dataset.Dataset` then a number of keyword parameters are also required. Please see the :doc:`decoding options documentation` for more information. indices : Iterable[int] | None, optional If ``None`` (default) then iterate through the entire pixel data, otherwise only iterate through the frames specified by `indices`. raw : bool, optional If ``True`` then yield the decoded pixel data after only minimal processing (see the processing section above). If ``False`` (default) then additional processing may be applied to convert the pixel data to it's most commonly used form (such as converting from YCbCr to RGB). To yield frames of pixel data with no processing whatsoever, use the :meth:`~pydicom.pixels.decoders.base.Decoder.iter_buffer` method. validate : bool, optional If ``True`` (default) then validate the supplied decoding options and encoded pixel data prior to decoding, otherwise if ``False`` no validation will be performed. decoding_plugin : str, optional The name of the decoding plugin to use when decoding compressed pixel data. If no `decoding_plugin` is specified (default) then all available plugins will be tried and the result from the first successful one yielded. For information on the available plugins for each decoder see the :doc:`API documentation`. **kwargs Optional keyword parameters for controlling decoding are also available, please see the :doc:`decoding options documentation ` for more information. Yields ------ numpy.ndarray A single frame of decoded and reshaped pixel data, with shape: * (rows, columns) for single sample data * (rows, columns, samples) for multi-sample data The :class:`~numpy.dtype` for the array will have an :attr:`~numpy.dtype.itemsize` sufficient to contain pixels of at least :ref:`bits allocated`. A writeable :class:`~numpy.ndarray` is returned by default. For native transfer syntaxes with ``view_only=True`` a read-only :class:`~numpy.ndarray` will be yielded if `src` is immutable. dict[str, str | int] The :dcm:`Image Pixel` module element values resulting from the decoding process that describe the array. See :meth:`DecodeRunner.pixel_properties() ` for the possible contents. rrr4FTr-r rr)rYrrrNrD)&rrr.r(rr!rr rrAr"r r#rSr$rr%r&rLr'r]rr`r1rrrrnrdrrQrRrUrrr(r2r)rxrr^rrrrrHrr)rYrrGr*rrrDrDrE iter_arrayszk                    zDecoder.iter_array)r^rrc kst|j}|||jdi||tttdf|||r(| |j r?|s?| D] }||j ddfVq1dS|j rF|j}n|j}|rM|nt|j}|D]} ||| |j ddfVqTdS)aaYield raw decoded pixel data frames as a buffer-like. .. warning:: This method should only be used by advanced users who understand the intricacies of converting raw decoded DICOM pixel data to a usable form. It may also require the installation of additional packages to perform the actual pixel data decoding (see the :doc:`pixel data decompression documentation` for more information). Parameters ---------- src : :class:`~pydicom.dataset.Dataset` | buffer-like | file-like Single or multi-frame pixel data as one of the following: * :class:`~pydicom.dataset.Dataset`: a dataset containing the pixel data to be decoded and the corresponding *Image Pixel* module elements. * :class:`bytes` | :class:`bytearray` | :class:`memoryview`: the encoded (and possibly encapsulated) pixel data to be decoded. * :class:`~typing.BinaryIO`: a file-like positioned at the start of the pixel data element's value. The position will be returned to the starting offset only after all frames have been yielded. When `src` is not a :class:`~pydicom.dataset.Dataset` then a number of keyword parameters are also required. Please see the :doc:`decoding options documentation` for more information. indices : Iterable[int] | None, optional If ``None`` (default) then iterate through the entire pixel data, otherwise only iterate through the frames specified by `indices`. validate : bool, optional If ``True`` (default) then validate the supplied decoding options and encoded pixel data prior to decoding, otherwise if ``False`` no validation will be performed. decoding_plugin : str, optional The name of the decoding plugin to use when decoding compressed pixel data. If no `decoding_plugin` is specified (default) then all available plugins will be tried and the result from the first successful one yielded. For information on the available plugins for each decoder see the :doc:`API documentation`. **kwargs Optional keyword parameters for controlling decoding are also available, please see the :doc:`decoding options documentation ` for more information. Yields ------- bytes | bytearray | memoryview A single frame of decoded pixel data. * For natively encoded pixel data when `src` is a buffer-like the same type in `src` will be yielded, except if `view_only` is ``True`` in which case a :class:`memoryview` on the original buffer will be yielded instead. If `src` is a file-like then :class:`bytes` will always be yielded. * Encapsulated pixel data will be yielded as :class:`bytearray`. 8-bit pixel data encoded as **OW** using *Explicit VR Big Endian* will be yielded as-is and may need byte-swapping. To facilitate this an extra byte before the expected start (for an odd `index`) or after the expected end (for an even `index`) is yielded if the frame contains an odd number of pixels. dict[str, str | int] The :dcm:`Image Pixel` module element values resulting from the decoding process that describe the decoded frame of pixel data. See :meth:`DecodeRunner.pixel_properties() ` for the possible contents. rTr NrD)r.r(rr!rr rrAr"rr]rrr%rQrRr2r) rxrr^rrrrHrrrrDrDrE iter_buffers. P    zDecoder.iter_buffer)r=r>r?r@r(ryrrCrAr0rrr+ staticmethodr.r'r&rrrSrrrRrQrrr_r`rrDrDrrErDs  (J e ]_  A r)gdcm)zpydicom.pixels.decoders.gdcmr pylibjpegz!pydicom.pixels.decoders.pylibjpegr)pillow)zpydicom.pixels.decoders.pillowrrbrd)rbrd)pyjpegls)z pydicom.pixels.decoders.pyjpeglsrrerf)pydicom)zpydicom.pixels.decoders.rlerz3.0cCstD]`\}}|j}|j}|j}t|t|}d|jd|dg}|d|d||d|rO|dd t |d|d|d |d|d d ||_ qd S) z'Override the default Decoder docstring.zA pixel data decoder for *z* - ``z``rz.. versionadded:: zAvailable decoding plugins: z, .zqPlugin-specific options are given in the :doc:`decoder options documentation`.zeSee the :class:`~pydicom.pixels.decoders.base.Decoder` reference for instance methods and attributes.rN) _PIXEL_DATA_DECODERSrr( _availablekeys _unavailablelistrrrsortedr@)dec versionaddedr available unavailablepluginsrrDrDrE_build_decoder_docstringss*      rvrcCs8t|}zt|dWStytd|jdw)a Return the pixel data decoder corresponding to `uid`. .. versionadded:: 3.0 +-----------------------------------------------------------------------------+ | Supported Transfer Syntaxes | +--------------------------------------+----------------------------+---------+ | Name | UID | Version | | | | added | +======================================+============================+=========+ | *Implicit VR Little Endian* | 1.2.840.10008.1.2 | 3.0 | +--------------------------------------+----------------------------+---------+ | *Explicit VR Little Endian* | 1.2.840.10008.1.2.1 | 3.0 | +--------------------------------------+----------------------------+---------+ | *Deflated Explicit VR Little Endian* | 1.2.840.10008.1.2.1.2.1.99 | 3.0 | +--------------------------------------+----------------------------+---------+ | *Explicit VR Big Endian* | 1.2.840.10008.1.2.2 | 3.0 | +--------------------------------------+----------------------------+---------+ | *JPEG Baseline 8-bit* | 1.2.840.10008.1.2.4.50 | 3.0 | +--------------------------------------+----------------------------+---------+ | *JPEG Extended 12-bit* | 1.2.840.10008.1.2.4.51 | 3.0 | +--------------------------------------+----------------------------+---------+ | *JPEG Lossless P14* | 1.2.840.10008.1.2.4.57 | 3.0 | +--------------------------------------+----------------------------+---------+ | *JPEG Lossless SV1* | 1.2.840.10008.1.2.4.70 | 3.0 | +--------------------------------------+----------------------------+---------+ | *JPEG-LS Lossless* | 1.2.840.10008.1.2.4.80 | 3.0 | +--------------------------------------+----------------------------+---------+ | *JPEG-LS Near Lossless* | 1.2.840.10008.1.2.4.81 | 3.0 | +--------------------------------------+----------------------------+---------+ | *JPEG2000 Lossless* | 1.2.840.10008.1.2.4.90 | 3.0 | +--------------------------------------+----------------------------+---------+ | *JPEG2000* | 1.2.840.10008.1.2.4.91 | 3.0 | +--------------------------------------+----------------------------+---------+ | *HTJ2K Lossless* | 1.2.840.10008.1.2.4.201 | 3.0 | +--------------------------------------+----------------------------+---------+ | *HTJ2K Lossless RPCL* | 1.2.840.10008.1.2.4.202 | 3.0 | +--------------------------------------+----------------------------+---------+ | *HTJ2K* | 1.2.840.10008.1.2.4.203 | 3.0 | +--------------------------------------+----------------------------+---------+ | *RLE Lossless* | 1.2.840.10008.1.2.5 | 3.0 | +--------------------------------------+----------------------------+---------+ rz2No pixel data decoders have been implemented for 'r)r(rkKeyErrorrr)rrDrDrE get_decoders,  rx)T)rGr/rHr.rJr/r)hr@collections.abcrrrloggingiormathrrrtypingrr r r numpyr`rrrir pydicom.encapsr r pydicom.miscrpydicom.pixels.commonrrrrrrNpydicom.pixels.processingrpydicom.pixels.utilsrr pydicom.uidrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+rr- getLoggerr=rSrrrrrArProcessingFunctionr0rXrCrdrnrororBr.rImplicitVRLittleEndianDecoderExplicitVRLittleEndianDecoderExplicitVRBigEndianDecoder%DeflatedExplicitVRLittleEndianDecoderJPEGBaseline8BitDecoder add_pluginsJPEGExtended12BitDecoderJPEGLosslessDecoderJPEGLosslessSV1DecoderJPEGLSLosslessDecoderJPEGLSNearLosslessDecoderJPEG2000LosslessDecoderJPEG2000DecoderHTJ2KLosslessDecoder add_pluginHTJ2KLosslessRPCLDecoder HTJ2KDecoderRLELosslessDecoderrkrvrxrDrDrDrEs8     X  & $ $/do