EMAN2
Public Member Functions | Static Public Member Functions | Static Public Attributes | Private Member Functions | Private Attributes | List of all members
EMAN::GaussFFTProjector Class Reference

Gaussian FFT 3D projection. More...

#include <projector.h>

Inheritance diagram for EMAN::GaussFFTProjector:
Inheritance graph
[legend]
Collaboration diagram for EMAN::GaussFFTProjector:
Collaboration graph
[legend]

Public Member Functions

 GaussFFTProjector ()
 
EMData * project3d (EMData *image) const
 Project an 3D image into a 2D image. More...
 
EMData * backproject3d (EMData *image) const
 Back-project a 2D image into a 3D image. More...
 
void set_params (const Dict &new_params)
 
string get_name () const
 Get the projector's name. More...
 
string get_desc () const
 
TypeDict get_param_types () const
 Get processor parameter information in a dictionary. More...
 
- Public Member Functions inherited from EMAN::Projector
virtual ~Projector ()
 
virtual Dict get_params () const
 Get the projector parameters in a key/value dictionary. More...
 
void set_params (const Dict &new_params)
 Set the projector parameters using a key/value dictionary. More...
 

Static Public Member Functions

static Projector * NEW ()
 

Static Public Attributes

static const string NAME = "gauss_fft"
 

Private Member Functions

bool interp_ft_3d (int mode, EMData *image, float x, float y, float z, float *data, float gauss_width) const
 

Private Attributes

float alt
 
float az
 
float phi
 

Additional Inherited Members

- Protected Attributes inherited from EMAN::Projector
Dict params
 

Detailed Description

Gaussian FFT 3D projection.

use integer 'mode' to determine the gaussian width and the way to interpolate a point in a 3d complex image. valid mode range: [1,7]. the gauss widths are as follows with mode from 1 to 7:

mode 1: 0; mode 2: 4.0 / (M_PI * M_PI); mode 3: 6.4 / (M_PI * M_PI); mode 4: 8.8 / (M_PI * M_PI); mode 5: 0; mode 6: 10.4 / (M_PI * M_PI); mode 7: 10.4 / (M_PI * M_PI);

Definition at line 146 of file projector.h.

Constructor & Destructor Documentation

◆ GaussFFTProjector()

EMAN::GaussFFTProjector::GaussFFTProjector ( )
inline

Definition at line 149 of file projector.h.

149 :alt(0), az(0), phi(0)
150 {
151 }

Referenced by NEW().

Member Function Documentation

◆ backproject3d()

EMData * GaussFFTProjector::backproject3d ( EMData *  image) const
virtual

Back-project a 2D image into a 3D image.

Returns
A 3D image from the backprojection.

Implements EMAN::Projector.

Definition at line 1890 of file projector.cpp.

1891{
1892 // no implementation yet
1893 EMData *ret = new EMData();
1894 return ret;
1895}
EMAN::EMData
EMData stores an image's data and defines core image processing routines.
Definition: emdata.h:82

◆ get_desc()

string EMAN::GaussFFTProjector::get_desc ( ) const
inlinevirtual

Implements EMAN::Projector.

Definition at line 171 of file projector.h.

172 {
173 return "Projections using a Gaussian kernel in Fourier space. Produces artifacts, not recommended.";
174 }

◆ get_name()

string EMAN::GaussFFTProjector::get_name ( ) const
inlinevirtual

Get the projector's name.

Each projector is indentified by unique name.

Returns
The projector's name.

Implements EMAN::Projector.

Definition at line 166 of file projector.h.

167 {
168 return NAME;
169 }
EMAN::GaussFFTProjector::NAME
static const string NAME
Definition: projector.h:190

References NAME.

◆ get_param_types()

TypeDict EMAN::GaussFFTProjector::get_param_types ( ) const
inlinevirtual

Get processor parameter information in a dictionary.

Each parameter has one record in the dictionary. Each record contains its name, data-type, and description.

Returns
A dictionary containing the parameter info.

Reimplemented from EMAN::Projector.

Definition at line 181 of file projector.h.

182 {
183 TypeDict d;
184 d.put("transform", EMObject::TRANSFORM);
185 d.put("mode", EMObject::INT);
186 d.put("returnfft", EMObject::INT);
187 return d;
188 }

References EMAN::EMObject::INT, EMAN::TypeDict::put(), and EMAN::EMObject::TRANSFORM.

◆ interp_ft_3d()

bool GaussFFTProjector::interp_ft_3d ( int  mode,
EMData *  image,
float  x,
float  y,
float  z,
float *  data,
float  gauss_width 
) const
private

Definition at line 216 of file projector.cpp.

218{
219 float *rdata = image->get_data();
220 int nx = image->get_xsize();
221 int ny = image->get_ysize();
222 int nz = image->get_zsize();
223
224 if ( mode == 0 ) {
225 int x0 = (int) floor(x);
226 int y0 = (int) floor(y);
227 int z0 = (int) floor(z);
228 float d0,d1,nrm;
229 d0=d1=nrm=0;
230
231 for (int ix=x0; ix<=x0+1; ix++){
232 for (int iy=y0; iy<=y0+1; iy++){
233 for (int iz=z0; iz<=z0+1; iz++){
234 float w=(1.0-fabs(ix-x))*(1.0-fabs(iy-y))*(1.0-fabs(iz-z));
235 d0 += w * rdata[2*ix + iy * nx + iz * nx * ny];
236 d1 += w * rdata[2*ix + iy * nx + iz * nx * ny + 1];
237 nrm+=w;
238 }}}
239// printf("%f\t%f\t%f\n", d0, d1, nrm);
240 data[0]=d0/nrm;
241 data[1]=d1/nrm;
242 return true;
243 }
244 if (mode == 1) {
245 int x0 = 2 * (int) floor(x + 0.5f);
246 int y0 = (int) floor(y + 0.5f);
247 int z0 = (int) floor(z + 0.5f);
248
249 data[0] = rdata[x0 + y0 * nx + z0 * nx * ny];
250 data[1] = rdata[x0 + y0 * nx + z0 * nx * ny + 1];
251 return true;
252 }
253 else if (mode == 2) {
254 int x0 = (int) floor(x);
255 int y0 = (int) floor(y);
256 int z0 = (int) floor(z);
257
258 float dx = x - x0;
259 float dy = y - y0;
260 float dz = z - z0;
261
262 if (x0 <= nx/2- 2 && y0 <= ny - 1 && z0 <= nz - 1) {
263 int i = (int) (x0 * 2 + y0 * nx + z0 * nx * ny);
264
265 float n = Util::agauss(1, dx, dy, dz, gw) +
266 Util::agauss(1, 1 - dx, dy, dz, gw) +
267 Util::agauss(1, dx, 1 - dy, dz, gw) +
268 Util::agauss(1, 1 - dx, 1 - dy, dz, gw) +
269 Util::agauss(1, dx, dy, 1 - dz, gw) +
270 Util::agauss(1, 1 - dx, dy, 1 - dz, gw) +
271 Util::agauss(1, dx, 1 - dy, 1 - dz, gw) + Util::agauss(1, 1 - dx, 1 - dy, 1 - dz, gw);
272
273 data[0] = Util::agauss(rdata[i], dx, dy, dz, gw) +
274 Util::agauss(rdata[i + 2], 1 - dx, dy, dz, gw) +
275 Util::agauss(rdata[i + nx], dx, 1 - dy, dz, gw) +
276 Util::agauss(rdata[i + nx + 2], 1 - dx, 1 - dy, dz, gw) +
277 Util::agauss(rdata[i + nx * ny], dx, dy, 1 - dz, gw) +
278 Util::agauss(rdata[i + 2 + nx * ny], 1 - dx, dy, 1 - dz, gw) +
279 Util::agauss(rdata[i + nx + nx * ny], dx, 1 - dy, 1 - dz, gw) +
280 Util::agauss(rdata[i + 2 + nx + nx * ny], 1 - dx, 1 - dy, 1 - dz, gw) / n;
281
282 i++;
283
284 data[1] = Util::agauss(rdata[i], dx, dy, dz, gw) +
285 Util::agauss(rdata[i + 2], 1 - dx, dy, dz, gw) +
286 Util::agauss(rdata[i + nx], dx, 1 - dy, dz, gw) +
287 Util::agauss(rdata[i + nx + 2], 1 - dx, 1 - dy, dz, gw) +
288 Util::agauss(rdata[i + nx * ny], dx, dy, 1 - dz, gw) +
289 Util::agauss(rdata[i + 2 + nx * ny], 1 - dx, dy, 1 - dz, gw) +
290 Util::agauss(rdata[i + nx + nx * ny], dx, 1 - dy, 1 - dz, gw) +
291 Util::agauss(rdata[i + 2 + nx + nx * ny], 1 - dx, 1 - dy, 1 - dz, gw) / n;
292 return true;
293 }
294 return false;
295 }
296 else if (mode == 3) {
297 int x0 = 2 * (int) floor(x + .5);
298 int y0 = (int) floor(y + .5);
299 int z0 = (int) floor(z + .5);
300
301 float *supp = image->setup4slice();
302
303 if (x0 < nx - 4 && y0 <= ny - 3 && z0 <= nz - 3 && y0 >= 2 && z0 >= 2) {
304 float n = 0;
305
306 if (x0 == 0) {
307 x0 += 4;
308 size_t idx;
309 float r, g;
310 for (int k = z0 - 1; k <= z0 + 1; k++) {
311 for (int j = y0 - 1; j <= y0 + 1; j++) {
312 for (int i = x0 - 2; i <= x0 + 2; i += 2) {
313 r = Util::hypot3sq(i / 2.0f - x - 2.0f, j - y, k - z);
314 g = exp(-r / gw);
315 n += g;
316 idx = i + j * 12 + (size_t)k * 12 * ny;
317 data[0] += supp[idx] * g;
318 data[1] += supp[idx + 1] * g;
319 }
320 }
321 }
322 }
323 else {
324 size_t idx;
325 float r, g;
326 for (int k = z0 - 1; k <= z0 + 1; k++) {
327 for (int j = y0 - 1; j <= y0 + 1; j++) {
328 for (int i = x0 - 2; i <= x0 + 2; i += 2) {
329 r = Util::hypot3sq(i / 2.0f - x, j - y, k - z);
330 g = exp(-r / gw);
331 n += g;
332 idx = i + j * nx + (size_t)k * nx * ny;
333 data[0] += rdata[idx] * g;
334 data[1] += rdata[idx + 1] * g;
335 }
336 }
337 }
338 }
339
340 data[0] /= n;
341 data[1] /= n;
342 return true;
343 }
344 return false;
345 }
346 else if (mode == 4) {
347 int x0 = 2 * (int) floor(x);
348 int y0 = (int) floor(y);
349 int z0 = (int) floor(z);
350
351 float *supp = image->setup4slice();
352
353 if (x0 < nx - 4 && y0 <= ny - 3 && z0 <= nz - 3 && y0 >= 2 && z0 >= 2) {
354 float n = 0;
355
356 if (x0 == 0) {
357 x0 += 4;
358 size_t idx;
359 float r, g;
360 for (int k = z0 - 1; k <= z0 + 2; k++) {
361 for (int j = y0 - 1; j <= y0 + 2; j++) {
362 for (int i = x0 - 2; i <= x0 + 4; i += 2) {
363 r = Util::hypot3sq(i / 2.0f - x - 2.0f, j - y, k - z);
364 g = exp(-r / gw);
365 n += g;
366 idx = i + j * 12 + (size_t)k * 12 * ny;
367 data[0] += supp[idx] * g;
368 data[1] += supp[idx + 1] * g;
369 }
370 }
371 }
372 }
373 else {
374 float r, g;
375 size_t idx;
376 for (int k = z0 - 1; k <= z0 + 2; k++) {
377 for (int j = y0 - 1; j <= y0 + 2; j++) {
378 for (int i = x0 - 2; i <= x0 + 4; i += 2) {
379 r = Util::hypot3sq(i / 2.0f - x, j - y, k - z);
380 g = exp(-r / gw);
381 n += g;
382 idx = i + j * nx + (size_t)k * nx * ny;
383 data[0] += rdata[idx] * g;
384 data[1] += rdata[idx + 1] * g;
385 }
386 }
387 }
388 }
389 data[0] /= n;
390 data[1] /= n;
391 return true;
392 }
393 return false;
394 }
395 else if (mode == 5) {
396 int x0 = 2 * (int) floor(x + .5);
397 int y0 = (int) floor(y + .5);
398 int z0 = (int) floor(z + .5);
399
400 float *supp = image->setup4slice();
401 float *gimx = Interp::get_gimx();
402
403 if (x0 < nx - 4 && y0 <= ny - 3 && z0 <= nz - 3 && y0 >= 2 && z0 >= 2) {
404 int mx0 = -(int) floor((x - x0 / 2) * 39.0 + .5) - 78;
405 int my0 = -(int) floor((y - y0) * 39.0 + .5) - 78;
406 int mz0 = -(int) floor((z - z0) * 39.0 + .5) - 78;
407
408 float n = 0;
409 int mmz = mz0;
410 int mmy = my0;
411 int mmx = mx0;
412
413 if (x0 < 4) {
414 x0 += 4;
415
416 size_t idx;
417 float g;
418 for (int k = z0 - 2; k <= z0 + 2; k++, mmz += 39) {
419 for (int j = y0 - 2; j <= y0 + 2; j++, mmy += 39) {
420 for (int i = x0 - 4; i <= x0 + 4; i += 2, mmx += 39) {
421 g = gimx[abs(mmx) + abs(mmy) * 100 + abs(mmz) * 10000];
422 n += g;
423 idx = i + j * 12 + (size_t)k * 12 * ny;
424 data[0] += supp[idx] * g;
425 data[1] += supp[idx + 1] * g;
426 }
427 }
428 }
429 }
430 else {
431 size_t ii;
432 float g;
433 for (int k = z0 - 2; k <= z0 + 2; k++, mmz += 39) {
434 for (int j = y0 - 2; j <= y0 + 2; j++, mmy += 39) {
435 for (int i = x0 - 4; i <= x0 + 4; i += 2, mmx += 39) {
436 ii = i + j * nx + (size_t)k * nx * ny;
437 g = gimx[abs(mmx) + abs(mmy) * 100 + abs(mmz) * 10000];
438 n += g;
439 data[0] += rdata[ii] * g;
440 data[1] += rdata[ii + 1] * g;
441 }
442 }
443 }
444 }
445
446 data[0] /= n;
447 data[1] /= n;
448 return true;
449 }
450 return false;
451 }
452 else if (mode == 6) {
453
454 int x0 = 2 * (int) floor(x + .5);
455 int y0 = (int) floor(y + .5);
456 int z0 = (int) floor(z + .5);
457
458 float *supp = image->setup4slice();
459
460 if (x0 < nx - 4 && y0 <= ny - 3 && z0 <= nz - 3 && y0 >= 2 && z0 >= 2) {
461 float n = 0;
462
463 if (x0 < 4) {
464 x0 += 4;
465 float r, g;
466 size_t idx;
467 for (int k = z0 - 2; k <= z0 + 2; k++) {
468 for (int j = y0 - 2; j <= y0 + 2; j++) {
469 for (int i = x0 - 4; i <= x0 + 4; i += 2) {
470 r = Util::hypot3sq(i / 2.0f - x - 2.0f, j - y, k - z);
471 g = exp(-r / gw);
472 n += g;
473 idx = i + j * 12 + (size_t)k * 12 * ny;
474 data[0] += supp[idx] * g;
475 data[1] += supp[idx + 1] * g;
476 }
477 }
478 }
479 }
480 else {
481 float r, g;
482 size_t idx;
483 for (int k = z0 - 2; k <= z0 + 2; k++) {
484 for (int j = y0 - 2; j <= y0 + 2; j++) {
485 for (int i = x0 - 4; i <= x0 + 4; i += 2) {
486 r = Util::hypot3sq(i / 2.0f - x, j - y, k - z);
487 g = exp(-r / gw);
488 n += g;
489 idx = i + j * nx + (size_t)k * nx * ny;
490 data[0] += rdata[idx] * g;
491 data[1] += rdata[idx + 1] * g;
492 }
493
494 }
495 }
496 }
497
498 data[0] /= n;
499 data[1] /= n;
500
501 return true;
502 }
503 return false;
504 }
505 else if (mode == 7) {
506 int x0 = 2 * (int) floor(x + .5);
507 int y0 = (int) floor(y + .5);
508 int z0 = (int) floor(z + .5);
509
510 float *supp = image->setup4slice();
511
512 if (x0 < nx - 4 && y0 <= ny - 3 && z0 <= nz - 3 && y0 >= 2 && z0 >= 2) {
513 float n = 0;
514 if (x0 < 4) {
515 x0 += 4;
516 float r, g;
517 size_t idx;
518 for (int k = z0 - 2; k <= z0 + 2; k++) {
519 for (int j = y0 - 2; j <= y0 + 2; j++) {
520 for (int i = x0 - 4; i <= x0 + 4; i += 2) {
521 r = sqrt(Util::hypot3sq(i / 2.0f - x - 2.0f, j - y, k - z));
522 g = Interp::hyperg(r);
523 n += g;
524 idx = i + j * 12 + (size_t)k * 12 * ny;
525 data[0] += supp[idx] * g;
526 data[1] += supp[idx + 1] * g;
527 }
528 }
529 }
530 }
531 else {
532 float r, g;
533 size_t idx;
534 for (int k = z0 - 2; k <= z0 + 2; k++) {
535 for (int j = y0 - 2; j <= y0 + 2; j++) {
536 for (int i = x0 - 4; i <= x0 + 4; i += 2) {
537 r = sqrt(Util::hypot3sq(i / 2.0f - x, j - y, k - z));
538 g = Interp::hyperg(r);
539 n += g;
540 idx = i + j * nx + (size_t)k * nx * ny;
541 data[0] += rdata[idx] * g;
542 data[1] += rdata[idx + 1] * g;
543 }
544
545 }
546 }
547 }
548 data[0] /= n;
549 data[1] /= n;
550 return true;
551 }
552 return false;
553
554 }
555// throw InvalidParameterException("Error, unkown mode");
556 return false;
557}
rdata
#define rdata(i)
Definition: analyzer.cpp:592
EMAN::EMData::setup4slice
float * setup4slice(bool redo=true)
Set up for fftslice operations.
Definition: emdata.cpp:822
EMAN::Interp::hyperg
static float hyperg(float v)
Definition: interp.h:51
EMAN::Interp::get_gimx
static float * get_gimx()
Definition: interp.h:62
EMAN::Util::hypot3sq
static int hypot3sq(int x, int y, int z)
Euclidean distance function squared in 3D: f(x,y,z) = (x*x + y*y + z*z);.
Definition: util.h:805
EMAN::Util::agauss
static float agauss(float a, float dx, float dy, float dz, float d)
Calculate Gaussian value.
Definition: util.h:912
sqrt
EMData * sqrt() const
return square root of current image
Definition: emdata_core.cpp:1084
y
#define y(i, j)
Definition: projector.cpp:1516
x
#define x(i)
Definition: projector.cpp:1517

References EMAN::Util::agauss(), EMAN::Interp::get_gimx(), EMAN::Interp::hyperg(), EMAN::Util::hypot3sq(), rdata, EMAN::EMData::setup4slice(), sqrt(), x, and y.

Referenced by project3d().

◆ NEW()

static Projector * EMAN::GaussFFTProjector::NEW ( )
inlinestatic

Definition at line 176 of file projector.h.

177 {
178 return new GaussFFTProjector();
179 }

References GaussFFTProjector().

◆ project3d()

EMData * GaussFFTProjector::project3d ( EMData *  image) const
virtual

Project an 3D image into a 2D image.

Returns
A 2D image from the projection.

Implements EMAN::Projector.

Definition at line 69 of file projector.cpp.

70{
71 Transform* t3d = params["transform"];
72 if ( t3d == NULL ) throw NullPointerException("The transform object (required for projection), was not specified");
73 if ( image->get_ndim() != 3 ) throw ImageDimensionException("Error, the projection volume must be 3D");
74
75 EMData *f = image;
76 if (!image->is_complex()) {
77 image->process_inplace("xform.phaseorigin.tocorner");
78 f = image->do_fft();
79 f->process_inplace("xform.fourierorigin.tocenter");
80 image->process_inplace("xform.phaseorigin.tocenter");
81 }
82
83 int f_nx = f->get_xsize();
84 int f_ny = f->get_ysize();
85 int f_nz = f->get_zsize();
86
87 if (!f->is_complex() || f_nz != f_ny || f_nx != f_ny + 2) {
88 LOGERR("Cannot project this image");
89 return 0;
90 }
91
92 f->ap2ri();
93
94 EMData *tmp = new EMData();
95 tmp->set_size(f_nx, f_ny, 1);
96 tmp->set_complex(true);
97 tmp->set_ri(true);
98
99 float *data = tmp->get_data();
100
101 Transform r = t3d->get_rotation_transform();
102 r.invert();
103 float scale = t3d->get_scale();
104
105 int mode = params["mode"];
106 float gauss_width = 1;
107// if ( mode == 0 ) mode = 2;
108 if (mode == 2 ) {
109 gauss_width = EMConsts::I2G;
110 }
111 else if (mode == 3) {
112 gauss_width = EMConsts::I3G;
113 }
114 else if (mode == 4) {
115 gauss_width = EMConsts::I4G;
116 }
117 else if (mode == 6 || mode == 7) {
118 gauss_width = EMConsts::I5G;
119 }
120
121 for (int y = 0; y < f_ny; y++) {
122 for (int x = 0; x < f_nx / 2; x++) {
123 int ii = x * 2 + y * f_nx;
124 if (hypot(x, y - f_ny / 2) >= f_ny / 2 - 1) {
125 data[ii] = 0;
126 data[ii + 1] = 0;
127 }
128 else {
129 Vec3f coord(x,(y - f_ny / 2),0);
130 Vec3f soln = r*coord;
131 float xx = soln[0];
132 float yy = soln[1];
133 float zz = soln[2];
134
135 int cc = 1;
136 if (xx < 0) {
137 xx = -xx;
138 yy = -yy;
139 zz = -zz;
140 cc = -1;
141 }
142
143 if (scale != 1.0) {
144 xx *= scale;
145 yy *= scale;
146 zz *= scale;
147 }
148
149 yy += f_ny / 2;
150 zz += f_nz / 2;
151
152 if (yy < 0 || xx < 0 || zz < 0) {
153 data[ii] = 0;
154 data[ii+1] = 0;
155 continue;
156 }
157
158 if (interp_ft_3d(mode, f, xx, yy, zz, data + ii, gauss_width)) {
159 data[ii + 1] *= cc;
160 } else {
161 data[ii] = 0;
162 data[ii+1] = 0;
163 }
164 }
165 }
166 }
167
168// f->update();
169 tmp->update();
170
171 int returnfft=params["returnfft"];
172 EMData *ret;
173 if (returnfft==1){
174 //apperently there is something wrong with translating images in fourier space...
175// printf("return fft!\n");
176 Vec3f trans=t3d->get_trans();
177 ret=tmp->copy();
178 ret->process_inplace("xform.fourierorigin.tocorner");
179 ret->process_inplace("xform", Dict("tx", (float)trans[0], "ty", (float)trans[1]));
180
181// if (t3d->get_mirror() ) ret->process_inplace("xform.flip",Dict("axis","x"));
182
183 }
184 else{
185
186 tmp->process_inplace("xform.fourierorigin.tocorner");
187 ret = tmp->do_ift();
188 ret->process_inplace("xform.phaseorigin.tocenter");
189
190 ret->translate(t3d->get_trans());
191
192 if (t3d->get_mirror() ) ret->process_inplace("xform.flip",Dict("axis","x"));
193
194 Dict filter_d;
195 filter_d["gauss_width"] = gauss_width;
196 // filter_d["ring_width"] = ret->get_xsize() / 2;
197 ret->process_inplace("math.gausskernelfix", filter_d);
198 }
199
200 if( tmp )
201 {
202 delete tmp;
203 tmp = 0;
204 }
205
206 ret->set_attr("xform.projection",t3d);
207 ret->update();
208
209 if(t3d) {delete t3d; t3d=0;}
210
211 return ret;
212}
EMAN::Dict
Dict is a dictionary to store <string, EMObject> pair.
Definition: emobject.h:385
EMAN::EMConsts::I5G
static const float I5G
Definition: emobject.h:75
EMAN::EMConsts::I4G
static const float I4G
Definition: emobject.h:74
EMAN::EMConsts::I3G
static const float I3G
Definition: emobject.h:73
EMAN::EMConsts::I2G
static const float I2G
Definition: emobject.h:72
EMAN::EMData::translate
void translate(float dx, float dy, float dz)
Translate this image.
Definition: emdata.cpp:904
EMAN::GaussFFTProjector::interp_ft_3d
bool interp_ft_3d(int mode, EMData *image, float x, float y, float z, float *data, float gauss_width) const
Definition: projector.cpp:216
EMAN::Transform
A Transform object is a somewhat specialized object designed specifically for EMAN2/Sparx storage of ...
Definition: transform.h:75
EMAN::Transform::get_mirror
bool get_mirror() const
Query whether x_mirroring is occurring.
Definition: transform.cpp:1250
EMAN::Transform::get_rotation_transform
Transform get_rotation_transform() const
Get the rotation part of the tranformation matrix as a Transform object.
Definition: transform.cpp:688
EMAN::Transform::get_trans
Vec3f get_trans() const
Get the post trans as a vec3f.
Definition: transform.cpp:1046
EMAN::Transform::get_scale
float get_scale() const
Get the scale that was applied.
Definition: transform.cpp:1145
EMAN::Transform::invert
void invert()
Get the inverse of this transformation matrix.
Definition: transform.cpp:1293
ImageDimensionException
#define ImageDimensionException(desc)
Definition: exception.h:166
NullPointerException
#define NullPointerException(desc)
Definition: exception.h:241
LOGERR
#define LOGERR
Definition: log.h:51

References EMAN::Transform::get_mirror(), EMAN::Transform::get_rotation_transform(), EMAN::Transform::get_scale(), EMAN::Transform::get_trans(), EMAN::EMConsts::I2G, EMAN::EMConsts::I3G, EMAN::EMConsts::I4G, EMAN::EMConsts::I5G, ImageDimensionException, interp_ft_3d(), EMAN::Transform::invert(), LOGERR, NullPointerException, EMAN::Projector::params, EMAN::EMData::translate(), x, and y.

◆ set_params()

void EMAN::GaussFFTProjector::set_params ( const Dict &  new_params)
inline

Definition at line 158 of file projector.h.

159 {
160 Projector::set_params(new_params);
161 alt = params["alt"];
162 az = params["az"];
163 phi = params["phi"];
164 }
EMAN::Projector::set_params
void set_params(const Dict &new_params)
Set the projector parameters using a key/value dictionary.
Definition: projector.h:111

References alt, az, EMAN::Projector::params, phi, and EMAN::Projector::set_params().

Member Data Documentation

◆ alt

float EMAN::GaussFFTProjector::alt
private

Definition at line 193 of file projector.h.

Referenced by set_params().

◆ az

float EMAN::GaussFFTProjector::az
private

Definition at line 193 of file projector.h.

Referenced by set_params().

◆ NAME

const string GaussFFTProjector::NAME = "gauss_fft"
static

Definition at line 190 of file projector.h.

Referenced by get_name().

◆ phi

float EMAN::GaussFFTProjector::phi
private

Definition at line 193 of file projector.h.

Referenced by set_params().

The documentation for this class was generated from the following files:
Generated by doxygen 1.9.2