i;dZddlmZmZmZmZddlmZddlZddlZ ddl m Z ddl m Z mZmZmZddlmZmZmZmZGd d eZdS) z mrcobject --------- Module which exports the :class:`MrcObject` class. Classes: :class:`MrcObject`: An object representing image or volume data in the MRC format. )absolute_importdivisionprint_functionunicode_literals)datetimeN)utils) HEADER_DTYPEVOXEL_SIZE_DTYPE NSTART_DTYPEget_ext_header_dtype)MAP_IDIMAGE_STACK_SPACEGROUPVOLUME_SPACEGROUPVOLUME_STACK_SPACEGROUPcneZdZdZfdZdZdZdZedZ edZ edZ d Z ed Z d Zd Zd ZedZejdZdZedZejdZdZdZdZdZdZdZdZdZdZdZd"dZdZ d Z!d"d!Z"xZ#S)# MrcObjecta An object representing image or volume data in the MRC format. The header, extended header and data are stored as numpy arrays and exposed as read-only attributes. To replace the data or extended header, call :meth:`set_data` or :meth:`set_extended_header`. The header cannot be replaced but can be modified in place. Voxel size is exposed as a writeable attribute, but is calculated on-the-fly from the header's ``cella`` and ``mx``/``my``/``mz`` fields. Three-dimensional data can represent either a stack of 2D images, or a 3D volume. This is indicated by the header's ``ispg`` (space group) field, which is set to 0 for image data and >= 1 for volume data. The :meth:`is_single_image`, :meth:`is_image_stack`, :meth:`is_volume` and :meth:`is_volume_stack` methods can be used to identify the type of information stored in the data array. For 3D data, the :meth:`set_image_stack` and :meth:`set_volume` methods can be used to switch between image stack and volume interpretations of the data. If the data contents have been changed, you can use the :meth:`update_header_from_data` and :meth:`update_header_stats` methods to make the header consistent with the data. These methods are called automatically if the data array is replaced by calling :meth:`set_data`. :meth:`update_header_from_data` is fast, even with very large data arrays, because it only examines the shape and type of the data array. :meth:`update_header_stats` calculates statistics from all items in the data array and so can be slow for very large arrays. If necessary, the :meth:`reset_header_stats` method can be called to set the header fields to indicate that the statistics are undetermined. Attributes: * :attr:`header` * :attr:`extended_header` * :attr:`indexed_extended_header` * :attr:`data` * :attr:`voxel_size` * :attr:`nstart` Methods: * :meth:`set_extended_header` * :meth:`set_data` * :meth:`is_single_image` * :meth:`is_image_stack` * :meth:`is_volume` * :meth:`is_volume_stack` * :meth:`set_image_stack` * :meth:`set_volume` * :meth:`update_header_from_data` * :meth:`update_header_stats` * :meth:`reset_header_stats` * :meth:`print_header` * :meth:`get_labels` * :meth:`add_label` Attributes and methods relevant to subclasses: * ``_read_only`` * :meth:`_check_writeable` * :meth:`_create_default_attributes` * :meth:`_close_data` * :meth:`_set_new_data` c tt|jdi|d|_d|_d|_d|_dS)aInitialise a new :class:`MrcObject`. This initialiser deliberately avoids creating any arrays and simply sets the header, extended header and data attributes to :data:`None`. This allows subclasses to call :meth:`__init__` at the start of their initialisers and then set the attributes themselves, probably by reading from a file, or by calling :meth:`_create_default_attributes` for a new empty object. Note that this behaviour might change in future: this initialiser could take optional arguments to allow the header and data to be provided by the caller, or might create the standard empty defaults rather than setting the attributes to :data:`None`. NF)superr__init___header_extended_header_data _read_only)selfkwargs __class__s [/srv/www/vhosts/g4struct/public_html/venv/lib/python3.11/site-packages/mrcfile/mrcobject.pyrzMrcObject.__init__csK (i'11&111 $ c2|jrtddS)z~Check that this MRC object is writeable. Raises: :exc:`ValueError`: If this object is read-only. zMRC object is read-onlyN)r ValueErrorrs r_check_writeablezMrcObject._check_writeablezs' ? 8677 7 8 8r c|tjdd|_|tjdtjdS)z39s} zCreated by mrcfile.pyrN)r*zerosr viewrecarrayrrmapnversionr machine_stamp_from_byte_ordermoder( byteordermachstrispgcellbalphabetagammamapcmaprmapsrnowstrftimeformatlabelnlablreset_header_stats)rheaderdefault_cell_angletimes rr)z MrcObject._create_default_headersxb ===BB2;OO  ;FK`.)rr#s rrKzMrcObject.headers |r c|jS)a;Get the extended header as a :class:`numpy array `. The dtype will be void (raw data, dtype ``V'``). If the actual data type of the extended header is known, the dtype of the array can be changed to match. For supported types (e.g. ``'FEI1'`` and ``'FEI2'``), the indexed part of the extended header (excluding any zero padding) can be accessed using :meth:`indexed_extended_header`. The extended header may be modified in place. To replace it completely, call :meth:`set_extended_header`. )rr#s rextended_headerzMrcObject.extended_headers $$r ct|jj|jjjj} |jj|jkrt|jd|j}||_|dd|jkrtnH#t$r;tj d |jjtYdSwxYwt|jd|jz} |jj|krt|jd|}||_nH#t$r;tj d |jjtYdSwxYw|S)a$Get the indexed part of the extended header as a :class:`numpy array ` with the appropriate dtype set. Currently only ``'FEI1'`` and ``'FEI2'`` extended headers are supported. Modifications to the indexed extended header will not change the extended header data recorded in this :class:`MrcObject`. If the extended header type is unrecognised or extended header data is not of sufficient length a warning will be produced and the indexed extended header will be None. rz Metadata sizezUThe header has exttyp '{}' but the extended header cannot be interpreted as that typeNnz)r rKexttypr:r(r;rPnbytesitemsizer"warningswarnrGRuntimeWarningint)rr(firstrTfulls rindexed_extended_headerz!MrcObject.indexed_extended_headers%T[%7%)[%5%;%EGG #*U^;;  (5>)9:EEK_%a(EN::  ;    MA#VDK$677 I I I44   T[&''%.8 #*V33  '&1DDJJ    MA#VDK$677 I I I44    s&ABAC  C 1-DAE$#E$cH||jtjtjjkrIt d|jtjtjj||_|j|j _ dS)atReplace the extended header. If you set the extended header you should also set the ``header.exttyp`` field to indicate the type of extended header. Raises: :exc:`ValueError`: If the new extended header has more than 2,147,483,647 bytes (and therefore its size cannot be stored in the header). zMNew extended header is too large! It has {} bytes. The maximum allowed is {}.N) r$rTr*iinfoint32maxr"rGrrKnsymbt)rrPs rset_extended_headerzMrcObject.set_extended_headers   !BHRX$6$6$: : :A$f_%;%'Xbh%7%7%;==>> >!0,3 r c|jS)z7Get the data as a :class:`numpy array `.rr#s rdatazMrcObject.datas zr c |tj|j}tj||jj}|jD]m}|tj tj j krDtd |tj tj j n||jkrd}tj||}|||||dS)a6Replace the data array. This replaces the current data with the given array (or a copy of it), and updates the header to match the new data dimensions. The data statistics (min, max, mean and rms) stored in the header will also be updated. Raises: :exc:`ValueError`: if the new data has a dimension larger than 2,147,483,647 (and therefore its size cannot be stored in the header). Warns: RuntimeWarning: If the data array contains Inf or NaN values. zUNew data array is too large! Found a dimension of size {}. The maximum allowed is {}.Nr')r$r mode_from_dtyper(dtype_from_mode newbyteorderr;r0r*r^r_r`r"rGascontiguousarray _close_datar,update_header_from_dataupdate_header_stats)rrer: new_dtypedimnew_datas rset_datazMrcObject.set_datas: $TZ00*400"l4:#788 : G GCRXbh''+++ "*#)&bhrx.@.@.D"E"EGGG,  " "I'I>>>  8$$$ $$&&&   """""r cd|_dS)zClose the data array.Nrdr#s rrkzMrcObject._close_data4s  r c||_dS)zReplace the data array with a new one. The new data array is not checked - it must already be valid for use in an MRC file. Nrd)rres rr,zMrcObject._set_new_data8s  r c"|jjj|jjz }|jjj|jjz }|jjj|jjz }tj |||ft}d|j _ |S)aGet or set the voxel size in angstroms. The voxel size is returned as a structured NumPy :class:`record array ` with three fields (x, y and z). For example: >>> mrc.voxel_size rec.array((0.44825, 0.3925, 0.45874998), dtype=[('x', '>> mrc.voxel_size.x array(0.44825, dtype=float32) Note that changing the voxel_size array in-place will *not* change the voxel size in the file -- to prevent this being overlooked accidentally, the writeable flag is set to :data:`False` on the voxel_size array. To set the voxel size, assign a new value to the voxel_size attribute. You may give a single number, a 3-tuple ``(x, y ,z)`` or a modified version of the voxel_size array. The following examples are all equivalent: >>> mrc.voxel_size = 1.0 >>> mrc.voxel_size = (1.0, 1.0, 1.0) >>> vox_sizes = mrc.voxel_size >>> vox_sizes.flags.writeable = True >>> vox_sizes.x = 1.0 >>> vox_sizes.y = 1.0 >>> vox_sizes.z = 1.0 >>> mrc.voxel_size = vox_sizes F)rKcellaxmxymyzmzr*recarrayr flags writeable)rrvrxrzsizess r voxel_sizezMrcObject.voxel_size@srD K  $+. 0 K  $+. 0 K  $+. 0 aAY(899 %  r c| t|fdz}n8#t$r+ |}n#t$r|}YnwxYwYnwxYw|j|dSNr3)r$float TypeErroritemAttributeError_set_voxel_size)rrrs rrzMrcObject.voxel_sizeis  #:&&(1,EE # # # ##))! # # #" #  # e$$$$2* AA  A AAAAAc||jjz|jj_||jjz|jj_||jjz|jj_dS)zSet the voxel size. Args: x_size: The voxel size in the X direction, in angstroms y_size: The voxel size in the Y direction, in angstroms z_size: The voxel size in the Z direction, in angstroms N)rKrwrurvryrxr{rz)rx_sizey_sizez_sizes rrzMrcObject._set_voxel_sizeysL%t{~5 $t{~5 $t{~5 r c|jj}|jj}|jj}tj|||ft}d|j_ |S)aGet or set the grid start locations. This provides a convenient way to get and set the values of the header's ``nxstart``, ``nystart`` and ``nzstart`` fields. Note that these fields are integers and are measured in voxels, not angstroms. The start locations are returned as a structured NumPy :class:`record array ` with three fields (x, y and z). For example: >>> mrc.header.nxstart array(0, dtype=int32) >>> mrc.header.nystart array(-21, dtype=int32) >>> mrc.header.nzstart array(-12, dtype=int32) >>> mrc.nstart rec.array((0, -21, -12), dtype=[('x', '>> mrc.nstart.y array(-21, dtype=int32) Note that changing the nstart array in-place will *not* change the values in the file -- to prevent this being overlooked accidentally, the writeable flag is set to :data:`False` on the nstart array. To set the start locations, assign a new value to the nstart attribute. You may give a single number, a 3-tuple ``(x, y ,z)`` or a modified version of the nstart array. The following examples are all equivalent: >>> mrc.nstart = -150 >>> mrc.nstart = (-150, -150, -150) >>> starts = mrc.nstart >>> starts.flags.writeable = True >>> starts.x = -150 >>> starts.y = -150 >>> starts.z = -150 >>> mrc.nstart = starts F) rKnxstartnystartnzstartr*r|r}r r~r)rrvrxrznstarts rrzMrcObject.nstartsMT K  K  K q!Qi66!&  r c| t|fdz}n8#t$r+ |}n#t$r|}YnwxYwYnwxYw|j|dSr)r$rYrrr _set_nstart)rrstartss rrzMrcObject.nstarts  &kk^a'FF     !      &!!!!rcN||j_||j_||j_dS)aSet the grid start locations. Args: nxstart: The location of the first column in the unit cell nystart: The location of the first row in the unit cell nzstart: The location of the first section in the unit cell N)rKrrr)rrrrs rrzMrcObject._set_nstarts(& % % r c"|jjdkS)zIdentify whether the file represents a single image. Returns: :data:`True` if the data array is two-dimensional. r2rendimr#s ris_single_imagezMrcObject.is_single_image y~""r cL|jjdko|jjtkS)zIdentify whether the file represents a stack of images. Returns: :data:`True` if the data array is three-dimensional and the space group is zero. r3rerrKr=rr#s ris_image_stackzMrcObject.is_image_stack) !#?K$(>> @r cL|jjdko|jjtkS)zIdentify whether the file represents a volume. Returns: :data:`True` if the data array is three-dimensional and the space group is not zero. r3rr#s r is_volumezMrcObject.is_volumerr c"|jjdkS)zIdentify whether the file represents a stack of volumes. Returns: :data:`True` if the data array is four-dimensional. rr#s ris_volume_stackzMrcObject.is_volume_stackrr c||jjdkrtdt|j_d|j_dS)zChange three-dimensional data to represent an image stack. This method changes the space group number (``header.ispg``) to zero. Raises: :exc:`ValueError`: If the data array is not three-dimensional. r3z/Only 3D data can be changed into an image stackrN)r$rerr"rrKr=r{r#s rset_image_stackzMrcObject.set_image_stacksK  9>Q  NOO O1  r c||jjdkrtd|r)t |j_|jj|j_ dSdS)a6Change three-dimensional data to represent a volume. If the space group was previously zero (representing an image stack), this method sets it to one. Otherwise the space group is not changed. Raises: :exc:`ValueError`: If the data array is not three-dimensional. r3z)Only 3D data can be changed into a volumeN) r$rerr"rrrKr=rRr{r#s r set_volumezMrcObject.set_volumesm  9>Q  HII I     ,0DK ![^DKNNN , ,r c\||j}tj|jj|_|jjj}|jjj}|dkrItj||s4| d|j ||_tj |jjj|_ |jj }t|}|dkrDt|_|dx|_|_|dx|_|_dx|_|_d S|dkrd|dx|_|_|dx|_|_|jtkrd|_|d|_d S|dx|_|_d S|dkrrtj|js t0|_|dx|_|_|dx|_|_|d|_|d|dz|_d St3d) aUpdate the header from the data array. This function updates the header byte order and machine stamp to match the byte order of the data. It also updates the file mode, space group and the dimension fields ``nx``, ``ny``, ``nz``, ``mx``, ``my`` and ``mz``. If the data is 2D, the space group is set to 0 (image stack). For 3D data the space group is not changed, and for 4D data the space group is set to 401 (simple P1 volume stack) unless it is already in the volume stack range (401--630). This means that new 3D data will be treated as an image stack if the previous data was a single image or image stack, or as a volume if the previous data was a volume or volume stack. Note that this function does *not* update the data statistics fields in the header (``dmin``, ``dmax``, ``dmean`` and ``rms``). Use the :meth:`update_header_stats` function to update the statistics. (This is for performance reasons -- updating the statistics can take a long time for large data sets, but updating the other header information is always fast because only the type and shape of the data array need to be inspected.) |Tr2rrr3rz$Data must be 2-, 3- or 4-dimensionalN)r$rKr rgrer(r:r;byte_orders_equalbyteswaprir9r<r0lenrr=nxrwnyryrRr{spacegroup_is_volume_stackrr")rrKdata_byte_orderheader_byte_orderr0axess rrlz!MrcObject.update_header_from_datas2 +DIO<< )/3"K-7 s " "+O=NOO # OOD ! ! !!<44_EEFL;FKA  ty)) B"$*TY]]__-A"B"B immooimmoo8C==TM"BNSSS8C==YBHSMMYM"GXXX#%:c??  #%:c??  $(INNN$D$D !"&)--bj-"A"A   # # % % % % %r c|d|j_d|j_d|j_d|j_dS)zBSet the header statistics to indicate that the values are unknown.rN)r$rKrrrrr#s rrJzMrcObject.reset_header_stats}s?     r Nc|jjjD]2}td||j||3dS)akPrint the contents of all header fields. Args: print_file: The output text stream to use for printing the header. This is passed directly to the ``file`` argument of Python's :func:`print` function. The default is :data:`None`, which means output will be printed to :data:`sys.stdout`. z {0:15s} : {1}fileN)rKr(namesprintrG)r print_filers r print_headerzMrcObject.print_headers]K%+ # #D /((t{4/@AA! # # # # # # #r cRd|jjd|jjDS)aDGet the labels from the MRC header. Up to ten labels are stored in the header as arrays of 80 bytes. This method returns the labels as Python strings, filtered to remove non-printable characters. To access the raw bytes (including any non-printable characters) use the ``header.label`` attribute (and note that ``header.nlabl`` stores the number of labels currently set). Returns: The labels, as a list of strings. The list will contain between 0 and 10 items, each containing up to 80 characters. c6g|]}tj|Sr)r printable_string_from_bytes).0rHs r z(MrcObject.get_labels..s3     -e 4 4   r N)rKrHrIr#s r get_labelszMrcObject.get_labelss8  *+=DK,=+=>    r ctj|stdtj|}t |dkrtd||jj|jj<|jxjdz c_dS)a Add a label to the MRC header. The new label will be stored after any labels already in the header. If all ten labels are already in use, an exception will be raised. Future versions of this method might add checks to ensure that labels containing valid text are not overwritten even if the ``nlabl`` value is incorrect. Args: label: The label value to store, as a string containing only printable ASCII characters. Raises: :exc:`ValueError`: If the label is longer than 80 bytes or contains non-printable or non-ASCII characters. :exc:`IndexError`: If the file already contains 10 labels and so an additional label cannot be stored. z4Label contains non-printable or non-ASCII charactersPz"Label value has more than 80 bytesrN)r is_printable_asciir"bytes_from_stringrrKrHrI)rrH label_bytess r add_labelzMrcObject.add_labels&'.. USTT T-e44 {  b ABB B/4 $++, Qr c  d}fd}|jjtkr0|d|jjtd} t j|jjn>#t$r1t j|jj}|d|zd}YnwxYw t j |jj n:#t$r-|d|jj d}YnwxYwdD]3}|j|dkr |d |d}4d D]8}|jj |dkr |d |d}9t}d D]/}| t|j|0|hd kr:|dtt!|d}t j|jjrR|jj|jjzdkr5|d|jj|jjd}d}d}|jjD]>} t-| dkr|dz }|r |dd}.logs ' + + + + + +r z4Map ID string is incorrect: found {0}, should be {1}FzInvalid machine stamp: zInvalid mode: {0})rrrRrwryr{r=rIrzHeader field '{0}' is negative)rvrxrzz Cell dimension '{0}' is negative)rBrCrD>rr2r3z4Invalid axis mapping: found {0}, should be [1, 2, 3]z]Error in dimensions for volume stack: nz should be divisible by mz. Found nz = {0}, mz = {1})rzJError in header labels: empty labels appear between text-containing labelsz@Error in header labels: nlabl is {0} but {1} labels contain text)iNr1zGFile does not declare MRC format version 20140 or 20141: nversion = {0})sCCP4sMRCOsSERIsAGARsFEI1sFEI2sHDF5zAExtended header type is undefined or unrecognised: exttyp = '{0}'asciiNg{Gz?)rtolz`Data statistics appear to be inaccurate: RMS deviation is {0} but the value in the header is {1}zZData statistics appear to be inaccurate: minimum is {0} but the value in the header is {1}zZData statistics appear to be inaccurate: maximum is {0} but the value in the header is {1}r'zWData statistics appear to be inaccurate: mean is {0} but the value in the header is {1})*rKr7rrGr byte_order_from_machine_stampr<r"pretty_machine_stamprhr:rusetaddrYsortedlistrr=rRr{rHrstriprIr8rarSrdecoderrerr*iscloserrrr`rrfloat64)rrvalidr pretty_bytesfieldrcountseen_empty_labelrHvalid_exttypesreal_rmsreal_minreal_max real_means ` rvalidatezMrcObject.validatesU\ , , , , , ;?f $ $ CF 00 2 2 2E   / 0B C C C C    5dk6HIIL C)L8 9 9 9EEE     !$+"2 3 3 3 3    C#**4;+;<< = = =EEE  K  E{5!A%%4;;EBBCCC%  E{ '!++6==eDDEEEuu- . .E HHSU+,, - - - - 999   CFtDzz**++ - - -E  +DK,< = = {~ .!33AVDKNDKN;;=== [& ( (E5;;==!!A%% #"C1222!E#'  DK% % % C..4fT[5F.N.N P P PE ; ~ 5 5 Cvdk233 5 5 5EYXX ;  ! !dk&8&N&N Ct{16688??HHII K K KE676686h ;?a  y$TY]););$9==??:h dCCC 66rs<  ************++++++++++++111111111111A A A A A A A A A A r