blobs.h

Go to the documentation of this file.

/***************************************************************************
 *
 * Authors:     Carlos Oscar S. Sorzano (coss@cnb.csic.es)
 *
 * Unidad de  Bioinformatica of Centro Nacional de Biotecnologia , CSIC
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
 * 02111-1307  USA
 *
 *  All comments concerning this program package may be sent to the
 *  e-mail address 'xmipp@cnb.csic.es'
 ***************************************************************************/

#ifndef _CORE_BLOBS_HH
#define _CORE_BLOBS_HH

#include "grids.h"

class ImageOver;

// Thread declaration
void * blobs2voxels_SimpleGrid( void * data );

// Mutex used to make load balancing thread-safe
extern pthread_mutex_t blobs_conv_mutex;

// There exist one integer per slice. If value == 0, this slice
// can be processed. If value == -1, this slice has already been processed and
// if value > 0, this slice is influenced by a neighbour slice being processed and,
// at this moment, can not be scheduled for processing. In the latest case, the
// threads will have to look for a value == 0 slice.
extern int * slices_status;

// Number of already processed slices.
extern int slices_processed;

// This structure is needed to pass parameters to threads. 
typedef struct{
    const MultidimArray<double> *vol_blobs;
    const SimpleGrid *grid;
    const struct blobtype *blob;
    MultidimArray<double> *vol_voxels;
    const Matrix2D<double> *D;
    int istep;
    MultidimArray<double> *vol_corr;
    const MultidimArray<double> *vol_mask;
    bool FORW;
    int eq_mode;
    int thread_id;
    int threads_num;
    int min_separation;
} ThreadBlobsToVoxels ;

/* ========================================================================= */
/* BLOBS                                                                     */
/* ========================================================================= */
// Blob structure ----------------------------------------------------------
struct blobtype
{
    double radius;

    int   order;

    double alpha;
};

// Blob value --------------------------------------------------------------
#define blob_val(r, blob) kaiser_value(r, blob.radius, blob.alpha, blob.order)

double kaiser_value(double r, double a, double alpha, int m);

// Blob projection ---------------------------------------------------------
#define blob_proj(r, blob) kaiser_proj(r, blob.radius, blob.alpha, blob.order)

double kaiser_proj(double r, double a, double alpha, int m);

#define blob_Fourier_val(w, blob) \
    kaiser_Fourier_value(w, blob.radius, blob.alpha, blob.order)

double kaiser_Fourier_value(double w, double a, double alpha, int m);

#define blob_mass(blob) \
    basvolume(blob.radius, blob.alpha, blob.order,3)

double  basvolume(double a, double alpha, int m, int n);

double in_zeroarg(int n);

double inph_zeroarg(int n);

double i_nph(int n, double x);

double i_n(int n, double x);

double blob_freq_zero(struct blobtype b);

double blob_att(double w, struct blobtype b);

double blob_ops(double w, struct blobtype b);

double optimal_CC_grid_relative_size(struct blobtype b);

double optimal_BCC_grid_relative_size(struct blobtype b);

double optimal_FCC_grid_relative_size(struct blobtype b);

/* ========================================================================= */
/* TOOLS                                                                     */
/* ========================================================================= */
blobtype best_blob(double alpha_0, double alpha_F, double inc_alpha,
                   double a_0, double a_F, double inc_a, double w, double *target_att,
                   int target_length = 1);

void footprint_blob(ImageOver &blobprint, const struct blobtype &blob,
                    int istep = 50, int normalise = 0);

double sum_blob_Grid(const struct blobtype &blob, const Grid &grid,
                     const Matrix2D<double> *D = nullptr);


void voxel_volume_shape(const GridVolume &vol_blobs,
                        const struct blobtype &blob, const Matrix2D<double> *D,
                        Matrix1D<int> &corner1, Matrix1D<int> &size);

void blobs2voxels(const GridVolume &vol_blobs,
                  const struct blobtype &blob, MultidimArray<double> *vol_voxels,
                  const Matrix2D<double> *D = nullptr, int threads = 1, int Zdim = 0, int Ydim = 0, int Xdim = 0);

void blobs2space_coefficients(const GridVolume &vol_blobs, const struct blobtype &blob,
                              MultidimArray<double> *vol_coefs);

constexpr int SHOW_CONVERSION = 1;
void voxels2blobs(const MultidimArray<double> *vol_voxels,
                  const struct blobtype &blob, GridVolume &vol_blobs,
                  int grid_type, double grid_relative_size,
                  double lambda, const MultidimArray<double> *vol_mask = nullptr,
                  const Matrix2D<double> *D = nullptr,
                  double final_error_change = 0.01, int tell = 0, double R = -1, int threads = 1);

constexpr int VARTK = 1;
constexpr int VMAXARTK = 2;

void ART_voxels2blobs_single_step(
    GridVolume &vol_in, GridVolume *vol_out, const struct blobtype &blob,
    const Matrix2D<double> *D, double lambda, MultidimArray<double> *theo_vol,
    const MultidimArray<double> *read_vol, MultidimArray<double> *corr_vol,
    const MultidimArray<double> *mask_vol,
    double &mean_error, double &max_error, int eq_mode = VARTK, int threads=1);
#endif