std::vector<mglText> Ptx; ///< Text labels for mglPrim\r
std::vector<mglText> Leg; ///< Text labels for legend\r
std::vector<mglTexture> Txt;///< Pointer to textures\r
-#ifdef HAVE_PTHREAD\r
+#if MGL_HAVE_PTHREAD\r
pthread_mutex_t mutexPnt, mutexTxt, mutexLeg;\r
#endif\r
\r
#define MGL_STACK_ENTRY 10\r
#endif\r
//-----------------------------------------------------------------------------\r
-#ifdef HAVE_GIF\r
+#if MGL_HAVE_GIF\r
#include <gif_lib.h>\r
#else\r
struct GifFileType;\r
unsigned char *G4; ///< Final picture in RGBA format. Prepared in Finish().\r
unsigned char *G; ///< Final picture in RGB format. Prepared in Finish().\r
std::vector<mglDrawDat> DrwDat; ///< Set of ALL drawing data for each frames\r
-#ifdef HAVE_PTHREAD\r
+#if MGL_HAVE_PTHREAD\r
pthread_mutex_t mutexSub, mutexPrm, mutexPtx, mutexStk, mutexGrp;\r
#endif\r
\r
/*****************************************************************************/\r
#include "mgl/base.h"\r
/*****************************************************************************/\r
-#ifndef NO_GSL\r
+#if MGL_HAVE_GSL\r
#include <gsl/gsl_vector.h>\r
#include <gsl/gsl_matrix.h>\r
#else\r
const unsigned long mgl_nan[2] = {0xffffffff, 0x7fffffff};\r
#define NANd (*(double*)mgl_nan)\r
#define NANf (*(float*)&(mgl_nan[1]))\r
-#if (MGL_USE_DOUBLE==1)\r
+#if MGL_USE_DOUBLE\r
#define NAN NANd\r
#else\r
#define NAN NANd\r
//-----------------------------------------------------------------------------\r
#include <mgl/config.h>\r
//-----------------------------------------------------------------------------\r
-#if (MGL_USE_DOUBLE==1)\r
+#if MGL_USE_DOUBLE\r
typedef double mreal;\r
#else\r
typedef float mreal;\r
#ifdef __cplusplus\r
}\r
#endif\r
-#ifdef HAVE_PTHREAD\r
+#if MGL_HAVE_PTHREAD\r
#include <pthread.h>\r
#define MGL_PUSH(a,v,m) {pthread_mutex_lock(&m); a.push_back(v); pthread_mutex_unlock(&m);}\r
#else\r
{\r
virtual int Draw(mglGraph *){} ///< Function for drawing\r
virtual void Reload() {} ///< Function for reloading data\r
-#ifdef HAVE_PTHREAD\r
+#if MGL_HAVE_PTHREAD\r
pthread_t thr;\r
bool running;\r
mglDraw() { running=false; }\r
// NOTE: mgl_draw_class() use mglWindow* only. Don't use it with inherited classes\r
int mgl_draw_class(mglBase *gr, void *p);\r
//-----------------------------------------------------------------------------\r
-#ifndef HAVE_QT\r
-#define MGL_WND_KIND 0\r
-#else\r
+#if MGL_HAVE_QT\r
#define MGL_WND_KIND 1\r
+#else\r
+#define MGL_WND_KIND 0\r
#endif\r
class mglWindow : public mglGraph\r
{\r
{\r
// memset(this,0,sizeof(mglBase)); // since mglBase is abstract then I can do it?!!\r
Flag=0; saved=false;\r
-#ifdef HAVE_PTHREAD\r
+#if MGL_HAVE_PTHREAD\r
pthread_mutex_init(&mutexPnt,0);\r
pthread_mutex_init(&mutexTxt,0);\r
#endif\r
ax.dir = mglPoint(1,0,0); ax.a = mglPoint(0,1,0); ax.b = mglPoint(0,0,1); ax.ch='x';\r
ay.dir = mglPoint(0,1,0); ay.a = mglPoint(1,0,0); ay.b = mglPoint(0,0,1); ay.ch='y';\r
az.dir = mglPoint(0,0,1); az.a = mglPoint(0,1,0); az.b = mglPoint(1,0,0); az.ch='z';\r
-#ifdef HAVE_PTHREAD\r
+#if MGL_HAVE_PTHREAD\r
pthread_mutex_init(&mutexSub,0); pthread_mutex_init(&mutexLeg,0);\r
pthread_mutex_init(&mutexPrm,0); pthread_mutex_init(&mutexPtx,0);\r
pthread_mutex_init(&mutexStk,0); pthread_mutex_init(&mutexGrp,0);\r
void mglFillP5(long x,long y, const mreal *a,long nx,long ny,mreal _p[6][6]);\r
void mglFillP5(long x, const mreal *a,long nx,mreal _p[6]);\r
//-----------------------------------------------------------------------------\r
-#ifdef HAVE_PTHREAD\r
+#if MGL_HAVE_PTHREAD\r
#ifdef WIN32\r
#include <windows.h>\r
#include <process.h>\r
const mreal *b, const mreal *c, const long *p, void *v, const mreal *d, const mreal *e, char *s)\r
{\r
if(!func) return;\r
-#ifdef HAVE_PTHREAD\r
+#if MGL_HAVE_PTHREAD\r
if(mglNumThr<1) mgl_set_num_thr(0);\r
if(mglNumThr>1)\r
{\r
#include <math.h>\r
#include <string.h>\r
#include <zlib.h>\r
-#ifdef HAVE_HDF5\r
-#include <hdf5.h>\r
-#endif\r
-#ifdef HAVE_HDF4\r
-#define intf hdf4_intf\r
-#include <hdf/mfhdf.h>\r
-#undef intf\r
-#endif\r
\r
#ifndef WIN32\r
#include <glob.h>\r
#include "mgl/data.h"\r
#include "mgl/eval.h"\r
\r
+#if MGL_HAVE_HDF5\r
+#include <hdf5.h>\r
+#endif\r
+#if MGL_HAVE_HDF4\r
+#define intf hdf4_intf\r
+#include <hdf/mfhdf.h>\r
+#undef intf\r
+#endif\r
+\r
//#define isn(ch) ((ch)<' ' && (ch)!='\t')\r
#define isn(ch) ((ch)=='\n')\r
//-----------------------------------------------------------------------------\r
//-----------------------------------------------------------------------------\r
void mgl_data_set_vector(HMDT d, gsl_vector *v)\r
{\r
-#ifndef NO_GSL\r
+#if MGL_HAVE_GSL\r
if(!v || v->size<1) return;\r
mgl_data_create(d, v->size,1,1);\r
for(long i=0;i<d->nx;i++) d->a[i] = v->data[i*v->stride];\r
//-----------------------------------------------------------------------------\r
void mgl_data_set_matrix(HMDT d, gsl_matrix *m)\r
{\r
-#ifndef NO_GSL\r
+#if MGL_HAVE_GSL\r
if(!m || m->size1<1 || m->size2<1) return;\r
mgl_data_create(d, m->size1,m->size2,1);\r
register long i,j;\r
{\r
if(NX<=0 || NY<=0 || NZ<=0) return;\r
mgl_data_create(d, NX,NY,NZ); if(!A) return;\r
-#if(MGL_USE_DOUBLE==1)\r
+#if MGL_USE_DOUBLE\r
for(long i=0;i<NX*NY*NZ;i++) d->a[i] = A[i];\r
#else\r
memcpy(d->a,A,NX*NY*NZ*sizeof(float));\r
{\r
if(NX<=0 || NY<=0 || NZ<=0) return;\r
mgl_data_create(d, NX,NY,NZ); if(!A) return;\r
-#if(MGL_USE_DOUBLE==1)\r
+#if MGL_USE_DOUBLE\r
memcpy(d->a,A,NX*NY*NZ*sizeof(double));\r
#else\r
for(long i=0;i<NX*NY*NZ;i++) d->a[i] = A[i];\r
{\r
if(N1<=0 || N2<=0) return;\r
mgl_data_create(d, N2,N1,1); if(!A) return;\r
-#if(MGL_USE_DOUBLE==1)\r
+#if MGL_USE_DOUBLE\r
for(long i=0;i<N1;i++) for(long j=0;j<N2;j++) d->a[j+i*N2] = A[i][j];\r
#else\r
for(long i=0;i<N1;i++) memcpy(d->a+i*N2,A[i],N2*sizeof(float));\r
{\r
if(N1<=0 || N2<=0) return;\r
mgl_data_create(d, N2,N1,1); if(!A) return;\r
-#if(MGL_USE_DOUBLE==1)\r
+#if MGL_USE_DOUBLE\r
for(long i=0;i<N1;i++) memcpy(d->a+i*N2,A[i],N2*sizeof(double));\r
#else\r
for(long i=0;i<N1;i++) for(long j=0;j<N2;j++) d->a[j+i*N2] = A[i][j];\r
{\r
if(N1<=0 || N2<=0 || N3<=0) return;\r
mgl_data_create(d, N3,N2,N1); if(!A) return;\r
-#if(MGL_USE_DOUBLE==1)\r
+#if MGL_USE_DOUBLE\r
for(long i=0;i<N1;i++) for(long j=0;j<N2;j++) for(long k=0;k<N3;k++)\r
d->a[k+N3*(j+i*N2)] = A[i][j][k];\r
#else\r
{\r
if(N1<=0 || N2<=0 || N3<=0) return;\r
mgl_data_create(d, N3,N2,N1); if(!A) return;\r
-#if(MGL_USE_DOUBLE==1)\r
+#if MGL_USE_DOUBLE\r
for(long i=0;i<N1;i++) for(long j=0;j<N2;j++)\r
memcpy(d->a+N3*(j+i*N2),A[i][j],N3*sizeof(double));\r
#else\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
mgl_data_fill_eq(_GR_,_DT_,s,_DA_(v),_DA_(w),o); delete []o; delete []s; }\r
//-----------------------------------------------------------------------------\r
-#ifdef HAVE_HDF4\r
+#if MGL_HAVE_HDF4\r
void mgl_data_read_hdf4(HMDT d,const char *fname,const char *data)\r
{\r
int32 sd = SDstart(fname,DFACC_READ), nn, i;\r
void mgl_data_read_hdf4(HMDT ,const char *,const char *){}\r
#endif\r
//-----------------------------------------------------------------------------\r
-#ifdef HAVE_HDF5\r
+#if MGL_HAVE_HDF5\r
void mgl_data_save_hdf(HCDT dat,const char *fname,const char *data,int rewrite)\r
{\r
const mglData *d = dynamic_cast<const mglData *>(dat); // NOTE: only for mglData\r
hid_t hf,hd,hs;\r
hsize_t dims[3];\r
long rank = 3, res;\r
-#ifndef H5_USE_16_API\r
+#if MGL_HAVE_HDF5_18\r
H5Eset_auto(H5E_DEFAULT,0,0);\r
#else\r
H5Eset_auto(0,0);\r
else if(d->nz==1) { rank=2; dims[0]=d->ny; dims[1]=d->nx; }\r
else { rank=3; dims[0]=d->nz; dims[1]=d->ny; dims[2]=d->nx; }\r
hs = H5Screate_simple(rank, dims, 0);\r
-#if(MGL_USE_DOUBLE==1)\r
+#if MGL_USE_DOUBLE\r
hid_t mem_type_id = H5T_NATIVE_DOUBLE;\r
#else\r
hid_t mem_type_id = H5T_NATIVE_FLOAT;\r
#endif\r
-#ifndef H5_USE_16_API\r
+#if MGL_HAVE_HDF5_18\r
hd = H5Dcreate(hf, data, mem_type_id, hs, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);\r
-#else /* ! HAVE_HDF5_18 */\r
+#else\r
hd = H5Dcreate(hf, data, mem_type_id, hs, H5P_DEFAULT);\r
-#endif /* HAVE_HDF5_18 */\r
+#endif\r
H5Dwrite(hd, mem_type_id, hs, hs, H5P_DEFAULT, d->a);\r
H5Dclose(hd); H5Sclose(hs); H5Fclose(hf);\r
}\r
if(res<=0) { mgl_data_read_hdf4(d,fname,data); return false; }\r
hf = H5Fopen(fname, H5F_ACC_RDONLY, H5P_DEFAULT);\r
if(hf<0) return false;\r
-#ifndef H5_USE_16_API\r
+#if MGL_HAVE_HDF5_18\r
hd = H5Dopen(hf,data,H5P_DEFAULT);\r
#else\r
hd = H5Dopen(hf,data);\r
else if(rank==2) { dims[2]=dims[1]; dims[1]=dims[0]; dims[0]=1; }\r
// else if(rank>3) continue;\r
mgl_data_create(d,dims[2],dims[1],dims[0]);\r
-#if(MGL_USE_DOUBLE==1)\r
+#if MGL_USE_DOUBLE\r
H5Dread(hd, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT, d->a);\r
#else\r
H5Dread(hd, H5T_NATIVE_FLOAT, H5S_ALL, H5S_ALL, H5P_DEFAULT, d->a);\r
buf[0]=0;\r
hf = H5Fopen(fname, H5F_ACC_RDONLY, H5P_DEFAULT);\r
if(!hf) return 0;\r
-#ifndef H5_USE_16_API\r
+#if MGL_HAVE_HDF5_18\r
hg = H5Gopen(hf,"/",H5P_DEFAULT);\r
#else\r
hg = H5Gopen(hf,"/");\r
{\r
if(H5Gget_objtype_by_idx(hg, i)!=H5G_DATASET) continue;\r
H5Gget_objname_by_idx(hg, i, name, 256);\r
-#ifndef H5_USE_16_API\r
+#if MGL_HAVE_HDF5_18\r
hd = H5Dopen(hf,name,H5P_DEFAULT);\r
#else\r
hd = H5Dopen(hf,name);\r
#include <math.h>\r
#include <string.h>\r
\r
-#ifndef NO_GSL\r
+#include "mgl/data.h"\r
+\r
+#if MGL_HAVE_GSL\r
#include <gsl/gsl_fft_complex.h>\r
#include <gsl/gsl_dht.h>\r
#include <gsl/gsl_sf.h>\r
#endif\r
-\r
-#include "mgl/data.h"\r
//-----------------------------------------------------------------------------\r
void mgl_data_envelop(HMDT d, char dir)\r
{\r
-#ifndef NO_GSL\r
+#if MGL_HAVE_GSL\r
register long i,j,k,i0;\r
long nx=d->nx,ny=d->ny,nz=d->nz,nn=nx*ny*nz;\r
double *b = new double[2*nn];\r
//-----------------------------------------------------------------------------\r
void mgl_data_fourier(HMDT re, HMDT im, const char *dir)\r
{\r
-#ifndef NO_GSL\r
+#if MGL_HAVE_GSL\r
long nx = re->nx, ny = re->ny, nz = re->nz;\r
if(nx*ny*nz != im->nx*im->ny*im->nz || !dir || dir[0]==0) return;\r
double *a = new double[2*nx*ny*nz];\r
HMDT mgl_data_stfa(HCDT re, HCDT im, long dn, char dir)\r
{\r
mglData *d=new mglData;\r
-#ifndef NO_GSL\r
+#if MGL_HAVE_GSL\r
if(dn<2) return d;\r
dn = 2*(dn/2);\r
long nx = re->GetNx(), ny = re->GetNy();\r
mreal *aa=d->a;\r
if(strchr(how,'h')) // Hankel\r
{\r
-#ifndef NO_GSL\r
+#if MGL_HAVE_GSL\r
gsl_dht *dht = gsl_dht_new(n,0,1);\r
for(i=0;i<n;i++)\r
aa[i] = xx ? gsl_dht_x_sample(dht, i) : gsl_dht_k_sample(dht, i);\r
//-----------------------------------------------------------------------------\r
void mgl_data_hankel(HMDT d, const char *dir)\r
{\r
-#ifndef NO_GSL\r
+#if MGL_HAVE_GSL\r
double *ai=0, *af=0, mm;\r
gsl_dht *dht=0;\r
register long i,j,k;\r
//-----------------------------------------------------------------------------\r
void mgl_data_cosfft(HMDT d, const char *dir)\r
{\r
-#ifndef NO_GSL\r
+#if MGL_HAVE_GSL\r
double *b = 0;\r
gsl_fft_complex_wavetable *wt=0;\r
gsl_fft_complex_workspace *ws=0;\r
//-----------------------------------------------------------------------------\r
void mgl_data_sinfft(HMDT d, const char *dir)\r
{\r
-#ifndef NO_GSL\r
+#if MGL_HAVE_GSL\r
double *b = 0;\r
gsl_fft_complex_wavetable *wt=0;\r
gsl_fft_complex_workspace *ws=0;\r
-/***************************************************************************
- * data_png.cpp is part of Math Graphic Library
- * Copyright (C) 2007 Alexey Balakin <balakin@appl.sci-nnov.ru> *
- * *
- * This program is free software; you can redistribute it and/or modify *
- * it under the terms of the GNU Library General Public License as *
- * published by the Free Software Foundation; either version 3 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 Library 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. *
- ***************************************************************************/
-#include <stdlib.h>
-#include <zlib.h>
-#ifndef NO_PNG
-#include <png.h>
-#endif
-#include "mgl/data.h"
-//-----------------------------------------------------------------------------
-long mgl_col_dif(unsigned char *c1,unsigned char *c2,bool sum)
-{
- long res,d1=abs(long(c1[0])-long(c2[0])),
- d2=abs(long(c1[1])-long(c2[1])),d3=abs(long(c1[2])-long(c2[2]));
- if(sum) res = d1+d2+d3;
- else res = mgl_max(d1,mgl_max(d2,d3));
- return res;
-}
-//-----------------------------------------------------------------------------
-unsigned char *mgl_create_scheme(const char *scheme,long &num)
-{
- unsigned char *c=0,*cc=new unsigned char[3*strlen(scheme)+3];
- long nc=1,np=0;
- register long i,j;
- mglColor col;
- for(i=0;i<long(strlen(scheme));i++)
- {
- col = mglColor(scheme[i]);
- if(col.Valid())
- { cc[3*np]=col.r; cc[3*np+1]=col.g; cc[3*np+2]=col.b; np++; }
- }
- if(np<2) { delete []cc; return 0; }
- for(i=0;i<np-1;i++) nc+=mgl_col_dif(cc+3*i,cc+3*i+3,false);
- c = new unsigned char[3*nc+3];
- long dd,pos=0;
- for(i=0;i<np-1;i++)
- {
- dd=mgl_col_dif(cc+3*i,cc+3*i+3,false);
- for(j=0;j<dd;j++)
- {
- c[3*(pos+j)] = cc[3*i]+(cc[3*i+3]-cc[3*i])*j/dd;
- c[3*(pos+j)+1] = cc[3*i+1]+(cc[3*i+4]-cc[3*i+1])*j/dd;
- c[3*(pos+j)+2] = cc[3*i+2]+(cc[3*i+5]-cc[3*i+2])*j/dd;
- }
- pos += dd;
- }
- memcpy(c+3*nc-3,cc+3*np-3,3*sizeof(unsigned char));
- delete []cc;
- num=nc;
- return c;
-}
-//-----------------------------------------------------------------------------
+/***************************************************************************\r
+ * data_png.cpp is part of Math Graphic Library\r
+ * Copyright (C) 2007 Alexey Balakin <balakin@appl.sci-nnov.ru> *\r
+ * *\r
+ * This program is free software; you can redistribute it and/or modify *\r
+ * it under the terms of the GNU Library General Public License as *\r
+ * published by the Free Software Foundation; either version 3 of the *\r
+ * License, or (at your option) any later version. *\r
+ * *\r
+ * This program is distributed in the hope that it will be useful, *\r
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of *\r
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *\r
+ * GNU General Public License for more details. *\r
+ * *\r
+ * You should have received a copy of the GNU Library General Public *\r
+ * License along with this program; if not, write to the *\r
+ * Free Software Foundation, Inc., *\r
+ * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *\r
+ ***************************************************************************/\r
+#include <stdlib.h>\r
+#include <zlib.h>\r
+#include <png.h>\r
+#include "mgl/data.h"\r
+//-----------------------------------------------------------------------------\r
+long mgl_col_dif(unsigned char *c1,unsigned char *c2,bool sum)\r
+{\r
+ long res,d1=abs(long(c1[0])-long(c2[0])),\r
+ d2=abs(long(c1[1])-long(c2[1])),d3=abs(long(c1[2])-long(c2[2]));\r
+ if(sum) res = d1+d2+d3;\r
+ else res = mgl_max(d1,mgl_max(d2,d3));\r
+ return res;\r
+}\r
+//-----------------------------------------------------------------------------\r
+unsigned char *mgl_create_scheme(const char *scheme,long &num)\r
+{\r
+ unsigned char *c=0,*cc=new unsigned char[3*strlen(scheme)+3];\r
+ long nc=1,np=0;\r
+ register long i,j;\r
+ mglColor col;\r
+ for(i=0;i<long(strlen(scheme));i++)\r
+ {\r
+ col = mglColor(scheme[i]);\r
+ if(col.Valid())\r
+ { cc[3*np]=col.r; cc[3*np+1]=col.g; cc[3*np+2]=col.b; np++; }\r
+ }\r
+ if(np<2) { delete []cc; return 0; }\r
+ for(i=0;i<np-1;i++) nc+=mgl_col_dif(cc+3*i,cc+3*i+3,false);\r
+ c = new unsigned char[3*nc+3];\r
+ long dd,pos=0;\r
+ for(i=0;i<np-1;i++)\r
+ {\r
+ dd=mgl_col_dif(cc+3*i,cc+3*i+3,false);\r
+ for(j=0;j<dd;j++)\r
+ {\r
+ c[3*(pos+j)] = cc[3*i]+(cc[3*i+3]-cc[3*i])*j/dd;\r
+ c[3*(pos+j)+1] = cc[3*i+1]+(cc[3*i+4]-cc[3*i+1])*j/dd;\r
+ c[3*(pos+j)+2] = cc[3*i+2]+(cc[3*i+5]-cc[3*i+2])*j/dd;\r
+ }\r
+ pos += dd;\r
+ }\r
+ memcpy(c+3*nc-3,cc+3*np-3,3*sizeof(unsigned char));\r
+ delete []cc;\r
+ num=nc;\r
+ return c;\r
+}\r
+//-----------------------------------------------------------------------------\r
void mgl_data_import(HMDT d, const char *fname, const char *scheme,float v1,float v2)\r
-{
- if(v1>=v2) return;
- long num=0;
-#ifndef NO_PNG
- FILE *fp = fopen(fname, "rb");
- if (!fp) return;
- png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
- if (!png_ptr) { fclose(fp); return; }
- png_infop info_ptr = png_create_info_struct(png_ptr);
- if (!info_ptr)
- { png_destroy_read_struct(&png_ptr,0,0); fclose(fp); return; }
- png_infop end_info = png_create_info_struct(png_ptr);
- if (!end_info)
- { png_destroy_read_struct(&png_ptr,&info_ptr,0); fclose(fp); return; }
-
- png_init_io(png_ptr, fp);
- png_read_png(png_ptr, info_ptr,
- PNG_TRANSFORM_STRIP_ALPHA|PNG_TRANSFORM_PACKING|
- PNG_TRANSFORM_STRIP_16|PNG_TRANSFORM_EXPAND,0);
- unsigned char **rows = png_get_rows(png_ptr, info_ptr);
- unsigned char *c = mgl_create_scheme(scheme,num);
- if(num>1)
- {
- long w=png_get_image_width(png_ptr, info_ptr);
- long h=png_get_image_height(png_ptr, info_ptr);
- d->Create(w,h,1);
- register long i,j,k;
- long pos=0,val,mval=256;
- for(i=0;i<d->ny;i++) for(j=0;j<d->nx;j++)
- {
- for(mval=256,k=0;k<num;k++)
- {
- val = mgl_col_dif(c+3*k,rows[d->ny-i-1]+3*j,true);
- if(val==0) { pos=k; break; }
- if(val<mval) { pos=k; mval=val; }
- }
- d->a[j+d->nx*i] = v1 + pos*(v2-v1)/num;
- }
- }
- delete []c;
- png_destroy_read_struct(&png_ptr, &info_ptr,&end_info);
- fclose(fp);
-#endif
-}
-//-----------------------------------------------------------------------------
+{\r
+ if(v1>=v2) return;\r
+ long num=0;\r
+ FILE *fp = fopen(fname, "rb");\r
+ if (!fp) return;\r
+ png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);\r
+ if (!png_ptr) { fclose(fp); return; }\r
+ png_infop info_ptr = png_create_info_struct(png_ptr);\r
+ if (!info_ptr)\r
+ { png_destroy_read_struct(&png_ptr,0,0); fclose(fp); return; }\r
+ png_infop end_info = png_create_info_struct(png_ptr);\r
+ if (!end_info)\r
+ { png_destroy_read_struct(&png_ptr,&info_ptr,0); fclose(fp); return; }\r
+\r
+ png_init_io(png_ptr, fp);\r
+ png_read_png(png_ptr, info_ptr,\r
+ PNG_TRANSFORM_STRIP_ALPHA|PNG_TRANSFORM_PACKING|\r
+ PNG_TRANSFORM_STRIP_16|PNG_TRANSFORM_EXPAND,0);\r
+ unsigned char **rows = png_get_rows(png_ptr, info_ptr);\r
+ unsigned char *c = mgl_create_scheme(scheme,num);\r
+ if(num>1)\r
+ {\r
+ long w=png_get_image_width(png_ptr, info_ptr);\r
+ long h=png_get_image_height(png_ptr, info_ptr);\r
+ d->Create(w,h,1);\r
+ register long i,j,k;\r
+ long pos=0,val,mval=256;\r
+ for(i=0;i<d->ny;i++) for(j=0;j<d->nx;j++)\r
+ {\r
+ for(mval=256,k=0;k<num;k++)\r
+ {\r
+ val = mgl_col_dif(c+3*k,rows[d->ny-i-1]+3*j,true);\r
+ if(val==0) { pos=k; break; }\r
+ if(val<mval) { pos=k; mval=val; }\r
+ }\r
+ d->a[j+d->nx*i] = v1 + pos*(v2-v1)/num;\r
+ }\r
+ }\r
+ delete []c;\r
+ png_destroy_read_struct(&png_ptr, &info_ptr,&end_info);\r
+ fclose(fp);\r
+}\r
+//-----------------------------------------------------------------------------\r
void mgl_data_export(HCDT dd, const char *fname, const char *scheme,float v1,float v2,long ns)\r
-{
- register long i,j,k;
- long nx=dd->GetNx(), ny=dd->GetNy(), nz=dd->GetNz();
- mreal vv;
- if(v1>v2) return;
- if(ns<0 || ns>=nz) ns=0;
- if(v1==v2)
- {
- v1 = 1e20; v2=-1e20;
- for(i=0;i<nx*ny*nz;i++)
- { vv = dd->vthr(i); if(vv<v1) v1=vv; if(vv>v2) v2=vv; }
- }
- if(v1==v2) return;
-#ifndef NO_PNG
- long num=0;
- unsigned char *c = mgl_create_scheme(scheme,num);
- if(num<2) { delete []c; return; }
-
- unsigned char **p = (unsigned char **)malloc(ny*sizeof(unsigned char *));
- unsigned char *d = (unsigned char *)malloc(3*nx*ny*sizeof(unsigned char));
- for(i=0;i<ny;i++) p[i] = d+3*nx*(ny-1-i);
- for(i=0;i<ny;i++) for(j=0;j<nx;j++)
- {
- k = long(num*(dd->v(j,i,ns)-v1)/(v2-v1));
- if(k<0) k=0; if(k>=num) k=num-1;
- memcpy(d+3*(j+i*nx),c+3*k,3*sizeof(unsigned char));
- }
- delete []c;
-
- FILE *fp = fopen(fname, "wb");
- if (!fp) return;
- png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
- if (!png_ptr) { fclose(fp); return; }
- png_infop info_ptr = png_create_info_struct(png_ptr);
- if (!info_ptr)
- { png_destroy_write_struct(&png_ptr,0); fclose(fp); return; }
- png_init_io(png_ptr, fp);
- png_set_filter(png_ptr, 0, PNG_ALL_FILTERS);
- png_set_compression_level(png_ptr, Z_BEST_COMPRESSION);
- png_set_IHDR(png_ptr, info_ptr, nx, ny, 8, PNG_COLOR_TYPE_RGB,
- PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
- png_set_rows(png_ptr, info_ptr, p);
- png_write_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, 0);
- png_write_end(png_ptr, info_ptr);
- png_destroy_write_struct(&png_ptr, &info_ptr);
- fclose(fp); free(p); free(d);
-#endif
-}
-//-----------------------------------------------------------------------------
-void mgl_data_export_(uintptr_t *d, const char *fname, const char *scheme,float *v1,float *v2,int *ns,int l,int n)
-{
- char *s=new char[l+1]; memcpy(s,fname,l); s[l]=0;
- char *f=new char[n+1]; memcpy(f,scheme,n); f[n]=0;
- mgl_data_export(_DT_,s,f,*v1,*v2,*ns);
- delete []s; delete []f;
-}
+{\r
+ register long i,j,k;\r
+ long nx=dd->GetNx(), ny=dd->GetNy(), nz=dd->GetNz();\r
+ mreal vv;\r
+ if(v1>v2) return;\r
+ if(ns<0 || ns>=nz) ns=0;\r
+ if(v1==v2)\r
+ {\r
+ v1 = 1e20; v2=-1e20;\r
+ for(i=0;i<nx*ny*nz;i++)\r
+ { vv = dd->vthr(i); if(vv<v1) v1=vv; if(vv>v2) v2=vv; }\r
+ }\r
+ if(v1==v2) return;\r
+ long num=0;\r
+ unsigned char *c = mgl_create_scheme(scheme,num);\r
+ if(num<2) { delete []c; return; }\r
+\r
+ unsigned char **p = (unsigned char **)malloc(ny*sizeof(unsigned char *));\r
+ unsigned char *d = (unsigned char *)malloc(3*nx*ny*sizeof(unsigned char));\r
+ for(i=0;i<ny;i++) p[i] = d+3*nx*(ny-1-i);\r
+ for(i=0;i<ny;i++) for(j=0;j<nx;j++)\r
+ {\r
+ k = long(num*(dd->v(j,i,ns)-v1)/(v2-v1));\r
+ if(k<0) k=0; if(k>=num) k=num-1;\r
+ memcpy(d+3*(j+i*nx),c+3*k,3*sizeof(unsigned char));\r
+ }\r
+ delete []c;\r
+\r
+ FILE *fp = fopen(fname, "wb");\r
+ if (!fp) return;\r
+ png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);\r
+ if (!png_ptr) { fclose(fp); return; }\r
+ png_infop info_ptr = png_create_info_struct(png_ptr);\r
+ if (!info_ptr)\r
+ { png_destroy_write_struct(&png_ptr,0); fclose(fp); return; }\r
+ png_init_io(png_ptr, fp);\r
+ png_set_filter(png_ptr, 0, PNG_ALL_FILTERS);\r
+ png_set_compression_level(png_ptr, Z_BEST_COMPRESSION);\r
+ png_set_IHDR(png_ptr, info_ptr, nx, ny, 8, PNG_COLOR_TYPE_RGB,\r
+ PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);\r
+ png_set_rows(png_ptr, info_ptr, p);\r
+ png_write_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, 0);\r
+ png_write_end(png_ptr, info_ptr);\r
+ png_destroy_write_struct(&png_ptr, &info_ptr);\r
+ fclose(fp); free(p); free(d);\r
+}\r
+//-----------------------------------------------------------------------------\r
+void mgl_data_export_(uintptr_t *d, const char *fname, const char *scheme,float *v1,float *v2,int *ns,int l,int n)\r
+{\r
+ char *s=new char[l+1]; memcpy(s,fname,l); s[l]=0;\r
+ char *f=new char[n+1]; memcpy(f,scheme,n); f[n]=0;\r
+ mgl_data_export(_DT_,s,f,*v1,*v2,*ns);\r
+ delete []s; delete []f;\r
+}\r
void mgl_data_import_(uintptr_t *d, const char *fname, const char *scheme,float *v1,float *v2,int l,int n)\r
-{
- char *s=new char[l+1]; memcpy(s,fname,l); s[l]=0;
- char *f=new char[n+1]; memcpy(f,scheme,n); f[n]=0;
- mgl_data_import(_DT_,s,f,*v1,*v2);
- delete []s; delete []f;
-}
-//-----------------------------------------------------------------------------
+{\r
+ char *s=new char[l+1]; memcpy(s,fname,l); s[l]=0;\r
+ char *f=new char[n+1]; memcpy(f,scheme,n); f[n]=0;\r
+ mgl_data_import(_DT_,s,f,*v1,*v2);\r
+ delete []s; delete []f;\r
+}\r
+//-----------------------------------------------------------------------------\r
#include <math.h>\r
#include <ctype.h>\r
#include <string.h>\r
-#ifndef NO_GSL\r
+\r
+#include "mgl/eval.h"\r
+\r
+#if MGL_HAVE_GSL\r
#include <gsl/gsl_sf.h>\r
#include <gsl/gsl_rng.h>\r
#include <gsl/gsl_errno.h>\r
#endif\r
-#include "mgl/eval.h"\r
//-----------------------------------------------------------------------------\r
// constants for expression parsing\r
enum{\r
bool mglCheck(char *str,int n);\r
int mglFindInText(char *str,const char *lst);\r
//-----------------------------------------------------------------------------\r
-#ifndef NO_GSL\r
+#if MGL_HAVE_GSL\r
gsl_rng *mgl_rng=0;\r
#endif\r
void mgl_srnd(long seed)\r
{\r
-#ifndef NO_GSL\r
+#if MGL_HAVE_GSL\r
if(mgl_rng==0)\r
{\r
gsl_rng_env_setup();\r
}\r
double mgl_rnd()\r
{\r
-#ifndef NO_GSL\r
+#if MGL_HAVE_GSL\r
if(mgl_rng==0)\r
{\r
gsl_rng_env_setup();\r
// Formula constructor (automatically parse and "compile" formula)\r
mglFormula::mglFormula(const char *string)\r
{\r
-#ifndef NO_GSL\r
+#if MGL_HAVE_GSL\r
gsl_set_error_handler_off();\r
#endif\r
Error=0;\r
double div(double a,double b) {return b?a/b:NAN;}\r
double ipw(double a,double b) {return fabs(b-int(b))<1e-5 ? mgl_ipow(a,int(b)) : pow(a,b);}\r
double llg(double a,double b) {return log(a)/log(b);}\r
-#ifndef NO_GSL\r
+#if MGL_HAVE_GSL\r
double gslEllE(double a,double b) {return gsl_sf_ellint_E(a,b,GSL_PREC_SINGLE);}\r
double gslEllF(double a,double b) {return gsl_sf_ellint_F(a,b,GSL_PREC_SINGLE);}\r
double gslLegP(double a,double b) {return gsl_sf_legendre_Pl(int(a),b);}\r
mreal mglFormula::CalcIn(const mreal *a1) const\r
{\r
float z2[22] = {3,3,3,3,0,3,3,0,0,0,0,0,NAN,0\r
-#ifndef NO_GSL\r
+#if MGL_HAVE_GSL\r
,3,NAN, 3,NAN, 0,0,3,1\r
#else\r
,0,0,0,0,0,0,0,0\r
#endif\r
};\r
func_2 f2[22] = {clt,cgt,ceq,cor,cand,add,sub,mul,div,ipw,pow,fmod,llg,arg\r
-#ifndef NO_GSL\r
+#if MGL_HAVE_GSL\r
,gsl_sf_bessel_Jnu,gsl_sf_bessel_Ynu,\r
gsl_sf_bessel_Inu,gsl_sf_bessel_Knu,\r
gslEllE,gslEllF,gslLegP,gsl_sf_beta\r
};\r
func_1 f1[42] = {sin,cos,tan,asin,acos,atan,sinh,cosh,tanh,\r
asinh,acosh,atanh,sqrt,exp,log,log10,sgn,stp,floor,fabs\r
-#ifndef NO_GSL\r
+#if MGL_HAVE_GSL\r
,gsl_sf_dilog,gslEllEc,gslEllFc,gslAi,gslBi,gsl_sf_erf,\r
gsl_sf_expint_3,gsl_sf_expint_Ei,gsl_sf_expint_E1,gsl_sf_expint_E2,\r
gsl_sf_Si,gsl_sf_Ci,gsl_sf_gamma,gsl_sf_psi,gsl_sf_lambert_W0,\r
return !isnan(b) ? f2[Kod-EQ_LT](a,b) : NAN;\r
}\r
else if(Kod<EQ_SN) return f1[Kod-EQ_SIN](a);\r
-#ifndef NO_GSL\r
+#if MGL_HAVE_GSL\r
else if(Kod<=EQ_DC)\r
{\r
double sn=0,cn=0,dn=0,b = Right->CalcIn(a1);\r
double exp3_d(double a) {return exp(-a*a*a);}\r
double e1_d(double a) {return exp(-a)/a;}\r
double sinc_d(double a) {return a ? (cos(M_PI*a)/a-sin(M_PI*a)/(M_PI*a*a)) : 0;}\r
-#ifndef NO_GSL\r
+#if MGL_HAVE_GSL\r
double e2_d(double a) {return -gsl_sf_expint_E1(a);}\r
double gslJnuD(double a,double b) {return 0.5*(gsl_sf_bessel_Jnu(a-1,b)-gsl_sf_bessel_Jnu(a+1,b));}\r
double gslYnuD(double a,double b) {return 0.5*(gsl_sf_bessel_Ynu(a-1,b)-gsl_sf_bessel_Ynu(a+1,b));}\r
mreal mglFormula::CalcDIn(int id, const mreal *a1) const\r
{\r
func_2 f21[22] = {mgz2,mgz2,mgz2, mgz2,mgz2,mgp, mgp,mul1,div1, ipw1,pow1,mgp,llg1, mgz2\r
-#ifndef NO_GSL\r
+#if MGL_HAVE_GSL\r
,mgz2,mgz2,mgz2, mgz2,gslEllE1,gslEllF2, mgz2,mgz2\r
#else\r
,mgz2,mgz2,mgz2,mgz2,mgz2,mgz2,mgz2,mgz2\r
#endif\r
};\r
func_2 f22[22] = {mgz2,mgz2,mgz2,mgz2,mgz2,mgp,mgm,mul2,div2,pow2,pow2,mgz2,llg2, mgz2\r
-#ifndef NO_GSL\r
+#if MGL_HAVE_GSL\r
,gslJnuD,gslYnuD,gslInuD,gslKnuD,gslEllE2,gslEllF2,mgz2/*gslLegP*/,mgz2\r
#else\r
,mgz2,mgz2,mgz2,mgz2,mgz2,mgz2,mgz2,mgz2\r
};\r
func_1 f11[42] = {cos,cos_d,tan_d,asin_d,acos_d,atan_d,cosh,sinh,tanh_d,\r
asinh_d,acosh_d,atanh_d,sqrt_d,exp,log_d,log10_d,mgz1,mgz1,mgz1,sgn\r
-#ifndef NO_GSL\r
+#if MGL_HAVE_GSL\r
,dilog_d,gslE_d,gslK_d,gslAi_d,gslBi_d,erf_d,exp3_d,ei_d,e1_d,e2_d,\r
si_d,ci_d,gamma_d,gsl_sf_psi_1,mgz1,mgz1,sinc_d,mgz1,mgz1,mgz1,mgz1,mgz1\r
#else\r
return !isnan(b) ? (d?f21[Kod-EQ_LT](a,b)*d:0) + (c?f22[Kod-EQ_LT](a,b)*c:0) : NAN;\r
}\r
else if(Kod<EQ_SN) return (d?f11[Kod-EQ_SIN](a)*d:0);\r
-#ifndef NO_GSL\r
+#if MGL_HAVE_GSL\r
else if(Kod<=EQ_DC)\r
{\r
double sn=0,cn=0,dn=0,b = Right->CalcIn(a1);\r
#include "mgl/evalc.h"\r
#include "mgl/addon.h"\r
#include "mgl/data.h"\r
-#ifndef NO_GSL\r
+#if MGL_HAVE_GSL\r
#include <gsl/gsl_sf.h>\r
#endif\r
//-----------------------------------------------------------------------------\r
-// êîíñòàíòû äëÿ ðàñïîçíîâàíèÿ âûðàæåíèÿ\r
+// ��������� ��� ������������� ���������\r
enum{\r
EQ_NUM=0, // a variable substitution\r
EQ_RND, // random number\r
EQ_A, // numeric constant\r
-// äâóìåñòíûå ôóíêöèè\r
+// ���������� �������\r
EQ_ADD, // addition x+y\r
EQ_SUB, // substraction x-y\r
EQ_MUL, // multiplication x*y\r
EQ_IPOW, // power x^n for integer n\r
EQ_POW, // power x^y\r
EQ_LOG, // logarithm of x on base a, log_a(x) = ln(x)/ln(a)\r
-// îäíîìåñòíûå ôóíêöèè\r
+// ����������� �������\r
EQ_SIN, // sine function \sin(x). !!! MUST BE FIRST 1-PLACE FUNCTION\r
EQ_COS, // cosine function \cos(x).\r
EQ_TAN, // tangent function \tan(x).\r
bool mglCheck(char *str,int n);\r
int mglFindInText(char *str,const char *lst);\r
//-----------------------------------------------------------------------------\r
-// äåñòðóêòîð ôîðìóëû\r
+// ���������� �������\r
mglFormulaC::~mglFormulaC()\r
{\r
if(Left) delete Left;\r
if(Right) delete Right;\r
}\r
//-----------------------------------------------------------------------------\r
-// êîíñòðóêòîð ôîðìóëû (àâòîìàòè÷åñêè ðàñïîçíàåò è "êîìïèëèðóåò" ôîðìóëó)\r
+// ����������� ������� (������������� ���������� � "�����������" �������)\r
mglFormulaC::mglFormulaC(const char *string)\r
{\r
Error=0;\r
mgl_strlwr(str);\r
len=strlen(str);\r
if(str[0]==0) { delete []str; return; }\r
- if(str[0]=='(' && mglCheck(&(str[1]),len-2)) // åñëè âñå âûðàæåíèå â ñêîáàõ, òî óáèðàåì èõ\r
+ if(str[0]=='(' && mglCheck(&(str[1]),len-2)) // ���� ��� ��������� � ������, �� ������� ��\r
{\r
strcpy(Buf,str+1);\r
len-=2; Buf[len]=0;\r
strcpy(str,Buf);\r
}\r
len=strlen(str);\r
- n=mglFindInText(str,"+-"); // ìåíüøèé ïðèîðèòåò - ñëîæåíèå, âû÷èòàíèå\r
+ n=mglFindInText(str,"+-"); // ������� ��������� - ��������, ���������\r
if(n>=0)\r
{\r
if(str[n]=='+') Kod=EQ_ADD; else Kod=EQ_SUB;\r
delete []str;\r
return;\r
}\r
- n=mglFindInText(str,"*/"); // ñðåäíèé ïðèîðèòåò - óìíîæåíèå, äåëåíèå\r
+ n=mglFindInText(str,"*/"); // ������� ��������� - ���������, �������\r
if(n>=0)\r
{\r
if(str[n]=='*') Kod=EQ_MUL; else Kod=EQ_DIV;\r
delete []str;\r
return;\r
}\r
- n=mglFindInText(str,"^"); // âûñîêèé ïðèîðèòåò - âîçâåäåíèå â ñòåïåíü\r
+ n=mglFindInText(str,"^"); // ������� ��������� - ���������� � �������\r
if(n>=0)\r
{\r
Kod=EQ_IPOW;\r
}\r
\r
for(n=0;n<len;n++) if(str[n]=='(') break;\r
- if(n>=len) // ýòî ÷èñëî èëè ïåðåìåííàÿ\r
+ if(n>=len) // ��� ����� ��� ����������\r
{\r
Kod = EQ_NUM;\r
// Left = Right = 0;\r
- if(str[1]==0 && str[0]>='a' && str[0]<='z') // äîñòóïíûå ïåðåìííûå\r
+ if(str[1]==0 && str[0]>='a' && str[0]<='z') // ��������� ���������\r
{ Kod=EQ_A; Res = str[0]-'a'; }\r
else if(!strcmp(str,"rnd")) Kod=EQ_RND;\r
else if(!strcmp(str,"pi")) Res=M_PI;\r
else if(str[0]=='i') Res = dual(0,atof(str+1));\r
- else Res=atof(str); // ýòî ÷èñëî\r
+ else Res=atof(str); // ��� �����\r
}\r
else\r
{\r
#include <math.h>
#include <wchar.h>
#include "mgl/parser.h"
-#ifndef NO_GSL
+#if MGL_HAVE_GSL
#include <gsl/gsl_sf.h>
#include <gsl/gsl_errno.h>
#endif
// NOTE: the speed is not a goal (mglFormula is faster). It is true interpreter!
mglData mglFormulaCalc(const wchar_t *string, mglParser *arg)
{
-#ifndef NO_GSL
+#if MGL_HAVE_GSL
gsl_set_error_handler_off();
#endif
mglData res;
else if(!wcscmp(name+1,L"bs"))
{ res=mglFormulaCalc(Buf, arg);
for(i=0;i<res.nx*res.ny*res.nz;i++) res.a[i] = fabs(res.a[i]); }
-#ifndef NO_GSL
+#if MGL_HAVE_GSL
else if(!wcscmp(name+1,L"i"))
{ res=mglFormulaCalc(Buf, arg);
for(i=0;i<res.nx*res.ny*res.nz;i++)
else if(!wcscmp(name+1,L"osh") || !wcscmp(name+1,L"h"))
{ res=mglFormulaCalc(Buf, arg);
for(i=0;i<res.nx*res.ny*res.nz;i++) res.a[i] = cosh(res.a[i]); }
-#ifndef NO_GSL
+#if MGL_HAVE_GSL
else if(!wcscmp(name+1,L"i"))
{ res=mglFormulaCalc(Buf, arg);
for(i=0;i<res.nx*res.ny*res.nz;i++)
if(!wcscmp(name+1,L"xp"))
{ res=mglFormulaCalc(Buf, arg);
for(i=0;i<res.nx*res.ny*res.nz;i++) res.a[i] = exp(res.a[i]); }
-#ifndef NO_GSL
+#if MGL_HAVE_GSL
else if(!wcscmp(name+1,L"rf"))
{ res=mglFormulaCalc(Buf, arg);
for(i=0;i<res.nx*res.ny*res.nz;i++)
else if(!wcscmp(name+1,L"n"))
{ res=mglFormulaCalc(Buf, arg);
for(i=0;i<res.nx*res.ny*res.nz;i++) res.a[i] = log(res.a[i]); }
-#ifndef NO_GSL
+#if MGL_HAVE_GSL
else if(!wcscmp(name+1,L"i2"))
{ res=mglFormulaCalc(Buf, arg);
for(i=0;i<res.nx*res.ny*res.nz;i++)
else if(!wcscmp(name+1,L"inh") || !wcscmp(name+1,L"h"))
{ res=mglFormulaCalc(Buf, arg);
for(i=0;i<res.nx*res.ny*res.nz;i++) res.a[i] = sinh(res.a[i]); }
-#ifndef NO_GSL
+#if MGL_HAVE_GSL
else if(!wcscmp(name+1,L"i"))
{ res=mglFormulaCalc(Buf, arg);
for(i=0;i<res.nx*res.ny*res.nz;i++)
else if(!wcscmp(name+1,L"int"))
{ res=mglFormulaCalc(Buf, arg);
for(i=0;i<res.nx*res.ny*res.nz;i++) res.a[i] = floor(res.a[i]); }
-#ifndef NO_GSL
+#if MGL_HAVE_GSL
else if(!wcscmp(name,L"i"))
{
n=mglFindInText(Buf,",");
#include <time.h>
#include <zlib.h>
#include <stdarg.h>
-#ifndef NO_PNG
#include <png.h>
-#endif
-#ifdef HAVE_JPEG
+
+#include "mgl/canvas.h"
+#include "mgl/canvas_cf.h"
+
+#if MGL_HAVE_JPEG
extern "C" {
#include <jpeglib.h>
}
#endif
-
-#include "mgl/canvas.h"
-#include "mgl/canvas_cf.h"
//-----------------------------------------------------------------------------
int mgl_pnga_save(const char *fname, int w, int h, unsigned char **p)
{
-#ifndef NO_PNG
FILE *fp = fopen(fname, "wb");
if (!fp) return 1;
png_destroy_write_struct(&png_ptr, &info_ptr);
fclose(fp);
return 0;
-#else
- return 1;
-#endif
}
//-----------------------------------------------------------------------------
int mgl_png_save(const char *fname, int w, int h, unsigned char **p)
{
-#ifndef NO_PNG
FILE *fp = fopen(fname, "wb");
if (!fp) return 1;
png_destroy_write_struct(&png_ptr, &info_ptr);
fclose(fp);
return 0;
-#else
- return 1;
-#endif
}
//-----------------------------------------------------------------------------
int mgl_bmp_save(const char *fname, int w, int h, unsigned char **p)
//-----------------------------------------------------------------------------
int mgl_jpeg_save(const char *fname, int w, int h, unsigned char **p)
{
-#ifdef HAVE_JPEG
+#if MGL_HAVE_JPEG
struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr jerr;
FILE * outfile;
//-----------------------------------------------------------------------------
int mgl_gif_save(const char *fname, int w, int h, unsigned char **l)
{
-#ifdef HAVE_GIF
+#if MGL_HAVE_GIF
GifFileType *fg = EGifOpenFileName(fname, 0);
// define colormap
GifColorType col[256];
//-----------------------------------------------------------------------------
void mglCanvas::StartGIF(const char *fname, int ms)
{
-#ifdef HAVE_GIF
+#if MGL_HAVE_GIF
if(gif) EGifCloseFile(gif);
EGifSetGifVersion("89a");
std::string fn=fname;
//-----------------------------------------------------------------------------
void mglCanvas::CloseGIF()
{
-#ifdef HAVE_GIF
+#if MGL_HAVE_GIF
if(gif) EGifCloseFile(gif);
#endif
gif = 0;
//-----------------------------------------------------------------------------
void mglCanvas::EndFrame()
{
-#ifdef HAVE_GIF
+#if MGL_HAVE_GIF
long width, height, n;
unsigned char *f=0, **l=0;
l = GetRGBLines(width, height, f);
* Free Software Foundation, Inc., *\r
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *\r
***************************************************************************/\r
-#ifndef NO_GSL\r
-#include <gsl/gsl_multifit_nlin.h>\r
-#include <gsl/gsl_blas.h>\r
-#endif\r
#include <ctype.h>\r
#include "mgl/fit.h"\r
#include "mgl/eval.h"\r
#include "mgl/data.h"\r
+\r
+#if MGL_HAVE_GSL\r
+#include <gsl/gsl_multifit_nlin.h>\r
+#include <gsl/gsl_blas.h>\r
+#endif\r
//-----------------------------------------------------------------------------\r
int mglFitPnts=100; ///< Number of output points in fitting\r
char mglFitRes[1024]; ///< Last fitted formula\r
const char *var; ///< variables for fitting\r
};\r
//-----------------------------------------------------------------------------\r
-#ifndef NO_GSL\r
+#if MGL_HAVE_GSL\r
int mgl_fit__f (const gsl_vector *x, void *data, gsl_vector *f)\r
{\r
mglFitData *fd = (mglFitData *)data;\r
/// GSL based fitting procedure for formula/arguments specified by string\r
mreal mgl_fit_base(mglFitData *fd, mreal *ini)\r
{\r
-#ifndef NO_GSL\r
+#if MGL_HAVE_GSL\r
register long i,m=fd->m,n=fd->n,iter=0;\r
if(n<1 || fd==0 || ini==0) return -1;\r
// setup data\r
#include <complex>\r
#define dual std::complex<double>\r
#define GAMMA 0.1\r
-#ifndef NO_GSL\r
+#if MGL_HAVE_GSL\r
#include <gsl/gsl_fft_complex.h>\r
#endif\r
//-----------------------------------------------------------------------------\r
if(ini_im->GetNx()*ini_im->GetNy() != nx*ny)// Wrong dimensions\r
{ gr->SetWarn(mglWarnDim,"PDE"); return res; }\r
mgl_data_create(res, nz, nx, ny);\r
-#ifndef NO_GSL\r
+#if MGL_HAVE_GSL\r
mglFormula eqs(ham);\r
dual *a = new dual[4*nx*ny], hh0; // Add "damping" area\r
dual *hxy = new dual[4*nx*ny], *hxv = new dual[4*nx*ny];\r
int nt = int(tmax/dt)+1;\r
mgl_data_create(res,7,nt,1);\r
mgl_data_set_id(res,"xyzpqvt");\r
-#ifndef NO_GSL\r
+#if MGL_HAVE_GSL\r
mreal x[6], k1[6], k2[6], k3[6], hh=dt/2;\r
mglFormula eqs(ham);\r
// initial conditions\r
int nx=ini_re->GetNx(), nt=ray->ny;\r
if(nx<2 || ini_im->GetNx()!=nx || nt<2) return res;\r
mgl_data_create(res,nx,nt,1);\r
-#ifndef NO_GSL\r
+#if MGL_HAVE_GSL\r
dual *a=new dual[2*nx], *hu=new dual[2*nx], *hx=new dual[2*nx], h0;\r
double *ru=new double[2*nx], *rx=new double[2*nx], *dmp=new double[2*nx],\r
*pu=new double[2*nx], *px=new double[2*nx];\r
void mglStartThread(void (mglCanvas::*func)(unsigned long i, unsigned long n, const void *p), mglCanvas *gr, unsigned long n, const void *p=NULL)\r
{\r
if(!func || !gr) return;\r
-#ifdef HAVE_PTHREAD\r
+#if MGL_HAVE_PTHREAD\r
if(mglNumThr<1) mgl_set_num_thr(0);\r
if(mglNumThr>1)\r
{\r
mglStartThread(&mglCanvas::pxl_other,this,Width*Height,gr);\r
}\r
//-----------------------------------------------------------------------------\r
-#ifndef HAVE_MPI\r
+#if !defined(MGL_HAVE_MPI) || MGL_HAVE_MPI==0\r
void mglCanvas::MPI_Send(int /*id*/) {} // TODO: add later\r
void mglCanvas::MPI_Recv(int /*id*/) {} // TODO: add later\r
#endif\r
mglPnt p=q;\r
float ss=fabs(size)*0.35*font_factor;\r
register long i,j;\r
-#ifdef HAVE_PTHREAD\r
+#if MGL_HAVE_PTHREAD\r
pthread_mutex_lock(&mutexPnt);\r
#endif\r
if(type=='.' || ss==0) pnt_draw(k,d);\r
PDef = pd; PenWidth = pw;\r
Pnt.erase(Pnt.begin()+pos,Pnt.end());\r
}\r
-#ifdef HAVE_PTHREAD\r
+#if MGL_HAVE_PTHREAD\r
pthread_mutex_unlock(&mutexPnt);\r
#endif\r
}\r
{\r
mglPnt p=Pnt[P->n1];\r
float f = p.w;\r
-#ifdef HAVE_PTHREAD\r
+#if MGL_HAVE_PTHREAD\r
pthread_mutex_lock(&mutexPnt);\r
#endif\r
Push(); B.clear();\r
glyph_wire(p,f,fnt->GetNl(ss,P->n4),fnt->GetLn(ss,P->n4), d);\r
}\r
Pop();\r
-#ifdef HAVE_PTHREAD\r
+#if MGL_HAVE_PTHREAD\r
pthread_mutex_unlock(&mutexPnt);\r
#endif\r
}\r
+ 2.6 2D data plotting
+ 2.7 3D data plotting
2.8 Dual data plotting
- 2.9 More samples
- 2.10 Hints
- 2.12 FAQ
+ 2.9 Hints
+ 2.10 FAQ
+ 3. General concepts (class-diagram)
+ 3.1 Coordinate axes
newCmdDlg->show();
}
//-----------------------------------------------------------------------------
-#ifndef HAVE_HDF5
+#if MGL_HAVE_HDF5==0
void TextPanel::saveHDF5(const QString &fileName){}
void TextPanel::loadHDF5(const QString &fileName){}
//-----------------------------------------------------------------------------
if(arg[i][0]!='-' && j<0) j=i;
}
mgl_ask_func = mgl_ask_gets;
-#if defined(HAVE_QT)
+#if MGL_HAVE_QT
int kind=1; mgl_ask_func = mgl_ask_qt;
-#elif defined(HAVE_FLTK)
+#else
int kind=0; mgl_ask_func = mgl_ask_fltk;
#endif
bool mgld=(j>0 && arg[j][strlen(arg[j])]=='d');
while(!feof(fp)) str.push_back(fgetwc(fp));
if(j>0) fclose(fp);
}
-#if defined(HAVE_FLTK) || defined(HAVE_QT)
mglWindow gr(mgld?NULL:show, j>0?arg[j]:"mglview", kind);
if(mgld)
{ gr.ImportMGLD(arg[j]); gr.Update(); }
gr.Run();
-#endif
return 0;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------\r
mglCanvasGLUT::mglCanvasGLUT() : mglCanvasGL() {}\r
//-----------------------------------------------------------------------------\r
-#ifdef HAVE_FLTK\r
+#if MGL_HAVE_FLTK\r
HMGL mgl_create_graph_fltk(int (*)(HMGL gr, void *p), const char *, void *)\r
{ return NULL; }\r
int mgl_fltk_run(){return 0;}\r
#endif\r
//-----------------------------------------------------------------------------\r
-#ifdef HAVE_QT\r
+#if MGL_HAVE_QT\r
HMGL mgl_create_graph_qt(int (*)(HMGL gr, void *p), const char *, void *)\r
{ return NULL; }\r
int mgl_qt_run(){return 0;}\r
{ mglCanvasW *g = dynamic_cast<mglCanvasW *>((HMGL)(*gr));\r
if(g) g->Animation(); }\r
//-----------------------------------------------------------------------------\r
-#ifndef HAVE_FLTK\r
+#if MGL_HAVE_FLTK==0\r
HMGL mgl_create_graph_fltk(int (*)(HMGL gr, void *p), const char *, void *)\r
{ return NULL; }\r
int mgl_fltk_run(){return 0;}\r
}\r
int mgl_fltk_run_() { return mgl_fltk_run(); }\r
//-----------------------------------------------------------------------------\r
-#ifndef HAVE_QT\r
+#if MGL_HAVE_QT==0\r
HMGL mgl_create_graph_qt(int (*)(HMGL gr, void *p), const char *, void *)\r
{ return NULL; }\r
int mgl_qt_run(){return 0;}\r
//-----------------------------------------------------------------------------\r
void *mgl_draw_calc(void *p)\r
{\r
-#ifdef HAVE_PTHREAD\r
+#if MGL_HAVE_PTHREAD\r
((mglDraw *)p)->Calc();\r
#endif\r
return 0;\r
//-----------------------------------------------------------------------------\r
void mgl_draw_thr(void *p)\r
{\r
-#ifdef HAVE_PTHREAD\r
+#if MGL_HAVE_PTHREAD\r
mglDraw *d = (mglDraw *)p;\r
if(!d || d->running) return;\r
pthread_create(&(d->thr),0,mgl_draw_calc,d);\r
projects / mathgl.git / commitdiff