volume_to_pseudoatoms.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'
 ***************************************************************************/
/* This file contains functions related to the Radon Transform */

#ifndef _CONVERT_VOL2PSEUDO_HH
#define _CONVERT_VOL2PSEUDO_HH

#include <core/xmipp_image.h>
#include <data/mask.h>
#include <core/xmipp_threads.h>
#include <core/xmipp_program.h>
#include <vector>
#include <data/fourier_filter.h>

class PseudoAtom
{
public:
    Matrix1D<double> location;
    
    double           intensity;
    
    PseudoAtom();

    friend std::ostream& operator << (std::ostream &o, const PseudoAtom &f);
};

bool operator <(const PseudoAtom &a, const PseudoAtom &b);

// Forward declaration
class ProgVolumeToPseudoatoms;

// Thread parameters
struct Prog_Convert_Vol2Pseudo_ThreadParams
{
    int myThreadID;
    ProgVolumeToPseudoatoms *parent;
    int Nintensity;
    int Nmovement;
};

class ProgVolumeToPseudoatoms: public XmippProgram
{
public:
    FileName fnVol;
    
    FileName fnOut;
    
    // Mask
    Mask mask_prm;

    // Use mask
    bool useMask;

    double sigma;
    
    double targetError;

    double stop;
    
    int initialSeeds;
    
    double growSeeds;
    
    bool allowMovement;
    
    bool allowIntensity;

    double intensityFraction;

    std::string intensityColumn;
    
    double minDistance;

    double penalty;
    
    int numThreads;
    
    double sampling;
    
    size_t Nclosest;

    bool dontScale;

    bool binarize;

    double threshold;
public:
    void readParams();
    
    void show() const;
    
    void defineParams();
    
    void produceSideInfo();
    
    void run();

    void placeSeeds(int Nseeds);
    
    void removeSeeds(int Nseeds);

    void removeTooCloseSeeds();

    double computeAverage(int k, int i, int j, MultidimArray<double> &V);

    void drawGaussian(double k, double i, double j, MultidimArray<double> &V,
        double intensity);

    void drawApproximation();

    void extractRegion(int idxGaussian, MultidimArray<double> &region,
        bool extended=false) const;

    void insertRegion(const MultidimArray<double> &region);

    double evaluateRegion(const MultidimArray<double> &region) const;

    void optimizeCurrentAtoms();
    
    static void* optimizeCurrentAtomsThread(void * threadArgs);
    
    void writeResults();
public:
    // Input volume
    Image<double> Vin;
    
    // Current approximation volume
    Image<double> Vcurrent;
    
    // Energy of the difference
    double energyDiff;
    
    // Maximum percentage diffence
    double percentageDiff;
    
    // Original energy
    double energyOriginal;
    
    // List of atoms
    std::vector< PseudoAtom > atoms;
    
    // Maximum radius
    double sigma3;
    
    // Percentil 1
    double percentil1;

    // Range
    double range;

    // Small atom intensity
    double smallAtom;

    // Gaussian table
    MultidimArray<double> gaussianTable;
    
    // Barrier
    barrier_t barrier;
    
#define KILLTHREAD -1
#define WORKTHREAD  0
    // Thread operation code
    int threadOpCode;
    
    // Pointer to thread arguments
    Prog_Convert_Vol2Pseudo_ThreadParams *threadArgs;
    
    // Pointer to threads
    pthread_t *threadIds;

    // Filter for the difference volume
    FourierFilter Filter;
};
#endif