set(MGL_HAVE_JPEG 0)
endif(enable-all OR enable-jpeg)
-if((enable-all OR enable-u3d OR enable-pdf) AND (NOT enable-lgpl) )
+#if((enable-all OR enable-u3d OR enable-pdf) AND (NOT enable-lgpl) )
+if((enable-u3d OR enable-pdf) AND (NOT enable-lgpl) )
set(MGL_HAVE_U3D 1)
find_library(U3D_LIB IDTF)
if(NOT U3D_LIB)
endif(NOT U3D_INCLUDE_DIR)
message(STATUS "Found U3D libraries at: ${U3D_LIB}")
message(STATUS "Found U3D headers: ${U3D_INCLUDE_DIR}")
+#else((enable-u3d OR enable-pdf) AND (NOT enable-lgpl) )
else((enable-all OR enable-u3d OR enable-pdf) AND (NOT enable-lgpl) )
set(MGL_HAVE_U3D 0)
-endif((enable-all OR enable-u3d OR enable-pdf) AND (NOT enable-lgpl) )
+#endif((enable-u3d OR enable-pdf) AND (NOT enable-lgpl) )
+endif((enable-u3d OR enable-pdf) AND (NOT enable-lgpl) )
-if((enable-all OR enable-pdf) AND (NOT enable-lgpl) )
+#if((enable-all OR enable-pdf) AND (NOT enable-lgpl) )
+if((enable-pdf) AND (NOT enable-lgpl) )
set(MGL_HAVE_PDF 1)
find_library(HPDF_LIB hpdf)
if(NOT HPDF_LIB)
endif(NOT HPDF_INCLUDE_DIR)
message(STATUS "Found libHaru library at: ${HPDF_LIB}")
message(STATUS "Found libHaru headers: ${HPDF_INCLUDE_DIR}")
-else((enable-all OR enable-pdf) AND (NOT enable-lgpl) )
+#else((enable-all OR enable-pdf) AND (NOT enable-lgpl) )
+else((enable-pdf) AND (NOT enable-lgpl) )
set(MGL_HAVE_PDF 0)
-endif((enable-all OR enable-pdf) AND (NOT enable-lgpl) )
+#endif((enable-all OR enable-pdf) AND (NOT enable-lgpl) )
+endif((enable-pdf) AND (NOT enable-lgpl) )
if(enable-all OR enable-gif)
set(MGL_HAVE_GIF 1)
void mgl_rotate_vector_(uintptr_t *graph, float *Tet,float *x,float *y,float *z);\r
void mgl_perspective_(uintptr_t *graph, float val);\r
/*****************************************************************************/\r
-int mgl_fortran_func(HMGL gr, void *);\r
-HMGL mgl_create_graph_qt(int (*draw)(HMGL gr, void *p), const char *title, void *par);\r
-HMGL mgl_create_graph_fltk(int (*draw)(HMGL gr, void *p), const char *title, void *par);\r
+HMGL mgl_create_graph_qt(int (*draw)(HMGL gr, void *p), const char *title, void *par, void (*load)(void *p));\r
+HMGL mgl_create_graph_fltk(int (*draw)(HMGL gr, void *p), const char *title, void *par, void (*load)(void *p));\r
int mgl_fltk_run();\r
+int mgl_fltk_thr();\r
int mgl_qt_run();\r
/*****************************************************************************/\r
uintptr_t mgl_create_graph_qt_(const char *title, int);\r
--- /dev/null
+/***************************************************************************\r
+ * window.h 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
+//-----------------------------------------------------------------------------\r
+#ifndef _MGL_CANVAS_WND_H_\r
+#define _MGL_CANVAS_WND_H_\r
+/*****************************************************************************/\r
+#include "mgl/window.h"\r
+//-----------------------------------------------------------------------------\r
+/// Base class for windows containing MathGL graphics\r
+class mglCanvasWnd : public mglCanvas\r
+{\r
+public:\r
+ mglCanvasWnd();\r
+ virtual ~mglCanvasWnd();\r
+\r
+ void SetSize(int w,int h);\r
+ void EndFrame();\r
+ const unsigned char *GetBits();\r
+ inline int GetNumFig() { return NumFig; }\r
+ inline int GetCurFig() { return CurFig; }\r
+ void SetCurFig(int c);\r
+ void ClearFrames();\r
+ inline mglPoint GetMousePos() { return LastMousePos;}\r
+ inline void SetMousePos(mglPoint p) { LastMousePos=p; }\r
+ inline void Setup(bool clf_upd=true, bool showpos=false)\r
+ { set(showpos,MGL_SHOW_POS); set(clf_upd,MGL_CLF_ON_UPD); }\r
+\r
+ virtual void ToggleAlpha()=0; ///< Switch on/off transparency (do not overwrite user settings)\r
+ virtual void ToggleLight()=0; ///< Switch on/off lighting (do not overwrite user settings)\r
+ virtual void ToggleZoom()=0; ///< Switch on/off zooming by mouse\r
+ virtual void ToggleRotate()=0; ///< Switch on/off rotation by mouse\r
+ virtual void ToggleNo()=0; ///< Switch off all zooming and rotation\r
+ virtual void Update()=0; ///< Update picture by calling user drawing function\r
+ virtual void Adjust()=0; ///< Adjust size of bitmap to window size\r
+ virtual void GotoFrame(int d)=0;///< Show arbitrary frame (use relative step)\r
+ virtual void NextFrame() {GotoFrame(+1);} ///< Show next frame (if one)\r
+ virtual void PrevFrame() {GotoFrame(-1);} ///< Show previous frame (if one)\r
+ virtual void Animation()=0; ///< Run slideshow (animation) of frames\r
+ void ReLoad(); ///< Reload user data and update picture\r
+ /// Create a window for plotting based on callback function (can be NULL).\r
+ virtual void Window(int argc, char **argv, int (*draw)(mglBase *gr, void *p),\r
+ const char *title, void *par=NULL,\r
+ void (*reload)(void *p)=NULL, bool maximize=false)=0;\r
+ void SetDrawFunc(int (*draw)(mglBase *gr, void *p), void *par=NULL, void (*reload)(void *p)=NULL);\r
+\r
+private:\r
+ mglPoint LastMousePos; ///< Last mouse position\r
+ int CurFig; ///< Current figure in the list.\r
+\r
+ unsigned char *GG; ///< images for all frames (may be too LARGE !!!)\r
+ int NumFig; ///< Number of figures in the list. If 0 then no list and mglCanvas::DrawFunc will called for each drawing.\r
+ void (*LoadFunc)(void *par);\r
+ void *FuncPar; ///< Parameters for drawing function mglCanvas::DrawFunc.\r
+ /// Drawing function for window procedure. It should return the number of frames.\r
+ int (*DrawFunc)(mglBase *gr, void *par);\r
+};\r
+//-----------------------------------------------------------------------------\r
+#endif\r
#define _MGL_DATA_H_\r
/*****************************************************************************/\r
#include "mgl/base.h"\r
-/*****************************************************************************/\r
-#if MGL_HAVE_GSL\r
-#include <gsl/gsl_vector.h>\r
-#include <gsl/gsl_matrix.h>\r
-#else\r
-struct gsl_vector;\r
-struct gsl_matrix;\r
-#endif\r
-/*****************************************************************************/\r
+#include "mgl/data_cf.h"\r
#ifdef __cplusplus\r
-extern "C" {\r
-#endif\r
-/*****************************************************************************/\r
-void mgl_srnd(long seed);\r
-double mgl_rnd();\r
-double mgl_ipow(double x,int n);\r
-/*****************************************************************************/\r
-HMDT mgl_create_data();\r
-HMDT mgl_create_data_size(long nx, long ny, long nz);\r
-HMDT mgl_create_data_file(const char *fname);\r
-void mgl_delete_data(HMDT dat);\r
-const char *mgl_data_info(HCDT dat);\r
-/*****************************************************************************/\r
-uintptr_t mgl_create_data_();\r
-uintptr_t mgl_create_data_size_(int *nx, int *ny, int *nz);\r
-uintptr_t mgl_create_data_file_(const char *fname, int len);\r
-void mgl_delete_data_(uintptr_t *dat);\r
-/*****************************************************************************/\r
-/* Data creation functions */\r
-/*****************************************************************************/\r
-void mgl_data_rearrange(HMDT dat, long mx,long my,long mz);\r
-void mgl_data_link(HMDT dat, mreal *A,long mx,long my,long mz);\r
-void mgl_data_set_float(HMDT dat, const float *A,long mx,long my,long mz);\r
-void mgl_data_set_double(HMDT dat, const double *A,long mx,long my,long mz);\r
-void mgl_data_set_float2(HMDT d, const float **A,long N1,long N2);\r
-void mgl_data_set_double2(HMDT d, const double **A,long N1,long N2);\r
-void mgl_data_set_float3(HMDT d, const float ***A,long N1,long N2,long N3);\r
-void mgl_data_set_double3(HMDT d, const double ***A,long N1,long N2,long N3);\r
-void mgl_data_set(HMDT dat, HCDT a);\r
-void mgl_data_set_vector(HMDT dat, gsl_vector *v);\r
-void mgl_data_set_matrix(HMDT dat, gsl_matrix *m);\r
-void mgl_data_set_value(HMDT dat, float v, long i, long j, long k);\r
-float mgl_data_get_value(HCDT dat, long i, long j, long k);\r
-void mgl_data_set_values(HMDT dat, const char *val, long nx, long ny, long nz);\r
-\r
-int mgl_data_read_hdf(HMDT d,const char *fname,const char *data);\r
-void mgl_data_save_hdf(HCDT d,const char *fname,const char *data,int rewrite);\r
-int mgl_datas_hdf(const char *fname, char *buf, long size);\r
-int mgl_data_read(HMDT dat, const char *fname);\r
-int mgl_data_read_mat(HMDT dat, const char *fname, long dim);\r
-int mgl_data_read_dim(HMDT dat, const char *fname,long mx,long my,long mz);\r
-int mgl_data_read_range(HMDT d, const char *templ, double from, double to, double step, int as_slice);\r
-int mgl_data_read_all(HMDT dat, const char *templ, int as_slice);\r
-void mgl_data_save(HCDT dat, const char *fname,long ns);\r
-void mgl_data_export(HCDT dat, const char *fname, const char *scheme,float v1,float v2,long ns);\r
-void mgl_data_import(HMDT dat, const char *fname, const char *scheme,float v1,float v2);\r
-\r
-void mgl_data_create(HMDT dat, long nx,long ny,long nz);\r
-void mgl_data_transpose(HMDT dat, const char *dim);\r
-void mgl_data_norm(HMDT dat, float v1,float v2,long sym,long dim);\r
-void mgl_data_norm_slice(HMDT dat, float v1,float v2,char dir,long keep_en,long sym);\r
-HMDT mgl_data_subdata(HCDT dat, long xx,long yy,long zz);\r
-HMDT mgl_data_subdata_ext(HCDT dat, HCDT xx, HCDT yy, HCDT zz);\r
-HMDT mgl_data_column(HCDT dat, const char *eq);\r
-void mgl_data_set_id(HMDT d, const char *id);\r
-void mgl_data_fill(HMDT dat, float x1,float x2,char dir);\r
-void mgl_data_fill_eq(HMGL gr, HMDT dat, const char *eq, HCDT vdat, HCDT wdat,const char *opt);\r
-void mgl_data_put_val(HMDT dat, mreal val, long i, long j, long k);\r
-void mgl_data_put_dat(HMDT dat, HCDT val, long i, long j, long k);\r
-void mgl_data_modify(HMDT dat, const char *eq,long dim);\r
-void mgl_data_modify_vw(HMDT dat, const char *eq,HCDT vdat,HCDT wdat);\r
-void mgl_data_squeeze(HMDT dat, long rx,long ry,long rz,long smooth);\r
-float mgl_data_max(HCDT dat);\r
-float mgl_data_min(HCDT dat);\r
-float *mgl_data_value(HMDT dat, long i,long j,long k);\r
-mreal *mgl_data_data(HMDT dat);\r
-\r
-float mgl_data_first(HCDT dat, const char *cond, long *i, long *j, long *k);\r
-float mgl_data_last(HCDT dat, const char *cond, long *i, long *j, long *k);\r
-long mgl_data_find(HCDT dat, const char *cond, char dir, long i, long j, long k);\r
-int mgl_data_find_any(HCDT dat, const char *cond);\r
-float mgl_data_max_int(HCDT dat, long *i, long *j, long *k);\r
-float mgl_data_max_real(HCDT dat, mreal *x, mreal *y, mreal *z);\r
-float mgl_data_min_int(HCDT dat, long *i, long *j, long *k);\r
-float mgl_data_min_real(HCDT dat, mreal *x, mreal *y, mreal *z);\r
-float mgl_data_momentum_val(HCDT d, char dir, mreal *m, mreal *w, mreal *s, mreal *k);\r
-\r
-HMDT mgl_data_combine(HCDT dat1, HCDT dat2);\r
-void mgl_data_extend(HMDT dat, long n1, long n2);\r
-void mgl_data_insert(HMDT dat, char dir, long at, long num);\r
-void mgl_data_delete(HMDT dat, char dir, long at, long num);\r
-/*****************************************************************************/\r
-/* Data manipulation functions */\r
-/*****************************************************************************/\r
-void mgl_data_smooth(HMDT d, const char *dirs, float delta);\r
-HMDT mgl_data_sum(HCDT dat, const char *dir);\r
-HMDT mgl_data_max_dir(HCDT dat, const char *dir);\r
-HMDT mgl_data_min_dir(HCDT dat, const char *dir);\r
-void mgl_data_cumsum(HMDT dat, const char *dir);\r
-void mgl_data_integral(HMDT dat, const char *dir);\r
-void mgl_data_diff(HMDT dat, const char *dir);\r
-void mgl_data_diff_par(HMDT dat, HCDT v1, HCDT v2, HCDT v3);\r
-void mgl_data_diff2(HMDT dat, const char *dir);\r
-void mgl_data_swap(HMDT dat, const char *dir);\r
-void mgl_data_roll(HMDT dat, char dir, long num);\r
-void mgl_data_mirror(HMDT dat, const char *dir);\r
-void mgl_data_sort(HMDT dat, long idx, long idy);\r
-\r
-void mgl_data_hankel(HMDT dat, const char *dir);\r
-void mgl_data_sinfft(HMDT dat, const char *dir);\r
-void mgl_data_cosfft(HMDT dat, const char *dir);\r
-void mgl_data_fill_sample(HMDT dat, const char *how);\r
-\r
-float mgl_data_spline(HCDT dat, float x,float y,float z);\r
-float mgl_data_linear(HCDT dat, float x,float y,float z);\r
-HMDT mgl_data_trace(HCDT d);\r
-HMDT mgl_data_resize(HCDT dat, long mx,long my,long mz);\r
-HMDT mgl_data_resize_box(HCDT dat, long mx,long my,long mz,float x1,float x2,float y1,float y2,float z1,float z2);\r
-HMDT mgl_data_hist(HCDT dat, long n, float v1, float v2, long nsub);\r
-HMDT mgl_data_hist_w(HCDT dat, HCDT weight, long n, float v1, float v2, long nsub);\r
-HMDT mgl_data_momentum(HCDT dat, char dir, const char *how);\r
-HMDT mgl_data_evaluate(HCDT dat, HCDT idat, HCDT jdat, HCDT kdat, int norm);\r
-void mgl_data_envelop(HMDT dat, char dir);\r
-void mgl_data_sew(HMDT dat, const char *dirs, float da);\r
-void mgl_data_crop(HMDT dat, long n1, long n2, char dir);\r
-/*****************************************************************************/\r
-/* Data operations */\r
-/*****************************************************************************/\r
-void mgl_data_mul_dat(HMDT dat, HCDT d);\r
-void mgl_data_div_dat(HMDT dat, HCDT d);\r
-void mgl_data_add_dat(HMDT dat, HCDT d);\r
-void mgl_data_sub_dat(HMDT dat, HCDT d);\r
-void mgl_data_mul_num(HMDT dat, float d);\r
-void mgl_data_div_num(HMDT dat, float d);\r
-void mgl_data_add_num(HMDT dat, float d);\r
-void mgl_data_sub_num(HMDT dat, float d);\r
-/*****************************************************************************/\r
-HMDT mgl_pde_solve(HMGL gr, const char *ham, HCDT ini_re, HCDT ini_im, float dz, float k0,const char *opt);\r
-HMDT mgl_qo2d_solve(const char *ham, HCDT ini_re, HCDT ini_im, HCDT ray, float r, float k0, HMDT xx, HMDT yy);\r
-HMDT mgl_ray_trace(const char *ham, float x0, float y0, float z0, float px, float py, float pz, float dt, float tmax);\r
-HMDT mgl_jacobian_2d(HCDT x, HCDT y);\r
-HMDT mgl_jacobian_3d(HCDT x, HCDT y, HCDT z);\r
-HMDT mgl_transform_a(HCDT am, HCDT ph, const char *tr);\r
-HMDT mgl_transform(HCDT re, HCDT im, const char *tr);\r
-void mgl_data_fourier(HMDT re, HMDT im, const char *dir);\r
-HMDT mgl_data_stfa(HCDT re, HCDT im, long dn, char dir);\r
-\r
-HMDT mgl_triangulation_3d(HCDT x, HCDT y, HCDT z, float er);\r
-HMDT mgl_triangulation_2d(HCDT x, HCDT y, float er);\r
-/*****************************************************************************/\r
-/* Data creation functions */\r
-/*****************************************************************************/\r
-void mgl_data_rearrange_(uintptr_t *dat, int *mx, int *my, int *mz);\r
-void mgl_data_set_float_(uintptr_t *dat, const float *A,int *NX,int *NY,int *NZ);\r
-void mgl_data_set_double_(uintptr_t *dat, const double *A,int *NX,int *NY,int *NZ);\r
-void mgl_data_set_float1_(uintptr_t *d, const float *A,int *N1);\r
-void mgl_data_set_double1_(uintptr_t *d, const double *A,int *N1);\r
-void mgl_data_set_float2_(uintptr_t *d, const float *A,int *N1,int *N2);\r
-void mgl_data_set_double2_(uintptr_t *d, const double *A,int *N1,int *N2);\r
-void mgl_data_set_float3_(uintptr_t *d, const float *A,int *N1,int *N2,int *N3);\r
-void mgl_data_set_double3_(uintptr_t *d, const double *A,int *N1,int *N2,int *N3);\r
-void mgl_data_set_(uintptr_t *dat, uintptr_t *a);\r
-\r
-void mgl_data_set_value_(uintptr_t *d, float *v, int *i, int *j, int *k);\r
-void mgl_data_set_values_(uintptr_t *d, const char *val, int *nx, int *ny, int *nz, int l);\r
-float mgl_data_get_value_(uintptr_t *d, int *i, int *j, int *k);\r
-int mgl_data_read_(uintptr_t *d, const char *fname,int l);\r
-int mgl_data_read_mat_(uintptr_t *dat, const char *fname, int *dim, int);\r
-int mgl_data_read_dim_(uintptr_t *dat, const char *fname,int *mx,int *my,int *mz,int);\r
-void mgl_data_save_(uintptr_t *dat, const char *fname,int *ns,int);\r
-void mgl_data_export_(uintptr_t *dat, const char *fname, const char *scheme,float *v1,float *v2,int *ns,int,int);\r
-void mgl_data_import_(uintptr_t *dat, const char *fname, const char *scheme,float *v1,float *v2,int,int);\r
-void mgl_data_create_(uintptr_t *dat, int *nx,int *ny,int *nz);\r
-void mgl_data_transpose_(uintptr_t *dat, const char *dim,int);\r
-void mgl_data_norm_(uintptr_t *dat, float *v1,float *v2,int *sym,int *dim);\r
-void mgl_data_norm_slice_(uintptr_t *dat, float *v1,float *v2,char *dir,int *keep_en,int *sym,int l);\r
-uintptr_t mgl_data_subdata_(uintptr_t *dat, int *xx,int *yy,int *zz);\r
-uintptr_t mgl_data_subdata_ext_(uintptr_t *dat, uintptr_t *xx,uintptr_t *yy,uintptr_t *zz);\r
-uintptr_t mgl_data_column_(uintptr_t *dat, const char *eq,int l);\r
-void mgl_data_set_id_(uintptr_t *dat, const char *id,int l);\r
-void mgl_data_fill_(uintptr_t *dat, float *x1,float *x2,const char *dir,int);\r
-void mgl_data_fill_eq_(uintptr_t *gr, uintptr_t *dat, const char *eq, uintptr_t *vdat, uintptr_t *wdat,const char *opt, int, int);\r
-void mgl_data_put_val_(uintptr_t *dat, float *val, int *i, int *j, int *k);\r
-void mgl_data_put_dat_(uintptr_t *dat, uintptr_t *val, int *i, int *j, int *k);\r
-void mgl_data_modify_(uintptr_t *dat, const char *eq,int *dim,int);\r
-void mgl_data_modify_vw_(uintptr_t *dat, const char *eq, uintptr_t *vdat, uintptr_t *wdat,int);\r
-void mgl_data_squeeze_(uintptr_t *dat, int *rx,int *ry,int *rz,int *smooth);\r
-float mgl_data_max_(uintptr_t *dat);\r
-float mgl_data_min_(uintptr_t *dat);\r
-\r
-float mgl_data_first_(uintptr_t *dat, const char *cond, int *i, int *j, int *k, int);\r
-float mgl_data_last_(uintptr_t *dat, const char *cond, int *i, int *j, int *k, int);\r
-int mgl_data_find_(uintptr_t *dat, const char *cond, char *dir, int *i, int *j, int *k, int,int);\r
-int mgl_data_find_any_(uintptr_t *dat, const char *cond, int);\r
-float mgl_data_max_int_(uintptr_t *dat, int *i, int *j, int *k);\r
-float mgl_data_max_real_(uintptr_t *dat, float *x, float *y, float *z);\r
-float mgl_data_min_int_(uintptr_t *dat, int *i, int *j, int *k);\r
-float mgl_data_min_real_(uintptr_t *dat, float *x, float *y, float *z);\r
-float mgl_data_momentum_val_(uintptr_t *dat, char *dir, float *m, float *w, float *s, float *k,int);\r
-\r
-uintptr_t mgl_data_combine_(uintptr_t *dat1, uintptr_t *dat2);\r
-void mgl_data_extend_(uintptr_t *dat, int *n1, int *n2);\r
-void mgl_data_insert_(uintptr_t *dat, const char *dir, int *at, int *num, int);\r
-void mgl_data_delete_(uintptr_t *dat, const char *dir, int *at, int *num, int);\r
-/*****************************************************************************/\r
-/* Data manipulation functions */\r
-/*****************************************************************************/\r
-void mgl_data_smooth_(uintptr_t *dat, const char *dirs, float *delta,int);\r
-uintptr_t mgl_data_sum_(uintptr_t *dat, const char *dir,int);\r
-uintptr_t mgl_data_max_dir_(uintptr_t *dat, const char *dir,int);\r
-uintptr_t mgl_data_min_dir_(uintptr_t *dat, const char *dir,int);\r
-void mgl_data_cumsum_(uintptr_t *dat, const char *dir,int);\r
-void mgl_data_integral_(uintptr_t *dat, const char *dir,int);\r
-void mgl_data_diff_(uintptr_t *dat, const char *dir,int);\r
-void mgl_data_diff_par_(uintptr_t *dat, uintptr_t *v1, uintptr_t *v2, uintptr_t *v3);\r
-void mgl_data_diff2_(uintptr_t *dat, const char *dir,int);\r
-void mgl_data_swap_(uintptr_t *dat, const char *dir,int);\r
-void mgl_data_roll_(uintptr_t *dat, const char *dir, int *num, int);\r
-void mgl_data_mirror_(uintptr_t *dat, const char *dir,int);\r
-void mgl_data_sort_(uintptr_t *dat, int *idx, int *idy);\r
-\r
-void mgl_data_hankel_(uintptr_t *dat, const char *dir,int);\r
-void mgl_data_sinfft_(uintptr_t *dat, const char *dir,int);\r
-void mgl_data_cosfft_(uintptr_t *dat, const char *dir,int);\r
-void mgl_data_fill_sample_(uintptr_t *dat, const char *how,int);\r
-\r
-float mgl_data_spline_(uintptr_t *dat, float *x,float *y,float *z);\r
-float mgl_data_linear_(uintptr_t *dat, float *x,float *y,float *z);\r
-uintptr_t mgl_data_trace_(uintptr_t *d);\r
-uintptr_t mgl_data_resize_(uintptr_t *dat, int *mx,int *my,int *mz);\r
-uintptr_t mgl_data_resize_box_(uintptr_t *dat, int *mx,int *my,int *mz,float *x1,float *x2,float *y1,float *y2,float *z1,float *z2);\r
-uintptr_t mgl_data_momentum_(uintptr_t *dat, char *dir, const char *how, int,int);\r
-uintptr_t mgl_data_hist_(uintptr_t *dat, int *n, float *v1, float *v2, int *nsub);\r
-uintptr_t mgl_data_hist_w_(uintptr_t *dat, uintptr_t *weight, int *n, float *v1, float *v2, int *nsub);\r
-uintptr_t mgl_data_evaluate_(uintptr_t *dat, uintptr_t *idat, uintptr_t *jdat, uintptr_t *kdat, int *norm);\r
-void mgl_data_envelop_(uintptr_t *dat, const char *dir, int);\r
-void mgl_data_sew_(uintptr_t *dat, const char *dirs, float *da, int);\r
-void mgl_data_crop_(uintptr_t *dat, int *n1, int *n2, const char *dir,int);\r
-/*****************************************************************************/\r
-/* Data operations */\r
-/*****************************************************************************/\r
-void mgl_data_mul_dat_(uintptr_t *dat, uintptr_t *d);\r
-void mgl_data_div_dat_(uintptr_t *dat, uintptr_t *d);\r
-void mgl_data_add_dat_(uintptr_t *dat, uintptr_t *d);\r
-void mgl_data_sub_dat_(uintptr_t *dat, uintptr_t *d);\r
-void mgl_data_mul_num_(uintptr_t *dat, float *d);\r
-void mgl_data_div_num_(uintptr_t *dat, float *d);\r
-void mgl_data_add_num_(uintptr_t *dat, float *d);\r
-void mgl_data_sub_num_(uintptr_t *dat, float *d);\r
-/*****************************************************************************/\r
-/* Nonlinear fitting */\r
-/*****************************************************************************/\r
-uintptr_t mgl_pde_solve_(uintptr_t* gr, const char *ham, uintptr_t* ini_re, uintptr_t* ini_im, float *dz, float *k0,const char *opt,int,int);\r
-uintptr_t mgl_qo2d_solve_(const char *ham, uintptr_t* ini_re, uintptr_t* ini_im, uintptr_t* ray, float *r, float *k0, uintptr_t* xx, uintptr_t* yy, int);\r
-uintptr_t mgl_ray_trace_(const char *ham, float *x0, float *y0, float *z0, float *px, float *py, float *pz, float *dt, float *tmax,int);\r
-uintptr_t mgl_jacobian_2d_(uintptr_t* x, uintptr_t* y);\r
-uintptr_t mgl_jacobian_3d_(uintptr_t* x, uintptr_t* y, uintptr_t* z);\r
-\r
-uintptr_t mgl_transform_a_(uintptr_t *am, uintptr_t *ph, const char *tr, int);\r
-uintptr_t mgl_transform_(uintptr_t *re, uintptr_t *im, const char *tr, int);\r
-void mgl_data_fourier_(uintptr_t *re, uintptr_t *im, const char *dir, int l);\r
-uintptr_t mgl_data_stfa_(uintptr_t *re, uintptr_t *im, int *dn, char *dir, int);\r
-\r
-uintptr_t mgl_triangulation_3d_(uintptr_t *x, uintptr_t *y, uintptr_t *z, float *er);\r
-uintptr_t mgl_triangulation_2d_(uintptr_t *x, uintptr_t *y, float *er);\r
-/*****************************************************************************/\r
-int mgl_data_read_hdf_(uintptr_t *d, const char *fname, const char *data,int l,int n);\r
-void mgl_data_link_(uintptr_t *d, float *A, int *nx,int *ny,int *nz);\r
-void mgl_data_save_hdf_(uintptr_t *d, const char *fname, const char *data, int *rewrite,int l,int n);\r
-int mgl_data_read_range_(uintptr_t *d, const char *fname, double *from, double *to, double *step, int *as_slice,int l);\r
-int mgl_data_read_all_(uintptr_t *d, const char *fname, int *as_slice,int l);\r
-\r
-/*****************************************************************************/\r
-#ifdef __cplusplus\r
-}\r
//-----------------------------------------------------------------------------\r
#include <vector>\r
//-----------------------------------------------------------------------------\r
inline void Fill(mglBase *gr, const char *eq, const mglData &vdat, const mglData &wdat,const char *opt="")\r
{ mgl_data_fill_eq(gr,this,eq,&vdat,&wdat,opt); }\r
/// Eqidistantly fill the data to range [x1,x2] in direction \a dir\r
- inline void Fill(mreal x1,mreal x2=NAN,char dir='x')\r
+ inline void Fill(mreal x1,mreal x2=NaN,char dir='x')\r
{ return mgl_data_fill(this,x1,x2,dir); }\r
/// Put value to data element(s)\r
inline void Put(mreal val, long i=-1, long j=-1, long k=-1)\r
inline void Envelop(char dir='x')\r
{ mgl_data_envelop(this,dir); }\r
/// Remove phase jump\r
- inline void Sew(const char *dirs="xyz", mreal da=2*M_PI)\r
+ inline void Sew(const char *dirs="xyz", mreal da=2*Pi)\r
{ mgl_data_sew(this,dirs,da); }\r
/// Smooth the data on specified direction or directions\r
inline void Smooth(const char *dirs="xyz",mreal delta=0)\r
inline void operator+=(mreal d) { mgl_data_add_num(this,d); }\r
/// Substract the number\r
inline void operator-=(mreal d) { mgl_data_sub_num(this,d); }\r
+#ifndef SWIG\r
/// Direct access to the data cell\r
inline mreal &operator[](long i) { return a[i]; }\r
// NOTE see 13.10 for operator(), operator[] -- m.b. I should add it ???\r
+#endif\r
protected:\r
/// Get the value in given cell of the data without border checking\r
inline mreal v(long i,long j=0,long k=0) const\r
return k>0? (k<nz-1? (a[i0+n]-a[i0-n])/2:a[i0]-a[i0-n]) : a[i0+n]-a[i0]; }\r
};\r
//-----------------------------------------------------------------------------\r
+#ifndef SWIG\r
inline mglData operator*(const mglData &b, const mglData &d)\r
{ mglData a(b); a*=d; return a; }\r
inline mglData operator*(mreal b, const mglData &d)\r
inline bool operator==(const mglData &b, const mglData &d)\r
{ if(b.nx!=d.nx || b.ny!=d.ny || b.ny!=d.ny) return false;\r
return !memcmp(b.a,d.a,b.nx*b.ny*b.nz*sizeof(mreal)); }\r
+#endif\r
//-----------------------------------------------------------------------------\r
mreal mglLinear(const mreal *a, long nx, long ny, long nz, mreal x, mreal y, mreal z);\r
mreal mglSpline3(const mreal *a, long nx, long ny, long nz, mreal x, mreal y, mreal z,mreal *dx=0, mreal *dy=0, mreal *dz=0);\r
--- /dev/null
+/***************************************************************************\r
+ * data_cf.h 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
+#ifndef _MGL_DATA_CF_H_\r
+#define _MGL_DATA_CF_H_\r
+/*****************************************************************************/\r
+#include "mgl/base.h"\r
+/*****************************************************************************/\r
+#if MGL_HAVE_GSL\r
+#include <gsl/gsl_vector.h>\r
+#include <gsl/gsl_matrix.h>\r
+#else\r
+struct gsl_vector;\r
+struct gsl_matrix;\r
+#endif\r
+/*****************************************************************************/\r
+#ifdef __cplusplus\r
+extern "C" {\r
+#endif\r
+/*****************************************************************************/\r
+void mgl_srnd(long seed);\r
+double mgl_rnd();\r
+double mgl_ipow(double x,int n);\r
+/*****************************************************************************/\r
+HMDT mgl_create_data();\r
+HMDT mgl_create_data_size(long nx, long ny, long nz);\r
+HMDT mgl_create_data_file(const char *fname);\r
+void mgl_delete_data(HMDT dat);\r
+const char *mgl_data_info(HCDT dat);\r
+/*****************************************************************************/\r
+uintptr_t mgl_create_data_();\r
+uintptr_t mgl_create_data_size_(int *nx, int *ny, int *nz);\r
+uintptr_t mgl_create_data_file_(const char *fname, int len);\r
+void mgl_delete_data_(uintptr_t *dat);\r
+/*****************************************************************************/\r
+/* Data creation functions */\r
+/*****************************************************************************/\r
+void mgl_data_rearrange(HMDT dat, long mx,long my,long mz);\r
+void mgl_data_link(HMDT dat, mreal *A,long mx,long my,long mz);\r
+void mgl_data_set_float(HMDT dat, const float *A,long mx,long my,long mz);\r
+void mgl_data_set_double(HMDT dat, const double *A,long mx,long my,long mz);\r
+void mgl_data_set_float2(HMDT d, const float **A,long N1,long N2);\r
+void mgl_data_set_double2(HMDT d, const double **A,long N1,long N2);\r
+void mgl_data_set_float3(HMDT d, const float ***A,long N1,long N2,long N3);\r
+void mgl_data_set_double3(HMDT d, const double ***A,long N1,long N2,long N3);\r
+void mgl_data_set(HMDT dat, HCDT a);\r
+void mgl_data_set_vector(HMDT dat, gsl_vector *v);\r
+void mgl_data_set_matrix(HMDT dat, gsl_matrix *m);\r
+void mgl_data_set_value(HMDT dat, float v, long i, long j, long k);\r
+float mgl_data_get_value(HCDT dat, long i, long j, long k);\r
+void mgl_data_set_values(HMDT dat, const char *val, long nx, long ny, long nz);\r
+\r
+int mgl_data_read_hdf(HMDT d,const char *fname,const char *data);\r
+void mgl_data_save_hdf(HCDT d,const char *fname,const char *data,int rewrite);\r
+int mgl_datas_hdf(const char *fname, char *buf, long size);\r
+int mgl_data_read(HMDT dat, const char *fname);\r
+int mgl_data_read_mat(HMDT dat, const char *fname, long dim);\r
+int mgl_data_read_dim(HMDT dat, const char *fname,long mx,long my,long mz);\r
+int mgl_data_read_range(HMDT d, const char *templ, double from, double to, double step, int as_slice);\r
+int mgl_data_read_all(HMDT dat, const char *templ, int as_slice);\r
+void mgl_data_save(HCDT dat, const char *fname,long ns);\r
+void mgl_data_export(HCDT dat, const char *fname, const char *scheme,float v1,float v2,long ns);\r
+void mgl_data_import(HMDT dat, const char *fname, const char *scheme,float v1,float v2);\r
+\r
+void mgl_data_create(HMDT dat, long nx,long ny,long nz);\r
+void mgl_data_transpose(HMDT dat, const char *dim);\r
+void mgl_data_norm(HMDT dat, float v1,float v2,long sym,long dim);\r
+void mgl_data_norm_slice(HMDT dat, float v1,float v2,char dir,long keep_en,long sym);\r
+HMDT mgl_data_subdata(HCDT dat, long xx,long yy,long zz);\r
+HMDT mgl_data_subdata_ext(HCDT dat, HCDT xx, HCDT yy, HCDT zz);\r
+HMDT mgl_data_column(HCDT dat, const char *eq);\r
+void mgl_data_set_id(HMDT d, const char *id);\r
+void mgl_data_fill(HMDT dat, float x1,float x2,char dir);\r
+void mgl_data_fill_eq(HMGL gr, HMDT dat, const char *eq, HCDT vdat, HCDT wdat,const char *opt);\r
+void mgl_data_put_val(HMDT dat, mreal val, long i, long j, long k);\r
+void mgl_data_put_dat(HMDT dat, HCDT val, long i, long j, long k);\r
+void mgl_data_modify(HMDT dat, const char *eq,long dim);\r
+void mgl_data_modify_vw(HMDT dat, const char *eq,HCDT vdat,HCDT wdat);\r
+void mgl_data_squeeze(HMDT dat, long rx,long ry,long rz,long smooth);\r
+float mgl_data_max(HCDT dat);\r
+float mgl_data_min(HCDT dat);\r
+mreal *mgl_data_value(HMDT dat, long i,long j,long k);\r
+mreal *mgl_data_data(HMDT dat);\r
+\r
+float mgl_data_first(HCDT dat, const char *cond, long *i, long *j, long *k);\r
+float mgl_data_last(HCDT dat, const char *cond, long *i, long *j, long *k);\r
+long mgl_data_find(HCDT dat, const char *cond, char dir, long i, long j, long k);\r
+int mgl_data_find_any(HCDT dat, const char *cond);\r
+float mgl_data_max_int(HCDT dat, long *i, long *j, long *k);\r
+float mgl_data_max_real(HCDT dat, mreal *x, mreal *y, mreal *z);\r
+float mgl_data_min_int(HCDT dat, long *i, long *j, long *k);\r
+float mgl_data_min_real(HCDT dat, mreal *x, mreal *y, mreal *z);\r
+float mgl_data_momentum_val(HCDT d, char dir, mreal *m, mreal *w, mreal *s, mreal *k);\r
+\r
+HMDT mgl_data_combine(HCDT dat1, HCDT dat2);\r
+void mgl_data_extend(HMDT dat, long n1, long n2);\r
+void mgl_data_insert(HMDT dat, char dir, long at, long num);\r
+void mgl_data_delete(HMDT dat, char dir, long at, long num);\r
+/*****************************************************************************/\r
+/* Data manipulation functions */\r
+/*****************************************************************************/\r
+void mgl_data_smooth(HMDT d, const char *dirs, float delta);\r
+HMDT mgl_data_sum(HCDT dat, const char *dir);\r
+HMDT mgl_data_max_dir(HCDT dat, const char *dir);\r
+HMDT mgl_data_min_dir(HCDT dat, const char *dir);\r
+void mgl_data_cumsum(HMDT dat, const char *dir);\r
+void mgl_data_integral(HMDT dat, const char *dir);\r
+void mgl_data_diff(HMDT dat, const char *dir);\r
+void mgl_data_diff_par(HMDT dat, HCDT v1, HCDT v2, HCDT v3);\r
+void mgl_data_diff2(HMDT dat, const char *dir);\r
+void mgl_data_swap(HMDT dat, const char *dir);\r
+void mgl_data_roll(HMDT dat, char dir, long num);\r
+void mgl_data_mirror(HMDT dat, const char *dir);\r
+void mgl_data_sort(HMDT dat, long idx, long idy);\r
+\r
+void mgl_data_hankel(HMDT dat, const char *dir);\r
+void mgl_data_sinfft(HMDT dat, const char *dir);\r
+void mgl_data_cosfft(HMDT dat, const char *dir);\r
+void mgl_data_fill_sample(HMDT dat, const char *how);\r
+\r
+float mgl_data_spline(HCDT dat, float x,float y,float z);\r
+float mgl_data_linear(HCDT dat, float x,float y,float z);\r
+HMDT mgl_data_trace(HCDT d);\r
+HMDT mgl_data_resize(HCDT dat, long mx,long my,long mz);\r
+HMDT mgl_data_resize_box(HCDT dat, long mx,long my,long mz,float x1,float x2,float y1,float y2,float z1,float z2);\r
+HMDT mgl_data_hist(HCDT dat, long n, float v1, float v2, long nsub);\r
+HMDT mgl_data_hist_w(HCDT dat, HCDT weight, long n, float v1, float v2, long nsub);\r
+HMDT mgl_data_momentum(HCDT dat, char dir, const char *how);\r
+HMDT mgl_data_evaluate(HCDT dat, HCDT idat, HCDT jdat, HCDT kdat, int norm);\r
+void mgl_data_envelop(HMDT dat, char dir);\r
+void mgl_data_sew(HMDT dat, const char *dirs, float da);\r
+void mgl_data_crop(HMDT dat, long n1, long n2, char dir);\r
+/*****************************************************************************/\r
+/* Data operations */\r
+/*****************************************************************************/\r
+void mgl_data_mul_dat(HMDT dat, HCDT d);\r
+void mgl_data_div_dat(HMDT dat, HCDT d);\r
+void mgl_data_add_dat(HMDT dat, HCDT d);\r
+void mgl_data_sub_dat(HMDT dat, HCDT d);\r
+void mgl_data_mul_num(HMDT dat, float d);\r
+void mgl_data_div_num(HMDT dat, float d);\r
+void mgl_data_add_num(HMDT dat, float d);\r
+void mgl_data_sub_num(HMDT dat, float d);\r
+/*****************************************************************************/\r
+HMDT mgl_pde_solve(HMGL gr, const char *ham, HCDT ini_re, HCDT ini_im, float dz, float k0,const char *opt);\r
+HMDT mgl_qo2d_solve(const char *ham, HCDT ini_re, HCDT ini_im, HCDT ray, float r, float k0, HMDT xx, HMDT yy);\r
+HMDT mgl_ray_trace(const char *ham, float x0, float y0, float z0, float px, float py, float pz, float dt, float tmax);\r
+HMDT mgl_jacobian_2d(HCDT x, HCDT y);\r
+HMDT mgl_jacobian_3d(HCDT x, HCDT y, HCDT z);\r
+HMDT mgl_transform_a(HCDT am, HCDT ph, const char *tr);\r
+HMDT mgl_transform(HCDT re, HCDT im, const char *tr);\r
+void mgl_data_fourier(HMDT re, HMDT im, const char *dir);\r
+HMDT mgl_data_stfa(HCDT re, HCDT im, long dn, char dir);\r
+\r
+HMDT mgl_triangulation_3d(HCDT x, HCDT y, HCDT z, float er);\r
+HMDT mgl_triangulation_2d(HCDT x, HCDT y, float er);\r
+/*****************************************************************************/\r
+/* Data creation functions */\r
+/*****************************************************************************/\r
+void mgl_data_rearrange_(uintptr_t *dat, int *mx, int *my, int *mz);\r
+void mgl_data_set_float_(uintptr_t *dat, const float *A,int *NX,int *NY,int *NZ);\r
+void mgl_data_set_double_(uintptr_t *dat, const double *A,int *NX,int *NY,int *NZ);\r
+void mgl_data_set_float1_(uintptr_t *d, const float *A,int *N1);\r
+void mgl_data_set_double1_(uintptr_t *d, const double *A,int *N1);\r
+void mgl_data_set_float2_(uintptr_t *d, const float *A,int *N1,int *N2);\r
+void mgl_data_set_double2_(uintptr_t *d, const double *A,int *N1,int *N2);\r
+void mgl_data_set_float3_(uintptr_t *d, const float *A,int *N1,int *N2,int *N3);\r
+void mgl_data_set_double3_(uintptr_t *d, const double *A,int *N1,int *N2,int *N3);\r
+void mgl_data_set_(uintptr_t *dat, uintptr_t *a);\r
+\r
+void mgl_data_set_value_(uintptr_t *d, float *v, int *i, int *j, int *k);\r
+void mgl_data_set_values_(uintptr_t *d, const char *val, int *nx, int *ny, int *nz, int l);\r
+float mgl_data_get_value_(uintptr_t *d, int *i, int *j, int *k);\r
+int mgl_data_read_(uintptr_t *d, const char *fname,int l);\r
+int mgl_data_read_mat_(uintptr_t *dat, const char *fname, int *dim, int);\r
+int mgl_data_read_dim_(uintptr_t *dat, const char *fname,int *mx,int *my,int *mz,int);\r
+void mgl_data_save_(uintptr_t *dat, const char *fname,int *ns,int);\r
+void mgl_data_export_(uintptr_t *dat, const char *fname, const char *scheme,float *v1,float *v2,int *ns,int,int);\r
+void mgl_data_import_(uintptr_t *dat, const char *fname, const char *scheme,float *v1,float *v2,int,int);\r
+void mgl_data_create_(uintptr_t *dat, int *nx,int *ny,int *nz);\r
+void mgl_data_transpose_(uintptr_t *dat, const char *dim,int);\r
+void mgl_data_norm_(uintptr_t *dat, float *v1,float *v2,int *sym,int *dim);\r
+void mgl_data_norm_slice_(uintptr_t *dat, float *v1,float *v2,char *dir,int *keep_en,int *sym,int l);\r
+uintptr_t mgl_data_subdata_(uintptr_t *dat, int *xx,int *yy,int *zz);\r
+uintptr_t mgl_data_subdata_ext_(uintptr_t *dat, uintptr_t *xx,uintptr_t *yy,uintptr_t *zz);\r
+uintptr_t mgl_data_column_(uintptr_t *dat, const char *eq,int l);\r
+void mgl_data_set_id_(uintptr_t *dat, const char *id,int l);\r
+void mgl_data_fill_(uintptr_t *dat, float *x1,float *x2,const char *dir,int);\r
+void mgl_data_fill_eq_(uintptr_t *gr, uintptr_t *dat, const char *eq, uintptr_t *vdat, uintptr_t *wdat,const char *opt, int, int);\r
+void mgl_data_put_val_(uintptr_t *dat, float *val, int *i, int *j, int *k);\r
+void mgl_data_put_dat_(uintptr_t *dat, uintptr_t *val, int *i, int *j, int *k);\r
+void mgl_data_modify_(uintptr_t *dat, const char *eq,int *dim,int);\r
+void mgl_data_modify_vw_(uintptr_t *dat, const char *eq, uintptr_t *vdat, uintptr_t *wdat,int);\r
+void mgl_data_squeeze_(uintptr_t *dat, int *rx,int *ry,int *rz,int *smooth);\r
+float mgl_data_max_(uintptr_t *dat);\r
+float mgl_data_min_(uintptr_t *dat);\r
+\r
+float mgl_data_first_(uintptr_t *dat, const char *cond, int *i, int *j, int *k, int);\r
+float mgl_data_last_(uintptr_t *dat, const char *cond, int *i, int *j, int *k, int);\r
+int mgl_data_find_(uintptr_t *dat, const char *cond, char *dir, int *i, int *j, int *k, int,int);\r
+int mgl_data_find_any_(uintptr_t *dat, const char *cond, int);\r
+float mgl_data_max_int_(uintptr_t *dat, int *i, int *j, int *k);\r
+float mgl_data_max_real_(uintptr_t *dat, float *x, float *y, float *z);\r
+float mgl_data_min_int_(uintptr_t *dat, int *i, int *j, int *k);\r
+float mgl_data_min_real_(uintptr_t *dat, float *x, float *y, float *z);\r
+float mgl_data_momentum_val_(uintptr_t *dat, char *dir, float *m, float *w, float *s, float *k,int);\r
+\r
+uintptr_t mgl_data_combine_(uintptr_t *dat1, uintptr_t *dat2);\r
+void mgl_data_extend_(uintptr_t *dat, int *n1, int *n2);\r
+void mgl_data_insert_(uintptr_t *dat, const char *dir, int *at, int *num, int);\r
+void mgl_data_delete_(uintptr_t *dat, const char *dir, int *at, int *num, int);\r
+/*****************************************************************************/\r
+/* Data manipulation functions */\r
+/*****************************************************************************/\r
+void mgl_data_smooth_(uintptr_t *dat, const char *dirs, float *delta,int);\r
+uintptr_t mgl_data_sum_(uintptr_t *dat, const char *dir,int);\r
+uintptr_t mgl_data_max_dir_(uintptr_t *dat, const char *dir,int);\r
+uintptr_t mgl_data_min_dir_(uintptr_t *dat, const char *dir,int);\r
+void mgl_data_cumsum_(uintptr_t *dat, const char *dir,int);\r
+void mgl_data_integral_(uintptr_t *dat, const char *dir,int);\r
+void mgl_data_diff_(uintptr_t *dat, const char *dir,int);\r
+void mgl_data_diff_par_(uintptr_t *dat, uintptr_t *v1, uintptr_t *v2, uintptr_t *v3);\r
+void mgl_data_diff2_(uintptr_t *dat, const char *dir,int);\r
+void mgl_data_swap_(uintptr_t *dat, const char *dir,int);\r
+void mgl_data_roll_(uintptr_t *dat, const char *dir, int *num, int);\r
+void mgl_data_mirror_(uintptr_t *dat, const char *dir,int);\r
+void mgl_data_sort_(uintptr_t *dat, int *idx, int *idy);\r
+\r
+void mgl_data_hankel_(uintptr_t *dat, const char *dir,int);\r
+void mgl_data_sinfft_(uintptr_t *dat, const char *dir,int);\r
+void mgl_data_cosfft_(uintptr_t *dat, const char *dir,int);\r
+void mgl_data_fill_sample_(uintptr_t *dat, const char *how,int);\r
+\r
+float mgl_data_spline_(uintptr_t *dat, float *x,float *y,float *z);\r
+float mgl_data_linear_(uintptr_t *dat, float *x,float *y,float *z);\r
+uintptr_t mgl_data_trace_(uintptr_t *d);\r
+uintptr_t mgl_data_resize_(uintptr_t *dat, int *mx,int *my,int *mz);\r
+uintptr_t mgl_data_resize_box_(uintptr_t *dat, int *mx,int *my,int *mz,float *x1,float *x2,float *y1,float *y2,float *z1,float *z2);\r
+uintptr_t mgl_data_momentum_(uintptr_t *dat, char *dir, const char *how, int,int);\r
+uintptr_t mgl_data_hist_(uintptr_t *dat, int *n, float *v1, float *v2, int *nsub);\r
+uintptr_t mgl_data_hist_w_(uintptr_t *dat, uintptr_t *weight, int *n, float *v1, float *v2, int *nsub);\r
+uintptr_t mgl_data_evaluate_(uintptr_t *dat, uintptr_t *idat, uintptr_t *jdat, uintptr_t *kdat, int *norm);\r
+void mgl_data_envelop_(uintptr_t *dat, const char *dir, int);\r
+void mgl_data_sew_(uintptr_t *dat, const char *dirs, float *da, int);\r
+void mgl_data_crop_(uintptr_t *dat, int *n1, int *n2, const char *dir,int);\r
+/*****************************************************************************/\r
+/* Data operations */\r
+/*****************************************************************************/\r
+void mgl_data_mul_dat_(uintptr_t *dat, uintptr_t *d);\r
+void mgl_data_div_dat_(uintptr_t *dat, uintptr_t *d);\r
+void mgl_data_add_dat_(uintptr_t *dat, uintptr_t *d);\r
+void mgl_data_sub_dat_(uintptr_t *dat, uintptr_t *d);\r
+void mgl_data_mul_num_(uintptr_t *dat, float *d);\r
+void mgl_data_div_num_(uintptr_t *dat, float *d);\r
+void mgl_data_add_num_(uintptr_t *dat, float *d);\r
+void mgl_data_sub_num_(uintptr_t *dat, float *d);\r
+/*****************************************************************************/\r
+/* Nonlinear fitting */\r
+/*****************************************************************************/\r
+uintptr_t mgl_pde_solve_(uintptr_t* gr, const char *ham, uintptr_t* ini_re, uintptr_t* ini_im, float *dz, float *k0,const char *opt,int,int);\r
+uintptr_t mgl_qo2d_solve_(const char *ham, uintptr_t* ini_re, uintptr_t* ini_im, uintptr_t* ray, float *r, float *k0, uintptr_t* xx, uintptr_t* yy, int);\r
+uintptr_t mgl_ray_trace_(const char *ham, float *x0, float *y0, float *z0, float *px, float *py, float *pz, float *dt, float *tmax,int);\r
+uintptr_t mgl_jacobian_2d_(uintptr_t* x, uintptr_t* y);\r
+uintptr_t mgl_jacobian_3d_(uintptr_t* x, uintptr_t* y, uintptr_t* z);\r
+\r
+uintptr_t mgl_transform_a_(uintptr_t *am, uintptr_t *ph, const char *tr, int);\r
+uintptr_t mgl_transform_(uintptr_t *re, uintptr_t *im, const char *tr, int);\r
+void mgl_data_fourier_(uintptr_t *re, uintptr_t *im, const char *dir, int l);\r
+uintptr_t mgl_data_stfa_(uintptr_t *re, uintptr_t *im, int *dn, char *dir, int);\r
+\r
+uintptr_t mgl_triangulation_3d_(uintptr_t *x, uintptr_t *y, uintptr_t *z, float *er);\r
+uintptr_t mgl_triangulation_2d_(uintptr_t *x, uintptr_t *y, float *er);\r
+/*****************************************************************************/\r
+int mgl_data_read_hdf_(uintptr_t *d, const char *fname, const char *data,int l,int n);\r
+void mgl_data_link_(uintptr_t *d, float *A, int *nx,int *ny,int *nz);\r
+void mgl_data_save_hdf_(uintptr_t *d, const char *fname, const char *data, int *rewrite,int l,int n);\r
+int mgl_data_read_range_(uintptr_t *d, const char *fname, double *from, double *to, double *step, int *as_slice,int l);\r
+int mgl_data_read_all_(uintptr_t *d, const char *fname, int *as_slice,int l);\r
+/*****************************************************************************/\r
+#ifdef __cplusplus\r
+}\r
+#endif\r
+#endif\r
#define _MGL_FLTK_H_\r
/*****************************************************************************/\r
#ifdef __cplusplus\r
-#include "mgl/window.h"\r
+#include "mgl/canvas_wnd.h"\r
//-----------------------------------------------------------------------------\r
#ifdef __MWERKS__\r
# define FL_DLL\r
{ popup = pmenu; wpar = wdg; vpar = v; }\r
protected:\r
mglCanvas *gr; ///< pointer to grapher\r
- void *draw_par; ///< Parameters for drawing function mglCanvasW::DrawFunc.\r
+ void *draw_par; ///< Parameters for drawing function mglCanvasWnd::DrawFunc.\r
/// Drawing function for window procedure. It should return the number of frames.\r
int (*draw_func)(mglBase *gr, void *par);\r
\r
//-----------------------------------------------------------------------------\r
/// Class allows the window creation for displaying plot bitmap with the help of FLTK library\r
/** NOTE!!! All frames are saved in memory. So animation with many frames require a lot memory and CPU time (for example, for mouse rotation).*/\r
-class mglCanvasFL : public mglCanvasW\r
+class mglCanvasFL : public mglCanvasWnd\r
{\r
public:\r
-using mglCanvasW::Window;\r
+using mglCanvasWnd::Window;\r
Fl_Window *Wnd; ///< Pointer to window\r
Fl_MGLView *mgl; ///< Pointer to MGL widget with buttons\r
\r
/*****************************************************************************/\r
void _mgl_key_up(unsigned char ch,int ,int );\r
HMGL mgl_create_graph_glut(int (*draw)(HMGL gr, void *p), const char *title, void *par);\r
-/*int mgl_fortran_func(HMGL gr, void *);\r
-uintptr_t mgl_create_graph_glut_(const char *title, int);*/\r
/*****************************************************************************/\r
#ifdef __cplusplus\r
}\r
#include "mgl/opengl.h"\r
#endif\r
//-----------------------------------------------------------------------------\r
-const float NaN = NAN;\r
-//-----------------------------------------------------------------------------\r
/// Wrapper class for all graphics\r
class mglGraph\r
{\r
~mglExpr() { mgl_delete_expr(ex); }\r
inline mreal Eval(mreal x, mreal y=0, mreal z=0)\r
{ return mgl_expr_eval(ex,x,y,z); }\r
- inline mreal Eval(mreal var[26])\r
- { return mgl_expr_eval_v(ex,var); }\r
inline mreal Diff(char dir, mreal x, mreal y=0, mreal z=0)\r
{ return mgl_expr_diff(ex,dir, x,y,z); }\r
+#ifndef SWIG\r
+ inline mreal Eval(mreal var[26])\r
+ { return mgl_expr_eval_v(ex,var); }\r
inline mreal Diff(char dir, mreal var[26])\r
{ return mgl_expr_diff_v(ex,dir, var); }\r
+#endif\r
};\r
//-----------------------------------------------------------------------------\r
#endif\r
#define _MGL_CF_H_\r
/*****************************************************************************/\r
#include "mgl/base_cf.h"\r
-#include "mgl/data.h"\r
+#include "mgl/data_cf.h"\r
#include "mgl/cont.h"\r
#include "mgl/fit.h"\r
#include "mgl/plot.h"\r
/*****************************************************************************/\r
#ifdef __cplusplus\r
//-----------------------------------------------------------------------------\r
-#include "mgl/window.h"\r
+#include "mgl/canvas_wnd.h"\r
#include <QtGui/QWidget>\r
#include <QtGui/QPixmap>\r
//-----------------------------------------------------------------------------\r
void mouseMoveEvent(QMouseEvent *);\r
\r
mglCanvas *gr; ///< Built-in mglCanvasQT-er instance (used by default)\r
- void *draw_par; ///< Parameters for drawing function mglCanvasW::DrawFunc.\r
+ void *draw_par; ///< Parameters for drawing function mglCanvasWnd::DrawFunc.\r
/// Drawing function for window procedure. It should return the number of frames.\r
int (*draw_func)(mglBase *gr, void *par);\r
QString mousePos; ///< Last mouse position\r
};\r
//-----------------------------------------------------------------------------\r
/// Base class for windows containing MathGL graphics\r
-class mglCanvasQT : public mglCanvasW\r
+class mglCanvasQT : public mglCanvasWnd\r
{\r
public:\r
-using mglCanvasW::Window;\r
+using mglCanvasWnd::Window;\r
int sshow; ///< Current state of animation switch (toggle button)\r
QMathGL *QMGL; ///< Control which draw graphics\r
QMainWindow *Wnd; ///< Pointer to window\r
{ gr->Highlight(line+1); mgl_parse_text(gr->Self(),par,text.toAscii()); return 0; }\r
};\r
//-----------------------------------------------------------------------------\r
-/// Convert bitmap from mglCanvasW to QPixmap\r
+/// Convert bitmap from mglCanvasWnd to QPixmap\r
void mglConvertFromGraph(QPixmap &pic, mglCanvas *gr, uchar **buf);\r
/// Make menu, toolbars and return popup menu for MainWindow\r
QMenu *mglMakeMenu(QMainWindow *Wnd, QMathGL *QMGL, QSpinBox *tet, QSpinBox *phi);\r
#endif
#include "mgl/define.h"
//-----------------------------------------------------------------------------
+const mreal Pi = M_PI;
+const mreal NaN = NAN;
+//-----------------------------------------------------------------------------
/// Class for incapsulating point in space
struct mglPoint
{
inline void operator*=(float a) { x*=a; y*=a; z*=a; }
inline void operator/=(float a) { x/=a; y/=a; z/=a; }
};
+#ifndef SWIG
inline mglPoint operator+(const mglPoint &a, const mglPoint &b)
{ return mglPoint(a.x+b.x, a.y+b.y, a.z+b.z, a.c+b.c); }
inline mglPoint operator-(const mglPoint &a, const mglPoint &b)
{ return memcmp(&a, &b, sizeof(mglPoint)); }
inline float mgl_norm(const mglPoint &p)
{ return sqrt(p.x*p.x+p.y*p.y+p.z*p.z); }
+#endif
//-----------------------------------------------------------------------------
/// Class for incapsulating color
struct mglColor
inline void operator+=(const mglColor &c) { r+=c.r; g+=c.g; b+=c.b; }
inline void operator-=(const mglColor &c) { r-=c.r; g-=c.g; b-=c.b; }
};
+#ifndef SWIG
inline mglColor operator+(const mglColor &a, const mglColor &b)
{ return mglColor(a.r+b.r, a.g+b.g, a.b+b.b, a.a+b.a); }
inline mglColor operator-(const mglColor &a, const mglColor &b)
{ return mglColor(a.r/b, a.g/b, a.b/b, a.a/b); }
inline mglColor operator!(const mglColor &a)
{ return mglColor(1-a.r, 1-a.g, 1-a.b, a.a); }
+#endif
//-----------------------------------------------------------------------------
#endif
\ No newline at end of file
{ mgl_draw_thr(this); }\r
#endif\r
};\r
-void mgl_reload_class(void *p);\r
typedef int (*draw_func)(mglGraph *gr);\r
int mgl_draw_graph(mglBase *gr, void *p);\r
-// NOTE: mgl_draw_class() use mglWindow* only. Don't use it with inherited classes\r
+// NOTE: mgl_draw_class() and mgl_draw_load() use mglWindow* only. Don't use it with inherited classes\r
int mgl_draw_class(mglBase *gr, void *p);\r
+void mgl_reload_class(void *p);\r
//-----------------------------------------------------------------------------\r
#if MGL_HAVE_QT\r
#define MGL_WND_KIND 1\r
#else\r
#define MGL_WND_KIND 0\r
#endif\r
+/// Wrapper class for windows displaying graphics\r
class mglWindow : public mglGraph\r
{\r
friend int mgl_draw_class(mglBase *gr, void *p);\r
+friend void mgl_reload_class(void *p);\r
protected:\r
mglDraw *dr;\r
int wnd; ///< Type of window\r
public:\r
- mglWindow(int (*draw)(HMGL gr, void *p)=NULL, const char *title="MathGL", void *par=NULL, int kind=MGL_WND_KIND) : mglGraph(-1)\r
+ mglWindow(const char *title="MathGL") : mglGraph(-1)\r
+ { wnd=0; dr=0; gr = mgl_create_graph_fltk(0,title,0,0); }\r
+ inline int RunThr() ///< Run main loop for event handling in separate thread (for FLTK only)\r
+ { return wnd==0 ? mgl_fltk_thr():0; }\r
+#ifndef SWIG\r
+ mglWindow(int (*draw)(HMGL gr, void *p), const char *title="MathGL", void *par=NULL, int kind=MGL_WND_KIND, void (*load)(void *p)=0) : mglGraph(-1)\r
{\r
wnd=kind; dr=0;\r
- if(wnd==1) gr = mgl_create_graph_qt(draw,title,par);\r
- else gr = mgl_create_graph_fltk(draw,title,par);\r
+ if(wnd==1) gr = mgl_create_graph_qt(draw,title,par,load);\r
+ else gr = mgl_create_graph_fltk(draw,title,par,load);\r
}\r
mglWindow(int (*draw)(mglGraph *gr), const char *title="MathGL", int kind=MGL_WND_KIND) : mglGraph(-1)\r
{\r
wnd=kind; dr=0;\r
- if(wnd==1) gr = mgl_create_graph_qt(mgl_draw_graph,title,(void*)draw);\r
- else gr = mgl_create_graph_fltk(mgl_draw_graph,title,(void*)draw);\r
+ if(wnd==1) gr = mgl_create_graph_qt(mgl_draw_graph,title,(void*)draw,0);\r
+ else gr = mgl_create_graph_fltk(mgl_draw_graph,title,(void*)draw,0);\r
}\r
mglWindow(mglDraw *draw, const char *title="MathGL", int kind=MGL_WND_KIND) : mglGraph(-1)\r
{\r
wnd=kind; dr=draw;\r
- if(wnd==1) gr = mgl_create_graph_qt(mgl_draw_class,title,this);\r
- else gr = mgl_create_graph_fltk(mgl_draw_class,title,this);\r
+ if(wnd==1) gr = mgl_create_graph_qt(mgl_draw_class,title,this,mgl_reload_class);\r
+ else gr = mgl_create_graph_fltk(mgl_draw_class,title,this,mgl_reload_class);\r
}\r
inline int Run() ///< Run main loop for event handling\r
{ return (wnd==1)? mgl_qt_run() : mgl_fltk_run(); }\r
+#endif\r
\r
inline void ToggleAlpha() ///< Switch on/off transparency (do not overwrite user settings)\r
{ mgl_wnd_toggle_alpha(gr); }\r
{ mglPoint p; mgl_get_last_mouse_pos(gr,&p.x,&p.y,&p.z); return p; }\r
};\r
//-----------------------------------------------------------------------------\r
-/// Base class for windows containing MathGL graphics\r
-class mglCanvasW : public mglCanvas\r
-{\r
-public:\r
- mglCanvasW();\r
- virtual ~mglCanvasW();\r
-\r
- void SetSize(int w,int h);\r
- void EndFrame();\r
- const unsigned char *GetBits();\r
- inline int GetNumFig() { return NumFig; }\r
- inline int GetCurFig() { return CurFig; }\r
- void SetCurFig(int c);\r
- void ClearFrames();\r
- inline mglPoint GetMousePos() { return LastMousePos;} // stupid thing to pass G++ bug\r
- inline void SetMousePos(mglPoint p) { LastMousePos=p; }\r
- inline void Setup(bool clf_upd=true, bool showpos=false)\r
- { set(showpos,MGL_SHOW_POS); set(clf_upd,MGL_CLF_ON_UPD); }\r
-\r
- virtual void ToggleAlpha()=0; ///< Switch on/off transparency (do not overwrite user settings)\r
- virtual void ToggleLight()=0; ///< Switch on/off lighting (do not overwrite user settings)\r
- virtual void ToggleZoom()=0; ///< Switch on/off zooming by mouse\r
- virtual void ToggleRotate()=0; ///< Switch on/off rotation by mouse\r
- virtual void ToggleNo()=0; ///< Switch off all zooming and rotation\r
- virtual void Update()=0; ///< Update picture by calling user drawing function\r
- virtual void Adjust()=0; ///< Adjust size of bitmap to window size\r
- virtual void GotoFrame(int d)=0;///< Show arbitrary frame (use relative step)\r
- virtual void NextFrame() {GotoFrame(+1);} ///< Show next frame (if one)\r
- virtual void PrevFrame() {GotoFrame(-1);} ///< Show previous frame (if one)\r
- virtual void Animation()=0; ///< Run slideshow (animation) of frames\r
- void ReLoad(); ///< Reload user data and update picture\r
- /// Create a window for plotting based on callback function (can be NULL).\r
- virtual void Window(int argc, char **argv, int (*draw)(mglBase *gr, void *p),\r
- const char *title, void *par=NULL,\r
- void (*reload)(void *p)=NULL, bool maximize=false)=0;\r
- void Window(int argc, char **argv, int (*draw)(mglGraph *gr), const char *title, bool maximize=false)\r
- { Window(argc,argv,mgl_draw_graph,title,(void*)draw,0,maximize); }\r
- /// Create a window for plotting based on class mglDraw.\r
- void Window(int argc, char **argv, const char *title, mglDraw *draw, bool maximize=false)\r
- { Window(argc, argv, mgl_draw_class, title, draw, mgl_reload_class, maximize); }\r
- void SetDrawFunc(int (*draw)(mglBase *gr, void *p), void *par=NULL, void (*reload)(void *p)=NULL);\r
-\r
-private:\r
- mglPoint LastMousePos; ///< Last mouse position\r
- int CurFig; ///< Current figure in the list.\r
-\r
- unsigned char *GG; ///< images for all frames (may be too LARGE !!!)\r
- int NumFig; ///< Number of figures in the list. If 0 then no list and mglCanvas::DrawFunc will called for each drawing.\r
- void (*LoadFunc)(void *par);\r
- void *FuncPar; ///< Parameters for drawing function mglCanvas::DrawFunc.\r
- /// Drawing function for window procedure. It should return the number of frames.\r
- int (*DrawFunc)(mglBase *gr, void *par);\r
-};\r
-//-----------------------------------------------------------------------------\r
#endif\r
configure_file(${MathGL_SOURCE_DIR}/lang/mgl.i ${MathGL_BINARY_DIR}/lang/mgl.i COPYONLY)
configure_file(${MathGL_SOURCE_DIR}/lang/numpy.i ${MathGL_BINARY_DIR}/lang/numpy.i COPYONLY)
SET(dep_libs mgl)
- if(MGL_HAVE_FLTK)
+# if(MGL_HAVE_FLTK)
get_property(path_to_mglwnd TARGET mgl-wnd PROPERTY LOCATION)
file(TO_NATIVE_PATH ${path_to_mglwnd} MGL_LIB_WND)
SET(dep_libs ${dep_libs} mgl-wnd)
- endif(MGL_HAVE_FLTK)
+# endif(MGL_HAVE_FLTK)
get_property(path_to_mgl TARGET mgl PROPERTY LOCATION)
file(TO_NATIVE_PATH ${path_to_mgl} MGL_LIB)
file(TO_NATIVE_PATH ${MathGL_BINARY_DIR}/lang/mgl.i MGL_I)
add_custom_command(OUTPUT _mathgl.so mathgl.py
COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_BINARY_DIR}/lang/setup.py build
DEPENDS ${dep_libs} ${CMAKE_BINARY_DIR}/lang/mgl.i ${CMAKE_BINARY_DIR}/lang/numpy.i
- IMPLICIT_DEPENDS CXX ${CMAKE_SOURCE_DIR}/include/mgl/type.h ${CMAKE_SOURCE_DIR}/include/mgl/data.h ${CMAKE_SOURCE_DIR}/include/mgl/mgl.h
+ IMPLICIT_DEPENDS CXX ${CMAKE_SOURCE_DIR}/include/mgl/type.h ${CMAKE_SOURCE_DIR}/include/mgl/data.h ${CMAKE_SOURCE_DIR}/include/mgl/mgl.h ${CMAKE_SOURCE_DIR}/include/mgl/window.h
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/lang
)
add_custom_target(mgl_python_module ALL DEPENDS _mathgl.so mathgl.py)
***************************************************************************/
%module mathgl
-#define MGL_NO_WIDGET
#ifdef SWIGOCTAVE
%feature("autodoc", 1);
#endif // SWIGOCTAVE
%ignore *::operator-=;
%ignore *::operator*=;
%ignore *::operator/=;
+//%ignore mglDataA
%{
#define SWIG_FILE_WITH_INIT
#include "mgl/type.h"
#include "mgl/data.h"
#include "mgl/mgl.h"
+#include "mgl/window.h"
%}
+#if MGL_USE_DOUBLE
+typedef double mreal;
+#else
+typedef float mreal;
+#endif
+
+
#ifdef SWIGOCTAVE
%rename(__add) operator+;
%rename(__sub) operator-;
%include "mgl/type.h"
%include "mgl/data.h"
%include "mgl/mgl.h"
+%include "mgl/window.h"
%extend mglData
{
float __getitem__( int i) { return self->GetVal(i); };
)
set(mgl_hdr
-../include/mgl/base_cf.h ../include/mgl/fit.h ../include/mgl/plot.h
-../include/mgl/base.h ../include/mgl/prim.h ../include/mgl/canvas_cf.h
-../include/mgl/font.h ../include/mgl/canvas.h ../include/mgl/surf.h
-${MathGL_BINARY_DIR}/include/mgl/config.h ../include/mgl/mgl_cf.h ../include/mgl/type.h
-../include/mgl/cont.h ../include/mgl/mgl.h ../include/mgl/vect.h
-../include/mgl/data.h ../include/mgl/volume.h
-../include/mgl/define.h ../include/mgl/other.h ../include/mgl/eval.h
-../include/mgl/parser.h ../include/mgl/addon.h ../include/mgl/evalc.h )
+../include/mgl/base_cf.h ../include/mgl/fit.h ../include/mgl/plot.h
+../include/mgl/base.h ../include/mgl/prim.h ../include/mgl/canvas_cf.h
+../include/mgl/font.h ../include/mgl/canvas.h ../include/mgl/surf.h
+../include/mgl/mgl_cf.h ../include/mgl/type.h ${MathGL_BINARY_DIR}/include/mgl/config.h
+../include/mgl/cont.h ../include/mgl/mgl.h ../include/mgl/vect.h
+../include/mgl/data.h ../include/mgl/volume.h ../include/mgl/data_cf.h
+../include/mgl/define.h ../include/mgl/other.h ../include/mgl/eval.h
+../include/mgl/parser.h ../include/mgl/addon.h ../include/mgl/evalc.h )
if(MGL_HAVE_OPENGL)
set(mgl_src ${mgl_src} opengl.cpp )
//-----------------------------------------------------------------------------\r
mreal *mgl_data_data(HMDT dat) { return dat->a; }\r
//-----------------------------------------------------------------------------\r
+mreal *mgl_data_value(HMDT dat, long i,long j,long k)\r
+{ register long ii=i*dat->nx*(j+dat->ny*k);\r
+ return ii>=0 && ii<dat->GetNN() ? dat->a+ii : 0; }\r
+//-----------------------------------------------------------------------------\r
<a target="main" href="web_en/web_en_4.html"><b>Pictures</b></a></p>
<a target="main" href="web_en/web_en_5.html"><b>MGL scripts</b></a></p>
<a target="main" href="web_en/web_en_6.html"><b>Download</b></a></p>
-<a target="main" href="web_en/web_en_7.html"><b>Documentation</b></a></p>
+<a target="main" href="mathgl_en/mathgl_en.html"><b>Documentation</b></a></p>
<a target="main" href="web_en/web_en_8.html"><b>Other projects</b></a></p>
<hr style="width: 100%; height: 1px;">
* Pictures::
* MGL scripts::
* Download::
-* Documentation::
* Other projects::
@end menu
@external
-@node Download, Documentation, MGL scripts, Top
+@node Download, Other projects, MGL scripts, Top
@section Download
@strong{Stable version (v.2.0)}
@external
-@node Documentation, Other projects, Download, Top
-@section Documentation
-
-Here you can view and download latest version of documentation. This documentation is just compiled version of @uref{https://sourceforge.net/svn/?group_id=152187,SVN} documentation.
-
-There are @uref{../mathgl_en/mathgl_en.html,English} and @uref{../mathgl_ru/mathgl_ru.html,Russian} versions. It also include @uref{../mathgl_en/mathgl_en_18.html#FAQ,FAQ} about MathGL.
-
-Another variant is download single @uref{mathgl_en.pdf,PDF} (about 7 Mb).
-
-@external
-
-@node Other projects, , Documentation, Top
+@node Other projects, , Download, Top
@section Other projects
Except scientific (non public) projects I also have some general interest projects:
This class is derived from mglGraph class (@pxref{MathGL core}). It provide methods for handling window with MathGL graphics.
-@deftypefn {Constructor on @code{mglWindow}} {} mglWindow (@code{int} (*draw)(@code{HMGL} gr, @code{void *}p)=@code{NULL}, @code{const char *}title=@code{"MathGL"}, @code{void *}par=@code{NULL}, @code{int} kind=@code{0})
+@deftypefn {Constructor on @code{mglWindow}} {} mglWindow (@code{const char *}title=@code{"MathGL"})
+@deftypefnx {Constructor on @code{mglWindow}} {} mglWindow (@code{int} (*draw)(@code{HMGL} gr, @code{void *}p), @code{const char *}title=@code{"MathGL"}, @code{void *}par=@code{NULL}, @code{int} kind=@code{0})
@deftypefnx {Constructor on @code{mglWindow}} {} mglWindow (@code{int} (*draw)(@code{mglGraph *}gr), @code{const char *}title=@code{"MathGL"}, @code{int} kind=@code{0})
@deftypefnx {Constructor on @code{mglWindow}} {} mglWindow (@code{mglDraw *}draw, @code{const char *}title=@code{"MathGL"}, @code{int} kind=@code{0})
@deftypefnx {C function} @code{HMGL} mgl_create_graph_qt (@code{int} (*draw)(@code{HMGL} gr, @code{void *}p), @code{const char *}title, @code{void *}par)
There are some keys handles for manipulating by the plot: 'a', 'd', 'w', 's' for the rotating; ',', '.' for viewing of the previous or next frames in the list; 'r' for the switching of transparency; 'f' for the switching of lightning; 'x' for hiding (closing) the window.
@end deftypefn
+@deftypefn {Method on @code{mglWindow}} @code{void} RunThr ()
+@c @deftypefnx {C function} @code{HMGL} mgl_qt_run ()
+@deftypefnx {C function} @code{HMGL} mgl_fltk_thr ()
+Run main loop for event handling in separate thread. Note, right now it work for FLTK windows only.
+@end deftypefn
+
@deftypefn {Method on @code{mglWindow}} @code{void} Run ()
@deftypefnx {C function} @code{HMGL} mgl_qt_run ()
@deftypefnx {C function} @code{HMGL} mgl_fltk_run ()
-set(mgl_wnd_hdr ../include/mgl/window.h)
+set(mgl_wnd_hdr ../include/mgl/window.h ../include/mgl/canvas_wnd.h)
set(mgl_wnd_src window.cpp)
#set(mgl_wnd_src )
// class mglCanvasFL
//
//-----------------------------------------------------------------------------
-mglCanvasFL::mglCanvasFL() : mglCanvasW() { Wnd=0; }
+mglCanvasFL::mglCanvasFL() : mglCanvasWnd() { Wnd=0; }
mglCanvasFL::~mglCanvasFL() { if(Wnd) delete Wnd; }
//-----------------------------------------------------------------------------
void mglCanvasFL::GotoFrame(int d)
if(GetNumFig()>0 && d) { SetCurFig(f); mgl->FMGL->redraw(); }
}
//-----------------------------------------------------------------------------
-void mgl_fl_next(void *v) { ((mglCanvasW*)v)->NextFrame(); } ///< Callback function for next frame
-void mgl_fl_prev(void *v) { ((mglCanvasW*)v)->PrevFrame(); } ///< Callback function for prev frame
-void mgl_fl_reload(void *v) { ((mglCanvasW*)v)->ReLoad(); } ///< Callback function for reloading
-float mgl_fl_delay(void *v) { return ((mglCanvasW*)v)->GetDelay(); } ///< Callback function for delay
+void mgl_fl_next(void *v) { ((mglCanvasWnd*)v)->NextFrame(); } ///< Callback function for next frame
+void mgl_fl_prev(void *v) { ((mglCanvasWnd*)v)->PrevFrame(); } ///< Callback function for prev frame
+void mgl_fl_reload(void *v) { ((mglCanvasWnd*)v)->ReLoad(); } ///< Callback function for reloading
+float mgl_fl_delay(void *v) { return ((mglCanvasWnd*)v)->GetDelay(); } ///< Callback function for delay
//-----------------------------------------------------------------------------
void mglCanvasFL::Window(int argc, char **argv, int (*draw)(mglBase *gr, void *p), const char *title, void *par, void (*reload)(void *p), bool maximize)
{
delete []tmp[0];
}
//-----------------------------------------------------------------------------
-HMGL mgl_create_graph_fltk(int (*draw)(HMGL gr, void *p), const char *title, void *par)
+HMGL mgl_create_graph_fltk(int (*draw)(HMGL gr, void *p), const char *title, void *par, void (*load)(void *p))
{
mglCanvasFL *g = new mglCanvasFL;
- g->Window(0,0,draw,title,par);
+ g->Window(0,0,draw,title,par,load);
return g;
}
int mgl_fltk_run() { return Fl::run(); }
//-----------------------------------------------------------------------------
-void *mgl_fl_tmp(void *) { Fl::run(); return 0; }
-/*void mgl_fltk_thread()
- * {
- * static pthread_t tmp;
- * pthread_create(&tmp, 0, mgl_fl_tmp, 0);
- * pthread_detach(tmp);
- * }*/
-//-----------------------------------------------------------------------------
mglCanvasGLUT::mglCanvasGLUT() : mglCanvasGL() {}\r
//-----------------------------------------------------------------------------\r
#if MGL_HAVE_FLTK\r
-HMGL mgl_create_graph_fltk(int (*)(HMGL gr, void *p), const char *, void *)\r
+HMGL mgl_create_graph_fltk(int (*)(HMGL gr, void *p), const char *, void *, void (*)(void *p))\r
{ return NULL; }\r
int mgl_fltk_run(){return 0;}\r
#endif\r
//-----------------------------------------------------------------------------\r
#if MGL_HAVE_QT\r
-HMGL mgl_create_graph_qt(int (*)(HMGL gr, void *p), const char *, void *)\r
+HMGL mgl_create_graph_qt(int (*)(HMGL gr, void *p), const char *, void *, void (*)(void *p))\r
{ return NULL; }\r
int mgl_qt_run(){return 0;}\r
#endif\r
//-----------------------------------------------------------------------------
void QMathGL::nextSlide()
{
- mglCanvasW *g = dynamic_cast<mglCanvasW *>(gr);
+ mglCanvasWnd *g = dynamic_cast<mglCanvasWnd *>(gr);
if(g && g->GetNumFig()>1) g->NextFrame();
emit frameChanged(+1);
}
void QMathGL::prevSlide()
{
- mglCanvasW *g = dynamic_cast<mglCanvasW *>(gr);
+ mglCanvasWnd *g = dynamic_cast<mglCanvasWnd *>(gr);
if(g && g->GetNumFig()>1) g->PrevFrame();
emit frameChanged(-1);
}
// class mglCanvasQT
//
//-----------------------------------------------------------------------------
-mglCanvasQT::mglCanvasQT() : mglCanvasW()
+mglCanvasQT::mglCanvasQT() : mglCanvasWnd()
{ Wnd = 0; }
//-----------------------------------------------------------------------------
void mglCanvasQT::GotoFrame(int d)
o->addAction(TR("About &Qt"), QMGL, SLOT(aboutQt()));
}
//-----------------------------------------------------------------------------
-HMGL mgl_create_graph_qt(int (*draw)(HMGL gr, void *p), const char *title, void *par)
+HMGL mgl_create_graph_qt(int (*draw)(HMGL gr, void *p), const char *title, void *par, void (*load)(void *p))
{
mglCanvasQT *g = new mglCanvasQT;
- g->Window(0,0,draw,title,par);
+ g->Window(0,0,draw,title,par,load);
return g;
}
int mgl_qt_run() { return (qApp)?qApp->exec():-1; }
//-----------------------------------------------------------------------------
-void *mgl_qt_tmp(void *) { mgl_qt_run(); return 0; }
-/*void mgl_qt_thread()
- * {
- * static pthread_t tmp;
- * pthread_create(&tmp, 0, mgl_qt_tmp, 0);
- * pthread_detach(tmp);
- }*/
-//-----------------------------------------------------------------------------
* Free Software Foundation, Inc., *\r
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *\r
***************************************************************************/\r
-#include "mgl/window.h"\r
+#include "mgl/canvas_wnd.h"\r
//-----------------------------------------------------------------------------\r
-mglCanvasW::mglCanvasW() : mglCanvas()\r
+mglCanvasWnd::mglCanvasWnd() : mglCanvas()\r
{\r
Setup(); LoadFunc=0; FuncPar=0; DrawFunc=0;\r
GG = 0; NumFig = 0; CurFig = -1;\r
// set(MGL_USEDRWDAT); // TODO: experimental feature -- test later\r
}\r
//-----------------------------------------------------------------------------\r
-mglCanvasW::~mglCanvasW() { if(GG) free(GG); }\r
+mglCanvasWnd::~mglCanvasWnd() { if(GG) free(GG); }\r
//-----------------------------------------------------------------------------\r
-void mglCanvasW::SetCurFig(int c) { CurFig=c; if(get(MGL_USEDRWDAT)) GetDrwDat(c); }\r
+void mglCanvasWnd::SetCurFig(int c) { CurFig=c; if(get(MGL_USEDRWDAT)) GetDrwDat(c); }\r
//-----------------------------------------------------------------------------\r
-void mglCanvasW::ClearFrames()\r
+void mglCanvasWnd::ClearFrames()\r
{\r
if(GG) free(GG); GG = 0;\r
CurFrameId = NumFig = CurFig = 0;\r
DrwDat.clear();\r
}\r
//-----------------------------------------------------------------------------\r
-void mglCanvasW::SetSize(int w,int h)\r
+void mglCanvasWnd::SetSize(int w,int h)\r
{\r
ClearFrames();\r
mglCanvas::SetSize(w,h);\r
// if(Wnd) Wnd->size(w,h);\r
}\r
//-----------------------------------------------------------------------------\r
-void mglCanvasW::EndFrame()\r
+void mglCanvasWnd::EndFrame()\r
{\r
CurFig = CurFrameId-1;\r
if(!GG)\r
CurFig++;\r
}\r
//-----------------------------------------------------------------------------\r
-void mglCanvasW::SetDrawFunc(int (*draw)(mglBase *gr, void *p), void *par, void (*reload)(void *p))\r
+void mglCanvasWnd::SetDrawFunc(int (*draw)(mglBase *gr, void *p), void *par, void (*reload)(void *p))\r
{\r
ClearFrames();\r
int n = draw ? draw(this,par) : 0;\r
LoadFunc = reload;\r
}\r
//-----------------------------------------------------------------------------\r
-const unsigned char *mglCanvasW::GetBits()\r
+const unsigned char *mglCanvasWnd::GetBits()\r
{\r
const unsigned char *g = mglCanvas::GetBits();\r
if(GG && NumFig>0 && CurFig<NumFig && CurFig>=0)\r
return g;\r
}\r
//-----------------------------------------------------------------------------\r
-void mglCanvasW::ReLoad()\r
+void mglCanvasWnd::ReLoad()\r
{\r
if(LoadFunc)\r
{\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_wnd_toggle_alpha(HMGL gr)\r
-{ mglCanvasW *g = dynamic_cast<mglCanvasW *>(gr); if(g) g->ToggleAlpha(); }\r
+{ mglCanvasWnd *g = dynamic_cast<mglCanvasWnd *>(gr); if(g) g->ToggleAlpha(); }\r
void mgl_wnd_toggle_light(HMGL gr)\r
-{ mglCanvasW *g = dynamic_cast<mglCanvasW *>(gr); if(g) g->ToggleLight(); }\r
+{ mglCanvasWnd *g = dynamic_cast<mglCanvasWnd *>(gr); if(g) g->ToggleLight(); }\r
void mgl_wnd_toggle_zoom(HMGL gr)\r
-{ mglCanvasW *g = dynamic_cast<mglCanvasW *>(gr); if(g) g->ToggleZoom(); }\r
+{ mglCanvasWnd *g = dynamic_cast<mglCanvasWnd *>(gr); if(g) g->ToggleZoom(); }\r
void mgl_wnd_toggle_rotate(HMGL gr)\r
-{ mglCanvasW *g = dynamic_cast<mglCanvasW *>(gr); if(g) g->ToggleRotate(); }\r
+{ mglCanvasWnd *g = dynamic_cast<mglCanvasWnd *>(gr); if(g) g->ToggleRotate(); }\r
void mgl_wnd_toggle_no(HMGL gr)\r
-{ mglCanvasW *g = dynamic_cast<mglCanvasW *>(gr); if(g) g->ToggleNo(); }\r
+{ mglCanvasWnd *g = dynamic_cast<mglCanvasWnd *>(gr); if(g) g->ToggleNo(); }\r
void mgl_wnd_update(HMGL gr)\r
-{ mglCanvasW *g = dynamic_cast<mglCanvasW *>(gr); if(g) g->Update(); }\r
+{ mglCanvasWnd *g = dynamic_cast<mglCanvasWnd *>(gr); if(g) g->Update(); }\r
void mgl_wnd_reload(HMGL gr)\r
-{ mglCanvasW *g = dynamic_cast<mglCanvasW *>(gr); if(g) g->ReLoad(); }\r
+{ mglCanvasWnd *g = dynamic_cast<mglCanvasWnd *>(gr); if(g) g->ReLoad(); }\r
void mgl_wnd_adjust(HMGL gr)\r
-{ mglCanvasW *g = dynamic_cast<mglCanvasW *>(gr); if(g) g->Adjust(); }\r
+{ mglCanvasWnd *g = dynamic_cast<mglCanvasWnd *>(gr); if(g) g->Adjust(); }\r
void mgl_wnd_next_frame(HMGL gr)\r
-{ mglCanvasW *g = dynamic_cast<mglCanvasW *>(gr); if(g) g->NextFrame(); }\r
+{ mglCanvasWnd *g = dynamic_cast<mglCanvasWnd *>(gr); if(g) g->NextFrame(); }\r
void mgl_wnd_prev_frame(HMGL gr)\r
-{ mglCanvasW *g = dynamic_cast<mglCanvasW *>(gr); if(g) g->PrevFrame(); }\r
+{ mglCanvasWnd *g = dynamic_cast<mglCanvasWnd *>(gr); if(g) g->PrevFrame(); }\r
void mgl_wnd_animation(HMGL gr)\r
-{ mglCanvasW *g = dynamic_cast<mglCanvasW *>(gr); if(g) g->Animation(); }\r
+{ mglCanvasWnd *g = dynamic_cast<mglCanvasWnd *>(gr); if(g) g->Animation(); }\r
void mgl_setup_window(HMGL gr, int clf_upd, int showpos)\r
-{ mglCanvasW *g = dynamic_cast<mglCanvasW *>(gr); if(g) g->Setup(clf_upd, showpos); }\r
+{ mglCanvasWnd *g = dynamic_cast<mglCanvasWnd *>(gr); if(g) g->Setup(clf_upd, showpos); }\r
//-----------------------------------------------------------------------------\r
void mgl_wnd_toggle_alpha_(uintptr_t *gr)\r
-{ mglCanvasW *g = dynamic_cast<mglCanvasW *>((HMGL)(*gr));\r
+{ mglCanvasWnd *g = dynamic_cast<mglCanvasWnd *>((HMGL)(*gr));\r
if(g) g->ToggleAlpha(); }\r
void mgl_wnd_toggle_light_(uintptr_t *gr)\r
-{ mglCanvasW *g = dynamic_cast<mglCanvasW *>((HMGL)(*gr));\r
+{ mglCanvasWnd *g = dynamic_cast<mglCanvasWnd *>((HMGL)(*gr));\r
if(g) g->ToggleLight(); }\r
void mgl_wnd_toggle_zoom_(uintptr_t *gr)\r
-{ mglCanvasW *g = dynamic_cast<mglCanvasW *>((HMGL)(*gr));\r
+{ mglCanvasWnd *g = dynamic_cast<mglCanvasWnd *>((HMGL)(*gr));\r
if(g) g->ToggleZoom(); }\r
void mgl_wnd_toggle_rotate_(uintptr_t *gr)\r
-{ mglCanvasW *g = dynamic_cast<mglCanvasW *>((HMGL)(*gr));\r
+{ mglCanvasWnd *g = dynamic_cast<mglCanvasWnd *>((HMGL)(*gr));\r
if(g) g->ToggleRotate(); }\r
void mgl_wnd_toggle_no_(uintptr_t *gr)\r
-{ mglCanvasW *g = dynamic_cast<mglCanvasW *>((HMGL)(*gr));\r
+{ mglCanvasWnd *g = dynamic_cast<mglCanvasWnd *>((HMGL)(*gr));\r
if(g) g->ToggleNo(); }\r
void mgl_wnd_update_(uintptr_t *gr)\r
-{ mglCanvasW *g = dynamic_cast<mglCanvasW *>((HMGL)(*gr));\r
+{ mglCanvasWnd *g = dynamic_cast<mglCanvasWnd *>((HMGL)(*gr));\r
if(g) g->Update(); }\r
void mgl_wnd_reload_(uintptr_t *gr)\r
-{ mglCanvasW *g = dynamic_cast<mglCanvasW *>((HMGL)(*gr));\r
+{ mglCanvasWnd *g = dynamic_cast<mglCanvasWnd *>((HMGL)(*gr));\r
if(g) g->ReLoad(); }\r
void mgl_wnd_adjust_(uintptr_t *gr)\r
-{ mglCanvasW *g = dynamic_cast<mglCanvasW *>((HMGL)(*gr));\r
+{ mglCanvasWnd *g = dynamic_cast<mglCanvasWnd *>((HMGL)(*gr));\r
if(g) g->Adjust(); }\r
void mgl_wnd_next_frame_(uintptr_t *gr)\r
-{ mglCanvasW *g = dynamic_cast<mglCanvasW *>((HMGL)(*gr));\r
+{ mglCanvasWnd *g = dynamic_cast<mglCanvasWnd *>((HMGL)(*gr));\r
if(g) g->NextFrame(); }\r
void mgl_wnd_prev_frame_(uintptr_t *gr)\r
-{ mglCanvasW *g = dynamic_cast<mglCanvasW *>((HMGL)(*gr));\r
+{ mglCanvasWnd *g = dynamic_cast<mglCanvasWnd *>((HMGL)(*gr));\r
if(g) g->PrevFrame(); }\r
void mgl_wnd_animation_(uintptr_t *gr)\r
-{ mglCanvasW *g = dynamic_cast<mglCanvasW *>((HMGL)(*gr));\r
+{ mglCanvasWnd *g = dynamic_cast<mglCanvasWnd *>((HMGL)(*gr));\r
if(g) g->Animation(); }\r
void mgl_setup_window_(uintptr_t *gr, int *clf_upd, int *showpos)\r
-{ mglCanvasW *g = dynamic_cast<mglCanvasW *>((HMGL)(*gr));\r
+{ mglCanvasWnd *g = dynamic_cast<mglCanvasWnd *>((HMGL)(*gr));\r
if(g) g->Setup(*clf_upd, *showpos); }\r
+void mgl_get_last_mouse_pos_(uintptr_t *gr, float *x, float *y, float *z)\r
+{ mglCanvasWnd *g = dynamic_cast<mglCanvasWnd *>((HMGL)(*gr));\r
+ mglPoint p; if(g) g->GetMousePos();\r
+ *x=p.x; *y=p.y; *z=p.z; } \r
+void mgl_get_last_mouse_pos(HMGL gr, float *x, float *y, float *z)\r
+{ mglCanvasWnd *g = dynamic_cast<mglCanvasWnd *>(gr);\r
+ mglPoint p; if(g) g->GetMousePos();\r
+ *x=p.x; *y=p.y; *z=p.z; }\r
//-----------------------------------------------------------------------------\r
#if MGL_HAVE_FLTK==0\r
-HMGL mgl_create_graph_fltk(int (*)(HMGL gr, void *p), const char *, void *)\r
+HMGL mgl_create_graph_fltk(int (*)(HMGL gr, void *p), const char *, void *, void (*)(void *p))\r
{ return NULL; }\r
int mgl_fltk_run(){return 0;}\r
#endif\r
uintptr_t mgl_create_graph_fltk_(const char *title, int l)\r
{\r
char *s = new char[l+1]; memcpy(s,title,l); s[l]=0;\r
- uintptr_t t = uintptr_t(mgl_create_graph_fltk(0,s,0));\r
+ uintptr_t t = uintptr_t(mgl_create_graph_fltk(0,s,0,0));\r
delete []s; return t;\r
}\r
int mgl_fltk_run_() { return mgl_fltk_run(); }\r
//-----------------------------------------------------------------------------\r
+void *mgl_fltk_tmp(void *)\r
+{ mgl_fltk_run(); return 0; }\r
+//-----------------------------------------------------------------------------\r
+int mgl_fltk_thr() // NOTE: Qt couldn't be running in non-primary thread\r
+{\r
+ static pthread_t thr;\r
+ pthread_create(&thr,0,mgl_fltk_tmp,0);\r
+ pthread_detach(thr);\r
+ return 0; // stupid, but I don't want keep result returned by Fl::Run()\r
+}\r
+//-----------------------------------------------------------------------------\r
+\r
#if MGL_HAVE_QT==0\r
-HMGL mgl_create_graph_qt(int (*)(HMGL gr, void *p), const char *, void *)\r
+HMGL mgl_create_graph_qt(int (*)(HMGL gr, void *p), const char *, void *, void (*)(void *p))\r
{ return NULL; }\r
int mgl_qt_run(){return 0;}\r
#endif\r
uintptr_t mgl_create_graph_qt_(const char *title, int l)\r
{\r
char *s = new char[l+1]; memcpy(s,title,l); s[l]=0;\r
- uintptr_t t = uintptr_t(mgl_create_graph_qt(0,s,0));\r
+ uintptr_t t = uintptr_t(mgl_create_graph_qt(0,s,0,0));\r
delete []s; return t;\r
}\r
int mgl_qt_run_() { return mgl_qt_run(); }\r
//-----------------------------------------------------------------------------\r
+//\r
+// mglDraw class handling\r
+//\r
+//-----------------------------------------------------------------------------\r
int mgl_draw_class(mglBase *gr, void *p)\r
{\r
mglGraph g(gr);\r
mglWindow *w = (mglWindow *)p; // so stupid way to save mglDraw class inheritance :(\r
return (w && w->dr) ? w->dr->Draw(&g) : 0;\r
}\r
-//return p ? ((mglDraw *)p)->Draw(&g) : 0; }\r
void mgl_reload_class(void *p)\r
-{ if(p) ((mglDraw *)p)->Reload(); }\r
+{\r
+ mglWindow *w = (mglWindow *)p; // so stupid way to save mglDraw class inheritance :(\r
+ if(w && w->dr) w->dr->Reload();\r
+}\r
//-----------------------------------------------------------------------------\r
int mgl_draw_graph(mglBase *gr, void *p)\r
{\r
projects / mathgl.git / commitdiff