xmipp_image_over.h

Go to the documentation of this file.

/***************************************************************************
 *
 * Authors:  Alberto Pascual Montano (pascual@cnb.csic.es)
 *
 * Unidad de  Bioinformatica of Centro Nacional de Biotecnologia , CSIC
 *
 * Part of this module has been developed by Lorenzo Zampighi and Nelson Tang
 * Dept. Physiology of the David Geffen School of Medicine
 * Univ. of California, Los Angeles.
 *
 * 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_IMAGEOVER_H
#define CORE_IMAGEOVER_H

#include <core/xmipp_image.h>
class ImageOver : public Image<double>
{
public:
    int uistep, vistep, wistep; // number of samples per
    // one sample on normal image (50)
    // in u,v,w directions

    int overumax, overvmax, overwmax; // table borders in normal units (-2,2)
    int overumin, overvmin, overwmin; // table borders in normal units (-2,2)
    // They should be an integer number

public:
    void init(int _umin, int _umax, int _uistep,
              int _vmin, int _vmax, int _vistep,
              int _wmin=0, int _wmax=0, int _wistep=1);

    void init(MultidimArray<double> &im, int _uistep=1, int _vistep=0, int _wistep=0);

    void window(int _v0, int _u0, int _vF, int _uF);

    void clear();

    void over2img(double v, double u, int& iv, int& iu) const
    {
        if (v < overvmin || v > overvmax)
            REPORT_ERROR(ERR_VALUE_INCORRECT, "ImgeOver::over2img: v out of range");

        if (u < overumin || u > overumax)
            REPORT_ERROR(ERR_VALUE_INCORRECT, "ImgeOver::over2img: u out of range");

        iu = (int) ROUND((((u) - overumin) * uistep));
        iv = (int) ROUND((((v) - overvmin) * vistep));
    }

#define OVER2IMG(IO, v, u, iv, iu) \
    iu = (int) round((((u)-(IO).overumin) * (IO).uistep)); \
    iv = (int) round((((v)-(IO).overvmin) * (IO).vistep));

#define OVER2IMG_Z(IO, w, iw) \
        iw = (int) round((((w)-(IO).overwmin) * (IO).wistep));

    void img2over(size_t iv, size_t iu, double & v, double & u) const
    {
        if (iu < 0 || iu > XSIZE(data))
            REPORT_ERROR(ERR_VALUE_INCORRECT, "ImageOver::img2over: iu out of range");
        if (iv < 0 || iv > YSIZE(data))
            REPORT_ERROR(ERR_VALUE_INCORRECT, "ImageOver::img2over: iv out of range");
        u = (double)(overumin) + iu / (double)(uistep);
        v = (double)(overvmin) + iv / (double)(vistep);
    }

#define IMG2OVER(IO, iv, iu, v, u) \
    u = (double) (IO).overumin + (iu) / (double) ((IO).uistep); \
    v = (double) (IO).overvmin + (iv) / (double) ((IO).vistep);

    double operator ()(double v, double u) const
    {
        if (v < overvmin || v > overvmax)
            REPORT_ERROR(ERR_VALUE_INCORRECT, "ImgeOver::over2img: v out of range");
        if (u < overumin || u > overumax)
            REPORT_ERROR(ERR_VALUE_INCORRECT, "ImgeOver::over2img: u out of range");
        int iu, iv;
        OVER2IMG(*this, v, u, iv, iu);
        return A2D_ELEM(data, iv, iu);
    }

    double & operator ()(double v, double u)
    {
        int iu, iv;
        OVER2IMG(*this, v, u, iv, iu);
        return A2D_ELEM(data, iv, iu);
    }

#define OVERPIXEL(IO, y, x) IMGPIXEL((IO), \
                                     (int) ROUND(((u) * (IO).uistep)), \
                                     (int) ROUND(((v) * (IO).vistep)))

    // The following two functions have been redefined (they should be
    // inherited from Image) because the compiler doesn't admit this
    // inheritance and the redefinition of the fractional index pixel
    // access.

    MultidimArray< double >& operator()()
    {
        return data;
    }

    const MultidimArray< double >& operator()() const
    {
        return data;
    }

    int umax() const
    {
        return overumax;
    }

    int vmax() const
    {
        return overvmax;
    }

    int wmax() const
    {
        return overwmax;
    }

    int umin() const
    {
        return overumin;
    }

    int vmin() const
    {
        return overvmin;
    }

    int Ustep() const
    {
        return uistep;
    }

    int Vstep() const
    {
        return vistep;
    }

    int Wstep() const
    {
        return wistep;
    }

    void downsample(Image< double >* I) const;
};
#endif