GXSM: gxsm/zdata.h Source File

00001 /* Gxsm - Gnome X Scanning Microscopy
00002  * universal STM/AFM/SARLS/SPALEED/... controlling and
00003  * data analysis software
00004  * 
00005  * Copyright (C) 1999,2000,2001,2002,2003 Percy Zahl
00006  *
00007  * Authors: Percy Zahl <zahl@users.sf.net>
00008  * additional features: Andreas Klust <klust@users.sf.net>
00009  * WWW Home: http://gxsm.sf.net
00010  *
00011  * This program is free software; you can redistribute it and/or modify
00012  * it under the terms of the GNU General Public License as published by
00013  * the Free Software Foundation; either version 2 of the License, or
00014  * (at your option) any later version.
00015  *
00016  * This program is distributed in the hope that it will be useful,
00017  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00018  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00019  * GNU General Public License for more details.
00020  *
00021  * You should have received a copy of the GNU General Public License
00022  * along with this program; if not, write to the Free Software
00023  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
00024  */
00025 
00026 /* -*- Mode: C++; indent-tabs-mode: nil; c-basic-offset: 8 c-style: "K&R" -*- */
00027 
00028 #ifndef __ZDATA_H
00029 #define __ZDATA_H
00030 
00039 class ZData{
00040         friend class Mem2d; 
00041 public:
00042         ZData(int Nx, int Ny, int Nv);
00043         virtual ~ZData();
00044 
00045         inline int GetNx(){ return nx; };
00046         inline int GetNy(){ return ny; };
00047         inline int GetNv(){ return nv; };
00048 
00049         double GetXLookup(int i){ if(i>=0 && i<nx) return Xlookup[i]; else return 0.; };
00050         double GetYLookup(int i){ if(i>=0 && i<ny) return Ylookup[i]; else return 0.; };
00051         double GetVLookup(int i){ if(i>=0 && i<nv) return Vlookup[i]; else return 0.; };
00052         void SetXLookup(int i, double lv){ if(i>=0 && i<nx) Xlookup[i]=lv; };
00053         void SetYLookup(int i, double lv){ if(i>=0 && i<ny) Ylookup[i]=lv; };
00054         void SetVLookup(int i, double lv){ if(i>=0 && i<nv) Vlookup[i]=lv; };
00055         void MkXLookup(double start, double end){ 
00056                 double d=(end-start)/(nx-1); 
00057                 for(int i=0; i<nx; ++i) Xlookup[i]=start+d*i;
00058         };
00059         void MkYLookup(double start, double end){ 
00060                 double d=(end-start)/(ny-1); 
00061                 for(int i=0; i<ny; ++i) Ylookup[i]=start+d*i;
00062         };
00063         void MkVLookup(double start, double end){ 
00064                 double d=(end-start)/(nv-1); 
00065                 for(int i=0; i<nv; ++i) Vlookup[i]=start+d*i;
00066         };
00067 
00068         virtual size_t Zsize()=0;
00069         virtual double Z(int x, int y)=0;
00070         virtual double Z(int x, int y, int v)=0;
00071         virtual double Z(double z, int x, int y)=0;
00072         virtual double Z(double z, int x, int y, int v)=0;
00073         virtual double Z(double vx, double vy)=0;
00074         virtual double Z(double z, double vx, double vy)=0;
00075         virtual void   Zadd(double z, int x, int y)=0;
00076         virtual void   Zmul(double z, int x, int y)=0;
00077         virtual void   Zdiv(double z, int x, int y)=0;
00078 
00079         virtual int  Resize(int Nx, int Ny, int Nv=1)=0;
00080 
00081         void         ZPutDataSetDest(int ix0, int num);
00082         virtual void ZPutDataLine(int y, void *src)=0;
00083         virtual void ZPutDataLine(int y, void *src, int mode)=0;
00084         virtual void ZGetDataLine(int y, void *dest)=0;
00085 
00086         virtual void           SetPtr(int x, int y)=0;
00087         virtual void           SetPtrT(int x, int y)=0;
00088         virtual void           SetPtrTB(int x, int y)=0;
00089         virtual double         GetNext()=0;
00090         virtual double         GetThis(double x=0.)=0;
00091         virtual double         GetThisL()=0;
00092         virtual double         GetThisLT()=0;
00093         virtual double         GetThisT()=0;
00094         virtual double         GetThisRT()=0;
00095         virtual double         GetThisR()=0;
00096         virtual double         GetThisRB()=0;
00097         virtual double         GetThisB()=0;
00098         virtual double         GetThisLB()=0;
00099         virtual void           IncPtrT()=0;
00100         virtual void           IncPtrTB()=0;
00101 
00102         virtual float          GetThis(float  x)=0;
00103         virtual long           GetThis(long   x)=0;
00104         virtual unsigned long  GetThis(unsigned long x)=0;
00105         virtual SHT            GetThis(SHT x)=0;
00106         virtual unsigned char  GetThis(unsigned char x)=0;
00107 
00108         virtual void           SetNext(double z)=0;
00109         virtual void           SetThis(double z)=0;  // Island-Labeling MB
00110 
00111         virtual int            CopyFrom(ZData *src, int x, int y, int tox, int toy, int nx, int ny=1)=0;
00112         virtual void           set_all_Z (double z, int v=-1, int x0=0, int y0=0, int xs=0, int ys=0)=0;
00113 
00114         virtual void*          GetPtr(int x, int y)=0;
00115         virtual double*        GetPtr(int x, int y, double z){return NULL;};
00116         virtual float*         GetPtr(int x, int y, float  z){return NULL;};
00117         virtual long*          GetPtr(int x, int y, long   z){return NULL;};
00118         virtual SHT*           GetPtr(int x, int y, SHT    z){return NULL;};
00119         virtual unsigned char* GetPtr(int x, int y, unsigned char z){return NULL;};
00120 
00121         virtual void operator =  (ZData &rhs)=0;
00122         virtual void operator += (ZData &rhs)=0;
00123         virtual void operator -= (ZData &rhs)=0;
00124         virtual void operator *= (ZData &rhs)=0;
00125         virtual void operator /= (ZData &rhs)=0;
00126         virtual void operator ++ ()=0;
00127         virtual void operator -- ()=0;
00128 
00129         virtual inline double operator [] (int idx)=0;
00130 
00131         virtual void NcPut(NcVar *ncfield)=0;
00132         virtual void NcGet(NcVar *ncfield)=0;
00133 
00134         void SetLayer(int l){ vlayer=l; };
00135         void StoreLayer(){ vlayerstore=vlayer; };
00136         void RestoreLayer(){ vlayer=vlayerstore; };
00137         int GetLayer(void){ return vlayer; };
00138 
00139 protected:
00140         int  ZResize(int Nx, int Ny, int Nv=0);
00141         int  nx, ny, nv;
00142         int  vlayer, vlayerstore;
00143         int  cp_ix0, cp_num;
00144         LineInfo *Li;
00145 private:
00146         double *Xlookup, *Ylookup, *Vlookup;
00147 };
00148 
00149 /*
00150  * Subclass of ZData
00151  * with arbitrary scalar Element Data Type <ZTYP>
00152  */
00153 template <class ZTYP> class TZData : public ZData{
00154         friend class Mem2d;
00155 public:
00156         TZData(int Nx=1, int Ny=1, int Nv=1);
00157         virtual ~TZData();
00158 
00159         size_t Zsize(){ return sizeof(ZTYP); };
00160         inline double Z(int x, int y){ return (double)Zdat[y*nv+vlayer][x]; };
00161         inline double Z(int x, int y, int v){ return (double)Zdat[y*nv+v][x]; };
00162         inline double Z(double z, int x, int y){ return (double)(Zdat[y*nv+vlayer][x]=(ZTYP)z); };
00163         inline double Z(double z, int x, int y, int v){ return (double)(Zdat[y*nv+v][x]=(ZTYP)z); };
00164         inline double Z(double vx, double vy);
00165         inline double Z(double z, double vx, double vy);
00166         inline void Zadd(double z, int x, int y){ Zdat[y*nv+vlayer][x]+=(ZTYP)z; };
00167         inline void Zmul(double z, int x, int y){ Zdat[y*nv+vlayer][x]*=(ZTYP)z; };
00168         inline void Zdiv(double z, int x, int y){ Zdat[y*nv+vlayer][x]/=(ZTYP)z; };
00169 
00170         int  Resize(int Nx, int Ny, int Nv=1);
00171         void ZPutDataLine(int y, void *src){
00172                 memcpy((void*)(Zdat[y*nv+vlayer]+cp_ix0), src, sizeof(ZTYP)*cp_num);
00173         };
00174         void ZPutDataLine(int y, void *src, int mode);
00175         void ZGetDataLine(int y, void *dest){
00176                 memcpy(dest, (void*)(Zdat[y*nv+vlayer]+cp_ix0), sizeof(ZTYP)*cp_num);
00177         };
00178         void set_all_Z (double z, int v=-1, int x0=0, int y0=0, int xs=0, int ys=0);
00179 
00180         // Achtung keine Bereichkontrolle !! fastest...
00181         inline void   SetPtr(int x, int y){ zptr = &Zdat[y*nv+vlayer][x];};
00182         inline void   SetPtrT(int x, int y){ 
00183                 zptr = &Zdat[y*nv+vlayer][x]; zptrT = &Zdat[(y-1)*nv+vlayer][x]; 
00184         };
00185         inline void   SetPtrTB(int x, int y){ 
00186                 zptr = &Zdat[y*nv+vlayer][x]; 
00187                 zptrT = &Zdat[(y-1)*nv+vlayer][x]; 
00188                 zptrB = &Zdat[(y+1)*nv+vlayer][x]; 
00189         };
00190         inline double GetNext(){ return (double)*zptr++; };
00191         inline double        GetThis(double x=0.){ return (double)*zptr; };
00192         inline double        GetThisL(){ return (double)*(zptr-1); };
00193         inline double        GetThisLT(){ return (double)*(zptrT-1); };
00194         inline double        GetThisT(){ return (double)*zptrT; };
00195         inline double        GetThisRT(){ return (double)*(zptrT+1); };
00196         inline double        GetThisR(){ return (double)*(zptr+1); };
00197         inline double        GetThisRB(){ return (double)*(zptrB+1); };
00198         inline double        GetThisB(){ return (double)*(zptrB); };
00199         inline double        GetThisLB(){ return (double)*(zptrB-1); };
00200         inline void          IncPtrT(){ ++zptr; ++zptrT; };
00201         inline void          IncPtrTB(){ ++zptr; ++zptrT; ++zptrB; };
00202 
00203         inline float         GetThis(float x=0.){ return (float)*zptr; };
00204         inline long          GetThis(long x){ return (long)*zptr; };
00205         inline unsigned long GetThis(unsigned long x){ return (unsigned long)*zptr; };
00206         inline SHT           GetThis(SHT x){ return (SHT)*zptr; };
00207         inline unsigned char GetThis(unsigned char x){ return (unsigned char)*zptr; };
00208         inline void          SetThis(double z){ *zptr=(ZTYP)z; };  // für Island-Labeling MB
00209 
00210         inline void          SetNext(double z){ *zptr++=(ZTYP)z; };
00211 
00212         // ==> rhs.GetThis((ZTYP)1)
00213         // Der Aufruf mit dem "Dummy" Argument dient zur Typenselection des Rückgabewertes
00214         inline void operator =  (ZData &rhs) { *zptr  = (ZTYP)rhs.GetThis((ZTYP)1); };
00215         inline void operator += (ZData &rhs) { *zptr += (ZTYP)rhs.GetThis((ZTYP)1); };
00216         inline void operator -= (ZData &rhs) { *zptr -= (ZTYP)rhs.GetThis((ZTYP)1); };
00217         inline void operator *= (ZData &rhs) { *zptr *= (ZTYP)rhs.GetThis((ZTYP)1); };
00218         inline void operator /= (ZData &rhs) { *zptr /= (ZTYP)rhs.GetThis((ZTYP)1); };
00219         inline void operator ++ () { zptr++; };
00220         inline void operator -- () { zptr--; };
00221 
00222         inline double operator [] (int idx) { return (double) *(zptr+idx); };
00223 
00224         // Rectangular Copy
00225         // Copy Src-Rect(x,y - x+nx,y+ny) to Dest-Rect(tox,toy - tox+nx, toy+ny)
00226         // Achtung: TYPEN muessen passen !!!!!!
00227         int  CopyFrom(ZData *src, int x, int y, int tox, int toy, int nx, int ny=1);
00228         inline void* GetPtr(int x, int y){ return (void*)&Zdat[y*nv+vlayer][x]; };
00229 
00230         inline ZTYP* GetPtr(int x, int y, ZTYP z){ return &Zdat[y*nv+vlayer][x]; };
00231 
00232         void NcPut(NcVar *ncfield);
00233         void NcGet(NcVar *ncfield);
00234 
00235 protected:
00236         ZTYP **Zdat;
00237 private:
00238         virtual void TNew( void );
00239         virtual void TDel( void );
00240 
00241         ZTYP *zptr, *zptrT, *zptrB;
00242 };
00243 
00244 #endif