i( jdZddlmZmZmZmZddlZddlZddlZ ddl m Z dZ dZ edd ddd d d Zd Ze je je je je je jdZdZdZdZededdZddZdZdZdZ dej!zej"zej#zZ$dZ%dZ&dZ'dS)a utils ----- Utility functions used by the other modules in the mrcfile package. Functions --------- * :func:`data_dtype_from_header`: Work out the data :class:`dtype ` from an MRC header. * :func:`data_shape_from_header`: Work out the data array shape from an MRC header * :func:`mode_from_dtype`: Convert a :class:`numpy dtype ` to an MRC mode number. * :func:`dtype_from_mode`: Convert an MRC mode number to a :class:`numpy dtype `. * :func:`pretty_machine_stamp`: Get a nicely-formatted string from a machine stamp. * :func:`machine_stamp_from_byte_order`: Get a machine stamp from a byte order indicator. * :func:`byte_orders_equal`: Compare two byte order indicators for equal endianness. * :func:`normalise_byte_order`: Convert a byte order indicator to ``<`` or ``>``. * :func:`spacegroup_is_volume_stack`: Identify if a space group number represents a volume stack. )absolute_importdivisionprint_functionunicode_literalsN)IMAGE_STACK_SPACEGROUPch|j}t||jjS)a_Return the data dtype indicated by the given header. This function calls :func:`dtype_from_mode` to get the basic dtype, and then makes sure that the byte order of the new dtype matches the byte order of the header's ``mode`` field. Args: header: An MRC header as a :class:`numpy record array `. Returns: The :class:`numpy dtype ` object for the data array corresponding to the given header. Raises: :exc:`ValueError`: If there is no corresponding dtype for the given mode. )modedtype_from_mode newbyteorderdtype byteorder)headerr s W/srv/www/vhosts/g4struct/public_html/venv/lib/python3.11/site-packages/mrcfile/utils.pydata_dtype_from_headerr.s,& ;D 4 - -dj.B C CCc"t|j}t|j}t|j}t|j}t |jr ||z|||f}n |jtkr |dkr||f}n|||f}|S)aReturn the data shape indicated by the given header. Args: header: An MRC header as a :class:`numpy record array `. Returns: The shape tuple for the data array corresponding to the given header. r)intnxnynzmzspacegroup_is_volume_stackispgr)rrrrrshapes rdata_shape_from_headerrEs VYB VYB VYB VYB!&+..r2r2& . . .277RR  Lr )f2f4i1i2u1u2c8c|jt|jz}|tvr t|St d|)aReturn the MRC mode number corresponding to the given :class:`numpy dtype `. The conversion is as follows: * float16 -> mode 12 * float32 -> mode 2 * int8 -> mode 0 * int16 -> mode 1 * uint8 -> mode 6 (data will be widened to 16 bits in the file) * uint16 -> mode 6 * complex64 -> mode 4 Note that there is no numpy dtype which corresponds to MRC mode 3. Args: dtype: A :class:`numpy dtype ` object. Returns: The MRC mode number. Raises: :exc:`ValueError`: If there is no corresponding MRC mode for the given dtype. z3dtype '{0}' cannot be converted to an MRC file mode)kindstritemsize_dtype_to_mode ValueErrorformat)r kind_and_sizes rmode_from_dtyper0asR4JU^!4!44M&&m,, ++16%== : ::r)rrrr rrc&t|tjr.|jdkrt d|}|t vrtjt |St d|)aReturn the :class:`numpy dtype ` corresponding to the given MRC mode number. The mode parameter may be given as a Python scalar, numpy scalar or single-item numpy array. The conversion is as follows: * mode 0 -> int8 * mode 1 -> int16 * mode 2 -> float32 * mode 4 -> complex64 * mode 6 -> uint16 * mode 12 -> float16 Note that modes 3 and 101 are not supported as there is no matching numpy dtype. Args: mode: The MRC mode number. This may be given as any type which can be converted to an int, for example a Python scalar (``int`` or ``float``), a numpy scalar or a single-item numpy array. Returns: The :class:`numpy dtype ` object corresponding to the given mode. Raises: :exc:`ValueError`: If there is no corresponding dtype for the given mode, or if ``mode`` is an array and does not contain exactly one item. rz*Mode array should contain exactly one itemzUnrecognised mode '{0}') isinstancenpndarraysizer-item_mode_to_dtyper r.)r s rr r s}@$ ## 9>>IJJ Jyy{{ ~xt,---299$??@@@rc@dd|DS)z7Return a human-readable hex string for a machine stamp. c3@K|]}d|VdS)z0x{:02x}N)r.).0bytes r z'pretty_machine_stamp..s0??J%%d++??????r)join)machsts rpretty_machine_stampr@s# 88????? ? ??rc|ddkr |ddvrdS|ddkr|ddkrdSt|}td|z) aReturn the byte order corresponding to the given machine stamp. Args: machst: The machine stamp, as a :class:`bytearray` or a :class:`numpy array ` of bytes. Returns: ``<`` if the machine stamp represents little-endian data, or ``>`` if it represents big-endian. Raises: :exc:`ValueError`: If the machine stamp is invalid. rDr)rBA<>zUnrecognised machine stamp: )r@r-)r? pretty_bytess rbyte_order_from_machine_stamprHsiayDVAY,66s )t  q T 1 1s+F33 7,FGGGr)rBrBrr)rErErr)rDrF=c:t|}t|S)axReturn the machine stamp corresponding to the given byte order indicator. Args: byte_order: The byte order indicator: one of ``=``, ``<`` or ``>``, as defined and used by numpy dtype objects. Returns: The machine stamp which corresponds to the given byte order, as a :class:`bytearray`. This will be either ``(0x44, 0x44, 0, 0)`` for little-endian or ``(0x11, 0x11, 0, 0)`` for big-endian. If the given byte order indicator is ``=``, the native byte order is used. Raises: :exc:`ValueError`: If the byte order indicator is unrecognised. )normalise_byte_order_byte_order_to_machine_stamp byte_orders rmachine_stamp_from_byte_orderrOs$&j11J ' 33rcBt|t|kS)aWork out if the byte order indicators represent the same endianness. Args: a: The first byte order indicator: one of ``=``, ``<`` or ``>``, as defined and used by :class:`numpy dtype ` objects. b: The second byte order indicator. Returns: :data:`True` if the byte order indicators represent the same endianness. Raises: :exc:`ValueError`: If the byte order indicator is not recognised. )rK)abs rbyte_orders_equalrSs   " "&:1&=&= ==rc|dvr"td||dkrtjdkrdndS|S)aConvert a numpy byte order indicator to one of ``<`` or ``>``. Args: byte_order: One of ``=``, ``<`` or ``>``. Returns: ``<`` if the byte order indicator represents little-endian data, or ``>`` if it represents big-endian. Therefore on a little-endian machine, ``=`` will be converted to ``<``, but on a big-endian machine it will be converted to ``>``. Raises: :exc:`ValueError`: If ``byte_order`` is not one of ``=``, ``<`` or ``>``. )rDrFrIz'Unrecognised byte order indicator '{0}'rIlittlerDrF)r-r.sysrrMs rrKrKsX ((B &,,.. .Smx//ssS8 rc"d|cxkodkncS)a Identify if the given space group number represents a volume stack. Args: ispg: The space group number, as an integer, numpy scalar or single- element numpy array. Returns: :data:`True` if the space group number is in the range 401--630. iiv)rs rrrs& $    #    rr9c t|ot|S#t$r/ t d|DcYS#t $rYYdSwxYwwxYw)zECheck if a string is entirely composed of printable ASCII characters.c3(K|] }|tvVdSN)printable_chars)r;chars rr=z%is_printable_ascii..'s'CC4t.CCCCCCrF)r* isprintableisasciiAttributeErrorallUnicodeDecodeErrorstring_s ris_printable_asciiresw''@CKK,@,@@  CC7CCCCC C C C!   555  s-36 A/AA/ A+&A/*A++A/ct|dd}t|s,dt d|D}|S)zVConvert bytes into a printable ASCII string by removing non-printable characters. asciiignoreencodingerrorsc38K|]}t||VdSr[)re)r;ss rr=z.printable_string_from_bytes..1s0KKQ5G5J5JKqKKKKKKr)bytesdecoderer>list)bytes_rds rprintable_string_from_bytesrs,sYll6GHlEEG g & &M''$KK'KKKKKLL NrcVtt|ddS)a7Convert a string to bytes. Even though this is a one-liner, the details are tricky to get right so things work properly in both Python 2 and 3. It's broken out as a separate function so it can be thoroughly tested. Raises: UnicodeError: If the input contains non-ASCII characters. rgstrictri)r*encodercs rbytes_from_stringrw5s" ::c'llWX: F FFr)rI)(__doc__ __future__rrrrstringrVnumpyr3 constantsrrrdictr,r0int8int16float32 complex64uint16float16r7r r@rH bytearrayrLrOrSrKr ascii_lettersdigits punctuationr\rersrwrXrrrs>************ ------DDD.4aA!a@@@:::Bghjliz $$'A'A'AT@@@ HHH.&/Y/A%B%B%.Y/A%B%B D D4444*>>>".   ,,v}