geometry.h

Go to the documentation of this file.

/*
 * Author: Steven Ludtke, 04/10/2003 (sludtke@bcm.edu)
 * Copyright (c) 2000-2006 Baylor College of Medicine
 * 
 * This software is issued under a joint BSD/GNU license. You may use the
 * source code in this file under either license. However, note that the
 * complete EMAN2 and SPARX software packages have some GPL dependencies,
 * so you are responsible for compliance with the licenses of these packages
 * if you opt to use BSD licensing. The warranty disclaimer below holds
 * in either instance.
 * 
 * This complete copyright notice must be included in any revised version of the
 * source code. Additional authorship citations may be added, but existing
 * author citations must be preserved.
 * 
 * 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
 * 
 * */
 
#ifndef eman_geometry_h_
#define eman_geometry_h_
 
#include <string>
using std::string;
 
#include <vector>
using std::vector;
 
#include <algorithm> // for copy
                 
namespace EMAN
{
 
        class IntSize
        {
        public:
                
                explicit IntSize(int xx=0, int yy=0, int zz=0)
                {
                        data[0] = xx;
                        data[1] = yy;
                        data[2] = zz;
                }
                
                
                int get_ndim() const
                {
                        if (data[2] > 1) {
                                return 3;
                        }
                        else if (data[1] > 1) {
                                return 2;
                        }
                        return 1;
                }
 
                int operator[] (int i) const
                {
                        return data[i];
                }
 
                int & operator[] (int i) 
                {
                        return data[i];
                }
                
        private:
                int data[3];
        };
 
        class FloatSize
        {
        public:
                
                explicit FloatSize(float xx=0, float yy=0, float zz=0)
                {
                        data[0] = xx;
                        data[1] = yy;
                        data[2] = zz;
                }
 
                FloatSize(int xx, int yy=0, int zz=0)
                {
                        data[0] = (float)xx;
                        data[1] = (float)yy;
                        data[2] = (float)zz;
                }
 
                FloatSize(double xx, double yy=0, double zz=0)
                {
                        data[0] = (float)xx;
                        data[1] = (float)yy;
                        data[2] = (float)zz;
                }
 
                int get_ndim() const
                {
                        if (data[2] > 1) {
                                return 3;
                        }
                        else if (data[1] > 1) {
                                return 2;
                        }
                        else if (data[0] > 1) {
                                return 1;
                        }
                        else {
                                return 0;
                        }
                }
                
                float operator[] (int i) const
                {
                        return data[i];
                }
                
                float & operator[] (int i) 
                {
                        return data[i];
                }
                
                inline operator vector<float>() const {
                        vector<float> t(data,data+3);
                        return t;
                }
 
        private:
                float data[3];
        };
        
        class IntPoint {
        public:
                IntPoint()
                {
                        data[0] = 0;
                        data[1] = 0;
                        data[2] = 0;
                        ndim = 0;
                }
                
                explicit IntPoint(int xx)
                {
                        data[0] = xx;
                        data[1] = 0;
                        data[2] = 0;
                        ndim = 1;
                }
                
                IntPoint(int xx, int yy)
                {
                        data[0] = xx;
                        data[1] = yy;
                        data[2] = 0;
                        ndim = 2;
                }
                
                IntPoint(int xx, int yy, int zz)
                {
                        data[0] = xx;
                        data[1] = yy;
                        data[2] = zz;
                        ndim = 3;
                }
 
                int get_ndim() const
                {
                        return ndim;
                }
                
                int operator[] (int i) const
                {
                        return data[i];
                }
 
                int & operator[] (int i) 
                {
                        return data[i];
                }
                
        private:
                int data[3];
                int ndim;
        };
        
        IntPoint operator -( const IntPoint& p);
//      {
//              return IntPoint(-p[0],-p[1],-p[2]);
//      }
 
        class FloatPoint {
        public:
 
                FloatPoint()
                {
                        data[0] = 0;
                        data[1] = 0;
                        data[2] = 0;
                        ndim = 0;
                }
                
                explicit FloatPoint(float xx)
                {
                        data[0] = xx;
                        data[1] = 0;
                        data[2] = 0;
                        ndim = 1;
                }
 
                FloatPoint(float xx, float yy)
                {
                        data[0] = xx;
                        data[1] = yy;
                        data[2] = 0;
                        ndim = 2;
                }
                
                FloatPoint(float xx, float yy, float zz)
                {
                        data[0] = xx;
                        data[1] = yy;
                        data[2] = zz;
                        ndim = 3;
                }
                
                explicit FloatPoint(int xx)
                {
                        data[0] = (float)xx;
                        data[1] = 0;
                        data[2] = 0;
                        ndim = 1;
                }
                
                FloatPoint(int xx, int yy)
                {
                        data[0] = (float)xx;
                        data[1] = (float)yy;
                        data[2] = 0;
                        ndim = 2;
                }
                
                FloatPoint(int xx, int yy, int zz)
                {
                        data[0] = (float)xx;
                        data[1] = (float)yy;
                        data[2] = (float)zz;
                        ndim = 3;
                }
                        
                explicit FloatPoint(double xx)
                {
                        data[0] = (float)xx;
                        data[1] = 0;
                        data[2] = 0;
                        ndim = 1;
                }
                
                FloatPoint(double xx, double yy)
                {
                        data[0] = (float)xx;
                        data[1] = (float)yy;
                        data[2] = 0;
                        ndim = 2;
                }
                
                FloatPoint(double xx, double yy, double zz)
                {
                        data[0] = (float)xx;
                        data[1] = (float)yy;
                        data[2] = (float)zz;
                        ndim = 3;
                }
 
                FloatPoint(const FloatPoint & fp)
                {
                        data[0] = fp.data[0];
                        data[1] = fp.data[1];
                        data[2] = fp.data[2];
                        ndim = fp.ndim;
                }
                
                int get_ndim() const
                {
                        return ndim;
                }
 
                float operator[] (int i) const
                {
                        return data[i];
                }
 
                float & operator[] (int i) 
                {
                        return data[i];
                }
                
                inline operator vector<float>() const {
                        vector<float> t(data,data+3);
                        return t;
                }
                
                operator IntPoint () const { return IntPoint((int)data[0],(int)data[1],(int)data[2]); }
                
                inline FloatPoint& operator=(const vector<float>& v) {
                        copy(v.begin(),v.end(),data);
                        return *this;
                }
                
        private:
                float data[3];
                int ndim;
        };
 
        class Pixel {
        public:
                Pixel(int xx, int yy, int zz, float vv) : x(xx), y(yy), z(zz), value(vv) { }
 
                Pixel(const Pixel & p) : x(p.x), y(p.y), z(p.z), value(p.value) {}
                
                IntPoint get_point() const
                {
                        return IntPoint(x, y, z);
                }
 
                float get_value() const
                {
                        return value;
                }
 
                int x;
                int y;
                int z;
                float value;
        };
 
        
        bool operator<(const Pixel& p1, const Pixel& p2);
        bool operator==(const Pixel& p1, const Pixel& p2);
        bool operator!=(const Pixel& p1, const Pixel& p2);
 
        
        class Region
        {
        public:
                Region()
                {
                        origin = FloatPoint ();
                        size = FloatSize();
                }
 
                Region(int x, int xsize)
                {
                        origin = FloatPoint (x);
                        size = FloatSize(xsize);
                }
 
                Region(int x, int y, int xsize, int ysize)
                {
                        origin = FloatPoint (x, y);
                        size = FloatSize(xsize, ysize);
                }
 
                Region(int x, int y, int z, int xsize, int ysize, int zsize)
                {
                        origin = FloatPoint(x, y, z);
                        size = FloatSize(xsize, ysize, zsize);
                }
                
                Region(float x, float xsize)
                {
                        origin = FloatPoint (x);
                        size = FloatSize(xsize);
                }
 
                Region(float x, float y, float xsize, float ysize)
                {
                        origin = FloatPoint (x, y);
                        size = FloatSize(xsize, ysize);
                }
                
                Region(float x, float y, float z, float xsize, float ysize, float zsize)
                {
                        origin = FloatPoint(x, y, z);
                        size = FloatSize(xsize, ysize, zsize);
                }
 
                Region(double x, double xsize)
                {
                        origin = FloatPoint (x);
                        size = FloatSize(xsize);
                }
 
                Region(double x, double y, double xsize, double ysize)
                {
                        origin = FloatPoint (x, y);
                        size = FloatSize(xsize, ysize);
                }
 
                Region(double x, double y, double z, double xsize, double ysize, double zsize)
                {
                        origin = FloatPoint(x, y, z);
                        size = FloatSize(xsize, ysize, zsize);
                }
 
                Region(const FloatPoint &o, const FloatSize & s):origin(o), size(s)
                {
                }
 
                Region(const Region & r)
                {
                        origin = r.origin;
                        size = r.size;
                }
 
                
                ~Region() {
                }
 
                bool inside_region() const;
                bool inside_region(const FloatPoint &p) const;
                bool inside_region(float x) const;
                bool inside_region(float x, float y) const;
                bool inside_region(float x, float y, float z) const;
 
 
                float get_width() const { return size[0]; }
                float get_height() const { return size[1]; }
                float get_depth() const { return size[2]; }
                
                void set_width(const float& v) { size[0] = v; }
                void set_height(const float& v) { size[1] = v; }
                void set_depth(const float& v) { size[2] = v; }
                
                float x_origin() const { return origin[0]; }
                float y_origin() const { return origin[1]; }
                float z_origin() const { return origin[2]; }
                
                vector<float> get_size() const { return size; }
                vector<float> get_origin() const { return origin; }
                void set_origin(const vector<float>& v) { origin = v; }
                
                
                bool is_region_in_box(const FloatSize & box) const;
                
                int get_ndim() const
                {
                        return origin.get_ndim();
                }
 
                string get_string() const;
 
                FloatPoint origin;  /* region original point. */
                FloatSize size;     /* region edge sizes. */
        };
}
 
#endif