Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members

emdata.h

Go to the documentation of this file.
00001 
00005 /*
00006  * Author: Steven Ludtke, 04/10/2003 (sludtke@bcm.edu)
00007  * Copyright (c) 2000-2006 Baylor College of Medicine
00008  *
00009  * This software is issued under a joint BSD/GNU license. You may use the
00010  * source code in this file under either license. However, note that the
00011  * complete EMAN2 and SPARX software packages have some GPL dependencies,
00012  * so you are responsible for compliance with the licenses of these packages
00013  * if you opt to use BSD licensing. The warranty disclaimer below holds
00014  * in either instance.
00015  *
00016  * This complete copyright notice must be included in any revised version of the
00017  * source code. Additional authorship citations may be added, but existing
00018  * author citations must be preserved.
00019  *
00020  * This program is free software; you can redistribute it and/or modify
00021  * it under the terms of the GNU General Public License as published by
00022  * the Free Software Foundation; either version 2 of the License, or
00023  * (at your option) any later version.
00024  *
00025  * This program is distributed in the hope that it will be useful,
00026  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00027  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
00028  * GNU General Public License for more details.
00029  *
00030  * You should have received a copy of the GNU General Public License
00031  * along with this program; if not, write to the Free Software
00032  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
00033  *
00034  * */
00035 
00036 #ifndef eman__emdata_h__
00037 #define eman__emdata_h__ 1
00038 
00039 #ifdef _WIN32
00040         #pragma warning(disable:4819)
00041 #endif  //_WIN32
00042 
00043 #include <cfloat>
00044 #include <complex>
00045 #include <fstream>
00046 
00047 #include "sparx/fundamentals.h"
00048 #include "emutil.h"
00049 #include "util.h"
00050 #include "sparx/emarray.h"
00051 #include "geometry.h"
00052 #include "transform.h"
00053 #ifdef EMAN2_USING_CUDA
00054 #include <cuda_runtime_api.h>
00055 #include "cuda/cuda_util.h"
00056 #endif // EMAN2_USING_CUDA
00057 using std::string;
00058 using std::vector;
00059 using std::map;
00060 //using std::complex;   //comment this out for conflict with ACML
00061 using std::ostream;
00062 
00063 #include <utility>
00064 using std::pair;
00065 
00066 namespace EMAN
00067 {
00068         class ImageIO;
00069         class Ctf;
00070         class XYData;
00071         class Transform3D;
00072         class Transform;
00073         class GLUtil;
00074 
00075         typedef boost::multi_array_ref<float, 2> MArray2D;
00076         typedef boost::multi_array_ref<float, 3> MArray3D;
00077         typedef boost::multi_array_ref<std::complex<float>, 2> MCArray2D;
00078         typedef boost::multi_array_ref<std::complex<float>, 3> MCArray3D;
00079         typedef boost::multi_array<int, 2> MIArray2D;
00080         typedef boost::multi_array<int, 3> MIArray3D;
00081 
00088         class EMData
00089         {
00090                 friend class GLUtil;
00091 
00093                 #include "emdata_io.h"
00094 
00096                 #include "emdata_metadata.h"
00097 
00099                 #include "emdata_modular.h"
00100 
00102                 #include "emdata_transform.h"
00103 
00105                 #include "emdata_core.h"
00106 
00108                 #include "sparx/emdata_sparx.h"
00109 #ifdef EMAN2_USING_CUDA
00110 
00111                 #include "emdata_cuda.h"
00112 #endif // EMAN2_USING_CUDA
00113 
00114         static int totalalloc;
00115         public:
00116                 enum FFTPLACE { FFT_OUT_OF_PLACE, FFT_IN_PLACE };
00117                 enum WINDOWPLACE { WINDOW_OUT_OF_PLACE, WINDOW_IN_PLACE };
00118 
00120                 EMData();
00121                 ~ EMData();
00122 
00126                 explicit EMData(const string& filename, int image_index=0);
00127 
00134                 EMData(int nx, int ny, int nz=1, bool is_real=true);
00135 
00145                 EMData(float* data, const int nx, const int ny, const int nz, const Dict& attr_dict = Dict());
00146 
00152                 EMData(const EMData& that);
00153 
00159                 EMData& operator=(const EMData& that);
00160 
00161 
00170                 EMData *get_clip(const Region & area, const float fill = 0) const;
00171 
00178                 void clip_inplace(const Region & area,const float& fill_value=0);
00179 
00184                 EMData *get_top_half() const;
00185 
00186 
00195                 EMData *get_rotated_clip(const Transform & xform, const IntSize &size, float scale=1.0);
00196 
00207                 EMData* window_center(int l);
00208 
00209 
00224                 float *setup4slice(bool redo = true);
00225 
00226 
00230                 void scale(float scale_factor);
00231 
00232 
00238                 void translate(float dx, float dy, float dz);
00239 
00240 
00244                 void translate(const Vec3f &translation);
00245 
00246 
00253                 void translate(int dx, int dy, int dz);
00254 
00255 
00260                 void translate(const Vec3i &translation);
00261 
00262 
00267                 void rotate(const Transform3D & t);
00268 
00269                 float max_3D_pixel_error(const Transform &t1, const Transform &t2, float r);
00270 
00277                 void rotate(float az, float alt, float phi);
00278 
00279 
00284                 void rotate_translate(const Transform3D & t);
00285 
00289                 inline void transform(const Transform& t) {
00290                         ENTERFUNC;
00291                         process_inplace("xform",Dict("transform",(Transform*)(&t)));
00292                         //update(); no need, process_inplace did it
00293                         EXITFUNC;
00294                 }
00295 
00300                 inline void rotate_translate(const Transform & t) {
00301                         cout << "Deprecation warning. Please consider using EMData::transform() instead " << endl;
00302                         transform(t); }
00303 
00313                 void rotate_translate(float az, float alt, float phi, float dx, float dy, float dz);
00314 
00315 
00328                 void rotate_translate(float az, float alt, float phi, float dx, float dy,
00329                                                           float dz, float pdx, float pdy, float pdz);
00330 
00331 
00337                 void rotate_x(int dx);
00338 
00339 
00344                 inline void rotate_180() {
00345                         ENTERFUNC;
00346                         process_inplace("math.rotate.180",Dict());
00347                         EXITFUNC;
00348                 }
00349 
00350 
00364                 double dot_rotate_translate(EMData * with, float dx, float dy, float da,const bool mirror=false);
00365 
00366 
00377                 EMData *little_big_dot(EMData * little_img, bool do_sigma = false);
00378 
00379 
00392                 EMData *do_radon();
00393 
00394 
00410                 EMData *calc_ccf(EMData * with, fp_flag fpflag = CIRCULANT, bool center=false);
00411 
00424                 void zero_corner_circulant(const int radius = 0);
00425 
00444                 EMData *calc_ccfx( EMData * const with, int y0 = 0, int y1 = -1, bool nosum = false);
00445 
00446 
00455                 EMData *make_rotational_footprint(bool unwrap = true);
00456                 EMData *make_rotational_footprint_e1(bool unwrap = true);
00457                 EMData *make_rotational_footprint_cmc(bool unwrap = true);
00458 
00475                 EMData *make_footprint(int type=0);
00476 
00477 
00490                 EMData *calc_mutual_correlation(EMData * with, bool tocorner = false, EMData * filter = 0);
00491 
00492 
00508                 EMData *unwrap(int r1 = -1, int r2 = -1, int xs = -1, int dx = 0,
00509                                                            int dy = 0, bool do360 = false, bool weight_radial=true) const;
00510 
00511                 EMData * unwrap_largerR(int r1,int r2,int xs, float rmax_f);
00512 #ifdef FFTW2
00513                 EMData *oneDfftPolar(int size, float rmax, float MAXR);
00514 #endif  //FFTW2
00515                 
00523                 void apply_radial_func(float x0, float dx, vector < float >array, bool interp = true);
00524 
00525 
00537                 vector < float >calc_radial_dist(int n, float x0, float dx,bool inten);
00538 
00539 
00551                 vector < float >calc_radial_dist(int n, float x0, float dx, int nwedge, bool inten);
00552 
00553 
00557                 void cconj();
00558 
00559 
00567                 void add_incoherent(EMData * obj);
00568 
00569 
00581                 vector <float> calc_hist(int hist_size = 128, float hist_min = 0, float hist_max = 0, const float& brt = 0.0f, const float& cont = 1.0f);
00582 
00583 
00595                 vector<float> calc_az_dist(int n, float a0, float da, float rmin,
00596                                                                    float rmax);
00597 
00598 #if 0
00599                 void calc_rcf(EMData * with, vector < float >&sum_array);
00600 #endif
00601 
00614                 float calc_dist(EMData * second_img, int y_index = 0) const;
00615 
00632                 EMData *calc_flcf(EMData * with);
00633 
00652                 EMData *calc_fast_sigma_image( EMData* mask);
00653 
00659                 EMData *convolute(EMData * with);
00660 
00661 #if 0
00662                 void create_ctf_map(CtfMapType type, XYData * sf = 0);
00663 #endif
00664 
00665 
00687                 void common_lines(EMData * image1, EMData * image2, int mode = 0,
00688                                                   int steps = 180, bool horizontal = false);
00689 
00700                 void common_lines_real(EMData * image1, EMData * image2,
00701                                                            int steps = 180, bool horizontal = false);
00702 
00716                 void cut_slice(const EMData * const map, const Transform& tr, bool interpolate = true);
00717 
00718 #ifdef EMAN2_USING_CUDA
00719 
00728                 EMData* cut_slice_cuda(const Transform& tr);
00729 #endif // EMAN2_USING_CUDA
00730 
00744                 void uncut_slice(EMData * const map, const Transform& tr) const;
00745 
00749                 int getResolution() const {
00750                         int resolution = 0;
00751                         int num = 1;
00752                         while(num < get_xsize()) {
00753                                 resolution++;
00754                                 num = 1 << resolution;
00755                         }
00756 
00757                         return resolution;
00758                 }
00759 
00762                 void debug_print_parms()
00763                 {
00764                         std::cout << "Printing EMData params" << std::endl;
00765                         for ( Dict::const_iterator it = attr_dict.begin(); it != attr_dict.end(); ++it )
00766                         {
00767                                 std::cout << (it->first) << " " << (it->second).to_str() << std::endl;
00768                         }
00769                         std::cout << "Done printing EMData params" << std::endl;
00770                 }
00771 
00777                 void set_xyz_origin(float origin_x, float origin_y, float origin_z);
00778         private:
00785                 enum EMDataFlags {
00786 //                      EMDATA_COMPLEX = 1 << 1,
00787 //                      EMDATA_RI = 1 << 2,            // real/imaginary or amp/phase
00788                         EMDATA_BUSY = 1 << 3,      // someone is modifying data, NO LONGER USED
00789                         EMDATA_HASCTFF = 1 << 4,   // has CTF info in the image file
00790                         EMDATA_NEEDUPD = 1 << 5,   // needs a real update
00791 //                      EMDATA_COMPLEXX = 1 << 6,  // 1D fft's in X
00792                         EMDATA_FLIP = 1 << 7,      // is the image flipped
00793                         EMDATA_PAD = 1 << 8,       // is the image fft padded
00794                         EMDATA_FFTODD = 1 << 9,    // is the (real-space) nx odd
00795                         EMDATA_SHUFFLE = 1 << 10,  // fft been shuffled? (so O is centered) PRB
00796                         EMDATA_FH = 1 << 11,        // is the complex image a FH image
00797                         EMDATA_CPU_NEEDS_UPDATE = 1 << 12, // CUDA related: is the CPU version of the image out out data
00798                         EMDATA_GPU_NEEDS_UPDATE = 1 << 13, // CUDA related: is the GPU version of the image out out data
00799                         EMDATA_GPU_RO_NEEDS_UPDATE = 1 << 14 // // CUDA related: is the GPU RO version of the image out out data
00800                 };
00801 
00802                 void update_stat() const;
00803                 void save_byteorder_to_dict(ImageIO * imageio);
00804 
00805         private:
00807                 mutable Dict attr_dict;
00809                 mutable float *rdata;
00811                 float *supp;
00812 
00815                 //Ctf *ctf;
00816 
00818                 mutable int flags;
00819                 // Incremented every time the image changes
00820                 int changecount;
00822                 int nx, ny, nz, nxy;
00823                 size_t nxyz;
00825                 int xoff, yoff, zoff;
00826 
00828                 Vec3f all_translation;
00829 //              Vec3f all_rotation;    /** rotation (az, alt, phi) from the original locaton*/
00830 
00831                 string path;
00832                 int pathnum;
00833 
00835                 mutable EMData* rot_fp;
00836 
00837                 // Clip inplace variables is a local class used from convenience in EMData::clip_inplace
00838                 // Added by d.woolford
00839                 class ClipInplaceVariables
00840                 {
00841                         public:
00842                                 ClipInplaceVariables(const int p_nx, const int p_ny, const int p_nz, const int n_nx, const int n_ny, const int n_nz,const int xtrans, const int ytrans, const int ztrans) :
00843                                         prv_nx(p_nx), prv_ny(p_ny), prv_nz(p_nz), new_nx(n_nx), new_ny(n_ny), new_nz(n_nz), xshift(xtrans), yshift(ytrans), zshift(ztrans),
00844                                  x_iter(prv_nx), y_iter(prv_ny), z_iter(prv_nz), new_z_top(0), new_z_bottom(0),  new_y_back(0), new_y_front(0),new_x_left(0), new_x_right(0),
00845                                 prv_z_top(0), prv_z_bottom(0), prv_y_back(0), prv_y_front(0), prv_x_left(0), prv_x_right(0)
00846                         {
00847                                 if ( xtrans > 0 ) x_iter -= xtrans;
00848                                 if ( x_iter < 0 ) x_iter = 0;
00849                                 if ( ytrans > 0 ) y_iter -= ytrans;
00850                                 if ( y_iter < 0 ) y_iter = 0;
00851                                 if ( ztrans > 0 ) z_iter -= ztrans;
00852                                 if ( z_iter < 0 ) z_iter = 0;
00853 
00854                                 // Get the depth in the new volume where slices are inserted
00855                                 // if this value is zero it means that the last z-slice in the new
00856                                 // volume contains image data
00857                                 if ( (new_nz + ztrans) > prv_nz ) new_z_top = new_nz + ztrans - prv_nz;
00858                                 if ( (new_ny + ytrans) > prv_ny ) new_y_back = new_ny + ytrans - prv_ny;
00859                                 if ( (new_nx + xtrans) > prv_nx ) new_x_right = new_nx + xtrans - prv_nx;
00860 
00861                                 if ( (new_nz + ztrans) < prv_nz )
00862                                 {
00863                                         prv_z_top = prv_nz - new_nz - ztrans;
00864                                         z_iter -= prv_z_top;
00865                                 }
00866                                 if ( (new_ny + ytrans) < prv_ny )
00867                                 {
00868                                         prv_y_back = prv_ny - new_ny - ytrans;
00869                                         y_iter -= prv_y_back;
00870                                 }
00871                                 if ( (new_nx + xtrans) < prv_nx )
00872                                 {
00873                                         prv_x_right = prv_nx - new_nx - xtrans;
00874                                         x_iter -= prv_x_right;
00875                                 }
00876 
00877                                 if ( xtrans > 0 ) prv_x_left = xtrans;
00878                                 if ( ytrans > 0 ) prv_y_front = ytrans;
00879                                 if ( ztrans > 0 ) prv_z_bottom = ztrans;
00880 
00881                                 if ( xtrans < 0 ) new_x_left = -xtrans;
00882                                 if ( ytrans < 0 ) new_y_front = -ytrans;
00883                                 if ( ztrans < 0 ) new_z_bottom = -ztrans;
00884 
00885                         }
00886                         ~ClipInplaceVariables() {}
00887 
00888                         int prv_nx, prv_ny, prv_nz, new_nx, new_ny, new_nz;
00889                         int xshift, yshift, zshift;
00890                         int x_iter, y_iter, z_iter;
00891                         int new_z_top, new_z_bottom, new_y_back, new_y_front, new_x_left, new_x_right;
00892                         int prv_z_top, prv_z_bottom,  prv_y_back, prv_y_front, prv_x_left, prv_x_right;
00893                 };
00894 
00895 
00896 
00897                 //              /**  Do the Fourier Harmonic Transform  PRB
00898                 //               * Takes a real image, returns the FH
00899                 //               * Sets the EMDATA_FH switch to indicate that it is an FH image
00900                 //               * @exception ImageFormatException If the image is not a square real odd image.
00901                 //               * @return the FH image.
00902                 //               */
00903                 //              EMData* do_FH();
00904 
00905                 //              /**   Do the Inverse Fourier Harmonic Transform   PRB
00906                 //               * Takes an FH image, returns a square  complex image with odd sides
00907                 //               * @exception ImageFormatException If the image is not the FH of something
00908                 //               * @return a square complex image with odd sides
00909                 //               */
00910                 //              EMData* do_FH2F();
00911 
00912 
00913 
00914                 //              /** Caclulates normalization and phase residual for a slice in
00915                 //               * an already existing volume. phase residual is calculated
00916                 //               * using only the inner 1/2 of the fourier sphere. Both the
00917                 //               * slice image and this image must be in complex image format.
00918                 //               *
00919                 //               * @param slice An slice image to be normalized.
00920                 //               * @param orient Orientation of the slice.
00921                 //               * @exception ImageFormatException If the images are not complex.
00922                 //               * @exception ImageDimensionException If the image is 3D.
00923                 //               * @return A float number pair (result, phase-residual).
00924                 //               */
00925                 //              FloatPoint normalize_slice(EMData * slice, const Transform3D & orient);
00926 
00927                 //              /** Caclulates normalization and phase residual for a slice in
00928                 //               * an already existing volume. phase residual is calculated
00929                 //               * using only the inner 1/2 of the fourier sphere. Both the
00930                 //               * slice image and this image must be in complex image format.
00931                 //               *
00932                 //               * @param slice An slice image to be normalized.
00933                 //               * @param alt Orientation euler angle alt (in EMAN convention).
00934                 //               * @param az  Orientation euler angle az  (in EMAN convention).
00935                 //               * @param phi Orientation euler angle phi (in EMAN convention).
00936                 //               * @exception ImageFormatException If the images are not complex.
00937                 //               * @exception ImageDimensionException If the image is 3D.
00938                 //               * @return A float number pair (result, phase-residual).
00939                 //               */
00940                 //              FloatPoint normalize_slice(EMData * slice, float az, float alt, float phi);
00941 
00942                 //              /** Get the normalization and phase residual values
00943                 //               * Used for normalizaton and error measurement when 2D slices are inserted into a 3D volume of Fourier pixels
00944                 //               * Originally added for use by the FourierReconstructor object
00945                 //               * @return the normalization const (pair.first) and the phase residual (pair.second)
00946                 //               * @param slice -the slice to be inserted into the 3D volume
00947                 //               * @param euler - the euler angle orientation of the slice
00948                 //               * @exception ImageDimensionException If this image is not 3D.ImageFormatException
00949                 //               * @exception ImageFormatException If this image is not complex
00950                 //               * @exception ImageFormatException If the slice not complex
00951                 //               */
00952                 //              pair<float, float> get_normalization_and_phaseres( const EMData* const slice, const Transform3D& euler );
00953 
00954                 //              /** cut a 2D slice out of a this 3D image and return it
00955                 //               * An alternative to cut_slice
00956                 //               * @param tr orientation of the slice as encapsulated in a Transform object
00957                 //               * @exception ImageDimensionException If this image is not 3D.
00958                 //               * @exception ImageFormatException If this image is complex
00959                 //               * @author David Woolford (adapted from an original version by Steve Ludtke)
00960                 //               * @date Feb 2009
00961                 //               */
00962                 //              EMData* get_cut_slice(const Transform& tr);
00963 
00964         };
00965 
00966 
00967         EMData * operator+(const EMData & em, float n);
00968         EMData * operator-(const EMData & em, float n);
00969         EMData * operator*(const EMData & em, float n);
00970         EMData * operator/(const EMData & em, float n);
00971 
00972         EMData * operator+(float n, const EMData & em);
00973         EMData * operator-(float n, const EMData & em);
00974         EMData * operator*(float n, const EMData & em);
00975         EMData * operator/(float n, const EMData & em);
00976 
00977         EMData * rsub(const EMData & em, float n);
00978         EMData * rdiv(const EMData & em, float n);
00979 
00980         EMData * operator+(const EMData & a, const EMData & b);
00981         EMData * operator-(const EMData & a, const EMData & b);
00982         EMData * operator*(const EMData & a, const EMData & b);
00983         EMData * operator/(const EMData & a, const EMData & b);
00984 
00985 
00986 /*   Next  is Modified by PRB      Transform3D::EMAN,
00987         inline Transform3D EMData::get_transform() const
00988         {
00989                 return Transform3D((float)attr_dict["euler_alt"],
00990                                    (float)attr_dict["euler_az"],
00991                                    (float)attr_dict["euler_phi"]);
00992         }
00993 */
00994 
00995 
00996 }
00997 
00998 
00999 #endif
01000 
01001 /* vim: set ts=4 noet nospell: */

Generated on Mon Jul 19 13:03:43 2010 for EMAN2 by  doxygen 1.4.4